pets-device/JBao_Magic_Box_FW
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1、低电 3.7V 只闪红灯不再 1 分钟后关机；电量低于约 5% 自动关机，未充电开机先闪 5 下红灯再睡回，只能充电后才能开机

Browse Source 
2、自动/手动互相切换都闪 2 下灯；APP 发停止后再发自动模式可正常启动，手动残留停止不再挡住自动
3、自动模式 1~6 单次最长跑 10 分钟后回待机；关机时长按 12 秒进 OTA，OTA 期间红绿交替闪
This commit is contained in:
wuchuyuan
2026-08-27 10:20:48 +08:00
parent 3d445ae5c5
commit fdb43011b7
28 changed files with 945 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files
AC701N.cbp
+4
View File
@@ -816,6 +816,10 @@
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/app_power.h" />
<Unit filename="apps/usr_app/app_battery.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/app_battery.h" />
<Unit filename="apps/usr_app/app_pair.c">
<Option compilerVar="CC" />
</Unit>
Makefile
+1
View File
@@ -407,6 +407,7 @@ c_SRC_FILES := \
apps/usr_app/key_manager.c \
apps/usr_app/app_mode.c \
apps/usr_app/app_power.c \
apps/usr_app/app_battery.c \
apps/usr_app/app_pair.c \
apps/usr_app/app_boot.c \
apps/usr_app/app_function.c \
apps/usr_app/app_battery.c
+505
View File
@@ -0,0 +1,505 @@
/******************************************************************************
* @file app_battery.c
* @brief 电量算法实现：电压滤波、充放电基准记录、突变防抖、缓冲平滑显示
* @author cyWu <1917507415@qq.com>
* @date 2026.08.27
* @version V1.0.1
* @history
* - V1.0.0, 2026.08.26, cyWu, 首次发布，实现电压滤波、充放电基准、突变防抖与缓冲平滑
* - V1.0.1, 2026.08.27, cyWu, 补充函数内部注释
******************************************************************************/
#include "app_battery.h"
#include "board_pin.h"
#include <string.h>
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP_BAT]"
#define LOG_INFO_ENABLE
#include "debug.h"
/*========================= 时间/阈值配置 =========================*/
#define BAT_SWITCH_WAIT_CHARGE_MS 60000u /**< 切到充电后等 60s 才记基准 */
#define BAT_SWITCH_WAIT_DISCHARGE_MS 60000u /**< 切到放电后等 60s 才记基准 */
#define BAT_CHARGE_BUFFER_MS 60000u /**< 充电缓冲：1 分钟走 1% */
#define BAT_DISCHARGE_BUFFER_MS 20000u /**< 放电缓冲：20 秒走 1% */
#define BAT_DISCHARGE_FILTER_W 90 /**< 放电指数滤波权重(/100)，压掉电机拉载噪声 */
#define BAT_SUDDEN_DROP_PCT 1 /**< 突变阈值：单次超过 1% 判定为突变 */
#define BAT_DROP_RECOVERY_MS 60000u /**< 突变超过此时长强制接受新电量 */
#define BAT_RECOVERY_WAIT_MS 30000u /**< 突变后电量回升，需稳定这么久才解除 */
#if APP_BATTERY_AUTO_INCREMENT_EN
#define BAT_AUTO_INC_INTERVAL_MS (3u * 60u * 1000u) /**< 自增间隔：3 分钟 */
#define BAT_AUTO_INC_TRIGGER_MV 2 /**< 距历史满电压 2mV 内触发自增模式 */
#endif
/** 充/放电各自的基准电压——记录"状态切换稳定后"的真实电压与当时电量，
* 之后按这个基准重新拟合电压-电量曲线，而不是死用出厂固定曲线 */
typedef struct {
uint16_t base_mv;
uint8_t base_percent;
uint8_t recorded;
} AppBatteryBase_t;
/** 模块状态，所有跟时间相关的字段都用 dt 累加，不依赖系统绝对时钟 */
typedef struct {
uint8_t initialized;
uint16_t voltage_mv; /**< 滤波后电压 */
uint8_t percent; /**< 当前对外显示的电量（已缓冲平滑） */
uint8_t target_percent; /**< 电压当下换算出的目标电量 */
uint8_t charging;
uint8_t is_switching; /**< 充放电状态刚切换，等稳定后才记基准 */
uint32_t switch_ms;
uint8_t is_buffering; /**< percent 正在按缓冲节奏逼近 target_percent */
uint32_t buffer_ms;
uint8_t drop_detected; /**< 放电时检测到电量单次跳变过大，先当噪声处理 */
uint8_t recovery_waiting;
uint8_t pre_drop_percent;
uint32_t drop_ms;
uint32_t recovery_ms;
#if APP_BATTERY_AUTO_INCREMENT_EN
uint8_t auto_inc_active;
uint8_t was_full;
uint32_t auto_inc_ms;
uint16_t max_charge_mv; /**< 本次充电周期内记录到的最高电压 */
uint16_t full_charge_mv; /**< 历史上电量到过 100% 时记录的电压，用于下次提前触发自增 */
#endif
} AppBatteryCtx_t;
static AppBatteryCtx_t s_batt;
static AppBatteryBase_t s_charge_base;
static AppBatteryBase_t s_discharge_base;
static uint8_t battery_mv_to_percent_discharge(uint16_t mv);
static uint8_t battery_mv_to_percent_charge(uint16_t mv);
static void battery_update_voltage_filter(uint16_t mv);
static void battery_start_buffer(uint8_t target_percent);
static void battery_update_buffer(uint16_t dt);
static uint8_t battery_check_sudden_drop(uint16_t dt, uint8_t target_percent);
#if APP_BATTERY_AUTO_INCREMENT_EN
static void battery_update_charge_max_mv(uint16_t mv);
static void battery_check_auto_increment(uint16_t mv);
static void battery_handle_auto_increment(uint16_t dt);
static void battery_learn_full_charge_mv(void);
#endif
/**
* @brief 初始化电量模块状态
* @return 无
*/
void app_battery_init(void)
{
memset(&s_batt, 0, sizeof(s_batt));
memset(&s_charge_base, 0, sizeof(s_charge_base));
memset(&s_discharge_base, 0, sizeof(s_discharge_base));
}
/**
* @brief 查询当前显示用电量百分比
* @return 0~100
*/
uint8_t app_battery_get_percent(void)
{
return s_batt.percent;
}
/**
* @brief 外部强制刷新电量，立即生效，清掉正在进行的缓冲，避免被缓冲拉回去
* @param percent 目标百分比，超过 100 会被钳到 100
* @return 无
*/
void app_battery_set_percent(uint8_t percent)
{
AppBatteryCtx_t *b = &s_batt;
if (percent > 100) {
percent = 100;
}
b->initialized = 1;
b->percent = percent;
b->target_percent = percent;
b->is_buffering = 0; /* 立刻生效，清掉正在走的缓冲，避免被拉回去 */
b->buffer_ms = 0;
log_info("battery percent forced to %d%%\n", percent);
}
/**
* @brief 按最新采样电压推进电量算法
* @param dt 距上次调用的毫秒数
* @param mv 本次采样均值电压，单位 mV
* @param charging 1=充电中，0=放电
* @return 无
*/
void app_battery_tick(uint16_t dt, uint16_t mv, uint8_t charging)
{
AppBatteryCtx_t *b = &s_batt;
int32_t new_percent;
uint8_t target;
/* 第一次进来：用当前电压直接算出显示电量，后面才走滤波/缓冲 */
if (!b->initialized) {
b->voltage_mv = mv;
b->charging = charging;
b->percent = charging ? battery_mv_to_percent_charge(mv)
: battery_mv_to_percent_discharge(mv);
b->target_percent = b->percent;
b->initialized = 1;
return;
}
/* 充放电状态刚切：先等电压稳定再记基准，这段时间显示电量维持原值 */
if (charging != b->charging) {
b->charging = charging;
b->is_switching = 1;
b->switch_ms = 0;
b->is_buffering = 0;
b->drop_detected = 0;
b->recovery_waiting = 0;
#if APP_BATTERY_AUTO_INCREMENT_EN
if (charging) {
b->max_charge_mv = 0;
b->auto_inc_active = 0;
}
#endif
log_info("battery switching to %s\n", charging ? "charge" : "discharge");
}
if (b->is_switching) {
uint32_t wait_ms = b->charging ? BAT_SWITCH_WAIT_CHARGE_MS : BAT_SWITCH_WAIT_DISCHARGE_MS;
b->switch_ms += dt;
if (b->switch_ms < wait_ms) {
return; /* 基准没记完前，显示电量维持原值，不参与后面的计算 */
}
{
AppBatteryBase_t *base = b->charging ? &s_charge_base : &s_discharge_base;
base->base_mv = mv;
base->base_percent = b->percent;
base->recorded = 1;
log_info("battery %s base %dmV %d%%\n",
b->charging ? "charge" : "discharge", mv, b->percent);
}
b->is_switching = 0;
b->voltage_mv = mv;
}
battery_update_voltage_filter(mv);
/* 电压换算成目标电量：放电只减不增，充电只增不减，避免噪声来回跳 */
if (!b->charging) {
new_percent = battery_mv_to_percent_discharge(b->voltage_mv);
if (new_percent > b->target_percent) {
new_percent = b->target_percent;
}
} else {
#if APP_BATTERY_AUTO_INCREMENT_EN
battery_update_charge_max_mv(mv);
battery_check_auto_increment(mv);
#endif
new_percent = battery_mv_to_percent_charge(b->voltage_mv);
if (new_percent < b->target_percent) {
new_percent = b->target_percent;
}
}
if (new_percent > 100) {
new_percent = 100;
} else if (new_percent < 0) {
new_percent = 0;
}
target = (uint8_t)new_percent;
/* 放电时单次跳变过大先当噪声，稳住后再更新 */
if (!b->charging && battery_check_sudden_drop(dt, target)) {
return;
}
if (target != b->target_percent) {
b->target_percent = target;
battery_start_buffer(target);
}
battery_update_buffer(dt);
#if APP_BATTERY_AUTO_INCREMENT_EN
if (b->charging) {
if (b->auto_inc_active) {
battery_handle_auto_increment(dt);
}
battery_learn_full_charge_mv();
}
#endif
}
/*========================= 私有函数实现 =========================*/
/**
* @brief 放电时电压转百分比：有基准用基准拟合，没有就用出厂固定曲线
*/
static uint8_t battery_mv_to_percent_discharge(uint16_t mv)
{
int32_t pct;
int32_t span;
/* 有放电基准：从当时记下的电压/电量，线性拟合到空电电压 */
if (s_discharge_base.recorded) {
uint16_t v0 = s_discharge_base.base_mv;
if (mv > v0) {
mv = v0; /* 放电电压不应比基准还高，高出的当噪声钳掉 */
}
span = (int32_t)v0 - BOARD_VBAT_EMPTY_MV;
if (span <= 0) {
return s_discharge_base.base_percent;
}
pct = (int32_t)(mv - BOARD_VBAT_EMPTY_MV) * s_discharge_base.base_percent / span;
if (pct < 0) {
pct = 0;
} else if (pct > s_discharge_base.base_percent) {
pct = s_discharge_base.base_percent;
}
return (uint8_t)pct;
}
/* 没有基准：用出厂固定曲线 空电~满电 线性换算 */
if (mv <= BOARD_VBAT_EMPTY_MV) {
return 0;
}
if (mv >= BOARD_VBAT_FULL_MV) {
return 100;
}
pct = (int32_t)(mv - BOARD_VBAT_EMPTY_MV) * 100 / (BOARD_VBAT_FULL_MV - BOARD_VBAT_EMPTY_MV);
return (uint8_t)pct;
}
/**
* @brief 充电时电压转百分比：有基准用基准拟合，没有就用出厂固定曲线
*/
static uint8_t battery_mv_to_percent_charge(uint16_t mv)
{
int32_t pct;
int32_t span;
int32_t remain;
/* 有充电基准：从当时记下的电压/电量，线性拟合到充满电压 */
if (s_charge_base.recorded) {
uint16_t v0 = s_charge_base.base_mv;
if (mv < v0) {
mv = v0; /* 充电电压不应比基准还低，低出的当噪声钳掉 */
}
span = (int32_t)BOARD_VBAT_CHARGE_FULL_MV - v0;
remain = 100 - s_charge_base.base_percent;
if (span <= 0) {
return 100;
}
pct = (int32_t)(mv - v0) * remain / span + s_charge_base.base_percent;
if (pct < s_charge_base.base_percent) {
pct = s_charge_base.base_percent;
} else if (pct > 100) {
pct = 100;
}
return (uint8_t)pct;
}
/* 没有基准：用出厂充电曲线线性换算 */
if (mv <= BOARD_VBAT_CHARGE_EMPTY_MV) {
return 0;
}
if (mv >= BOARD_VBAT_CHARGE_FULL_MV) {
return 100;
}
pct = (int32_t)(mv - BOARD_VBAT_CHARGE_EMPTY_MV) * 100
/ (BOARD_VBAT_CHARGE_FULL_MV - BOARD_VBAT_CHARGE_EMPTY_MV);
return (uint8_t)pct;
}
/**
* @brief 更新电压滤波值：放电用指数滤波压噪声，充电直接用采样值（充电曲线本身平缓）
*/
static void battery_update_voltage_filter(uint16_t mv)
{
if (!s_batt.charging) {
/* 放电：指数滤波压掉电机拉载噪声，权重越大越平滑、越滞后 */
s_batt.voltage_mv = (uint16_t)(((uint32_t)s_batt.voltage_mv * BAT_DISCHARGE_FILTER_W
+ (uint32_t)mv * (100 - BAT_DISCHARGE_FILTER_W)) / 100);
} else {
s_batt.voltage_mv = mv; /* 充电曲线本身平缓，直接用采样值 */
}
}
/**
* @brief 启动电量缓冲：目标变了就重新计时，percent 后面按固定节奏逼近 target
*/
static void battery_start_buffer(uint8_t target_percent)
{
if (target_percent == s_batt.percent) {
s_batt.is_buffering = 0;
return;
}
s_batt.is_buffering = 1;
s_batt.buffer_ms = 0;
}
/**
* @brief 推进电量缓冲：满一个步进周期就 ±1%，保留余数不清零，避免长期漂移
*/
static void battery_update_buffer(uint16_t dt)
{
AppBatteryCtx_t *b = &s_batt;
uint32_t step_ms;
if (!b->is_buffering) {
return;
}
step_ms = b->charging ? BAT_CHARGE_BUFFER_MS : BAT_DISCHARGE_BUFFER_MS;
b->buffer_ms += dt;
if (b->buffer_ms < step_ms) {
return;
}
b->buffer_ms -= step_ms; /* 减一个周期而不是清零，余数留给下次，避免长期漂移 */
if (b->charging) {
if (b->percent < b->target_percent) {
b->percent++;
}
} else {
if (b->percent > b->target_percent) {
b->percent--;
}
}
if (b->percent == b->target_percent) {
b->is_buffering = 0;
b->buffer_ms = 0;
}
}
/**
* @brief 放电突变检测：单次跳变超过阈值先当噪声，回升稳定一段时间才解除；
* 若一直没回升，超时后强制接受，避免误判卡死电量不更新
* @param dt 距上次调用的毫秒数
* @param target_percent 本次电压算出来的目标电量
* @return 1=仍在突变检测中（不更新电量），0=正常
*/
static uint8_t battery_check_sudden_drop(uint16_t dt, uint8_t target_percent)
{
AppBatteryCtx_t *b = &s_batt;
if (b->drop_detected) {
int16_t recovery_diff;
b->drop_ms += dt;
recovery_diff = (int16_t)target_percent - (int16_t)b->pre_drop_percent;
/* 电量已经回升到突变阈值以内：再稳一段时间才真正解除 */
if (recovery_diff >= -(int16_t)BAT_SUDDEN_DROP_PCT) {
if (!b->recovery_waiting) {
b->recovery_waiting = 1;
b->recovery_ms = 0;
} else {
b->recovery_ms += dt;
}
if (b->recovery_ms >= BAT_RECOVERY_WAIT_MS) {
b->drop_detected = 0;
b->recovery_waiting = 0;
return 0;
}
return 1;
}
b->recovery_waiting = 0;
/* 一直没回升：超时后强制接受新电量，避免卡死不更新 */
if (b->drop_ms >= BAT_DROP_RECOVERY_MS) {
b->drop_detected = 0;
return 0;
}
return 1;
}
/* 单次跳变超过阈值，先当噪声，锁住显示电量 */
if ((int16_t)b->percent - (int16_t)target_percent > BAT_SUDDEN_DROP_PCT) {
b->drop_detected = 1;
b->pre_drop_percent = b->percent;
b->drop_ms = 0;
b->recovery_waiting = 0;
return 1;
}
return 0;
}
#if APP_BATTERY_AUTO_INCREMENT_EN
/**
* @brief 记录本次充电周期内的最高电压，用作下次提前触发自增的参考
*/
static void battery_update_charge_max_mv(uint16_t mv)
{
if (mv > s_batt.max_charge_mv) {
s_batt.max_charge_mv = mv;
}
}
/**
* @brief 接近历史满电压时提前启动自增模式，避免曲线末期平台期卡住不动
*/
static void battery_check_auto_increment(uint16_t mv)
{
AppBatteryCtx_t *b = &s_batt;
uint16_t trigger_mv;
if (b->auto_inc_active || b->full_charge_mv == 0 || b->percent >= 99) {
return;
}
trigger_mv = b->full_charge_mv - BAT_AUTO_INC_TRIGGER_MV;
if (mv >= trigger_mv) {
b->auto_inc_active = 1;
b->auto_inc_ms = 0;
log_info("battery auto-inc start %dmV trigger=%dmV full=%dmV\n",
mv, trigger_mv, b->full_charge_mv);
}
}
/**
* @brief 自增模式下每隔固定间隔 +1%，最多到 99%（100% 交给真实电压判定）
*/
static void battery_handle_auto_increment(uint16_t dt)
{
AppBatteryCtx_t *b = &s_batt;
if (b->percent >= 99) {
b->auto_inc_active = 0;
return;
}
b->auto_inc_ms += dt;
if (b->auto_inc_ms >= BAT_AUTO_INC_INTERVAL_MS) {
b->auto_inc_ms = 0;
b->percent++;
b->target_percent = b->percent;
log_info("battery auto-inc +1%% -> %d%%\n", b->percent);
if (b->percent >= 99) {
b->auto_inc_active = 0;
}
}
}
/**
* @brief 电量首次到达 100% 时记下当时电压，供下次充电提前触发自增
*/
static void battery_learn_full_charge_mv(void)
{
AppBatteryCtx_t *b = &s_batt;
if (b->percent == 100) {
if (!b->was_full && b->max_charge_mv > 0) {
b->full_charge_mv = b->max_charge_mv;
log_info("battery full-charge voltage learned: %dmV\n", b->full_charge_mv);
b->auto_inc_active = 0;
}
b->was_full = 1;
} else {
b->was_full = 0;
}
}
#endif /* APP_BATTERY_AUTO_INCREMENT_EN */
apps/usr_app/app_battery.h
+58
View File
@@ -0,0 +1,58 @@
/******************************************************************************
* @file app_battery.h
* @brief 电量算法：电压滤波、充放电基准记录、突变防抖、缓冲平滑显示
* @author cyWu <1917507415@qq.com>
* @date 2026.08.27
* @version V1.0.1
* @history
* - V1.0.0, 2026.08.26, cyWu, 首次发布，实现电压滤波、充放电基准、突变防抖与缓冲平滑
* - V1.0.1, 2026.08.27, cyWu, 补充模块说明注释
*
* @note 本模块只认识"电压(mV) + 是否在充电"，不碰 ADC/GPIO，电压采样、
* USB 在位判定由调用方（app_power）负责，保持单向依赖。
* 低电告警迟滞（app_power.c 里的 check_low/check_empty）不受本模块
* 影响，两者各管一段：本模块只负责"电量数字怎么变得好看"，低电告警/
* 深睡门限仍按原始电压判断。
******************************************************************************/
#ifndef __APP_BATTERY_H__
#define __APP_BATTERY_H__
#include <stdint.h>
/*========================= 功能配置 =========================*/
/** 充电末期自动 +1% 模式：解决充电曲线末期长时间平台期、电量显示卡住的问题；
* 是否需要取决于实测充电曲线，先关掉，确认卡电量再打开 */
#define APP_BATTERY_AUTO_INCREMENT_EN 0
/**
* @brief 初始化电量模块状态（含充放电基准，不做持久化，每次重启重新学习）
* @return 无
*/
void app_battery_init(void);
/**
* @brief 按最新采样电压推进电量算法
* @param dt 距上次调用的毫秒数
* @param mv 本次采样均值电压，单位 mV（由调用方滑动平均后传入）
* @param charging 1=充电中（USB 在位），0=放电
* @return 无
*/
void app_battery_tick(uint16_t dt, uint16_t mv, uint8_t charging);
/**
* @brief 查询当前显示用电量百分比（已做防抖/缓冲平滑，非原始电压换算值）
* @return 0~100
*/
uint8_t app_battery_get_percent(void);
/**
* @brief 外部强制刷新电量（例如硬件判定充满后收尾到 100%），立即生效不走缓冲
* @note 充电场景下曲线拟合可能因基准/温漂等原因走不到 100% 就被充电芯片
* 判满，靠这个接口兜底，避免显示卡在 98%/99% 不动
* @param percent 目标百分比，超过 100 会被钳到 100
* @return 无
*/
void app_battery_set_percent(uint8_t percent);
#endif /* __APP_BATTERY_H__ */
apps/usr_app/app_boot.c
+74 -10
View File
@@ -2,10 +2,11 @@
* @file app_boot.c
* @brief 深睡唤醒 / 上电按键判定实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @date 2026.08.26
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现深睡唤醒按键判定（3s 开机 / 5s 配对）
* - V1.1.0, 2026.08.26, cyWu, 新增 12s 长按进 OTA、开机前低电量拦截
******************************************************************************/
#include "app_boot.h"
@@ -60,6 +61,42 @@ static void boot_sleep(void)
}
}
/**
* @brief 拒绝开机前的低电提示：红灯闪烁 BOARD_BOOT_LOWBAT_BLINK_N 下
* @return 无
*/
static void boot_blink_low_battery(void)
{
uint8_t i;
for (i = 0; i < BOARD_BOOT_LOWBAT_BLINK_N; i++) {
bsp_led_red_set(1);
boot_delay_ms(BOARD_BOOT_LOWBAT_ON_MS);
bsp_led_red_set(0);
boot_delay_ms(BOARD_BOOT_LOWBAT_OFF_MS);
}
}
/**
* @brief 开机前电量判定：连续采样取均值，避免单次毛刺误判
* @note 此时 app_battery/app_power 均未初始化，只能摸裸电压，不走那套
* 滤波/缓冲算法；和运行中的自动关机（app_power）共用同一门限
* BOARD_VBAT_SHUTDOWN_MV（约 5%），口径一致
* @return 1=电量过低（约 <=5%），0=正常
*/
static uint8_t boot_battery_too_low(void)
{
uint32_t acc = 0;
uint8_t i;
const uint8_t n = 4;
for (i = 0; i < n; i++) {
acc += bsp_vbat_mv();
boot_delay_ms(5);
}
return (uint8_t)((acc / n) <= BOARD_VBAT_SHUTDOWN_MV);
}
/**
* @brief 上电是否跳过 3s/5s 按键判定
* @note 只有“真的断电后重新插电池 / 用户主动按键”才需要走 3s/5s 判定；
@@ -96,6 +133,9 @@ static uint8_t boot_skip_key_wait(void)
/**
* @brief 等待并判定开机按键
* @note 配对（5s）不再一到点就立即提交：需要继续按住观察是否会按到 12s
* 触发 OTA，真正的配对提交放在松手那一刻做，行为上仍是“按满 5s
* 再松手即进配对”，只是多给了继续按到 12s 改道 OTA 的机会。
* @return 无（深睡分支不返回）
*/
void app_boot_wait_key(void)
@@ -103,9 +143,11 @@ void app_boot_wait_key(void)
uint32_t t0;
uint32_t elapsed;
uint8_t green_on = 0;
uint8_t pair_armed = 0;
usr_var.usr_goto_pair = 0;
/* USB 在位直接开机，不走 3s/5s/12s 按键判定 */
if (boot_skip_key_wait()) {
return;
}
@@ -115,22 +157,36 @@ void app_boot_wait_key(void)
boot_sleep();
}
/* 未充电时电量过低：闪灯提示后继续深睡，不给开机 */
if (boot_battery_too_low()) {
log_info("boot battery <=5%%, blink %d and stay off\n", BOARD_BOOT_LOWBAT_BLINK_N);
boot_blink_low_battery();
boot_sleep();
}
t0 = timer_get_ms();
bsp_led_all_off();
log_info("boot key hold, wait 3s on / 5s pair\n");
log_info("boot key hold, wait 3s on / 5s pair / 12s ota\n");
while (bsp_key_is_pressed()) {
elapsed = timer_get_ms() - t0;
clr_wdt();
if (elapsed >= BOARD_KEY_PAIR_MS) {
usr_var.usr_goto_pair = 1;
usr_clear_pair_info_noreset();
app_pair_start();
log_info("boot hold %ums, power on + pair\n", (unsigned)elapsed);
/* 12s 优先于配对：按满 12s 直接进 OTA，不再等松手 */
if (elapsed >= BOARD_KEY_OTA_MS) {
log_info("boot hold %ums, power on + ota\n", (unsigned)elapsed);
usr_app_ota_init();
return;
}
/* 5s 只武装配对，真正提交放到松手那一刻，给继续按到 12s 改道 OTA 的机会 */
if (!pair_armed && (elapsed >= BOARD_KEY_PAIR_MS)) {
pair_armed = 1;
log_info("boot hold %ums, pair armed (release now for pair, "
"keep holding to %ums for ota)\n",
(unsigned)elapsed, (unsigned)BOARD_KEY_OTA_MS);
}
if (!green_on && (elapsed >= BOARD_KEY_POWER_MS)) {
green_on = 1;
bsp_led_green_set(1);
@@ -144,5 +200,13 @@ void app_boot_wait_key(void)
boot_sleep();
}
log_info("boot hold %ums, power on\n", (unsigned)elapsed);
/* 松手时已过 5s（且没按到 12s）：提交配对；否则只是正常开机 */
if (pair_armed) {
usr_var.usr_goto_pair = 1;
usr_clear_pair_info_noreset();
app_pair_start();
log_info("boot hold %ums, power on + pair\n", (unsigned)elapsed);
} else {
log_info("boot hold %ums, power on\n", (unsigned)elapsed);
}
}
apps/usr_app/app_boot.h
+12 -5
View File
@@ -1,11 +1,15 @@
/******************************************************************************
* @file app_boot.h
* @brief 深睡唤醒 / 上电按键判定：3s 开机，5s 开机并配对，不足 3s 松手再睡
* @brief 深睡唤醒 / 上电按键判定：3s 开机，5s 配对，12s OTA，不足 3s 松手再睡；
* 开机前电量低于约 5% 且未充电时拒绝开机
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @date 2026.08.26
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现深睡唤醒按键判定（3s 开机 / 5s 配对）
* - V1.1.0, 2026.08.26, cyWu, 新增 12s 长按进 OTA；新增开机前低电量
* （BOARD_VBAT_SHUTDOWN_MV）拦截，仅闪 5 下红灯
* 提示后继续深睡，不接受非充电状态下的开机
*
* @note 必须在 BLE 协议栈起来、1ms 定时器启动之前调用。杰理 jiffies 此时
* 往往 10ms 才跳一次，所以内部一律用 timer_get_ms 直接量时间，
@@ -17,7 +21,10 @@
/**
* @brief 等待并判定开机按键：不足 3s 松手、或全程未按键，直接原地深睡（不返回）；
* 满 3s 视为正常开机；满 5s 视为开机并进入配对（内部会调用 app_pair_start）
* 满 3s 视为正常开机；松手时已过 5s 视为开机并进入配对（内部会调用
* app_pair_start）；持续按满 12s 直接开机并进入 OTA（调用
* usr_app_ota_init）。若未充电且电量低于约 5%，则闪 5 下红灯后
* 继续深睡，拒绝开机。
* @return 无（深睡分支通过 while(1) 喂狗不返回；其余情况正常返回）
*/
void app_boot_wait_key(void);
apps/usr_app/app_function.c
+81 -22
View File
@@ -2,10 +2,15 @@
* @file app_function.c
* @brief 设备功能开关 + 自动玩法 + 手动点动 + 按键动作实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @date 2026.08.26
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 DP0 开关、自动玩法、手动点动与按键动作
* - V1.1.0, 2026.08.26, cyWu, 切模式闪灯改到 function_play_mode_apply 统一
* 触发（自动互切/手动切自动都会闪）；手动点动
* 启动也补上闪灯；DP2 停转（cmd=3）改边沿触发，
* 避免残留的 03 一直把刚启动的自动模式打断；
* 自动模式新增单次最长运行时长，到点回待机
******************************************************************************/
#include "app_function.h"
@@ -15,6 +20,7 @@
#include "app_led.h"
#include "app_time_util.h"
#include "bsp_hw.h"
#include "board_pin.h"
#include "jb_product.h"
#include "system/includes.h"
@@ -27,8 +33,9 @@
typedef struct {
uint8_t app_power; /**< DP0：0=软关，电机/玩法停，BLE 仍在 */
uint8_t play_mode; /**< 当前自动模式 0~6 */
uint32_t play_ms; /**< 当前自动模式已运行时长，超时回待机 */
uint8_t hand_busy; /**< 手动点动进行中 */
uint8_t hand_cmd_last; /**< 边沿：同一 1/2 不重复启动 */
uint8_t hand_cmd_last; /**< 边沿：同一 1/2/3 不重复触发 */
uint16_t hand_ms;
volatile uint8_t hand_write_pending; /**< DP2 刚写入（03 停转要靠事件） */
volatile uint8_t hand_write_cmd;
@@ -39,8 +46,9 @@ static AppFunctionCtx_t s_func;
static void function_hand_stop(void);
static void function_play_mode_apply(uint8_t mode);
static void function_play_mode_poll(void);
static void function_play_mode_timeout(uint16_t dt);
static void function_hand_poll(void);
static uint8_t function_on_click(void);
static void function_on_click(void);
/**
* @brief 初始化功能模块状态
@@ -68,7 +76,7 @@ void app_function_dp_hand_write(uint8_t cmd)
*/
void app_function_poll(void)
{
/* DP0：APP 下发开关 */
/* DP0：APP 下发开关。充电中 / 正在关机时不跟，避免和 USB 软关抢状态 */
if (!app_power_usb_online() && !app_power_poweroff_pending()) {
if (gDevData.power && !s_func.app_power) {
s_func.app_power = 1;
@@ -79,6 +87,7 @@ void app_function_poll(void)
}
}
/* 先跟自动模式，再处理手动点动：同一拍里 APP 发自动模式时，能先把手动停掉 */
function_play_mode_poll();
function_hand_poll();
}
@@ -91,10 +100,11 @@ void app_function_poll(void)
void app_function_tick_1ms(uint16_t dt)
{
if (s_func.hand_busy) {
bsp_motor_switch_tick();
bsp_motor_switch_tick(); /* 手动点动期间也要走换向死区 */
s_func.hand_ms = app_add_ms(s_func.hand_ms, dt);
} else {
app_mode_run();
function_play_mode_timeout(dt); /* 自动模式跑满 10 分钟回待机 */
}
}
@@ -116,6 +126,7 @@ static void function_hand_stop(void)
void app_function_stop_all(void)
{
s_func.play_mode = 0;
s_func.play_ms = 0;
gDevData.play_mode = 0;
app_mode_stop();
function_hand_stop();
@@ -130,6 +141,7 @@ void app_function_soft_off(void)
s_func.app_power = 0;
gDevData.power = 0;
s_func.play_mode = 0;
s_func.play_ms = 0;
gDevData.play_mode = 0;
app_mode_stop();
function_hand_stop();
@@ -174,30 +186,47 @@ uint8_t app_function_play_mode(void)
}
/**
* @brief 切换自动模式 0~6
* @brief 切换自动模式 0~6，并统一在这里判定要不要闪灯提示
* @note 闪灯规则：只要 play_mode 真的变了就闪两下。手动点动期间 play_mode
* 恒为 0（见 function_hand_poll），所以“手动切到自动”落到这里时
* old_mode 必是 0、新 mode 非 0，天然满足“变了”，不用额外判断；
* 由充电/软关/配对等条件被动摁回 0 且本来就是 0 的情况才不闪，
* 避免刷屏式误闪
* @param mode 0=停转，1~6=对应玩法
* @return 无
*/
static void function_play_mode_apply(uint8_t mode)
{
uint8_t old_mode = s_func.play_mode;
if (mode > 6) {
mode = 0;
}
/* 充电 / 软关 / 关机中 / 配对中：不允许跑自动，强制回到待机 */
if (app_power_usb_online() || !s_func.app_power || app_power_poweroff_pending()
|| s_func.hand_busy || app_pair_is_active()) {
|| app_pair_is_active()) {
mode = 0;
}
if (mode != 0 && s_func.hand_busy) {
function_hand_stop(); /* 手动切到自动：先停手动点动，再进自动模式 */
}
s_func.play_mode = mode;
s_func.play_ms = 0; /* 每次切模式都重新计 10 分钟 */
gDevData.play_mode = mode;
if (mode == 0) {
app_mode_stop();
} else {
app_mode_start(mode);
}
if (mode != old_mode) {
app_led_request_mode_blink(); /* 模式真变了才闪两下 */
}
}
/**
* @brief 跟随 APP 下发的 DP1 自动模式
* @note 手动点动进行中也允许响应，因为选中一个自动模式本身就代表要从
* 手动切回自动（function_play_mode_apply 内部会先停手动）
* @return 无
*/
static void function_play_mode_poll(void)
@@ -205,7 +234,7 @@ static void function_play_mode_poll(void)
uint8_t mode;
if (app_power_usb_online() || !s_func.app_power || app_power_poweroff_pending()
|| s_func.hand_busy || app_pair_is_active()) {
|| app_pair_is_active()) {
return;
}
mode = gDevData.play_mode;
@@ -214,12 +243,36 @@ static void function_play_mode_poll(void)
gDevData.play_mode = 0;
}
if (mode == s_func.play_mode) {
return;
return; /* 没变化，不重复 start */
}
function_play_mode_apply(mode);
log_info("APP play_mode=%d\n", mode);
}
/**
* @brief 自动模式单次最长运行 BOARD_AUTO_MODE_MAX_MS，到点自动回待机
* @note 不走 function_play_mode_apply 的闪灯提示：这是保护性超时，不是
* 用户主动切模式，闪灯提示反而会让用户误以为是自己按到了什么
* @param dt 距上次调用的毫秒数
* @return 无
*/
static void function_play_mode_timeout(uint16_t dt)
{
if (s_func.play_mode == 0) {
return;
}
s_func.play_ms += dt;
if (s_func.play_ms < BOARD_AUTO_MODE_MAX_MS) {
return;
}
log_info("auto mode %d run %ums, timeout to standby\n",
s_func.play_mode, (unsigned)s_func.play_ms);
s_func.play_mode = 0;
s_func.play_ms = 0;
gDevData.play_mode = 0;
app_mode_stop();
}
/**
* @brief DP2 手动：只看第 1 字节。0=空闲，1=顺时针，2=逆时针，3=停
* @note 00 00 是 DP 默认值，不当停止。百分比/力度、DP3、DP4 预留不接。
@@ -230,6 +283,7 @@ static void function_hand_poll(void)
uint8_t cmd;
uint8_t got_write = s_func.hand_write_pending;
/* 优先用 DP 写入钩子带来的边沿；没有新写入才读协议层当前值 */
if (got_write) {
s_func.hand_write_pending = 0;
cmd = s_func.hand_write_cmd;
@@ -247,12 +301,17 @@ static void function_hand_poll(void)
}
if (cmd == 0) {
s_func.hand_cmd_last = 0;
s_func.hand_cmd_last = 0; /* 00 是 DP 默认值，不当停止命令 */
return;
}
/* cmd==3 改边沿触发：只在“刚收到停止”这一拍才可能真的停一次，避免
* DP2 停留在 03（APP 没有再写别的值）时，后面随便什么原因一进自动/
* 手动就被这个陈旧的 03 立刻打断——这正是之前“自动运行中，APP 发
* 停止，再发运行自动模式却启动不了”的根因 */
if (cmd == 3) {
if (got_write || s_func.hand_busy || app_mode_get_active()) {
if ((got_write || (cmd != s_func.hand_cmd_last))
&& (s_func.hand_busy || app_mode_get_active())) {
app_function_stop_all();
log_info("hand stop cmd=3\n");
}
@@ -262,30 +321,31 @@ static void function_hand_poll(void)
if ((cmd == 1 || cmd == 2) && (got_write || (cmd != s_func.hand_cmd_last))) {
s_func.play_mode = 0;
s_func.play_ms = 0;
gDevData.play_mode = 0;
app_mode_stop();
app_mode_stop(); /* 自动切手动：先停自动玩法 */
s_func.hand_busy = 1;
s_func.hand_ms = 0;
/* 1=顺时针收绳，2=逆时针放绳（BOARD_MOTOR_IN_INA_HIGH=1） */
bsp_motor_set((cmd == 1) ? BSP_MOTOR_IN : BSP_MOTOR_OUT);
app_led_request_mode_blink(); /* 自动/空闲切到手动，闪两下提示 */
log_info("hand cmd=%d %s until 03\n", cmd, (cmd == 1) ? "cw" : "ccw");
}
s_func.hand_cmd_last = cmd;
}
/**
* @brief 短按：自动模式 0→1→…→6→0
* @return 1=已切换，0=手动点动中被忽略
* @brief 短按：自动模式 0→1→…→6→0（闪灯提示交给 function_play_mode_apply）
* @return 无
*/
static uint8_t function_on_click(void)
static void function_on_click(void)
{
if (s_func.hand_busy) {
log_info("key click ignored, hand busy\n");
return 0;
return;
}
function_play_mode_apply((uint8_t)((s_func.play_mode + 1) % 7));
log_info("key click play_mode=%d\n", s_func.play_mode);
return 1;
}
/**
@@ -306,15 +366,14 @@ void usr_on_key_short(void)
return;
}
if (!s_func.app_power) {
/* 软关状态下短按：只唤醒功能，不切模式 */
s_func.app_power = 1;
gDevData.power = 1;
app_led_hint_power_on();
log_info("key click cancel soft off\n");
return;
}
if (function_on_click()) {
app_led_request_mode_blink();
}
function_on_click();
}
/**
apps/usr_app/app_function.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出，状态收进 AppFunctionCtx_t
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 DP0 开关、自动玩法、手动点动与按键动作
*
* @note 本模块决定“电机现在该不该转、转哪种”，会读 app_power/app_pair 的
* 状态作为阻塞条件（充电中/深睡中/配对中都不能转），也会触发
apps/usr_app/app_led.c
+41 -4
View File
@@ -7,9 +7,10 @@
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.25, cyWu, 开机绿灯只提示几秒
* - V2.0.0, 2026.08.25, cyWu, 改用充电板 LED 事件表，红绿通道独立
* - V2.0.0, 2026.08.25, cyWu, 改用 LED 事件表，红绿通道独立
* - V2.1.0, 2026.08.25, cyWu, 自己从 app_power/app_pair 取数并内部组装
* - V2.2.0, 2026.08.25, cyWu, 重启/清场逻辑各提一个小函数，把意图写进注释
* - V2.3.0, 2026.08.27, cyWu, 新增 OTA 红绿交替灯效
******************************************************************************/
#include "app_led.h"
@@ -20,6 +21,7 @@
#include "app_pair.h"
static uint8_t s_initialized;
static uint8_t s_ota; /* 1=OTA 灯效中，app_led_run 不再叠其它灯 */
static void led_start_pair_result(uint8_t ok);
@@ -87,7 +89,7 @@ AppLed_Ret_t app_led_get_status(void)
*/
void app_led_request_mode_blink(void)
{
if (!s_initialized) {
if (!s_initialized || s_ota) {
return;
}
led_restart(LED_EVENT_MODE);
@@ -99,12 +101,36 @@ void app_led_request_mode_blink(void)
*/
void app_led_hint_power_on(void)
{
if (!s_initialized) {
if (!s_initialized || s_ota) {
return;
}
led_restart(LED_EVENT_STANDBY);
}
/**
* @brief 进入 OTA：清掉其它灯，挂红绿交替一直闪
* @return 无
*/
void app_led_request_ota(void)
{
if (!s_initialized) {
return;
}
s_ota = 1;
LED_EventAllDelete();
bsp_led_all_off();
LED_EventAdd(LED_EVENT_OTA);
}
/**
* @brief 查询是否处于 OTA 灯效
* @return 1=OTA 灯效中，0=否
*/
uint8_t app_led_is_ota(void)
{
return s_ota;
}
/**
* @brief 播放一次性配对结果灯
* @param ok 1=成功常绿，0=失败红绿交替
@@ -112,7 +138,7 @@ void app_led_hint_power_on(void)
*/
static void led_start_pair_result(uint8_t ok)
{
LED_EventDelete(LED_EVENT_PAIRING);
LED_EventDelete(LED_EVENT_PAIRING); /* 结果灯盖住配对快闪 */
led_restart(ok ? LED_EVENT_PAIR_OK : LED_EVENT_PAIR_FAIL);
}
@@ -153,6 +179,14 @@ void app_led_run(uint16_t dt, uint8_t app_power)
return;
}
/* OTA 期间只跑红绿交替，充电/待机/配对都不要叠上去 */
if (s_ota) {
LED_EventAdd(LED_EVENT_OTA);
user_led_handle();
return;
}
/* 配对成功/失败是边沿事件，只在那一拍切灯效 */
pair_evt = app_pair_tick_1ms(dt);
if (pair_evt == APP_PAIR_EVT_OK) {
led_start_pair_result(1);
@@ -165,6 +199,7 @@ void app_led_run(uint16_t dt, uint8_t app_power)
func_on = app_power ? 1 : 0;
pairing = (uint8_t)(app_pair_is_active() && func_on);
/* 充电红 / 充满绿：和功能开关无关，关着设备也可能在充电 */
if (charge_led == 1) {
LED_EventAdd(LED_EVENT_CHARGE);
} else {
@@ -177,12 +212,14 @@ void app_led_run(uint16_t dt, uint8_t app_power)
LED_EventDelete(LED_EVENT_CHARGE_FULL);
}
/* 绿灯正被切模式/配对结果占用时，不要再挂配对快闪，避免互相覆盖 */
if (pairing && !green_pattern_busy()) {
LED_EventAdd(LED_EVENT_PAIRING);
} else if (!pairing) {
LED_EventDelete(LED_EVENT_PAIRING);
}
/* 低电红闪：只在功能开、没接电时才挂，充电红优先 */
if (func_on && low_bat && (charge_led == 0)) {
LED_EventAdd(LED_EVENT_LOWBAT);
} else {
apps/usr_app/app_led.h
+14 -1
View File
@@ -7,9 +7,10 @@
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.25, cyWu, 开机绿灯只提示几秒，避免待机常亮耗电
* - V2.0.0, 2026.08.25, cyWu, 改用充电板 LED 事件表
* - V2.0.0, 2026.08.25, cyWu, 改用 LED 事件表，红绿通道独立
* - V2.1.0, 2026.08.25, cyWu, 改为自己从 app_power/app_pair 取数，
* 调用方不用再手填 AppLedCtx_t
* - V2.3.0, 2026.08.27, cyWu, 新增 OTA 红绿交替灯效
******************************************************************************/
#ifndef __APP_LED_H__
@@ -49,6 +50,18 @@ void app_led_request_mode_blink(void);
*/
void app_led_hint_power_on(void);
/**
* @brief 进入 OTA：红绿交替一直闪，盖住其它灯效，直到升级结束或复位
* @return 无
*/
void app_led_request_ota(void);
/**
* @brief 查询是否处于 OTA 灯效
* @return 1=OTA 灯效中，0=否
*/
uint8_t app_led_is_ota(void);
/**
* @brief 清空全部灯事件并灭灯（关机前调用）
* @return 无
apps/usr_app/app_mode.c
+3 -3
View File
@@ -115,7 +115,7 @@ static void app_mode_apply_step(void)
return;
}
if (tbl[s_mode.step].ms == 0) {
s_mode.step = 0;
s_mode.step = 0; /* 表尾，回到第 0 步循环 */
}
s_mode.step_t0 = timer_get_ms();
if (tbl[s_mode.step].dir == BSP_MOTOR_STOP) {
@@ -172,7 +172,7 @@ AppMode_Ret_t app_mode_start(uint8_t mode)
return APP_MODE_ERR_PARAM;
}
s_mode.active = mode;
s_mode.step = 0;
s_mode.step = 0; /* 从节拍表第 0 步重新开始 */
app_mode_apply_step();
log_info("auto mode %d start\n", mode);
return APP_MODE_OK;
@@ -201,7 +201,7 @@ void app_mode_run(void)
{
const AppModeStep_t *tbl;
bsp_motor_switch_tick();
bsp_motor_switch_tick(); /* 换向死区：H 桥松开后再切方向 */
if (!s_mode.initialized || s_mode.active == 0) {
return;
}
apps/usr_app/app_pair.c
+2 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现配对会话计时与成功/超时判定
******************************************************************************/
#include "app_pair.h"
@@ -47,6 +47,7 @@ AppPairEvt_t app_pair_tick_1ms(uint16_t dt)
return APP_PAIR_EVT_NONE;
}
/* BLE 侧绑定成功：结束本次配对会话 */
if (usr_get_pair_flag()) {
s_pair.active = 0;
s_pair.elapsed_ms = 0;
apps/usr_app/app_pair.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现配对会话计时与成功/超时判定
*
* @note 真正的 BLE 广播/绑定逻辑在 usr_le_code；本模块只负责“进入配对后
* 60s 内 usr_get_pair_flag() 是否变 1”这件事，纯状态，不碰灯/按键。
apps/usr_app/app_power.c
+51 -84
View File
@@ -2,14 +2,18 @@
* @file app_power.c
* @brief USB / 充电检测、电量采样与低电策略、深睡请求生命周期实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @date 2026.08.26
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 USB/充电检测、电量采样与深睡请求
* - V1.1.0, 2026.08.26, cyWu, 取消低电闪烁 1 分钟后自动关机；自动关机门限
* 改为约 5%（BOARD_VBAT_SHUTDOWN_MV），与开机
* 低电拦截（app_boot）共用同一门限
******************************************************************************/
#include "app_power.h"
#include "app_time_util.h"
#include "app_battery.h"
#include "bsp_hw.h"
#include "board_pin.h"
#include "jb_product.h"
@@ -26,10 +30,11 @@
#define BAT_SAMPLE_MS 100
#define BAT_AVG_N 8
#define BAT_UPDATE_MS (BAT_SAMPLE_MS * BAT_AVG_N) /**< 凑够一次新均值的真实耗时，喂给 app_battery */
#define BAT_BOOT_MS 3000 /* 上电 3s 内不因低电深睡 */
#define BAT_LOG_MS 10000
#define BAT_LOW_WIN 3 /* 连续约 2.4s 才进低电告警 */
#define BAT_EMPTY_WIN 5 /* 连续约 4s 才 3.2V 深睡 */
#define BAT_LOW_WIN 3 /* 连续约 2.4s 才进低电告警（仅闪灯，不关机） */
#define BAT_EMPTY_WIN 5 /* 连续约 4s 才判定 <=5%，自动关机 */
/** 充电检测：CHG/VPWR 消抖后的结果 */
typedef struct {
@@ -50,10 +55,12 @@ typedef struct {
uint16_t log_ms;
} AppBatterySample_t;
/** 低电告警：进入/退出都要连续窗口消抖，避免电机拉压降误报 */
/** 低电告警：进入/退出都要连续窗口消抖，避免电机拉压降误报
* @note 低电（BOARD_VBAT_LOW_MV）只负责红灯闪烁提示，不再有超时自动关机；
* 真正的自动关机改由 power_battery_check_empty 在电量约 5%
* （BOARD_VBAT_SHUTDOWN_MV）时触发 */
typedef struct {
uint8_t low_bat;
uint32_t low_ms; /**< 低电已持续时长，满 1 分钟深睡 */
uint8_t empty_win;
uint8_t enter_win;
uint8_t exit_win;
@@ -74,12 +81,10 @@ static AppPowerCtx_t s_power;
static void power_do_poweroff(void *priv);
static AppPowerEvt_t power_charge_tick(uint16_t dt);
static void power_battery_tick(uint16_t dt);
static uint8_t power_bat_percent(uint16_t mv);
static uint8_t power_battery_sample_ready(uint16_t dt, uint16_t *out_mv);
static void power_battery_update_percent(uint16_t mv);
static void power_battery_check_empty(uint16_t mv);
static void power_battery_check_low(uint16_t mv);
static void power_battery_check_low_timeout(uint16_t dt);
static void power_battery_periodic_log(uint16_t dt);
/**
@@ -90,6 +95,7 @@ void app_power_init(void)
{
memset(&s_power, 0, sizeof(s_power));
s_power.charge.charge_led_last = 0xff;
app_battery_init();
}
/**
@@ -151,14 +157,14 @@ uint8_t app_power_low_bat(void)
void app_power_request_poweroff(void)
{
if (s_power.req_poweroff) {
return;
return; /* 已经在关机流程里，不要重复挂 50ms 定时器 */
}
s_power.req_poweroff = 1;
log_info("request deep off\n");
if (s_power.on_request) {
s_power.on_request();
s_power.on_request(); /* 立刻停电机、灯全灭 */
}
sys_timeout_add(NULL, power_do_poweroff, 50);
sys_timeout_add(NULL, power_do_poweroff, 50); /* 给 GPIO 落稳一点再真正掉电 */
}
/**
@@ -198,12 +204,14 @@ static AppPowerEvt_t power_charge_tick(uint16_t dt)
AppPowerEvt_t evt = APP_POWER_EVT_NONE;
if (chg_low) {
/* CHG 拉低：正在充电，红灯 */
c->full_ms = 0;
c->charge_led = 1;
gDevData.charge = CHARGE_1;
usb = 1;
} else if (vpwr) {
/* 拔电时 CHG 先变高、VPWR 还没掉，不能立刻当充满 */
/* VPWR 在但 CHG 已高：可能是充满，也可能是拔电瞬间 CHG 先变高。
* 等满 BOARD_CHG_FULL_MS 才当真充满，避免拔电误报绿灯 */
c->full_ms = app_add_ms(c->full_ms, dt);
if (c->full_ms >= BOARD_CHG_FULL_MS) {
c->charge_led = 2;
@@ -211,6 +219,7 @@ static AppPowerEvt_t power_charge_tick(uint16_t dt)
gDevData.charge = (c->charge_led == 1) ? CHARGE_1 : CHARGE_2;
usb = 1;
} else {
/* USB 不在位：充电灯灭 */
c->full_ms = 0;
c->charge_led = 0;
gDevData.charge = CHARGE_2;
@@ -235,37 +244,18 @@ static AppPowerEvt_t power_charge_tick(uint16_t dt)
c->charge_led_last = c->charge_led;
log_info("charge_led=%d chg=%d vpwr=%d mv=%d\n",
c->charge_led, chg_low, vpwr, bsp_vpwr_mv());
if (c->charge_led == 2) {
/* 硬件（CHG+VPWR 满 BOARD_CHG_FULL_MS）判定充满，电量强制收尾到
* 100%，避免电压拟合曲线因基准/温漂等原因走不到 100% 就卡住 */
app_battery_set_percent(100);
s_power.sample.pct = 100;
gDevData.battery = 100;
}
}
return evt;
}
/**
* @brief 电压换算电量：4.2V=100%，3.2V=0%
* @param mv 电池电压，单位 mV
* @return 电量百分比，范围 0~100
*/
static uint8_t power_bat_percent(uint16_t mv)
{
int32_t span = (int32_t)BOARD_VBAT_FULL_MV - (int32_t)BOARD_VBAT_EMPTY_MV;
int32_t pct;
if (mv <= BOARD_VBAT_EMPTY_MV) {
return 0;
}
if (mv >= BOARD_VBAT_FULL_MV) {
return 100;
}
pct = ((int32_t)mv - BOARD_VBAT_EMPTY_MV) * 100 / span;
if (pct < 0) {
pct = 0;
}
if (pct > 100) {
pct = 100;
}
return (uint8_t)pct;
}
/**
* @brief 滑动平均采样：每 BAT_SAMPLE_MS 采一次电压，凑够 BAT_AVG_N 个才出新均值
* @note 靠采样点数（而非时间）判满，dt 波动也不会多算/少算样本
@@ -279,13 +269,13 @@ static uint8_t power_battery_sample_ready(uint16_t dt, uint16_t *out_mv)
s->tick_ms = app_add_ms(s->tick_ms, dt);
if (s->tick_ms < BAT_SAMPLE_MS) {
return 0;
return 0; /* 还没到采样点 */
}
s->tick_ms = 0;
s->acc_mv += bsp_vbat_mv();
s->n++;
if (s->n < BAT_AVG_N) {
return 0;
return 0; /* 样本还不够，继续累加 */
}
*out_mv = (uint16_t)(s->acc_mv / s->n);
@@ -296,14 +286,17 @@ static uint8_t power_battery_sample_ready(uint16_t dt, uint16_t *out_mv)
}
/**
* @brief 按新均值刷新电量百分比，仅在变化时才写协议层数据
* @brief 喂给电量算法模块（防抖/充放电基准/缓冲平滑见 app_battery.c），
* 仅在结果变化时才写协议层数据
* @param mv 本次均值电压，单位 mV
* @return 无
*/
static void power_battery_update_percent(uint16_t mv)
{
uint8_t pct = power_bat_percent(mv);
uint8_t pct;
app_battery_tick(BAT_UPDATE_MS, mv, s_power.charge.usb_online);
pct = app_battery_get_percent();
if (pct != s_power.sample.pct) {
s_power.sample.pct = pct;
gDevData.battery = pct;
@@ -311,8 +304,9 @@ static void power_battery_update_percent(uint16_t mv)
}
/**
* @brief 电量耗尽判定：连续 BAT_EMPTY_WIN 次采样都 <= EMPTY_MV 才认定，直接请求深睡
* @note 充电中不判定；用连续窗口而非单次采样，避免电机拉压降瞬间跌破误报
* @brief 低电自动关机判定：连续 BAT_EMPTY_WIN 次采样都 <= SHUTDOWN_MV（约 5%）才认定，直接请求深睡
* @note 充电中不判定；用连续窗口而非单次采样，避免电机拉压降瞬间跌破误报。
* 对应“电量低于 5% 自动关机”，与开机时的低电拦截（app_boot）用同一门限。
* @param mv 本次均值电压，单位 mV
* @return 无
*/
@@ -320,20 +314,20 @@ static void power_battery_check_empty(uint16_t mv)
{
AppBatteryAlarm_t *a = &s_power.alarm;
if (s_power.charge.usb_online || mv > BOARD_VBAT_EMPTY_MV) {
a->empty_win = 0;
if (s_power.charge.usb_online || mv > BOARD_VBAT_SHUTDOWN_MV) {
a->empty_win = 0; /* 充电中或电压还够，窗口清零 */
return;
}
if (a->empty_win < 0xFF) {
a->empty_win++;
}
if (a->empty_win < BAT_EMPTY_WIN) {
return;
return; /* 还没连续够次数，可能是电机拉压降的瞬间 */
}
a->low_bat = 1;
gDevData.alm_low_battery = 1;
if (!s_power.req_poweroff) {
log_info("vbat %dmV empty, deep off\n", mv);
log_info("vbat %dmV <=5%%, deep off\n", mv);
app_power_request_poweroff();
}
}
@@ -350,14 +344,13 @@ static void power_battery_check_low(uint16_t mv)
if (mv < BOARD_VBAT_LOW_MV) {
a->exit_win = 0;
if (a->low_bat || a->enter_win >= 0xFF) {
return;
return; /* 已经在低电，或窗口已饱和，不用再加 */
}
a->enter_win++;
if (a->enter_win >= BAT_LOW_WIN) {
a->low_bat = 1;
a->low_ms = 0;
a->low_bat = 1; /* 连续够次数才进低电，只闪灯不关机 */
gDevData.alm_low_battery = 1;
log_info("low battery %dmV %d%%\n", mv, s_power.sample.pct);
log_info("low battery %dmV %d%%, blink only, no auto off\n", mv, s_power.sample.pct);
}
} else if (mv > (BOARD_VBAT_LOW_MV + BOARD_VBAT_LOW_HYST_MV)) {
a->enter_win = 0;
@@ -369,7 +362,6 @@ static void power_battery_check_low(uint16_t mv)
}
if (a->exit_win >= BAT_LOW_WIN) {
a->low_bat = 0;
a->low_ms = 0;
gDevData.alm_low_battery = 0;
log_info("battery recover %dmV %d%%\n", mv, s_power.sample.pct);
}
@@ -380,32 +372,6 @@ static void power_battery_check_low(uint16_t mv)
}
}
/**
* @brief 低电持续满 BOARD_LOWBAT_SLEEP_MS（1 分钟）才请求深睡
* @note 充电中 / 已请求深睡 / 仍在开机保护期内，计时清零不累加
* @param dt 距上次调用的毫秒数
* @return 无
*/
static void power_battery_check_low_timeout(uint16_t dt)
{
AppBatteryAlarm_t *a = &s_power.alarm;
if (s_power.charge.usb_online || s_power.req_poweroff
|| (s_power.sample.boot_ms < BAT_BOOT_MS)) {
a->low_ms = 0;
return;
}
if (!a->low_bat || a->low_ms >= BOARD_LOWBAT_SLEEP_MS) {
return;
}
a->low_ms += dt;
if (a->low_ms >= BOARD_LOWBAT_SLEEP_MS) {
a->low_ms = BOARD_LOWBAT_SLEEP_MS;
log_info("low battery 1min, deep off\n");
app_power_request_poweroff();
}
}
/**
* @brief 每 BAT_LOG_MS 打印一次电量状态，方便离线看日志排查
* @param dt 距上次调用的毫秒数
@@ -424,9 +390,11 @@ static void power_battery_periodic_log(uint16_t dt)
/**
* @brief 电量采样与低电策略，每个业务 tick 调用一次
* @note 电机运转时只记电压、不改百分比/告警，避免电流拉垮 VBAT 误报。
* 电机是否忙由调用方（app_function）决定，本模块不认识电机，
* 这里用「外部传入」而非直接查询，保持单向依赖。
* @note 显示用的百分比（滤波/充放电基准/突变防抖/缓冲平滑）交给 app_battery
* 模块处理；这里的 check_empty/check_low 是另一套基于原始电压的
* 低电告警迟滞，直接判 mv 阈值，跟 app_battery 各管一段、互不干扰。
* check_low（3.7V）只负责红灯闪烁提示，不再有超时自动关机；
* check_empty（约 5%/3.25V）才是真正触发自动关机的判定。
* @param dt 距上次调用的毫秒数
* @return 无
*/
@@ -448,6 +416,5 @@ static void power_battery_tick(uint16_t dt)
}
}
power_battery_check_low_timeout(dt);
power_battery_periodic_log(dt);
}
apps/usr_app/app_power.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从 usr_jb_main 拆出，状态收进 AppPowerCtx_t
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 USB/充电检测、电量采样与深睡请求
*
* @note 本模块只管“电从哪来、还剩多少、要不要关机”，不认识电机/灯/按键。
* 需要在 USB 插拔 / 深睡时联动其它模块的地方，一律走 app_power_set_hooks
apps/usr_app/app_time_util.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布（从 usr_jb_main 拆出）
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 16 位毫秒饱和累加
******************************************************************************/
#ifndef __APP_TIME_UTIL_H__
apps/usr_app/key.c
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植到杰理 BR28
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按键短按/长按/释放状态机
******************************************************************************/
#include "key.h"
apps/usr_app/key.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植到杰理 BR28
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按键短按/长按/释放状态机
******************************************************************************/
#ifndef __KEY_H__
apps/usr_app/key_manager.c
+5 -4
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植到杰理 BR28
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现短按切模式、长按 3s 关机与开机按键锁
******************************************************************************/
#include "system/includes.h"
@@ -54,7 +54,7 @@ static void key_user_release(void)
static void key_user_short(void)
{
if (s_km.boot_key_lock) {
s_km.boot_key_lock = 0;
s_km.boot_key_lock = 0; /* 开机松手当成释放，不当短按切模式 */
log_info("boot key released\n");
return;
}
@@ -68,7 +68,7 @@ static void key_user_short(void)
static void key_user_long(void)
{
if (s_km.boot_key_lock) {
return;
return; /* 开机手还按着，忽略这次 3s 长按，避免一开机就关机 */
}
usr_on_key_long();
}
@@ -109,7 +109,7 @@ void user_key_lock_if_held(void)
{
reset_key_Status(USR_KEY_USER);
if (bsp_key_is_pressed()) {
s_km.boot_key_lock = 1;
s_km.boot_key_lock = 1; /* 开机手还按着，等松开才认短按/长按，避免立刻关机 */
log_info("boot key held, wait release\n");
}
}
@@ -129,6 +129,7 @@ void user_key_scan(uint16_t dt)
if (dt == 0) {
dt = 1;
}
/* 按键库按 1ms 步进，业务节拍是 20ms，这里循环 dt 次对齐真实时间 */
for (i = 0; i < dt; i++) {
keyCheckProcess();
}
apps/usr_app/key_manager.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现短按切模式、长按 3s 关机与开机按键锁
******************************************************************************/
#ifndef __KEY_MANAGER_H__
apps/usr_app/led.c
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植到杰理 BR28
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按通道掩码独立开关的 LED 事件框架
******************************************************************************/
#include "led.h"
apps/usr_app/led.h
+3 -2
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植到杰理 BR28
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按通道掩码独立开关的 LED 事件框架
******************************************************************************/
#ifndef __LED_H__
@@ -51,6 +51,7 @@ typedef enum {
LED_EVENT_MODE, /**< 切模式绿闪两下 */
LED_EVENT_PAIR_OK, /**< 配对成功常绿若干秒 */
LED_EVENT_PAIR_FAIL, /**< 配对失败红绿交替 */
LED_EVENT_OTA, /**< OTA：红绿交替闪，直到升级结束/复位 */
LED_EVENT_MAX
} LED_Event_t;
@@ -61,7 +62,7 @@ typedef enum {
PRIORITY_1 = 0, /**< 待机绿灯 */
PRIORITY_2, /**< 低电红闪 */
PRIORITY_3, /**< 充电红 / 充满绿 */
PRIORITY_4, /**< 配对 / 切模式 / 配对结果 */
PRIORITY_4, /**< 配对 / 切模式 / 配对结果 / OTA */
PRIORITY_MAX
} LED_EventPriority_t;
apps/usr_app/led_manager.c
+28 -4
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植到杰理 BR28
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现红绿独立通道灯事件表
******************************************************************************/
#include "led_manager.h"
@@ -19,6 +19,7 @@ static uint8_t led_pairing_handler(LED_Config_t *led_config);
static uint8_t led_mode_handler(LED_Config_t *led_config);
static uint8_t led_pair_ok_handler(LED_Config_t *led_config);
static uint8_t led_pair_fail_handler(LED_Config_t *led_config);
static uint8_t led_ota_handler(LED_Config_t *led_config);
/**
* @brief 只改掩码里的通道，其它灯保持原样
@@ -44,7 +45,7 @@ static void set_led_multi(uint16_t led, uint8_t state)
static uint8_t led_keep_handler(LED_Config_t *led_config)
{
(void)LED_Update(led_config);
return 0;
return 0; /* 返回 0：不独占，其它通道的事件还能继续跑 */
}
/**
@@ -55,7 +56,7 @@ static uint8_t led_keep_handler(LED_Config_t *led_config)
static uint8_t led_standby_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_STANDBY);
LED_EventDelete(LED_EVENT_STANDBY); /* runNum 到点（限时待机绿）后删事件 */
}
return 0;
}
@@ -79,7 +80,7 @@ static uint8_t led_pairing_handler(LED_Config_t *led_config)
static uint8_t led_mode_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_MODE);
LED_EventDelete(LED_EVENT_MODE); /* 闪完两下后删，绿灯还给待机/配对 */
}
return 0;
}
@@ -112,6 +113,17 @@ static uint8_t led_pair_fail_handler(LED_Config_t *led_config)
return 1;
}
/**
* @brief OTA 红绿交替（无限）：拦住其它灯，升级期间只剩这一种提示
* @param led_config 配置
* @return 1=拦住更低优先级
*/
static uint8_t led_ota_handler(LED_Config_t *led_config)
{
(void)LED_Update(led_config);
return 1;
}
/**
* @brief 注册回调并装载 CBC2 事件表（GPIO 已在 bsp_hw_init）
* @return 无
@@ -208,6 +220,18 @@ void user_led_init(void)
/ (BOARD_LED_ALT_MS * 2u)),
.ledEventHandler = led_pair_fail_handler,
},
[LED_EVENT_OTA] = {
/* OTA：红绿交替一直闪，直到升级结束或 60s 复位 */
.event = LED_EVENT_OTA,
.priority = PRIORITY_4,
.config.ledMask = (uint16_t)(LED_CHANNEL(LED_CH_RED) | LED_CHANNEL(LED_CH_GREEN)),
.config.state = LED_ALTERNATING_BLINK,
.config.alternatingBlinkParams.Group[0] = LED_CHANNEL(LED_CH_RED),
.config.alternatingBlinkParams.Group[1] = LED_CHANNEL(LED_CH_GREEN),
.config.alternatingBlinkParams.Cycle = (uint32_t)(BOARD_LED_ALT_MS * 2u),
.config.runNum = 0, /* 0=无限 */
.ledEventHandler = led_ota_handler,
},
};
LED_SetStateInit(set_led_multi);
apps/usr_app/led_manager.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 从天誉 MJ-1.0 充电板移植
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现红绿独立通道灯事件表
******************************************************************************/
#ifndef __LED_MANAGER_H__
apps/usr_jb_proto/usr_jb_main.c
+29 -7
View File
@@ -10,7 +10,7 @@
* - V1.2.0, 2026.08.24, cyWu, 按键：深睡 3s 开机、5s 开机+配对；开机中 3s 深睡
* - V1.3.0, 2026.08.24, cyWu, DP2：00=空闲，01/02 转，03 停
* - V1.4.0, 2026.08.25, cyWu, 空闲改可休眠定时器，系统才能进 sleep
* - V1.5.0, 2026.08.25, cyWu, LED/按键改充电板事件库，红绿可同时亮
* - V1.5.0, 2026.08.25, cyWu, LED/按键改事件库，红绿可同时亮
* - V2.0.0, 2026.08.25, cyWu, 重构：电源/配对/开机/功能拆成独立模块，
* 本文件只剩初始化顺序、1ms 调度、模块间接线
* - V2.1.0, 2026.08.26, cyWu, 电机运转期间长期占用 1ms 硬件定时器中断，
@@ -24,7 +24,7 @@
* 具体业务逻辑请去对应模块找：
* app_power —— USB/充电/电量/深睡请求
* app_pair —— 配对会话计时
* app_boot —— 开机 3s/5s 按键判定
* app_boot —— 开机 3s/5s/12s 按键判定
* app_function —— DP0/DP1/DP2 与按键动作
* app_led —— 灯效
******************************************************************************/
@@ -179,7 +179,20 @@ static void usr_timer_rearm(UsrTickMode_t mode)
/**
* @brief 业务定时器：固定 USR_TIMER_IDLE_MS 一拍；忙时禁睡，空闲可睡
* @param priv 未使用
* @note 禁止在这里直接 sys_enter_soft_poweroff，一律走 app_power 的深睡钩子
* @note ⚠️ 本函数运行在硬件定时器时基上下文（usr_timer_add 的 SDK 说明：
* "扫描函数将在硬件定时器中时基到时候被调用"），不是普通任务线程。
* priority=1 能禁止休眠正是因为走的这条路——SDK 里能"禁睡"的定时器
* 只有这一种，没有"任务线程 + 禁睡"的组合可选。
* 代价是这里执行的每一行代码都会占用中断时间，跟 BLE 协议栈自己的
* 收发中断抢时序；这次的看门狗复位就是因为这条路径长期以 1kHz
* 触发。现在虽然降到了 20ms 一拍，但仍要守住底线：
* - 禁止阻塞等待（信号量/循环等 ACK 之类）
* - 禁止耗时操作（flash 擦写、大块 memcpy、长循环）
* 按键短按/长按走到的 usr_on_key_short/long、jbSendReqWithAck
* 目前都只是改几个标志位 + 入队发送，没有阻塞，符合这个要求；
* 以后往 user_key_handle / app_function_poll 这条链路上加新功能，
* 必须先确认不违反以上两条，否则会重新引入同一类复位问题。
* 另外，禁止在这里直接 sys_enter_soft_poweroff，一律走 app_power 的深睡钩子
* @return 无
*/
static void usr_timer_tick(void *priv)
@@ -196,7 +209,7 @@ static void usr_timer_tick(void *priv)
if (!app_power_poweroff_pending()) {
user_key_scan(dt);
user_key_handle();
user_key_handle(); /* 长按 3s 会在这里同步触发 app_power_request_poweroff() */
}
pwr_evt = app_power_tick_1ms(dt);
@@ -205,15 +218,20 @@ static void usr_timer_tick(void *priv)
app_function_poll();
app_function_tick_1ms(dt);
if (app_power_poweroff_pending()) {
/* 重新查询而非复用上面的判断：user_key_handle() 可能在本拍内刚请求关机，
* 要用最新状态决定这一拍还要不要播灯效，否则会多播一帧才熄灭。
* OTA 期间灯效优先：关机钩子也不要把红绿交替清掉。 */
if (app_led_is_ota()) {
app_led_run(dt, app_function_is_power_on());
} else if (app_power_poweroff_pending()) {
app_led_clear();
} else {
app_led_run(dt, app_function_is_power_on());
}
want = usr_timer_pick_mode();
want = usr_timer_pick_mode();//判断能不能休眠
if (want != s_sched.mode) {
usr_timer_rearm(want);
usr_timer_rearm(want);//切换业务定时器
}
}
@@ -234,6 +252,10 @@ void usr_jb_init(void)
jbInit();
userInit();
app_led_init();
if (usr_var.usr_goto_updata) {
/* 开机 12s 已进 OTA：灯表刚起来，立刻挂红绿交替 */
app_led_request_ota();
}
app_mode_init();
app_power_init();
apps/usr_periph/board_pin.h
+22 -6
View File
@@ -2,13 +2,16 @@
* @file board_pin.h
* @brief CBC2 门夹弹力绳板级引脚、电平与时序（换板只改本文件）
* @author cyWu <1917507415@qq.com>
* @date 2026.08.24
* @version V1.3.0
* @date 2026.08.26
* @version V1.4.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.24, cyWu, 收口：去掉实验开关与未贴件限位
* - V1.2.0, 2026.08.24, cyWu, 按键：深睡 3s 开机、5s 开机+配对
* - V1.3.0, 2026.08.24, cyWu, 电机改 MCPWM 50% 占空比降速
* - V1.4.0, 2026.08.26, cyWu, 新增 5% 自动关机门限、开机低电闪灯拦截、
* 12s 长按 OTA、自动模式单次最长运行时长；
* 取消低电闪烁 1 分钟后自动关机门限
******************************************************************************/
#ifndef __BOARD_PIN_H__
@@ -52,13 +55,15 @@
/*============================================================================*/
#define BOARD_VBAT_FULL_MV 4200 /**< 100% */
#define BOARD_VBAT_EMPTY_MV 3200 /**< 0%，持续低于此值深睡 */
#define BOARD_VBAT_LOW_MV 3700 /**< 低电预警阈值 */
#define BOARD_VBAT_EMPTY_MV 3200 /**< 0%，电量曲线下限（仅用于百分比换算） */
#define BOARD_VBAT_CHARGE_FULL_MV 4250 /**< 充电基准未记录时 100%（充电内阻压降，比放电阈值高）*/
#define BOARD_VBAT_CHARGE_EMPTY_MV 3350 /**< 充电基准未记录时 0% */
#define BOARD_VBAT_LOW_MV 3700 /**< 低电预警阈值：只闪红灯提示，不关机 */
#define BOARD_VBAT_LOW_HYST_MV 50 /**< 低电恢复回差 */
#define BOARD_VBAT_SHUTDOWN_MV 3250 /**< 约 5%，运行中低于此值自动关机；关机时低于此值拒绝开机 */
#define BOARD_VPWR_ONLINE_MV 4000 /**< VPWR 判定 USB 插入 */
#define BOARD_VPWR_OFF_MV 1500 /**< 低于此值认定已拔出 */
#define BOARD_CHG_FULL_MS 1000 /**< CHG 已高且 VPWR 在，满 1s 认充满 */
#define BOARD_LOWBAT_SLEEP_MS (60u * 1000u) /**< 低电告警满 1 分钟后深睡 */
/*============================================================================*/
/* 按键 / 灯效 */
@@ -67,12 +72,17 @@
#define BOARD_KEY_CLICK_MS 1000 /**< 开机后：按下 <1s 松开为短按切模式 */
#define BOARD_KEY_POWER_MS 3000 /**< 深睡：按住 3s 开机；开机中：按住 3s 深睡 */
#define BOARD_KEY_PAIR_MS 5000 /**< 深睡：按住 5s 开机并进配对（开机中继续按不住配对） */
#define BOARD_KEY_OTA_MS 12000 /**< 深睡：按住 12s 开机并进 OTA */
#define BOARD_KEY_DEBOUNCE_MS 20 /**< 按键消抖 */
#define BOARD_PAIR_TIMEOUT_MS (120u * 1000u) /**< 配对超时 120s，失败后保持开机 */
#define BOARD_BOOT_LOWBAT_BLINK_N 5 /**< 关机时电量过低：拒绝开机前红灯闪烁次数 */
#define BOARD_BOOT_LOWBAT_ON_MS 200 /**< 拒绝开机提示：闪烁亮时间 */
#define BOARD_BOOT_LOWBAT_OFF_MS 200 /**< 拒绝开机提示：闪烁灭时间 */
#define BOARD_LED_FAST_ON_MS 100 /**< 配对绿快闪：亮 */
#define BOARD_LED_FAST_OFF_MS 100 /**< 配对绿快闪：灭 */
#define BOARD_LED_ALT_MS 200 /**< 配对失败红绿交替半周期 */
#define BOARD_LED_ALT_MS 200 /**< 配对失败 / OTA 红绿交替半周期 */
#define BOARD_LED_PAIR_OK_MS 3000 /**< 配对成功绿灯常亮时长 */
#define BOARD_LED_PAIR_FAIL_MS 3000 /**< 配对失败提示时长 */
#define BOARD_LED_LOWBAT_ON_MS 200 /**< 低电红闪：亮 */
@@ -93,4 +103,10 @@
#define BOARD_MOTOR_PWM_DUTY 8000 /**< 占空比 0~10000=0%~100%，80% */
#define BOARD_MOTOR_PWM_IDLE_CLOSE 1 /**< 1=空闲/轻睡关 MCPWM；0=保持开着，方便对比待机电流 */
/*============================================================================*/
/* 自动玩法 */
/*============================================================================*/
#define BOARD_AUTO_MODE_MAX_MS (10u * 60u * 1000u) /**< 自动模式 1~6 单次最长运行时长，到点自动回待机 */
#endif /* __BOARD_PIN_H__ */
apps/usr_periph/usr_rtc.c
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.19
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.19, cyWu, 从模组固件移植至 SOC SDK
* - V1.0.0, 2026.08.19, cyWu, 首次发布，实现板级硬件 RTC 对时与本地日历读取
* - V1.1.0, 2026.08.19, cyWu, 精简公共接口与缓存逻辑
******************************************************************************/
apps/usr_periph/usr_rtc.h
+1 -1
View File
@@ -5,7 +5,7 @@
* @date 2026.08.19
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.19, cyWu, 从模组固件移植至 SOC SDK
* - V1.0.0, 2026.08.19, cyWu, 首次发布，实现板级硬件 RTC 对时与本地日历读取
* - V1.1.0, 2026.08.19, cyWu, 精简接口；usr_rtc_get_time 返回本地日历
******************************************************************************/