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

Compare commits

base: pets-device/JBao_Door_Clamp_FW:81bd2f724d50649aa2f194baeae4090802834cc0
Branches Tags
pets-device/JBao_Door_Clamp_FW:develop
...
compare: pets-device/JBao_Door_Clamp_FW:215e1be6bb2b0c32f2d9e1195e9e429d064fdb22
Branches Tags
pets-device/JBao_Door_Clamp_FW:develop
10 Commits
81bd2f724d ... 215e1be6bb
Author SHA1 Message Date
wuchuyuan 215e1be6bb 1、运行中空电关机改看显示百分比，到 5% 立刻停电机、关绿灯，红灯闪 5 下后再深睡，避免电压先掉、APP 还没到 5% 就关机 
2、充电/放电电量缓冲加快，放电突变拦截先关掉，电量曲线满电点收到 4.12V
3、上电串口打印软硬件版本和编译时间
 2026-08-27 11:40:57 +08:00
wuchuyuan fdb43011b7 1、低电 3.7V 只闪红灯不再 1 分钟后关机；电量低于约 5% 自动关机，未充电开机先闪 5 下红灯再睡回，只能充电后才能开机 
2、自动/手动互相切换都闪 2 下灯；APP 发停止后再发自动模式可正常启动，手动残留停止不再挡住自动
3、自动模式 1~6 单次最长跑 10 分钟后回待机；关机时长按 12 秒进 OTA，OTA 期间红绿交替闪
 2026-08-27 10:20:48 +08:00
wuchuyuanandCursor 3d445ae5c5 1、业务调度统一为 20ms 节拍，取消电机运转时的 1ms 高频定时器，避免配网后 BLE 收发与 1kHz 中断抢时序导致看门狗复位 
2、调度器只保留可休眠/禁休眠两档，换向死区改由阈值检查判定，不再单独切 1ms 精度

Co-authored-by: Cursor <cursoragent@cursor.com>
 2026-08-26 17:16:08 +08:00
wuchuyuan 4ee0f86d13 1、Makefile 与 CodeBlocks 编译单元对齐，补 make pack / BURN_KEY，增加 build.bat 与固件打包脚本 
2、下载脚本同时生成无 Key / 带 Key 镜像，USB 默认烧无 Key，build.bat key 烧带 Key
3、配对超时从 60s 改为 120s
4、增加需求文档
 2026-08-26 17:06:28 +08:00
wuchuyuan 93c1943992 1、充电时不再叠待机绿灯；意外复位不再跳过 3s 开机按键判定 
2、电机停转去掉反接刹车改自由滑行，避免电流冲击触发 LVD 复位；
3、关机直接 power_set_soft_poweroff，跳过耳机 SDK 优雅关机流程，按键关机从十几秒压到瞬间掉电
 2026-08-25 20:05:59 +08:00
wuchuyuan 5e5f921a3a 添加音频智能语音功能配置，不添加待机功耗降不下去，现在LED亮着待机功耗有500多uA，LED灭着待机功耗有280uA，关机功耗8uA 2026-08-25 18:50:28 +08:00
wuchuyuan 5252471aca 优化程序架构 2026-08-25 14:59:39 +08:00
wuchuyuan d5ec6ecde0 功耗减低到900uA,还有优化空间，还要陈杰明那边支持一下 2026-08-25 11:16:54 +08:00
wuchuyuan e0f5da6f39 把静态库换成源码方便调试 2026-08-25 10:20:14 +08:00
wuchuyuan 0e6a93c12d 基本功能已完成，还差功耗和架构优化 2026-08-24 18:03:39 +08:00
66 changed files with 14894 additions and 282 deletions
Expand all files Collapse all files
AC701N.cbp
+69 -1
View File
@@ -177,6 +177,7 @@
<Add directory="apps/usr_jb_proto/Protocol" />
<Add directory="apps/usr_jb_proto/Utils" />
<Add directory="apps/usr_periph" />
<Add directory="apps/usr_app" />
</Compiler>
<Linker>
<Add option="-flto" />
@@ -258,7 +259,6 @@
<Add option="cpu/br28/liba/libllns.a" />
<Add option="cpu/br28/liba/libkwscommon.a" />
<Add option="apps/common/third_party_profile/tuya_protocol/sdk/lib/libtuya_lib.a" />
<Add option="apps/usr_le_code/lib/libusr_le_code.a" />
<Add option="cpu/br28/liba/lib_icsd_adt.a" />
<Add option="cpu/br28/liba/lib_diafx.a" />
<Add option="cpu/br28/liba/libFFT_pi32v2_OnChip.a" />
@@ -783,13 +783,81 @@
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_periph/usr_rtc.h" />
<Unit filename="apps/usr_periph/board_pin.h" />
<Unit filename="apps/usr_periph/bsp_hw.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_periph/bsp_hw.h" />
<Unit filename="apps/usr_app/app_led.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/app_led.h" />
<Unit filename="apps/usr_app/led.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/led.h" />
<Unit filename="apps/usr_app/led_manager.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/led_manager.h" />
<Unit filename="apps/usr_app/key.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/key.h" />
<Unit filename="apps/usr_app/key_manager.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/key_manager.h" />
<Unit filename="apps/usr_app/app_mode.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/app_mode.h" />
<Unit filename="apps/usr_app/app_power.c">
<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>
<Unit filename="apps/usr_app/app_pair.h" />
<Unit filename="apps/usr_app/app_boot.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/app_boot.h" />
<Unit filename="apps/usr_app/app_function.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_app/app_function.h" />
<Unit filename="apps/usr_app/app_time_util.h" />
<Unit filename="apps/usr_le_code/ble_proto.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_le_code/ble_proto.h" />
<Unit filename="apps/usr_le_code/bleproto.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_le_code/bleproto.h" />
<Unit filename="apps/usr_le_code/bleproto_api.h" />
<Unit filename="apps/usr_le_code/bleproto_packer.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_le_code/bleproto_packer.h" />
<Unit filename="apps/usr_le_code/thirdpart/mjson/mjson.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_le_code/thirdpart/mjson/mjson.h" />
<Unit filename="apps/usr_le_code/usr_le_adv.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="apps/usr_le_code/usr_le_api.h" />
<Unit filename="apps/usr_le_code/usr_le_product.h" />
<Unit filename="apps/usr_le_code/usr_le_recieve.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="cpu/br28/adc_api.c">
<Option compilerVar="CC" />
</Unit>
Makefile
+54 -204
View File
@@ -1,8 +1,14 @@
# make 编译并下载
# make 编译并下载，成功后自动打包到 release/
# make pack 仅打包（需已编译生成 jl_isd.fw）
# make VERBOSE=1 显示编译详细过程
# make clean 清除编译临时文件
#
# USB 烧录（两套镜像都会生成，只烧其中一套）：
# .\build.bat 或 .\build.bat nokey -> 烧不带 Key
# .\build.bat key -> 烧带 Key
# make BURN_KEY=1 与 build.bat key 相同
#
# 注意： Linux 下编译方式：
# 1. 从 http://pkgman.jieliapp.com/doc/all 处找到下载链接
# 2. 下载后，解压到 /opt/jieli 目录下，保证
@@ -31,6 +37,11 @@ export PATH:=$(TOOL_DIR);$(PATH)
FIXBAT := tools\utils\fixbat.exe # 用于处理 utf8->gbk 编码问题
POST_SCRIPT := cpu/br28/tools/download.bat
RUN_POST_SCRIPT := cpu\br28\tools\download.bat
PACK_SCRIPT := powershell -NoProfile -ExecutionPolicy Bypass -File tools\pack_firmware.ps1
# USB: 1/key/yes = flash keyed image; default = nokey
ifneq ($(filter 1 key yes,$(BURN_KEY)),)
export JL_BURN_KEY := 1
endif
else
# Linux 下工具链位置
TOOL_DIR := /opt/jieli/pi32v2/bin
@@ -53,6 +64,7 @@ export PATH:=$(TOOL_DIR):$(PATH)
FIXBAT := touch # Linux下不需要处理 bat 编码问题
POST_SCRIPT := cpu/br28/tools/download.sh
RUN_POST_SCRIPT := bash $(POST_SCRIPT)
PACK_SCRIPT :=
endif
CC := $(TOOL_DIR)/$(CC)
@@ -251,6 +263,7 @@ INCLUDES := \
-Iapps/usr_jb_proto/Protocol \
-Iapps/usr_jb_proto/Utils \
-Iapps/usr_periph \
-Iapps/usr_app \
-I$(SYS_INC_DIR) \
@@ -265,17 +278,9 @@ c_SRC_FILES := \
apps/common/audio/audio_utils.c \
apps/common/audio/decode/audio_key_tone.c \
apps/common/audio/decode/decode.c \
apps/common/audio/demo/audio_demo.c \
apps/common/audio/online_debug/aud_data_export.c \
apps/common/audio/online_debug/aud_mic_dut.c \
apps/common/audio/online_debug/aud_spatial_effect_dut.c \
apps/common/audio/online_debug/audio_online_debug.c \
apps/common/audio/sine_make.c \
apps/common/audio/uartPcmSender.c \
apps/common/audio/wm8978/iic.c \
apps/common/audio/wm8978/wm8978.c \
apps/common/bt_common/bt_test_api.c \
apps/common/cJSON/cJSON.c \
apps/common/config/app_config.c \
apps/common/config/bt_profile_config.c \
apps/common/config/ci_transport_uart.c \
@@ -285,35 +290,6 @@ c_SRC_FILES := \
apps/common/dev_manager/dev_manager.c \
apps/common/dev_manager/dev_reg.c \
apps/common/dev_manager/dev_update.c \
apps/common/device/gSensor/SC7A20.c \
apps/common/device/gSensor/STK8321.c \
apps/common/device/gSensor/da230.c \
apps/common/device/gSensor/gSensor_manage.c \
apps/common/device/gSensor/mpu6050.c \
apps/common/device/gx8002_npu/gx8002_enc/gx8002_enc.c \
apps/common/device/gx8002_npu/gx8002_npu.c \
apps/common/device/gx8002_npu/gx8002_npu_event_deal.c \
apps/common/device/gx8002_npu/gx8002_upgrade/app_upgrade/gx_uart_upgrade_app.c \
apps/common/device/gx8002_npu/gx8002_upgrade/app_upgrade/gx_uart_upgrade_tws.c \
apps/common/device/gx8002_npu/gx8002_upgrade/gx_uart_upgrade.c \
apps/common/device/gx8002_npu/gx8002_upgrade/gx_uart_upgrade_porting.c \
apps/common/device/gx8002_npu/gx8002_upgrade/sdfile_upgrade/gx_uart_upgrade_sdfile.c \
apps/common/device/gx8002_npu/gx8002_upgrade/spp_upgrade/gx_fifo.c \
apps/common/device/gx8002_npu/gx8002_upgrade/spp_upgrade/gx_uart_upgrade_spp.c \
apps/common/device/imu_sensor/icm_42670p/icm_42670p.c \
apps/common/device/imu_sensor/icm_42670p/inv_imu_apex.c \
apps/common/device/imu_sensor/icm_42670p/inv_imu_driver.c \
apps/common/device/imu_sensor/icm_42670p/inv_imu_transport.c \
apps/common/device/imu_sensor/imuSensor_manage.c \
apps/common/device/imu_sensor/lsm6dsl/lsm6dsl.c \
apps/common/device/imu_sensor/mpu6887/mpu6887p.c \
apps/common/device/imu_sensor/mpu9250/mpu9250.c \
apps/common/device/imu_sensor/qmi8658/qmi8658c.c \
apps/common/device/imu_sensor/sh3001/sh3001.c \
apps/common/device/in_ear_detect/in_ear_detect.c \
apps/common/device/in_ear_detect/in_ear_manage.c \
apps/common/device/ir_sensor/ir_manage.c \
apps/common/device/ir_sensor/jsa1221.c \
apps/common/device/key/adkey.c \
apps/common/device/key/adkey_rtcvdd.c \
apps/common/device/key/ctmu_touch_key.c \
@@ -323,7 +299,6 @@ c_SRC_FILES := \
apps/common/device/key/touch_key.c \
apps/common/device/key/uart_key.c \
apps/common/device/norflash/norflash_sfc.c \
apps/common/device/ntc/ntc_det.c \
apps/common/device/usb/device/cdc.c \
apps/common/device/usb/device/descriptor.c \
apps/common/device/usb/device/hid.c \
@@ -345,43 +320,11 @@ c_SRC_FILES := \
apps/common/device/usb/host/usb_storage.c \
apps/common/device/usb/usb_config.c \
apps/common/device/usb/usb_host_config.c \
apps/common/ezxml/ezxml.c \
apps/common/ezxml/ezxml_example.c \
apps/common/fat_nor/cfg_private.c \
apps/common/fat_nor/virfat_flash.c \
apps/common/file_operate/file_bs_deal.c \
apps/common/file_operate/file_manager.c \
apps/common/icsd/adt/icsd_adt.c \
apps/common/icsd/adt/icsd_adt_app.c \
apps/common/icsd/anc/icsd_anc_app.c \
apps/common/icsd/anc/icsd_anc_board.c \
apps/common/icsd/anc/icsd_anc_data.c \
apps/common/jl_kws/jl_kws_algo.c \
apps/common/jl_kws/jl_kws_audio.c \
apps/common/jl_kws/jl_kws_event.c \
apps/common/jl_kws/jl_kws_main.c \
apps/common/music/breakpoint.c \
apps/common/music/music_decrypt.c \
apps/common/music/music_id3.c \
apps/common/music/music_player.c \
apps/common/temp_trim/dtemp_pll_trim.c \
apps/common/test/fs_test.c \
apps/common/test/os_test.c \
apps/common/third_party_profile/Tecent_LL/tecent_ll_demo/ll_demo.c \
apps/common/third_party_profile/Tecent_LL/tecent_ll_demo/ll_task.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_import.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_llsync_data.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_llsync_device.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_llsync_event.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_llsync_ota.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_service.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_template.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_utils_base64.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_utils_crc.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_utils_hmac.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_utils_log.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_utils_md5.c \
apps/common/third_party_profile/Tecent_LL/tecent_protocol/ble_qiot_utils_sha1.c \
apps/common/third_party_profile/common/3th_profile_api.c \
apps/common/third_party_profile/common/custom_cfg.c \
apps/common/third_party_profile/common/mic_rec.c \
@@ -398,7 +341,6 @@ c_SRC_FILES := \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_anc_voice_key.c \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_bt_name_setting.c \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_eq_setting.c \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_hearing_aid_setting.c \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_high_low_vol_setting.c \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_key_setting.c \
apps/common/third_party_profile/jieli/JL_rcsp/adv_app_setting/adv_led_setting.c \
@@ -415,85 +357,26 @@ c_SRC_FILES := \
apps/common/third_party_profile/jieli/JL_rcsp/rcsp_updata/rcsp_adv_user_update.c \
apps/common/third_party_profile/jieli/JL_rcsp/rcsp_updata/rcsp_ch_loader_download.c \
apps/common/third_party_profile/jieli/JL_rcsp/rcsp_updata/rcsp_user_update.c \
apps/common/third_party_profile/jieli/le_hogp.c \
apps/common/third_party_profile/jieli/online_db/online_db_deal.c \
apps/common/third_party_profile/jieli/online_db/spp_online_db.c \
apps/common/third_party_profile/jieli/trans_data_demo/le_trans_data.c \
apps/common/third_party_profile/jieli/trans_data_demo/spp_trans_data.c \
apps/common/third_party_profile/jieli/wireless_mic/le_wireless_mic_client.c \
apps/common/third_party_profile/jieli/wireless_mic/le_wireless_mic_server.c \
apps/common/third_party_profile/tuya_protocol/app/demo/tuya_ble_app_demo.c \
apps/common/third_party_profile/tuya_protocol/app/demo/tuya_ota.c \
apps/common/third_party_profile/tuya_protocol/app/product_test/tuya_ble_app_production_test.c \
apps/common/third_party_profile/tuya_protocol/app/uart_common/tuya_ble_app_uart_common_handler.c \
apps/common/third_party_profile/tuya_protocol/extern_components/mbedtls/aes.c \
apps/common/third_party_profile/tuya_protocol/extern_components/mbedtls/ccm.c \
apps/common/third_party_profile/tuya_protocol/extern_components/mbedtls/hmac.c \
apps/common/third_party_profile/tuya_protocol/extern_components/mbedtls/md5.c \
apps/common/third_party_profile/tuya_protocol/extern_components/mbedtls/sha1.c \
apps/common/third_party_profile/tuya_protocol/extern_components/mbedtls/sha256.c \
apps/common/third_party_profile/tuya_protocol/port/tuya_ble_port.c \
apps/common/third_party_profile/tuya_protocol/port/tuya_ble_port_JL.c \
apps/common/third_party_profile/tuya_protocol/port/tuya_ble_port_peripheral.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_api.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_bulk_data.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_data_handler.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_event.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_event_handler.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_event_handler_weak.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_feature_weather.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_gatt_send_queue.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_heap.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_main.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_mem.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_mutli_tsf_protocol.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_queue.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_storage.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_unix_time.c \
apps/common/third_party_profile/tuya_protocol/sdk/src/tuya_ble_utils.c \
apps/common/ui/lcd_simple/lcd_simple_api.c \
apps/common/ui/lcd_simple/ui.c \
apps/common/ui/lcd_simple/ui_mainmenu.c \
apps/common/update/testbox_update.c \
apps/common/update/update.c \
apps/common/update/update_tws.c \
apps/common/update/update_tws_new.c \
apps/earphone/aec/br28/audio_aec.c \
apps/earphone/aec/br28/audio_aec_demo.c \
apps/earphone/aec/br28/audio_aec_dms.c \
apps/earphone/aec/br28/audio_aec_online.c \
apps/earphone/aec/br28/audio_cvp_3mic.c \
apps/earphone/aec/br28/audio_cvp_ais_3mic.c \
apps/earphone/app_ancbox.c \
apps/earphone/app_anctool.c \
apps/earphone/app_main.c \
apps/earphone/app_protocol_deal.c \
apps/earphone/app_task_switch.c \
apps/earphone/app_testbox.c \
apps/earphone/audio_enc_mpt_cvp_ctr.c \
apps/earphone/audio_enc_mpt_self.c \
apps/earphone/ble_adv.c \
apps/earphone/board/br28/board_jl7016g_hybrid.c \
apps/earphone/board/br28/board_jl7018f_demo.c \
apps/earphone/board/br28/board_jl701n_anc.c \
apps/earphone/board/br28/board_jl701n_btemitter.c \
apps/earphone/board/br28/board_jl701n_demo.c \
apps/earphone/bt_auto_test.c \
apps/earphone/bt_background.c \
apps/earphone/bt_ble.c \
apps/earphone/bt_ble_hid.c \
apps/earphone/bt_emitter.c \
apps/earphone/bt_tws.c \
apps/earphone/default_event_handler.c \
apps/earphone/dual_update_demo.c \
apps/earphone/earphone.c \
apps/earphone/eartch_event_deal.c \
apps/earphone/font/fontinit.c \
apps/earphone/idle.c \
apps/earphone/key_event_deal.c \
apps/earphone/kws_voice_event_deal.c \
apps/earphone/linein/linein.c \
apps/earphone/ll_sync_demo/ll_sync_demo.c \
apps/earphone/log_config/app_config.c \
apps/earphone/log_config/lib_btctrler_config.c \
apps/earphone/log_config/lib_btstack_config.c \
@@ -501,53 +384,45 @@ c_SRC_FILES := \
apps/earphone/log_config/lib_media_config.c \
apps/earphone/log_config/lib_system_config.c \
apps/earphone/log_config/lib_update_config.c \
apps/earphone/music/sd_music.c \
apps/earphone/pbg_demo.c \
apps/earphone/pc/pc.c \
apps/earphone/power_manage/app_charge.c \
apps/earphone/power_manage/app_chargestore.c \
apps/earphone/power_manage/app_power_manage.c \
apps/earphone/power_manage/app_umidigi_chargestore.c \
apps/earphone/rcsp/jl_phone_app.c \
apps/earphone/rcsp/rcsp_adv.c \
apps/earphone/tone_table.c \
apps/earphone/trans_data_demo/trans_data_demo.c \
apps/earphone/tuya/tuya_app.c \
apps/earphone/tuya/tuya_demo.c \
apps/earphone/ui/lcd_simple/my_demo.c \
apps/earphone/ui_manage.c \
apps/earphone/user_cfg.c \
apps/earphone/version.c \
apps/earphone/vol_sync.c \
apps/earphone/wireless_mic/app_main_wireless_mic.c \
apps/earphone/wireless_mic/audio/adapter_adc.c \
apps/earphone/wireless_mic/audio/adapter_media.c \
apps/earphone/wireless_mic/audio/wireless/adapter_wireless_dec.c \
apps/earphone/wireless_mic/audio/wireless/adapter_wireless_enc.c \
apps/earphone/wireless_mic/bt/bt_edr_fun.c \
apps/earphone/wireless_mic/bt/bt_status_event.c \
apps/earphone/wireless_mic/idev/adapter_idev.c \
apps/earphone/wireless_mic/idev/idev_bt/adapter_idev_bt.c \
apps/earphone/wireless_mic/idev/idev_bt/idev_ble/adapter_idev_ble.c \
apps/earphone/wireless_mic/idev/idev_mic/adapter_idev_mic.c \
apps/earphone/wireless_mic/odev/adapter_odev.c \
apps/earphone/wireless_mic/odev/odev_bt/adapter_odev_bt.c \
apps/earphone/wireless_mic/odev/odev_bt/odev_ble/adapter_odev_ble.c \
apps/earphone/wireless_mic/odev/odev_bt/odev_ble/odev_ble_wireless.c \
apps/earphone/wireless_mic/odev/odev_bt/odev_edr/adapter_odev_edr.c \
apps/earphone/wireless_mic/odev/odev_dac/adapter_odev_dac.c \
apps/earphone/wireless_mic/process/adapter_process.c \
apps/usr_jb_proto/Protocol/jb_product.c \
apps/usr_jb_proto/Protocol/jb_protocol.c \
apps/usr_jb_proto/Utils/jb_common.c \
apps/usr_jb_proto/Utils/jb_ringbuffer.c \
apps/usr_jb_proto/usr_jb_main.c \
apps/usr_periph/usr_rtc.c \
apps/usr_periph/bsp_hw.c \
apps/usr_app/app_led.c \
apps/usr_app/led.c \
apps/usr_app/led_manager.c \
apps/usr_app/key.c \
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_le_code/ble_proto.c \
apps/usr_le_code/bleproto.c \
apps/usr_le_code/bleproto_packer.c \
apps/usr_le_code/thirdpart/mjson/mjson.c \
apps/usr_le_code/usr_le_adv.c \
apps/usr_le_code/usr_le_recieve.c \
cpu/br28/adc_api.c \
cpu/br28/aec_tool.c \
cpu/br28/app_audio.c \
cpu/br28/audio_anc.c \
cpu/br28/audio_anc_fade_ctr.c \
cpu/br28/audio_anc_mult_scene.c \
cpu/br28/audio_capture.c \
cpu/br28/audio_codec_clock.c \
cpu/br28/audio_common/audio_mic_codec.c \
cpu/br28/audio_cvp_dut.c \
cpu/br28/audio_cvp_sync.c \
cpu/br28/audio_dec.c \
cpu/br28/audio_dec/audio_dec_file.c \
cpu/br28/audio_dec/audio_dec_iis.c \
@@ -555,17 +430,8 @@ c_SRC_FILES := \
cpu/br28/audio_dec/audio_dec_pcm.c \
cpu/br28/audio_dec/audio_usb_mic.c \
cpu/br28/audio_dec_eff.c \
cpu/br28/audio_demo/audio_adc_demo.c \
cpu/br28/audio_demo/audio_dac_demo.c \
cpu/br28/audio_demo/audio_fft_demo.c \
cpu/br28/audio_demo/audio_matrix_demo.c \
cpu/br28/audio_demo/audio_wind_detect_demo.c \
cpu/br28/audio_effect_develop.c \
cpu/br28/audio_enc.c \
cpu/br28/audio_general.c \
cpu/br28/audio_hearing/audio_hearing_aid.c \
cpu/br28/audio_hearing/audio_hearing_aid_lp.c \
cpu/br28/audio_hearing/audio_sidetone.c \
cpu/br28/audio_link.c \
cpu/br28/audio_sync.c \
cpu/br28/charge.c \
@@ -573,7 +439,6 @@ c_SRC_FILES := \
cpu/br28/clock_manager.c \
cpu/br28/eq_config.c \
cpu/br28/hw_fft.c \
cpu/br28/icsd_anc_user.c \
cpu/br28/iic_hw.c \
cpu/br28/iic_soft.c \
cpu/br28/irflt.c \
@@ -594,37 +459,12 @@ c_SRC_FILES := \
cpu/br28/pwm_led.c \
cpu/br28/rdec.c \
cpu/br28/setup.c \
cpu/br28/smart_voice/aispeech_asr.c \
cpu/br28/smart_voice/jl_kws_platform.c \
cpu/br28/smart_voice/kws_event.c \
cpu/br28/smart_voice/nn_vad.c \
cpu/br28/smart_voice/smart_voice_config.c \
cpu/br28/smart_voice/smart_voice_core.c \
cpu/br28/smart_voice/user_asr.c \
cpu/br28/smart_voice/vad_clock_trim.c \
cpu/br28/smart_voice/vad_mic.c \
cpu/br28/smart_voice/voice_mic_data.c \
cpu/br28/sound_device.c \
cpu/br28/spatial_effect/spatial_effect.c \
cpu/br28/spatial_effect/spatial_effect_imu.c \
cpu/br28/spatial_effect/spatial_effect_test.c \
cpu/br28/spatial_effect/spatial_effect_tws.c \
cpu/br28/spatial_effect/spatial_imu_trim.c \
cpu/br28/spi.c \
cpu/br28/tone_player.c \
cpu/br28/tws_audio.c \
cpu/br28/uart_dev.c \
cpu/br28/umidigi_chargestore.c \
apps/usr_jb_proto/Protocol/jb_product.c \
apps/usr_jb_proto/Protocol/jb_protocol.c \
apps/usr_jb_proto/Utils/jb_common.c \
apps/usr_jb_proto/Utils/jb_ringbuffer.c \
apps/usr_jb_proto/usr_jb_main.c \
apps/usr_periph/usr_rtc.c \
# usr_le_code 预编译静态库（Release 不附带协议源码，禁止本地重建）
USR_LE_LIB := apps/usr_le_code/lib/libusr_le_code.a
cpu/br28/uart_test.c
@@ -729,7 +569,6 @@ LFLAGS := \
cpu/br28/liba/libllns.a \
cpu/br28/liba/libkwscommon.a \
apps/common/third_party_profile/tuya_protocol/sdk/lib/libtuya_lib.a \
apps/usr_le_code/lib/libusr_le_code.a \
cpu/br28/liba/lib_icsd_adt.a \
cpu/br28/liba/lib_diafx.a \
cpu/br28/liba/libFFT_pi32v2_OnChip.a \
@@ -788,16 +627,27 @@ LINK_AT ?= 1
# 表示下面的不是一个文件的名字，无论是否存在 all, clean, pre_build 这样的文件
# 还是要执行命令
# see: https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html
.PHONY: all clean pre_build
.PHONY: all clean pre_build pack
# 不要使用 make 预设置的规则
# see: https://www.gnu.org/software/make/manual/html_node/Suffix-Rules.html
.SUFFIXES:
all: pre_build $(USR_LE_LIB) $(OUT_ELF)
all: pre_build $(OUT_ELF)
$(info +POST-BUILD)
$(QUITE) $(RUN_POST_SCRIPT) sdk
ifneq ($(PACK_SCRIPT),)
$(info +PACK-FIRMWARE)
$(QUITE) $(PACK_SCRIPT)
endif
pack:
$(info +PACK-FIRMWARE)
ifneq ($(PACK_SCRIPT),)
$(QUITE) $(PACK_SCRIPT)
else
$(error pack script is Windows-only)
endif
pre_build:
$(info +PRE-BUILD)
@@ -814,13 +664,13 @@ clean:
ifeq ($(LINK_AT), 1)
$(OUT_ELF): $(OBJS) $(USR_LE_LIB)
$(OUT_ELF): $(OBJS)
$(info +LINK $@)
$(shell $(MKDIR) $(@D))
$(file >$(OBJ_FILE), $(OBJS))
$(QUITE) $(LD) -o $(OUT_ELF) @$(OBJ_FILE) $(LFLAGS) $(LIBPATHS) $(LIBS)
else
$(OUT_ELF): $(OBJS) $(USR_LE_LIB)
$(OUT_ELF): $(OBJS)
$(info +LINK $@)
$(shell $(MKDIR) $(@D))
$(QUITE) $(LD) -o $(OUT_ELF) $(OBJS) $(LFLAGS) $(LIBPATHS) $(LIBS)
apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c
+1 -1
View File
@@ -57,7 +57,7 @@
#include "chgbox_box.h"
#endif
/* usr_le_code 库钩子：由静态库导出，供 RCSP BLE 栈回调，非应用层公开 API */
/* usr_le_code 钩子：由 usr_le_code 导出，供 RCSP BLE 栈回调，非应用层公开 API */
extern void usr_le_data_recieve(u8* data,u16 len);
extern void usr_ble_adv_init();
#if 1
apps/earphone/app_main.c
+3 -7
View File
@@ -156,7 +156,6 @@ extern void uart_dev_test_main();
extern int ana_demo();
extern void uart_dev_main_init();
extern void usr_check_mcu_all_sta();
extern void usr_clear_pair_info_noreset(void);
extern void usr_disable_intterupt();
extern void usr_disable_charge_intterupt();
u8 power_reset_flag=0;
@@ -327,13 +326,10 @@ void app_main()
}
/*
* 上电强制进入配对模式：
* 1) usr_goto_pair=1：后续 usr_ble_adv_init() 走绑定广播(encode4bind)，不走重连广播
* 2) usr_clear_pair_info_noreset()：清 VM 中三元组，保证 paired_flag=0
* 注意：须在 BLE 协议栈调用 usr_ble_adv_init() 之前设置；此处不清复位，避免上电死循环复位
* 配对只在 usr_jb_init() 里、BLE 起来之前处理：
* 深睡长按 5s → usr_goto_pair=1 + 清绑定；长按 3s 仅开机。
* 此处不要再强制配对，也不要在协议栈起来后调用 usr_goto_pair_mode()。
*/
usr_var.usr_goto_pair = 1;
usr_clear_pair_info_noreset();
ui_manage_init();
ui_update_status(STATUS_POWERON);
apps/earphone/board/br28/board_jl701n_demo.c
+2
View File
@@ -24,6 +24,7 @@
#endif
#include "norflash_sfc.h"
#include "asm/power/power_port.h"
#include "bsp_hw.h"
//#include "app_umidigi_chargestore.h"
#if TCFG_AUDIO_ANC_ENABLE
#include "audio_anc.h"
@@ -1022,6 +1023,7 @@ void sleep_enter_callback(u8 step)
{
/* 此函数禁止添加打印 */
if (step == 1) {
bsp_hw_sleep_pwm_off();
putchar('<');
} else {
gpio_set_pull_up(TCFG_CHARGESTORE_PORT, 0);
apps/earphone/board/br28/board_jl701n_demo_cfg.h
+15
View File
@@ -690,6 +690,21 @@ DAC硬件上的连接方式,可选的配置：
#endif
#endif
//*********************************************************************************//
// Audio Smart Voice （必须，不然功耗会增加） //
//*********************************************************************************//
#define TCFG_SMART_VOICE_ENABLE DISABLE_THIS_MOUDLE //ENABLE_THIS_MOUDLE
#define TCFG_KWS_VOICE_EVENT_HANDLE_ENABLE TCFG_SMART_VOICE_ENABLE //语音事件处理流程开关
#if TCFG_SMART_VOICE_ENABLE
#define TCFG_VAD_LOWPOWER_CLOCK VAD_CLOCK_USE_PMU_STD12M
#else
#define TCFG_VAD_LOWPOWER_CLOCK VAD_CLOCK_USE_LRC
#endif/*TCFG_AUDIO_SMART_VOICE_ENABLE*/
#if TCFG_KWS_VOICE_RECOGNITION_ENABLE
#define TCFG_CALL_KWS_SWITCH_ENABLE DISABLE_THIS_MOUDLE
#else
#define TCFG_CALL_KWS_SWITCH_ENABLE TCFG_SMART_VOICE_ENABLE
#endif
//*********************************************************************************//
// 充电参数配置 //
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 40000u /**< 充电缓冲：40 秒走 1% */
#define BAT_DISCHARGE_BUFFER_MS 10000u /**< 放电缓冲：10 秒走 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）不受本模块影响：
* 本模块负责显示电量怎么变得好看；低电红灯仍按原始电压判断，
* 5% 自动关机则读本模块给出的显示百分比。
******************************************************************************/
#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
+212
View File
@@ -0,0 +1,212 @@
/******************************************************************************
* @file app_boot.c
* @brief 深睡唤醒 / 上电按键判定实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.26
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现深睡唤醒按键判定（3s 开机 / 5s 配对）
* - V1.1.0, 2026.08.26, cyWu, 新增 12s 长按进 OTA、开机前低电量拦截
******************************************************************************/
#include "app_boot.h"
#include "app_pair.h"
#include "bsp_hw.h"
#include "board_pin.h"
#include "app_main.h"
#include "usr_le_api.h"
#include "asm/power/power_api.h"
#include "asm/power/power_reset.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP_BOOT]"
#define LOG_INFO_ENABLE
#include "debug.h"
extern void clr_wdt(void);
extern u32 timer_get_ms(void);
/**
* @brief 忙等若干毫秒，并喂狗
* @param ms 等待时长
* @return 无
*/
static void boot_delay_ms(uint32_t ms)
{
uint32_t t0 = timer_get_ms();
while ((timer_get_ms() - t0) < ms) {
clr_wdt();
}
}
/**
* @brief BLE 起来前进深睡（1ms 定时器尚未启动），原地喂狗不返回
* @note power_set_soft_poweroff() 只是向 SDK 底层发起软关机请求（置个标志位），
* 不是同步断电——仓库里其它调用点（如 app_power_manage.c）调用完都是
* 正常往下走/return，真正切电源是底层电源管理在之后某个时机才执行的。
* 此时 BLE 栈、1ms 业务定时器都还没起来，如果这里直接 return，代码会
* 接着把 usr_jb_init 剩下的初始化和开机流程跑完，等于白判定了。所以
* 必须用 while(1) 卡住不返回：一边喂狗防止看门狗把这个等待打断，
* 一边等底层真正把电断掉（或者外部条件变化触发复位）。
* @return 无（不会返回）
*/
static void boot_sleep(void)
{
log_info("boot sleep\n");
bsp_hw_enter_sleep_io();
power_set_soft_poweroff();
while (1) {
clr_wdt();
}
}
/**
* @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 判定；
* USB 在位、或者芯片自己意外重启的情况，都应该直接保持开机，
* 否则用户会遇到“设备莫名关机、还要求重新按 3 秒才能开机”的怪现象。
* @return 1=USB / 软复位 / LVD / 看门狗，保持开机且不进配对；0=需要走按键判定
*/
static uint8_t boot_skip_key_wait(void)
{
uint8_t i;
/* USB 在位（充电口有电）：说明是插着电源，不是用户凭空按键开机 */
for (i = 0; i < 10; i++) {
if (bsp_chg_is_low() || bsp_vpwr_is_online()) {
log_info("boot usb, skip key wait\n");
return 1;
}
boot_delay_ms(5);
}
// /* 以下都是“芯片自己意外重启了一下”，不是用户主动按开机键，
// * 不能因此逼用户重新按键，否则相当于设备无故“关机”了一次 */
// if (cpu_reset_by_soft() /* SDK 综合判断：是否软件复位 */
// || is_reset_source(MSYS_SOFT_RST) /* 主系统软件复位（断言/异常/OTA 后重启等） */
// || is_reset_source(P33_SOFT_RST) /* P33 软件复位，最常见的软复位入口 */
// || is_reset_source(P33_VDDIO_LVD_RST) /* VDDIO 低压复位（电机启动拉低电压误触发） */
// || is_reset_source(P11_WDT_RST)) { /* 看门狗复位（程序卡死被强制重启） */
// log_info("boot reset-keep, skip key wait\n");
// return 1;
// }
return 0;
}
/**
* @brief 等待并判定开机按键
* @note 配对（5s）不再一到点就立即提交：需要继续按住观察是否会按到 12s
* 触发 OTA，真正的配对提交放在松手那一刻做，行为上仍是“按满 5s
* 再松手即进配对”，只是多给了继续按到 12s 改道 OTA 的机会。
* @return 无（深睡分支不返回）
*/
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;
}
if (!bsp_key_is_pressed()) {
log_info("boot no key, sleep\n");
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 / 12s ota\n");
while (bsp_key_is_pressed()) {
elapsed = timer_get_ms() - t0;
clr_wdt();
/* 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);
log_info("boot hold 3s, will power on\n");
}
}
elapsed = timer_get_ms() - t0;
if (elapsed < BOARD_KEY_POWER_MS) {
log_info("boot hold %ums < 3s, sleep\n", (unsigned)elapsed);
boot_sleep();
}
/* 松手时已过 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
+32
View File
@@ -0,0 +1,32 @@
/******************************************************************************
* @file app_boot.h
* @brief 深睡唤醒 / 上电按键判定：3s 开机，5s 配对，12s OTA，不足 3s 松手再睡；
* 开机前电量低于约 5% 且未充电时拒绝开机
* @author cyWu <1917507415@qq.com>
* @date 2026.08.26
* @version V1.1.0
* @history
* - 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 直接量时间，
* 不能借用按键库的 1ms 状态机（否则长按时长会被严重低估）。
******************************************************************************/
#ifndef __APP_BOOT_H__
#define __APP_BOOT_H__
/**
* @brief 等待并判定开机按键：不足 3s 松手、或全程未按键，直接原地深睡（不返回）；
* 满 3s 视为正常开机；松手时已过 5s 视为开机并进入配对（内部会调用
* app_pair_start）；持续按满 12s 直接开机并进入 OTA（调用
* usr_app_ota_init）。若未充电且电量低于约 5%，则闪 5 下红灯后
* 继续深睡，拒绝开机。
* @return 无（深睡分支通过 while(1) 喂狗不返回；其余情况正常返回）
*/
void app_boot_wait_key(void);
#endif /* __APP_BOOT_H__ */
apps/usr_app/app_function.c
+398
View File
@@ -0,0 +1,398 @@
/******************************************************************************
* @file app_function.c
* @brief 设备功能开关 + 自动玩法 + 手动点动 + 按键动作实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.26
* @version V1.1.0
* @history
* - 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"
#include "app_power.h"
#include "app_pair.h"
#include "app_mode.h"
#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"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP_FUNC]"
#define LOG_INFO_ENABLE
#include "debug.h"
/** 功能模块总状态，替代原来一堆散落的 static 变量 */
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/3 不重复触发 */
uint16_t hand_ms;
volatile uint8_t hand_write_pending; /**< DP2 刚写入（03 停转要靠事件） */
volatile uint8_t hand_write_cmd;
} AppFunctionCtx_t;
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 void function_on_click(void);
/**
* @brief 初始化功能模块状态
* @return 无
*/
void app_function_init(void)
{
memset(&s_func, 0, sizeof(s_func));
}
/**
* @brief DP2 写入钩子：仅记录第 1 字节，真正执行在 app_function_poll
* @param cmd 0=空闲，1=顺时针，2=逆时针，3=停
* @return 无
*/
void app_function_dp_hand_write(uint8_t cmd)
{
s_func.hand_write_cmd = cmd;
s_func.hand_write_pending = 1;
}
/**
* @brief 跟随 APP 下发的 DP0/DP1，并处理 DP2 手动点动
* @return 无
*/
void app_function_poll(void)
{
/* DP0：APP 下发开关。充电中 / 正在关机时不跟，避免和 USB 软关抢状态 */
if (!app_power_usb_online() && !app_power_poweroff_pending()) {
if (gDevData.power && !s_func.app_power) {
s_func.app_power = 1;
app_led_hint_power_on();
log_info("APP power on\n");
} else if (!gDevData.power && s_func.app_power) {
app_function_soft_off();
}
}
/* 先跟自动模式，再处理手动点动：同一拍里 APP 发自动模式时，能先把手动停掉 */
function_play_mode_poll();
function_hand_poll();
}
/**
* @brief 推进当前玩法节拍或手动刹车
* @param dt 距上次调用的毫秒数
* @return 无
*/
void app_function_tick_1ms(uint16_t dt)
{
if (s_func.hand_busy) {
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 分钟回待机 */
}
}
/**
* @brief 停手动点动（走电机反转刹车）
* @return 无
*/
static void function_hand_stop(void)
{
s_func.hand_busy = 0;
s_func.hand_ms = 0;
bsp_motor_set(BSP_MOTOR_STOP);
}
/**
* @brief 停手动 + 自动模式，并清 DP1
* @return 无
*/
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();
}
/**
* @brief 软关：电机停、DP0=0，等 APP/短按再开。不断 BLE
* @return 无
*/
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();
log_info("soft off, wait APP power on\n");
}
/**
* @brief 上电默认开启功能（DP0=1），不带开机灯效提示
* @return 无
*/
void app_function_power_on_silent(void)
{
s_func.app_power = 1;
gDevData.power = 1;
}
/**
* @brief 查询功能开关状态（DP0）
* @return 1=开，0=关
*/
uint8_t app_function_is_power_on(void)
{
return s_func.app_power;
}
/**
* @brief 查询手动点动是否进行中
* @return 1=进行中，0=空闲
*/
uint8_t app_function_is_hand_busy(void)
{
return s_func.hand_busy;
}
/**
* @brief 查询当前自动玩法编号
* @return 0=停转，1~6=对应玩法
*/
uint8_t app_function_play_mode(void)
{
return s_func.play_mode;
}
/**
* @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()
|| 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)
{
uint8_t mode;
if (app_power_usb_online() || !s_func.app_power || app_power_poweroff_pending()
|| app_pair_is_active()) {
return;
}
mode = gDevData.play_mode;
if (mode > 6) {
mode = 0;
gDevData.play_mode = 0;
}
if (mode == s_func.play_mode) {
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 预留不接。
* @return 无
*/
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;
} else {
cmd = gDevData.hand_mode[0];
}
if (app_power_usb_online() || !s_func.app_power || app_power_poweroff_pending()
|| app_pair_is_active()) {
if (s_func.hand_busy || (got_write && (cmd == 3))) {
app_function_stop_all();
}
s_func.hand_cmd_last = cmd;
return;
}
if (cmd == 0) {
s_func.hand_cmd_last = 0; /* 00 是 DP 默认值，不当停止命令 */
return;
}
/* cmd==3 改边沿触发：只在“刚收到停止”这一拍才可能真的停一次，避免
* DP2 停留在 03（APP 没有再写别的值）时，后面随便什么原因一进自动/
* 手动就被这个陈旧的 03 立刻打断——这正是之前“自动运行中，APP 发
* 停止，再发运行自动模式却启动不了”的根因 */
if (cmd == 3) {
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");
}
s_func.hand_cmd_last = 3;
return;
}
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(); /* 自动切手动：先停自动玩法 */
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（闪灯提示交给 function_play_mode_apply）
* @return 无
*/
static void function_on_click(void)
{
if (s_func.hand_busy) {
log_info("key click ignored, hand busy\n");
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);
}
/**
* @brief 短按回调：充电/配对忽略；软关时唤醒；否则切模式
* @return 无
*/
void usr_on_key_short(void)
{
if (app_power_poweroff_pending()) {
return;
}
if (app_power_usb_online()) {
log_info("key click ignored, charging\n");
return;
}
if (app_pair_is_active()) {
log_info("key click ignored, pairing\n");
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;
}
function_on_click();
}
/**
* @brief 长按 3s：运行中深睡（开机 3s/5s 不走这里）
* @return 无
*/
void usr_on_key_long(void)
{
if (app_power_poweroff_pending()) {
return;
}
if (app_power_usb_online()) {
log_info("key hold 3s ignored, charging\n");
return;
}
if (app_pair_is_active()) {
log_info("key hold 3s ignored, pairing\n");
return;
}
log_info("key hold 3s, poweroff\n");
app_power_request_poweroff();
}
apps/usr_app/app_function.h
+94
View File
@@ -0,0 +1,94 @@
/******************************************************************************
* @file app_function.h
* @brief 设备功能开关（DP0）+ 自动玩法（DP1）+ 手动点动（DP2）+ 按键动作
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 DP0 开关、自动玩法、手动点动与按键动作
*
* @note 本模块决定“电机现在该不该转、转哪种”，会读 app_power/app_pair 的
* 状态作为阻塞条件（充电中/深睡中/配对中都不能转），也会触发
* app_led 的一次性提示灯（切模式闪、开机绿灯），但不会被它们反向依赖。
******************************************************************************/
#ifndef __APP_FUNCTION_H__
#define __APP_FUNCTION_H__
#include <stdint.h>
/**
* @brief 初始化功能模块状态（电机停，DP0=1 视调用方而定）
* @return 无
*/
void app_function_init(void);
/**
* @brief DP2 写入钩子：仅记录第 1 字节，真正执行在 app_function_poll
* @param cmd 0=空闲，1=顺时针，2=逆时针，3=停
* @return 无
*/
void app_function_dp_hand_write(uint8_t cmd);
/**
* @brief 跟随 APP 下发的 DP0/DP1，并处理 DP2 手动点动，每个业务 tick 调用一次
* @return 无
*/
void app_function_poll(void);
/**
* @brief 推进当前玩法节拍或手动刹车，每个业务 tick 调用一次
* @param dt 距上次调用的毫秒数
* @return 无
*/
void app_function_tick_1ms(uint16_t dt);
/**
* @brief 停手动 + 自动模式，并清 DP1（USB 插入 / 请求关机时用）
* @return 无
*/
void app_function_stop_all(void);
/**
* @brief 软关：电机停、DP0=0，等 APP/短按再开（USB 拔出 / APP 关时用）
* @return 无
*/
void app_function_soft_off(void);
/**
* @brief 上电默认开启功能（DP0=1），不带开机灯效提示
* @return 无
*/
void app_function_power_on_silent(void);
/**
* @brief 查询功能开关状态（DP0）
* @return 1=开，0=关
*/
uint8_t app_function_is_power_on(void);
/**
* @brief 查询手动点动是否进行中
* @return 1=进行中，0=空闲
*/
uint8_t app_function_is_hand_busy(void);
/**
* @brief 查询当前自动玩法编号
* @return 0=停转，1~6=对应玩法
*/
uint8_t app_function_play_mode(void);
/**
* @brief 业务层短按回调：由 key_manager 触发（key_manager.h 声明）
* @return 无
*/
void usr_on_key_short(void);
/**
* @brief 业务层长按 3s 回调：由 key_manager 触发（key_manager.h 声明）
* @return 无
*/
void usr_on_key_long(void);
#endif /* __APP_FUNCTION_H__ */
apps/usr_app/app_led.c
+286
View File
@@ -0,0 +1,286 @@
/******************************************************************************
* @file app_led.c
* @brief CBC2 灯效适配：充电红与待机绿可同时亮，不再 if-else 互斥
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V2.0.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.25, cyWu, 开机绿灯只提示几秒
* - 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 红绿交替灯效
* - V2.4.0, 2026.08.27, cyWu, 新增空电关机红闪 5 下灯效
******************************************************************************/
#include "app_led.h"
#include "led_manager.h"
#include "bsp_hw.h"
#include "board_pin.h"
#include "app_power.h"
#include "app_pair.h"
static uint8_t s_initialized;
static uint8_t s_ota; /* 1=OTA 灯效中，app_led_run 不再叠其它灯 */
static uint8_t s_empty_off; /* 1=空电关机红闪中，只跑红灯 5 下 */
static void led_start_pair_result(uint8_t ok);
/**
* @brief 重新播放一次「一次性/限时」灯效，让它从第 0 帧重新开始
* @note led.c 的 LED_EventAdd 只有在“该优先级槽位当前不是这个事件”时才会把
* currentTime 重置为现在；如果动画正播到一半直接再 Add 一次，事件已经
* 占着槽位，不会重置，会接着上次的进度走。所以要先 Delete 清空槽位，
* 再 Add 才能强制重新计时——这不是多余代码，是“重启”这个事件的手段。
* @param evt 要重启的事件（切模式闪、开机绿灯提示、配对结果）
* @return 无
*/
static void led_restart(LED_Event_t evt)
{
LED_EventDelete(evt);
LED_EventAdd(evt);
}
/**
* @brief 绿灯正被切模式/配对结果占用（不含配对快闪本身）
* @return 1=绿灯忙
*/
static uint8_t green_pattern_busy(void)
{
return (uint8_t)(LED_IsEventExist(LED_EVENT_MODE)
|| LED_IsEventExist(LED_EVENT_PAIR_OK)
|| LED_IsEventExist(LED_EVENT_PAIR_FAIL));
}
/**
* @brief 绿灯正被配对/切模式/结果占用时，不要再挂待机绿
* @return 1=绿灯忙
*/
static uint8_t green_busy(void)
{
return (uint8_t)(LED_IsEventExist(LED_EVENT_PAIRING) || green_pattern_busy());
}
/**
* @brief 灯效初始化
* @return APP_LED_OK=成功
*/
AppLed_Ret_t app_led_init(void)
{
if (s_initialized) {
return APP_LED_OK;
}
user_led_init();
s_initialized = 1;
return APP_LED_OK;
}
/**
* @brief 查询模块是否已初始化
* @return APP_LED_OK=已初始化，APP_LED_ERR_NOT_INIT=未初始化
*/
AppLed_Ret_t app_led_get_status(void)
{
return s_initialized ? APP_LED_OK : APP_LED_ERR_NOT_INIT;
}
/**
* @brief 请求切模式绿灯闪两下（与配对灯同优先级，会盖住配对闪）
* @return 无
*/
void app_led_request_mode_blink(void)
{
if (!s_initialized || s_ota || s_empty_off) {
return;
}
led_restart(LED_EVENT_MODE);
}
/**
* @brief 重新挂待机绿灯（常亮或提示几秒，看 BOARD_LED_STANDBY_ON）
* @return 无
*/
void app_led_hint_power_on(void)
{
if (!s_initialized || s_ota || s_empty_off) {
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 空电关机：清掉其它灯（含绿灯），只挂红灯闪 5 下
* @return 无
*/
void app_led_request_empty_off(void)
{
if (!s_initialized || s_ota) {
return; /* OTA 灯效优先，不打断升级提示 */
}
s_empty_off = 1;
LED_EventAllDelete();
bsp_led_all_off(); /* 先关绿灯 */
LED_EventAdd(LED_EVENT_EMPTY);
}
/**
* @brief 查询是否处于空电关机灯效
* @return 1=空电红闪中，0=否
*/
uint8_t app_led_is_empty_off(void)
{
return s_empty_off;
}
/**
* @brief 播放一次性配对结果灯
* @param ok 1=成功常绿，0=失败红绿交替
* @return 无
*/
static void led_start_pair_result(uint8_t ok)
{
LED_EventDelete(LED_EVENT_PAIRING); /* 结果灯盖住配对快闪 */
led_restart(ok ? LED_EVENT_PAIR_OK : LED_EVENT_PAIR_FAIL);
}
/**
* @brief 功能关闭（DP0=0）时清掉所有“功能相关”的灯事件
* @note 故意不用 LED_EventAllDelete()：那会把优先级表全清空，连充电红/满灯
* （LED_EVENT_CHARGE / LED_EVENT_CHARGE_FULL）也会跟着灭掉。但充电状态
* 和 DP0 开关是两码事——设备功能关着也可能正在充电，充电灯必须继续亮，
* 所以这里只挑功能相关的几个事件逐个删，充电事件不动它。
* @return 无
*/
static void led_clear_function_events(void)
{
LED_EventDelete(LED_EVENT_STANDBY);
LED_EventDelete(LED_EVENT_PAIRING);
LED_EventDelete(LED_EVENT_MODE);
LED_EventDelete(LED_EVENT_PAIR_OK);
LED_EventDelete(LED_EVENT_PAIR_FAIL);
LED_EventDelete(LED_EVENT_LOWBAT);
}
/**
* @brief 按优先级刷新灯：充电/低电从 app_power 取，配对从 app_pair 取，
* 只有“功能是否开”这一项由调用方传入
* @param dt 距上次调用的毫秒数
* @param app_power 1=功能开（DP0），0=功能关，功能灯全灭
* @return 无
*/
void app_led_run(uint16_t dt, uint8_t app_power)
{
uint8_t charge_led;
uint8_t low_bat;
uint8_t pairing;
uint8_t func_on;
AppPairEvt_t pair_evt;
if (!s_initialized) {
return;
}
/* OTA 期间只跑红绿交替，充电/待机/配对都不要叠上去 */
if (s_ota) {
LED_EventAdd(LED_EVENT_OTA);
user_led_handle();
return;
}
/* 空电关机：绿灯已关，只跑红灯闪 5 下；事件在 request 时已挂上，这里不要再 Add，
* 否则闪完被删后又会重新开始闪。 */
if (s_empty_off) {
user_led_handle();
return;
}
/* 配对成功/失败是边沿事件，只在那一拍切灯效 */
pair_evt = app_pair_tick_1ms(dt);
if (pair_evt == APP_PAIR_EVT_OK) {
led_start_pair_result(1);
} else if (pair_evt == APP_PAIR_EVT_FAIL) {
led_start_pair_result(0);
}
charge_led = app_power_charge_led();
low_bat = app_power_low_bat();
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 {
LED_EventDelete(LED_EVENT_CHARGE);
}
if (charge_led == 2) {
LED_EventAdd(LED_EVENT_CHARGE_FULL);
} else {
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 {
LED_EventDelete(LED_EVENT_LOWBAT);
}
if (!func_on) {
led_clear_function_events();
} else {
#if BOARD_LED_STANDBY_ON
/* 正在充电（红）或已充满（绿）时都不叠加待机绿，只有完全没接电才显示待机 */
if ((charge_led == 0) && !pairing && !green_busy()) {
LED_EventAdd(LED_EVENT_STANDBY);
} else {
LED_EventDelete(LED_EVENT_STANDBY);
}
#endif
}
user_led_handle();
}
/**
* @brief 清空全部灯事件并灭灯
* @return 无
*/
void app_led_clear(void)
{
LED_EventAllDelete();
bsp_led_all_off();
}
apps/usr_app/app_led.h
+90
View File
@@ -0,0 +1,90 @@
/******************************************************************************
* @file app_led.h
* @brief CBC2 灯效：红绿独立通道，充电红与待机绿可同时亮
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V2.0.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.25, cyWu, 开机绿灯只提示几秒，避免待机常亮耗电
* - 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 红绿交替灯效
* - V2.4.0, 2026.08.27, cyWu, 新增空电关机红灯闪 5 下
******************************************************************************/
#ifndef __APP_LED_H__
#define __APP_LED_H__
#include <stdint.h>
typedef enum {
APP_LED_OK = 0,
APP_LED_ERR_NOT_INIT
} AppLed_Ret_t;
/**
* @brief 灯效初始化，先全灭
* @return APP_LED_OK=成功
*/
AppLed_Ret_t app_led_init(void);
/**
* @brief 按优先级刷新灯：充电/低电从 app_power 取，配对从 app_pair 取，
* 只有“功能是否开”这一项由调用方（app_function）传入
* @param dt 距上次调用的毫秒数
* @param app_power 1=功能开（DP0），0=功能关，功能灯全灭
* @return 无
*/
void app_led_run(uint16_t dt, uint8_t app_power);
/**
* @brief 请求切模式绿灯闪两下
* @return 无
*/
void app_led_request_mode_blink(void);
/**
* @brief 重新亮几秒开机绿灯
* @return 无
*/
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 空电关机灯效：关掉绿灯，只闪红灯 5 下
* @return 无
*/
void app_led_request_empty_off(void);
/**
* @brief 查询是否处于空电关机灯效
* @return 1=空电红闪中，0=否
*/
uint8_t app_led_is_empty_off(void);
/**
* @brief 清空全部灯事件并灭灯（关机前调用）
* @return 无
*/
void app_led_clear(void);
/**
* @brief 查询是否已初始化
* @return APP_LED_OK=已初始化，APP_LED_ERR_NOT_INIT=未初始化
*/
AppLed_Ret_t app_led_get_status(void);
#endif /* __APP_LED_H__ */
apps/usr_app/app_mode.c
+218
View File
@@ -0,0 +1,218 @@
/******************************************************************************
* @file app_mode.c
* @brief 自动模式 1~6：按节拍改方向与 PWM 占空比
* @author cyWu <1917507415@qq.com>
* @date 2026.08.24
* @version V1.2.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.24, cyWu, 接入 H 桥往返节拍
* - V1.2.0, 2026.08.24, cyWu, 节拍带占空比；六档波形加花样
******************************************************************************/
#include "system/includes.h"
#include "app_mode.h"
#include "bsp_hw.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP_MODE]"
#define LOG_INFO_ENABLE
#include "debug.h"
typedef struct {
BspMotorDir_t dir;
uint16_t ms;
uint16_t duty; /**< 0~10000，STOP 忽略 */
} AppModeStep_t;
#define DUTY_SOFT 3500 /* 轻 */
#define DUTY_MID 5500 /* 中 */
#define DUTY_RUN 8000 /* 主速度 80% */
#define DUTY_PUNCH 9500 /* 猛一下 */
#define STEP_OUT(ms, duty) { BSP_MOTOR_OUT, (ms), (duty) }
#define STEP_IN(ms, duty) { BSP_MOTOR_IN, (ms), (duty) }
#define STEP_STOP(ms) { BSP_MOTOR_STOP, (ms), 0 }
#define STEP_END { BSP_MOTOR_STOP, 0, 0 }
/* 节拍以 ms=0 结尾，循环播放。同向连续步进只改占空比，换向才刹车。 */
static const AppModeStep_t s_mode1[] = { /* 弹力呼吸：慢加速放、慢加速收，最长 2s */
STEP_OUT(500, DUTY_MID), STEP_OUT(1200, DUTY_RUN), STEP_OUT(500, DUTY_PUNCH),
STEP_STOP(400),
STEP_IN(500, DUTY_MID), STEP_IN(1200, DUTY_RUN), STEP_IN(500, DUTY_PUNCH),
STEP_STOP(400),
STEP_END
};
static const AppModeStep_t s_mode2[] = { /* 飞鸟俯冲：快冲出去，2s 慢慢收回 */
STEP_OUT(500, DUTY_PUNCH), STEP_OUT(500, DUTY_RUN),
STEP_STOP(400),
STEP_IN(2800, DUTY_MID),
STEP_STOP(400),
STEP_END
};
static const AppModeStep_t s_mode3[] = { /* 云阶陀螺：短步往返加长，力度一档档加 */
STEP_OUT(800, DUTY_SOFT), STEP_IN(800, DUTY_SOFT),
STEP_OUT(800, DUTY_MID), STEP_IN(800, DUTY_MID),
STEP_OUT(800, DUTY_RUN), STEP_IN(800, DUTY_RUN),
STEP_STOP(400),
STEP_END
};
static const AppModeStep_t s_mode4[] = { /* 起伏攻防：2s 慢逗再猛收 */
STEP_OUT(500, DUTY_SOFT), STEP_OUT(1200, DUTY_MID), STEP_OUT(500, DUTY_RUN),
STEP_STOP(400),
STEP_IN(500, DUTY_PUNCH), STEP_IN(500, DUTY_MID),
STEP_STOP(400),
STEP_END
};
static const AppModeStep_t s_mode5[] = { /* 微风拂动：轻点后歇 2s */
STEP_OUT(500, DUTY_MID), STEP_STOP(1000),
STEP_IN(500, DUTY_MID), STEP_STOP(1200),
STEP_OUT(500, DUTY_RUN), STEP_STOP(800),
STEP_IN(500, DUTY_RUN), STEP_STOP(1500),
STEP_END
};
static const AppModeStep_t s_mode6[] = { /* 闪电快闪：两下轻、两下重，短停防 LVD */
STEP_OUT(400, DUTY_MID), STEP_IN(400, DUTY_MID),
STEP_OUT(800, DUTY_RUN), STEP_IN(800, DUTY_RUN),
STEP_OUT(500, DUTY_PUNCH), STEP_IN(500, DUTY_PUNCH),
STEP_OUT(700, DUTY_PUNCH), STEP_IN(700, DUTY_PUNCH),
STEP_STOP(300),
STEP_END
};
static const AppModeStep_t *const s_tables[7] = {
0, s_mode1, s_mode2, s_mode3, s_mode4, s_mode5, s_mode6
};
/** 模块状态，替代原来散落的 4 个 static */
typedef struct {
uint8_t initialized;
uint8_t active; /**< 0=停转，1~6=当前玩法 */
uint8_t step; /**< 当前节拍在表里的下标 */
u32 step_t0; /**< 当前节拍起始时间戳，用于判断是否该跳下一步 */
} AppModeCtx_t;
static AppModeCtx_t s_mode;
extern u32 timer_get_ms(void);
/**
* @brief 输出当前节拍的方向与占空比；ms=0 表示表尾，回到第 0 步循环
* @return 无
*/
static void app_mode_apply_step(void)
{
const AppModeStep_t *tbl = s_tables[s_mode.active];
if (!tbl) {
bsp_motor_set(BSP_MOTOR_STOP);
return;
}
if (tbl[s_mode.step].ms == 0) {
s_mode.step = 0; /* 表尾，回到第 0 步循环 */
}
s_mode.step_t0 = timer_get_ms();
if (tbl[s_mode.step].dir == BSP_MOTOR_STOP) {
bsp_motor_set(BSP_MOTOR_STOP);
} else {
bsp_motor_set_pwm(tbl[s_mode.step].dir, tbl[s_mode.step].duty);
}
}
/**
* @brief 玩法初始化，电机停
* @return APP_MODE_OK=成功
*/
AppMode_Ret_t app_mode_init(void)
{
s_mode.active = 0;
s_mode.step = 0;
s_mode.step_t0 = timer_get_ms();
s_mode.initialized = 1;
bsp_motor_set(BSP_MOTOR_STOP);
return APP_MODE_OK;
}
/**
* @brief 查询模块是否已初始化
* @return APP_MODE_OK=已初始化，APP_MODE_ERR_NOT_INIT=未初始化
*/
AppMode_Ret_t app_mode_get_status(void)
{
return s_mode.initialized ? APP_MODE_OK : APP_MODE_ERR_NOT_INIT;
}
/**
* @brief 读取当前自动模式
* @return 0=停转，1~6=对应玩法
*/
uint8_t app_mode_get_active(void)
{
return s_mode.active;
}
/**
* @brief 启动自动模式 1~6，按节拍表循环
* @param mode 玩法编号，范围 1~6
* @return APP_MODE_OK=成功，APP_MODE_ERR_NOT_INIT=未初始化，APP_MODE_ERR_PARAM=参数非法
*/
AppMode_Ret_t app_mode_start(uint8_t mode)
{
if (!s_mode.initialized) {
return APP_MODE_ERR_NOT_INIT;
}
if (mode < 1 || mode > 6) {
app_mode_stop();
return APP_MODE_ERR_PARAM;
}
s_mode.active = mode;
s_mode.step = 0; /* 从节拍表第 0 步重新开始 */
app_mode_apply_step();
log_info("auto mode %d start\n", mode);
return APP_MODE_OK;
}
/**
* @brief 停止当前玩法并刹车
* @return 无
*/
void app_mode_stop(void)
{
if (s_mode.active) {
log_info("auto mode %d stop\n", s_mode.active);
}
s_mode.active = 0;
s_mode.step = 0;
s_mode.step_t0 = timer_get_ms();
bsp_motor_set(BSP_MOTOR_STOP);
}
/**
* @brief 推进当前节拍（按 timer_get_ms 真实时间）
* @return 无
*/
void app_mode_run(void)
{
const AppModeStep_t *tbl;
bsp_motor_switch_tick(); /* 换向死区：H 桥松开后再切方向 */
if (!s_mode.initialized || s_mode.active == 0) {
return;
}
tbl = s_tables[s_mode.active];
if (!tbl) {
return;
}
if ((timer_get_ms() - s_mode.step_t0) >= tbl[s_mode.step].ms) {
s_mode.step++;
app_mode_apply_step();
}
}
apps/usr_app/app_mode.h
+61
View File
@@ -0,0 +1,61 @@
/******************************************************************************
* @file app_mode.h
* @brief 6 种自动玩法：节拍含方向与 PWM 占空比（0=停，1~6=波形）
* @author cyWu <1917507415@qq.com>
* @date 2026.08.24
* @version V1.2.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.24, cyWu, 接入 H 桥往返节拍
* - V1.2.0, 2026.08.24, cyWu, 节拍带占空比；六档波形加花样
******************************************************************************/
#ifndef __APP_MODE_H__
#define __APP_MODE_H__
#include <stdint.h>
typedef enum {
APP_MODE_OK = 0,
APP_MODE_ERR_PARAM,
APP_MODE_ERR_NOT_INIT
} AppMode_Ret_t;
/**
* @brief 初始化，电机停
* @return APP_MODE_OK=成功
*/
AppMode_Ret_t app_mode_init(void);
/**
* @brief 启动自动模式 1~6，循环播放节拍
* @param mode 玩法编号，范围 1~6
* @return APP_MODE_OK=成功，APP_MODE_ERR_NOT_INIT=未初始化，APP_MODE_ERR_PARAM=参数非法
*/
AppMode_Ret_t app_mode_start(uint8_t mode);
/**
* @brief 停止玩法并刹车
* @return 无
*/
void app_mode_stop(void);
/**
* @brief 推进当前节拍（按真实毫秒，不依赖回调是否刚好 1ms）
* @return 无
*/
void app_mode_run(void);
/**
* @brief 读取当前自动模式
* @return 0=停转，1~6=对应玩法
*/
uint8_t app_mode_get_active(void);
/**
* @brief 查询是否已初始化
* @return APP_MODE_OK=已初始化，APP_MODE_ERR_NOT_INIT=未初始化
*/
AppMode_Ret_t app_mode_get_status(void);
#endif /* __APP_MODE_H__ */
apps/usr_app/app_pair.c
+76
View File
@@ -0,0 +1,76 @@
/******************************************************************************
* @file app_pair.c
* @brief 配对会话计时实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现配对会话计时与成功/超时判定
******************************************************************************/
#include "app_pair.h"
#include "board_pin.h"
#include "usr_le_api.h"
#include "system/includes.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP_PAIR]"
#define LOG_INFO_ENABLE
#include "debug.h"
/** 配对会话状态，替代原来散落的 s_pairing / s_pair_ms */
typedef struct {
uint8_t active;
uint32_t elapsed_ms;
} AppPairCtx_t;
static AppPairCtx_t s_pair;
/**
* @brief 开始一次配对会话（计时清零）
* @return 无
*/
void app_pair_start(void)
{
s_pair.active = 1;
s_pair.elapsed_ms = 0;
}
/**
* @brief 推进配对计时并检查结果，每个业务 tick 调用一次
* @param dt 距上次调用的毫秒数
* @return APP_PAIR_EVT_OK=配对成功，APP_PAIR_EVT_FAIL=超时，否则 NONE
*/
AppPairEvt_t app_pair_tick_1ms(uint16_t dt)
{
if (!s_pair.active) {
return APP_PAIR_EVT_NONE;
}
/* BLE 侧绑定成功：结束本次配对会话 */
if (usr_get_pair_flag()) {
s_pair.active = 0;
s_pair.elapsed_ms = 0;
log_info("pair ok\n");
return APP_PAIR_EVT_OK;
}
s_pair.elapsed_ms += dt;
if (s_pair.elapsed_ms >= BOARD_PAIR_TIMEOUT_MS) {
s_pair.active = 0;
s_pair.elapsed_ms = 0;
log_info("pair timeout 120s, stay on\n");
return APP_PAIR_EVT_FAIL;
}
return APP_PAIR_EVT_NONE;
}
/**
* @brief 查询是否仍在配对会话中
* @return 1=进行中，0=未在配对
*/
uint8_t app_pair_is_active(void)
{
return s_pair.active;
}
apps/usr_app/app_pair.h
+45
View File
@@ -0,0 +1,45 @@
/******************************************************************************
* @file app_pair.h
* @brief 配对会话计时：开机配对窗口是否成功/超时，与 BLE 配对本身解耦
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现配对会话计时与成功/超时判定
*
* @note 真正的 BLE 广播/绑定逻辑在 usr_le_code；本模块只负责“进入配对后
* 60s 内 usr_get_pair_flag() 是否变 1”这件事，纯状态，不碰灯/按键。
******************************************************************************/
#ifndef __APP_PAIR_H__
#define __APP_PAIR_H__
#include <stdint.h>
/** 配对结果边沿事件，仅在状态变化那一次返回一次 */
typedef enum {
APP_PAIR_EVT_NONE = 0,
APP_PAIR_EVT_OK,
APP_PAIR_EVT_FAIL
} AppPairEvt_t;
/**
* @brief 开始一次配对会话（计时清零）
* @return 无
*/
void app_pair_start(void);
/**
* @brief 推进配对计时并检查结果，每个业务 tick 调用一次
* @param dt 距上次调用的毫秒数
* @return APP_PAIR_EVT_OK=配对成功，APP_PAIR_EVT_FAIL=超时，否则 NONE
*/
AppPairEvt_t app_pair_tick_1ms(uint16_t dt);
/**
* @brief 查询是否仍在配对会话中
* @return 1=进行中，0=未在配对
*/
uint8_t app_pair_is_active(void);
#endif /* __APP_PAIR_H__ */
apps/usr_app/app_power.c
+441
View File
@@ -0,0 +1,441 @@
/******************************************************************************
* @file app_power.c
* @brief USB / 充电检测、电量采样与低电策略、深睡请求生命周期实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.27
* @version V1.2.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 USB/充电检测、电量采样与深睡请求
* - V1.1.0, 2026.08.26, cyWu, 取消低电闪烁 1 分钟后自动关机；自动关机门限
* 改为约 5%（BOARD_VBAT_SHUTDOWN_MV），与开机
* 低电拦截（app_boot）共用同一门限
* - V1.2.0, 2026.08.27, cyWu, 运行中空电关机改用显示百分比，到 5% 立即停电机
* 并请求空电灯效后再掉电，不再做连续次数窗口
******************************************************************************/
#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"
#include "app_main.h"
#include "usr_le_api.h"
#include "system/includes.h"
#include "ui_manage.h"
#include <string.h>
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP_PWR]"
#define LOG_INFO_ENABLE
#include "debug.h"
#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 才进低电告警（仅闪灯，不关机） */
/** 充电检测：CHG/VPWR 消抖后的结果 */
typedef struct {
uint8_t usb_online;
uint8_t charge_led; /**< 0=无 1=充电红 2=充满绿 */
uint8_t charge_led_last; /**< 仅用于变化时打日志 */
uint16_t full_ms; /**< 拔电瞬间 CHG 先变高，需等满 1s 才当充满 */
} AppChargeState_t;
/** 电量采样：滑动平均 + 百分比 */
typedef struct {
uint16_t tick_ms;
uint16_t acc_mv;
uint8_t n;
uint16_t mv;
uint8_t pct;
uint16_t boot_ms;
uint16_t log_ms;
} AppBatterySample_t;
/** 低电告警：进入/退出都要连续窗口消抖，避免电机拉压降误报
* @note 低电（BOARD_VBAT_LOW_MV）只负责红灯闪烁提示，不再有超时自动关机；
* 真正的自动关机改由 power_battery_check_empty 在显示电量
* <= BOARD_BATTERY_SHUTDOWN_PCT（5%）时立刻触发 */
typedef struct {
uint8_t low_bat;
uint8_t enter_win;
uint8_t exit_win;
} AppBatteryAlarm_t;
/** 电源模块总状态，替代原来一堆散落的 static 变量 */
typedef struct {
AppChargeState_t charge;
AppBatterySample_t sample;
AppBatteryAlarm_t alarm;
uint8_t req_poweroff;
uint8_t empty_off; /**< 1=空电路径：闪完红灯再掉电 */
AppPowerHook_t on_request;
AppPowerHook_t on_finalize;
} AppPowerCtx_t;
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_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(void);
static void power_battery_check_low(uint16_t mv);
static void power_battery_periodic_log(uint16_t dt);
/**
* @brief 初始化电源模块状态
* @return 无
*/
void app_power_init(void)
{
memset(&s_power, 0, sizeof(s_power));
s_power.charge.charge_led_last = 0xff;
app_battery_init();
}
/**
* @brief 注册深睡请求的两段式回调
* @param on_request 刚请求深睡时调用（停电机；灯效由调用方按关机类型决定）
* @param on_finalize 延时到点后调用（真正进深睡，不会返回）
* @return 无
*/
void app_power_set_hooks(AppPowerHook_t on_request, AppPowerHook_t on_finalize)
{
s_power.on_request = on_request;
s_power.on_finalize = on_finalize;
}
/**
* @brief 充电检测 + 电量采样，每个业务 tick 调用一次
* @param dt 距上次调用的毫秒数
* @return USB 插拔边沿事件，多数时候是 APP_POWER_EVT_NONE
*/
AppPowerEvt_t app_power_tick_1ms(uint16_t dt)
{
AppPowerEvt_t evt = power_charge_tick(dt);
power_battery_tick(dt);
return evt;
}
/**
* @brief 查询 USB 是否在位（含正在充电）
* @return 1=在位，0=未接
*/
uint8_t app_power_usb_online(void)
{
return s_power.charge.usb_online;
}
/**
* @brief 查询充电灯状态
* @return 0=无 1=充电中红灯 2=已充满绿灯
*/
uint8_t app_power_charge_led(void)
{
return s_power.charge.charge_led;
}
/**
* @brief 查询是否处于低电告警
* @return 1=低电，0=正常
*/
uint8_t app_power_low_bat(void)
{
return s_power.alarm.low_bat;
}
/**
* @brief 请求深睡（按键 3s 等）：立即触发 on_request 钩子，50ms 后触发 on_finalize
* @return 无
*/
void app_power_request_poweroff(void)
{
if (s_power.req_poweroff) {
return; /* 已经在关机流程里，不要重复挂定时器 */
}
s_power.req_poweroff = 1;
s_power.empty_off = 0;
log_info("request deep off\n");
if (s_power.on_request) {
s_power.on_request(); /* 立刻停电机、灯全灭 */
}
sys_timeout_add(NULL, power_do_poweroff, 50); /* 给 GPIO 落稳一点再真正掉电 */
}
/**
* @brief 空电关机：立刻停电机，等红灯闪完 5 下后再真正掉电
* @return 无
*/
void app_power_request_empty_poweroff(void)
{
if (s_power.req_poweroff) {
return;
}
s_power.req_poweroff = 1;
s_power.empty_off = 1;
log_info("request empty off, wait %ums\n", (unsigned)BOARD_LED_EMPTY_OFF_WAIT_MS);
if (s_power.on_request) {
s_power.on_request(); /* 立刻停电机，调用方挂空电红闪 */
}
sys_timeout_add(NULL, power_do_poweroff, BOARD_LED_EMPTY_OFF_WAIT_MS);
}
/**
* @brief 查询深睡请求是否已发起
* @return 1=已发起，0=未发起
*/
uint8_t app_power_poweroff_pending(void)
{
return s_power.req_poweroff;
}
/**
* @brief 当前这次关机是否为空电路径
* @return 1=空电关机，0=普通关机
*/
uint8_t app_power_empty_off_pending(void)
{
return s_power.empty_off;
}
/**
* @brief 50ms 延时到点：真正进入深睡
* @param priv 未使用
* @return 无
*/
static void power_do_poweroff(void *priv)
{
(void)priv;
log_info("enter deep off\n");
if (s_power.on_finalize) {
s_power.on_finalize();
}
}
/**
* @brief 充电检测：CHG 低=充电中；VPWR 在且 CHG 高满 1s=充满；拔电报 USB_OUT
* @param dt 距上次调用的毫秒数
* @return USB 插拔边沿事件
*/
static AppPowerEvt_t power_charge_tick(uint16_t dt)
{
AppChargeState_t *c = &s_power.charge;
uint8_t chg_low = bsp_chg_is_low();
uint8_t vpwr = bsp_vpwr_is_online();
uint8_t usb;
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) {
/* 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;
}
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;
usb = 0;
}
if (usb != c->usb_online) {
c->usb_online = usb;
log_info("usb %s vpwr=%d chg=%d mv=%d pair=%d goto=%d\n",
usb ? "in" : "out", vpwr, chg_low, bsp_vpwr_mv(),
usr_get_pair_flag(), usr_var.usr_goto_pair);
usr_var.usr_power_charge_flag = usb ? 1 : 2;
if (usb) {
evt = APP_POWER_EVT_USB_IN;
} else {
ui_update_status(STATUS_NORMAL_POWER);
evt = APP_POWER_EVT_USB_OUT;
}
}
if (c->charge_led != c->charge_led_last) {
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 滑动平均采样：每 BAT_SAMPLE_MS 采一次电压，凑够 BAT_AVG_N 个才出新均值
* @note 靠采样点数（而非时间）判满，dt 波动也不会多算/少算样本
* @param dt 距上次调用的毫秒数
* @param out_mv 新均值输出，仅在返回 1 时有效
* @return 1=本次凑出新均值，0=还在累积
*/
static uint8_t power_battery_sample_ready(uint16_t dt, uint16_t *out_mv)
{
AppBatterySample_t *s = &s_power.sample;
s->tick_ms = app_add_ms(s->tick_ms, dt);
if (s->tick_ms < BAT_SAMPLE_MS) {
return 0; /* 还没到采样点 */
}
s->tick_ms = 0;
s->acc_mv += bsp_vbat_mv();
s->n++;
if (s->n < BAT_AVG_N) {
return 0; /* 样本还不够，继续累加 */
}
*out_mv = (uint16_t)(s->acc_mv / s->n);
s->acc_mv = 0;
s->n = 0;
s->mv = *out_mv;
return 1;
}
/**
* @brief 喂给电量算法模块（防抖/充放电基准/缓冲平滑见 app_battery.c），
* 仅在结果变化时才写协议层数据
* @param mv 本次均值电压，单位 mV
* @return 无
*/
static void power_battery_update_percent(uint16_t 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;
}
}
/**
* @brief 空电关机判定：显示电量一到 <= 5% 立刻停电机并请求空电关机
* @note 充电中不判定。百分比已经在 app_battery 做过滤波/缓冲，这里不再做连续次数窗口。
* 开机拦截（app_boot）仍用 BOARD_VBAT_SHUTDOWN_MV，因为那时电量算法还没跑。
* @return 无
*/
static void power_battery_check_empty(void)
{
uint8_t pct = s_power.sample.pct;
if (s_power.charge.usb_online || pct > BOARD_BATTERY_SHUTDOWN_PCT) {
return;
}
s_power.alarm.low_bat = 1;
gDevData.alm_low_battery = 1;
if (!s_power.req_poweroff) {
log_info("battery %d%% <=%d%%, stop motor + blink red then off\n",
pct, BOARD_BATTERY_SHUTDOWN_PCT);
app_power_request_empty_poweroff();
}
}
/**
* @brief 低电迟滞判定：进入/退出各自要求连续 BAT_LOW_WIN 次采样，避免电压在门限附近抖动
* @param mv 本次均值电压，单位 mV
* @return 无
*/
static void power_battery_check_low(uint16_t mv)
{
AppBatteryAlarm_t *a = &s_power.alarm;
if (mv < BOARD_VBAT_LOW_MV) {
a->exit_win = 0;
if (a->low_bat || a->enter_win >= 0xFF) {
return; /* 已经在低电，或窗口已饱和，不用再加 */
}
a->enter_win++;
if (a->enter_win >= BAT_LOW_WIN) {
a->low_bat = 1; /* 连续够次数才进低电，只闪灯不关机 */
gDevData.alm_low_battery = 1;
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;
if (!a->low_bat) {
return;
}
if (a->exit_win < 0xFF) {
a->exit_win++;
}
if (a->exit_win >= BAT_LOW_WIN) {
a->low_bat = 0;
gDevData.alm_low_battery = 0;
log_info("battery recover %dmV %d%%\n", mv, s_power.sample.pct);
}
} else {
/* 低电门限与迟滞上限之间的死区，两个窗口都不动 */
a->enter_win = 0;
a->exit_win = 0;
}
}
/**
* @brief 每 BAT_LOG_MS 打印一次电量状态，方便离线看日志排查
* @param dt 距上次调用的毫秒数
* @return 无
*/
static void power_battery_periodic_log(uint16_t dt)
{
AppBatterySample_t *s = &s_power.sample;
s->log_ms = app_add_ms(s->log_ms, dt);
if (s->log_ms >= BAT_LOG_MS) {
s->log_ms = 0;
log_info("bat %d%% %dmV alm=%d\n", s->pct, s->mv, s_power.alarm.low_bat);
}
}
/**
* @brief 电量采样与低电策略，每个业务 tick 调用一次
* @note 显示用的百分比（滤波/充放电基准/突变防抖/缓冲平滑）交给 app_battery
* 模块处理。check_low 仍按原始电压做 3.7V 红灯提示；check_empty
* 按显示电量 <= BOARD_BATTERY_SHUTDOWN_PCT（5%）关机，跟 APP 看到
* 的数字对齐，避免电压先掉、百分比还没到 5% 就关机。
* @param dt 距上次调用的毫秒数
* @return 无
*/
static void power_battery_tick(uint16_t dt)
{
AppBatterySample_t *s = &s_power.sample;
uint16_t mv;
if (s->boot_ms < BAT_BOOT_MS) {
s->boot_ms = app_add_ms(s->boot_ms, dt);
}
if (power_battery_sample_ready(dt, &mv)) {
power_battery_update_percent(mv);
/* 开机保护期内只更新百分比，不判定任何告警 */
if (s->boot_ms >= BAT_BOOT_MS) {
power_battery_check_empty();
power_battery_check_low(mv);
}
}
power_battery_periodic_log(dt);
}
apps/usr_app/app_power.h
+96
View File
@@ -0,0 +1,96 @@
/******************************************************************************
* @file app_power.h
* @brief USB / 充电检测、电量采样与低电策略、深睡请求生命周期
* @author cyWu <1917507415@qq.com>
* @date 2026.08.27
* @version V1.2.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 USB/充电检测、电量采样与深睡请求
* - V1.2.0, 2026.08.27, cyWu, 显示电量到 5% 立即走空电关机（停电机、红灯闪 5 下再掉电）
*
* @note 本模块只管“电从哪来、还剩多少、要不要关机”，不认识电机/灯/按键。
* 需要在 USB 插拔 / 深睡时联动其它模块的地方，一律走 app_power_set_hooks
* 注册的回调，调用方（usr_jb_main）负责接线，避免本模块反过来依赖别的模块。
******************************************************************************/
#ifndef __APP_POWER_H__
#define __APP_POWER_H__
#include <stdint.h>
/** USB 插拔的边沿事件，仅在状态变化那一次返回一次 */
typedef enum {
APP_POWER_EVT_NONE = 0,
APP_POWER_EVT_USB_IN,
APP_POWER_EVT_USB_OUT
} AppPowerEvt_t;
/** 深睡请求的钩子：on_request 立刻停电机并按关机类型处理灯；on_finalize 真正掉电 */
typedef void (*AppPowerHook_t)(void);
/**
* @brief 初始化电源模块状态
* @return 无
*/
void app_power_init(void);
/**
* @brief 注册深睡请求的两段式回调
* @param on_request 刚请求深睡时调用（停电机；灯效由调用方按关机类型决定）
* @param on_finalize 延时到点后调用（真正进深睡，不会返回）
* @return 无
*/
void app_power_set_hooks(AppPowerHook_t on_request, AppPowerHook_t on_finalize);
/**
* @brief 充电检测 + 电量采样，每个业务 tick 调用一次
* @param dt 距上次调用的毫秒数
* @return USB 插拔边沿事件，多数时候是 APP_POWER_EVT_NONE
*/
AppPowerEvt_t app_power_tick_1ms(uint16_t dt);
/**
* @brief 查询 USB 是否在位（含正在充电）
* @return 1=在位，0=未接
*/
uint8_t app_power_usb_online(void);
/**
* @brief 查询充电灯状态
* @return 0=无 1=充电中红灯 2=已充满绿灯
*/
uint8_t app_power_charge_led(void);
/**
* @brief 查询是否处于低电告警
* @return 1=低电，0=正常
*/
uint8_t app_power_low_bat(void);
/**
* @brief 请求深睡（按键 3s 等）：立即触发 on_request 钩子，50ms 后触发 on_finalize
* @return 无
*/
void app_power_request_poweroff(void);
/**
* @brief 空电关机：立刻停电机，等红灯闪完 5 下后再真正掉电
* @note 调用方在 on_request 里根据 app_power_empty_off_pending() 挂空电灯效，
* 不要立刻灭灯。延时为 BOARD_LED_EMPTY_OFF_WAIT_MS。
* @return 无
*/
void app_power_request_empty_poweroff(void);
/**
* @brief 查询深睡请求是否已发起（发起后其它模块应停止响应新操作）
* @return 1=已发起，0=未发起
*/
uint8_t app_power_poweroff_pending(void);
/**
* @brief 当前这次关机是否为空电路径（红灯闪 5 下再掉电）
* @return 1=空电关机，0=普通关机
*/
uint8_t app_power_empty_off_pending(void);
#endif /* __APP_POWER_H__ */
apps/usr_app/app_time_util.h
+29
View File
@@ -0,0 +1,29 @@
/******************************************************************************
* @file app_time_util.h
* @brief 业务模块共用的毫秒计时小工具，避免每个模块各写一份
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现 16 位毫秒饱和累加
******************************************************************************/
#ifndef __APP_TIME_UTIL_H__
#define __APP_TIME_UTIL_H__
#include <stdint.h>
/**
* @brief 毫秒累加，饱和到 0xFFFF，避免 16 位计时溢出回绕
* @param v 当前值
* @param dt 本次增加量
* @return 累加结果，最大 0xFFFF
*/
static inline uint16_t app_add_ms(uint16_t v, uint16_t dt)
{
uint32_t n = (uint32_t)v + dt;
return (n > 0xffffu) ? 0xffffu : (uint16_t)n;
}
#endif /* __APP_TIME_UTIL_H__ */
apps/usr_app/key.c
+267
View File
@@ -0,0 +1,267 @@
/******************************************************************************
* @file key.c
* @brief 按键状态机实现
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按键短按/长按/释放状态机
******************************************************************************/
#include "key.h"
#include <stddef.h>
static uint32_t s_key_count_time;
static uint8_t s_key_num = USR_KEY_COUNT;
keyCategory_t keyTable[USR_KEY_COUNT];
/**
* @brief 读按键电平到 fsm
* @param key 状态机
* @return 1=已读，0=被屏蔽
*/
static uint8_t get_key_level(keyFSM_t *key)
{
if (key->keyShield == KEY_DISABLE) {
return 0;
}
if (key->keyReadValue == NULL) {
return 0;
}
key->keyLevel = (key->keyReadValue() == key->keyDownLevel) ? Bit_SET : Bit_RESET;
return 1;
}
/**
* @brief 单击 / 双击间隔判定
* @param click 状态机
* @return 1=可以出事件
*/
static uint8_t key_click_frequency(keyFSM_t *click)
{
click->keyInterval++;
switch (click->keyFrequency) {
case CLICK:
if (click->keyInterval >= (KEY_INTERVAL / (DEBOUNCE_TIME * KEY_TIMER_MS))) {
click->eventType = SHORT_Event;
return 1;
}
break;
case DbLCLICK:
if (click->keyInterval >= (KEY_INTERVAL / (DEBOUNCE_TIME * KEY_TIMER_MS))) {
click->eventType = DBCL_Event;
return 1;
}
break;
default:
return 1;
}
return 0;
}
/**
* @brief 按键状态机步进
* @param key_buf 状态机
* @return 1=已处理
*/
static uint8_t read_key_status(keyFSM_t *key_buf)
{
if (!get_key_level(key_buf)) {
return 0;
}
switch (key_buf->keyStatus) {
case KEY_ST_NULL:
if (key_buf->keyLevel == Bit_SET) {
key_buf->keyStatus = KEY_ST_SURE;
}
break;
case KEY_ST_SURE:
if (key_buf->keyLevel == Bit_SET) {
key_buf->eventType = DOWN_Event;
key_buf->keyStatus = KEY_ST_DOWN;
key_buf->keyCount = 0;
key_buf->keyLongFlag = 1;
} else {
key_buf->keyStatus = KEY_ST_NULL;
}
break;
case KEY_ST_DOWN:
if (key_buf->keyLevel != Bit_SET) {
if (key_buf->keyShortFlag == 0) {
key_buf->keyShortFlag = 1;
key_buf->keyFrequency++;
key_buf->keyInterval = 0;
}
if (key_click_frequency(key_buf)) {
key_buf->keyFrequency = 0;
key_buf->keyStatus = KEY_ST_NULL;
}
if ((key_buf->keyCount >= key_buf->keyLongTime / DEBOUNCE_TIME)
&& (key_buf->keyCount < key_buf->keyLastTime / DEBOUNCE_TIME)) {
key_buf->keyFrequency = 0;
key_buf->keyStatus = KEY_ST_NULL;
key_buf->eventType = RELEASE_Event;
}
key_buf->keyCount = 0;
key_buf->keyLongFlag = 1;
} else {
if ((++key_buf->keyCount >= key_buf->keyLastTime / DEBOUNCE_TIME)) {
key_buf->keyCount = 0;
key_buf->keyFrequency = 0;
key_buf->keyStatus = KEY_ST_LONG;
key_buf->eventType = LAST_Event;
key_buf->keyLongFlag = 1;
}
if ((key_buf->keyCount >= key_buf->keyLongTime / DEBOUNCE_TIME)
&& (key_buf->keyCount < key_buf->keyLastTime / DEBOUNCE_TIME)) {
key_buf->keyFrequency = 0;
if (key_buf->keyLongFlag == 1) {
key_buf->eventType = LONG_Event;
key_buf->keyLongFlag = 0;
}
}
key_buf->keyShortFlag = 0;
}
break;
case KEY_ST_LONG:
if (key_buf->keyLevel != Bit_SET) {
key_buf->keyStatus = KEY_ST_NULL;
key_buf->eventType = RELEASE_Event;
}
break;
default:
break;
}
return 1;
}
/**
* @brief 扫描全部按键状态机
* @return 无
*/
static void key_event_process(void)
{
size_t i;
for (i = 0; i < s_key_num; i++) {
(void)read_key_status(&keyTable[i].fsm);
}
}
/**
* @brief 1ms 调用一次；满 DEBOUNCE_TIME 才真正采样
* @return 无
*/
void keyCheckProcess(void)
{
s_key_count_time++;
if (s_key_count_time >= (DEBOUNCE_TIME / KEY_TIMER_MS)) {
s_key_count_time = 0;
key_event_process();
}
}
/**
* @brief 拷贝产品按键表
* @param keys 按键数组，长度 USR_KEY_COUNT
* @return 无
*/
void keyParaInit(keyCategory_t *keys)
{
if (keys == NULL) {
return;
}
if (USR_KEY_COUNT >= KEY_MAX_NUMBER) {
s_key_num = KEY_MAX_NUMBER;
}
memcpy(keyTable, keys, sizeof(keyCategory_t) * s_key_num);
}
/**
* @brief 运行中改长按/连按时长并复位状态
* @param key_event 按键索引
* @param key_param 新参数
* @return 无
*/
void setKeyEventParams(uint8_t key_event, keyCategory_t key_param)
{
if (key_event >= s_key_num) {
return;
}
keyTable[key_event].fsm.keyShield = key_param.fsm.keyShield;
keyTable[key_event].fsm.keyLongTime = key_param.fsm.keyLongTime;
keyTable[key_event].fsm.keyLastTime = key_param.fsm.keyLastTime;
keyTable[key_event].fsm.keyStatus = KEY_ST_NULL;
keyTable[key_event].fsm.eventType = NULL_Event;
keyTable[key_event].fsm.keyCount = 0;
}
/**
* @brief 派发按键事件回调
* @return 无
*/
void keyHandle(void)
{
size_t i;
for (i = 0; i < s_key_num; i++) {
if (keyTable[i].fsm.eventType == NULL_Event) {
continue;
}
switch (keyTable[i].fsm.eventType) {
case RELEASE_Event:
if (keyTable[i].func.releasePressCb != NULL) {
keyTable[i].func.releasePressCb();
}
keyTable[i].fsm.eventType = NULL_Event;
break;
case SHORT_Event:
if (keyTable[i].func.ShortPressCb != NULL) {
keyTable[i].func.ShortPressCb();
}
keyTable[i].fsm.eventType = NULL_Event;
break;
case DOWN_Event:
if (keyTable[i].func.downPressCb != NULL) {
keyTable[i].func.downPressCb();
}
keyTable[i].fsm.eventType = NULL_Event;
break;
case LONG_Event:
if (keyTable[i].func.longPressCb != NULL) {
keyTable[i].func.longPressCb();
}
keyTable[i].fsm.eventType = NULL_Event;
break;
case LAST_Event:
if (keyTable[i].func.lastPressCb != NULL) {
keyTable[i].func.lastPressCb();
}
break;
case DBCL_Event:
if (keyTable[i].func.dbclPressCb != NULL) {
keyTable[i].func.dbclPressCb();
}
keyTable[i].fsm.eventType = NULL_Event;
break;
default:
break;
}
}
}
/**
* @brief 复位指定按键状态机
* @param key_index 按键索引
* @return 无
*/
void reset_key_Status(keyList key_index)
{
if (key_index >= USR_KEY_COUNT) {
return;
}
keyTable[key_index].fsm.keyStatus = KEY_ST_NULL;
keyTable[key_index].fsm.eventType = NULL_Event;
keyTable[key_index].fsm.keyCount = 0;
}
apps/usr_app/key.h
+100
View File
@@ -0,0 +1,100 @@
/******************************************************************************
* @file key.h
* @brief 按键状态机：短按 / 长按 / 释放
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按键短按/长按/释放状态机
******************************************************************************/
#ifndef __KEY_H__
#define __KEY_H__
#include <stdint.h>
#include <string.h>
/*============================================================================*/
/* 宏定义 */
/*============================================================================*/
#define KEY_TIMER_MS 1
#define KEY_MAX_NUMBER 12
#define DEBOUNCE_TIME 30
#define KEY_INTERVAL 30
#define CLICK 1
#define DbLCLICK 2
typedef enum {
USR_KEY_USER = 0,
USR_KEY_COUNT
} keyList;
typedef enum {
Bit_RESET = 0,
Bit_SET
} BitAction_t;
typedef enum {
KEY_ST_NULL = 0,
KEY_ST_RELEASE,
KEY_ST_SURE,
KEY_ST_UP,
KEY_ST_DOWN,
KEY_ST_LONG
} keyStatus_t;
typedef enum {
NULL_Event = 0,
DOWN_Event,
SHORT_Event,
LONG_Event,
LAST_Event,
DBCL_Event,
RELEASE_Event
} keyEvent_t;
typedef enum {
KEY_DISABLE = 0,
KEY_ENABLE = !KEY_DISABLE
} keyEnable_t;
typedef struct {
uint8_t keyShortFlag;
uint8_t keyLongFlag;
uint8_t keyInterval;
uint8_t keyFrequency;
uint16_t keyLongTime;
uint16_t keyLastTime;
uint32_t keyCount;
keyEnable_t keyShield;
BitAction_t keyLevel;
BitAction_t keyDownLevel;
keyStatus_t keyStatus;
keyEvent_t eventType;
uint8_t (*keyReadValue)(void);
} keyFSM_t;
typedef struct {
void (*nullPressCb)(void);
void (*releasePressCb)(void);
void (*downPressCb)(void);
void (*ShortPressCb)(void);
void (*longPressCb)(void);
void (*lastPressCb)(void);
void (*dbclPressCb)(void);
} keyFunc_t;
typedef struct {
keyFSM_t fsm;
keyFunc_t func;
} keyCategory_t;
void keyParaInit(keyCategory_t *keys);
void setKeyEventParams(uint8_t key_event, keyCategory_t key_param);
void keyCheckProcess(void);
void keyHandle(void);
void reset_key_Status(keyList key_index);
#endif /* __KEY_H__ */
apps/usr_app/key_manager.c
+148
View File
@@ -0,0 +1,148 @@
/******************************************************************************
* @file key_manager.c
* @brief CBC2 按键：读 PB1，短按/长按交给 usr_jb_main
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现短按切模式、长按 3s 关机与开机按键锁
******************************************************************************/
#include "system/includes.h"
#include "key_manager.h"
#include "bsp_hw.h"
#include "board_pin.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[KEY]"
#define LOG_INFO_ENABLE
#include "debug.h"
/** 模块状态，替代原来 2 个散落的 static */
typedef struct {
uint8_t initialized;
uint8_t boot_key_lock; /**< 1=开机判定时键还按着，等松开才认短按/长按 */
} KeyManagerCtx_t;
static KeyManagerCtx_t s_km;
/**
* @brief 读按键：1=按下
* @return 1=按下，0=松开
*/
static uint8_t key_user_read(void)
{
return bsp_key_is_pressed();
}
/**
* @brief 松开：清掉开机按着键的锁
* @return 无
*/
static void key_user_release(void)
{
if (s_km.boot_key_lock) {
s_km.boot_key_lock = 0;
log_info("boot key released\n");
}
}
/**
* @brief 短按：开机未松手前忽略
* @return 无
*/
static void key_user_short(void)
{
if (s_km.boot_key_lock) {
s_km.boot_key_lock = 0; /* 开机松手当成释放，不当短按切模式 */
log_info("boot key released\n");
return;
}
usr_on_key_short();
}
/**
* @brief 长按 3s：开机未松手前忽略，避免开机手还按着就关机
* @return 无
*/
static void key_user_long(void)
{
if (s_km.boot_key_lock) {
return; /* 开机手还按着，忽略这次 3s 长按，避免一开机就关机 */
}
usr_on_key_long();
}
static keyCategory_t s_keys[USR_KEY_COUNT] = {
[USR_KEY_USER] = {
.fsm.keyShield = KEY_ENABLE,
.fsm.keyDownLevel = Bit_SET,
.fsm.eventType = NULL_Event,
.fsm.keyLongTime = BOARD_KEY_POWER_MS,
.fsm.keyLastTime = (BOARD_KEY_POWER_MS + 7000), /* 大于长按即可，不使用持续按 */
.fsm.keyReadValue = key_user_read,
.func.ShortPressCb = key_user_short,
.func.longPressCb = key_user_long,
.func.releasePressCb = key_user_release,
},
};
/**
* @brief 装载按键表
* @return 无
*/
void user_key_init(void)
{
if (s_km.initialized) {
return;
}
keyParaInit(s_keys);
s_km.boot_key_lock = 0;
s_km.initialized = 1;
}
/**
* @brief 开机判定结束后：键还按着则锁住，松开才认短按/长按
* @return 无
*/
void user_key_lock_if_held(void)
{
reset_key_Status(USR_KEY_USER);
if (bsp_key_is_pressed()) {
s_km.boot_key_lock = 1; /* 开机手还按着，等松开才认短按/长按，避免立刻关机 */
log_info("boot key held, wait release\n");
}
}
/**
* @brief 按真实毫秒推进状态机
* @param dt 距上次调用的毫秒数
* @return 无
*/
void user_key_scan(uint16_t dt)
{
uint16_t i;
if (!s_km.initialized) {
return;
}
if (dt == 0) {
dt = 1;
}
/* 按键库按 1ms 步进，业务节拍是 20ms，这里循环 dt 次对齐真实时间 */
for (i = 0; i < dt; i++) {
keyCheckProcess();
}
}
/**
* @brief 派发按键回调
* @return 无
*/
void user_key_handle(void)
{
if (!s_km.initialized) {
return;
}
keyHandle();
}
apps/usr_app/key_manager.h
+53
View File
@@ -0,0 +1,53 @@
/******************************************************************************
* @file key_manager.h
* @brief CBC2 单按键：短按切模式，长按 3s 关机；开机 3s/5s 不走本库
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现短按切模式、长按 3s 关机与开机按键锁
******************************************************************************/
#ifndef __KEY_MANAGER_H__
#define __KEY_MANAGER_H__
#include "key.h"
/**
* @brief 业务层短按回调（app_function 实现）
* @return 无
*/
void usr_on_key_short(void);
/**
* @brief 业务层长按 3s 回调（app_function 实现）
* @return 无
*/
void usr_on_key_long(void);
/**
* @brief 装载按键表
* @return 无
*/
void user_key_init(void);
/**
* @brief 开机判定结束后：若键还按着则锁住，松开才认短按/长按
* @return 无
*/
void user_key_lock_if_held(void);
/**
* @brief 按真实毫秒推进状态机（空闲 20ms 节拍会循环 dt 次）
* @param dt 距上次调用的毫秒数
* @return 无
*/
void user_key_scan(uint16_t dt);
/**
* @brief 派发按键回调
* @return 无
*/
void user_key_handle(void);
#endif /* __KEY_MANAGER_H__ */
apps/usr_app/led.c
+328
View File
@@ -0,0 +1,328 @@
/******************************************************************************
* @file led.c
* @brief LED 事件框架实现：只改 ledMask 对应通道，红绿互不抢
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按通道掩码独立开关的 LED 事件框架
******************************************************************************/
#include "led.h"
#include <stddef.h>
static LED_EventTableItem_t s_led_priority_table[PRIORITY_MAX];
static LED_EventTableItem_t s_led_event_table[LED_EVENT_MAX];
static LED_SetState_t s_led_set_state;
static TIME_Get_t s_time_get;
static uint32_t get_tick_diff(uint32_t meiosis);
static uint8_t led_lighting_update(LED_Config_t *led);
#if (BLINK_ENABLE)
static uint8_t led_blinking_update(LED_Config_t *led);
#endif
#if (ALTERNATING_BLINK_ENABLE)
static uint8_t led_alternating_update(LED_Config_t *led);
#endif
/**
* @brief 注册写灯回调，只对掩码里的通道动手
* @param setState 回调，led=通道掩码，state=LED_ON/OFF
* @return 无
*/
void LED_SetStateInit(LED_SetState_t setState)
{
s_led_set_state = setState;
}
/**
* @brief 注册毫秒时间戳回调
* @param getTime 回调
* @return 无
*/
void SET_TimeGetInit(TIME_Get_t getTime)
{
s_time_get = getTime;
}
/**
* @brief 拷贝产品事件表
* @param ledEvent 长度必须为 LED_EVENT_MAX
* @return 无
*/
void LED_EventTableInit(LED_EventTableItem_t ledEvent[])
{
if (ledEvent == NULL) {
return;
}
memset(s_led_priority_table, 0, sizeof(s_led_priority_table));
memset(s_led_event_table, 0, sizeof(s_led_event_table));
memcpy(s_led_event_table, ledEvent, sizeof(s_led_event_table));
}
/**
* @brief 把事件挂到对应优先级槽；同优先级会被覆盖
* @param ledEvent 事件号
* @return 无
*/
void LED_EventAdd(LED_Event_t ledEvent)
{
size_t i;
LED_EventTableItem_t *item;
LED_EventPriority_t prio;
if ((s_time_get == NULL) || (s_led_set_state == NULL)) {
return;
}
if (ledEvent >= LED_EVENT_MAX) {
return;
}
for (i = 0; i < LED_EVENT_MAX; i++) {
item = &s_led_event_table[i];
if (item->event != ledEvent) {
continue;
}
prio = item->priority;
if (prio >= PRIORITY_MAX) {
return;
}
if (s_led_priority_table[prio].event != ledEvent) {
item->config.currentTime = s_time_get();
if (s_led_priority_table[prio].event != LED_EVENT_NONE) {
/* 同优先级换事件：只关掉旧灯里新事件用不到的通道 */
s_led_set_state((uint16_t)(s_led_priority_table[prio].config.ledMask
^ item->config.ledMask),
LED_OFF);
}
}
s_led_priority_table[prio] = *item;
return;
}
}
/**
* @brief 清空优先级表（不改 GPIO，由调用方灭灯）
* @return 无
*/
void LED_EventAllDelete(void)
{
memset(s_led_priority_table, 0, sizeof(s_led_priority_table));
}
/**
* @brief 删除指定事件并关掉它占用的通道
* @param ledEvent 事件号
* @return 无
*/
void LED_EventDelete(LED_Event_t ledEvent)
{
size_t i;
for (i = 0; i < PRIORITY_MAX; i++) {
if (s_led_priority_table[i].event != ledEvent) {
continue;
}
memset(&s_led_priority_table[i], 0, sizeof(LED_EventTableItem_t));
if ((s_led_set_state != NULL) && (ledEvent < LED_EVENT_MAX)) {
s_led_set_state(s_led_event_table[ledEvent].config.ledMask, LED_OFF);
}
return;
}
}
/**
* @brief 从高优先级往下跑事件
* @note handler 返回 1 会拦住更低优先级。红绿要共存时 handler 必须返回 0
* @return 无
*/
void LED_EventHandle(void)
{
int i;
uint8_t ret;
for (i = (int)PRIORITY_MAX - 1; i >= 0; i--) {
if (s_led_priority_table[i].event == LED_EVENT_NONE) {
continue;
}
if (s_led_priority_table[i].ledEventHandler == NULL) {
continue;
}
ret = s_led_priority_table[i].ledEventHandler(&s_led_priority_table[i].config);
if (ret) {
return;
}
}
}
/**
* @brief 是否有事件在跑
* @return 1=有，0=无
*/
uint8_t LED_IsEventActive(void)
{
size_t i;
for (i = 0; i < PRIORITY_MAX; i++) {
if (s_led_priority_table[i].event != LED_EVENT_NONE) {
return 1;
}
}
return 0;
}
/**
* @brief 指定事件是否挂在优先级表里
* @param ledEvent 事件号
* @return 1=在，0=不在
*/
uint8_t LED_IsEventExist(LED_Event_t ledEvent)
{
size_t i;
for (i = 0; i < PRIORITY_MAX; i++) {
if (s_led_priority_table[i].event == ledEvent) {
return 1;
}
}
return 0;
}
/**
* @brief 按配置刷新一次灯效
* @param led 配置，不可为空
* @return 1=还在跑，0=次数用完
*/
uint8_t LED_Update(LED_Config_t *led)
{
if (led == NULL) {
return 0;
}
switch (led->state) {
case LED_LIGHT:
return led_lighting_update(led);
#if (BLINK_ENABLE)
case LED_BLINKING:
return led_blinking_update(led);
#endif
#if (ALTERNATING_BLINK_ENABLE)
case LED_ALTERNATING_BLINK:
return led_alternating_update(led);
#endif
default:
return 0;
}
}
/**
* @brief 毫秒时间差，兼容溢出
* @param meiosis 起点时间戳
* @return 差值 ms
*/
static uint32_t get_tick_diff(uint32_t meiosis)
{
uint32_t now;
if (s_time_get == NULL) {
return 0;
}
now = s_time_get();
if (now >= meiosis) {
return now - meiosis;
}
return (0xFFFFFFFFu - meiosis) + now;
}
/**
* @brief 常亮；runNum 按秒计，0=一直亮
* @param led 配置
* @return 1=还在亮，0=到点灭
*/
static uint8_t led_lighting_update(LED_Config_t *led)
{
uint16_t sec_count;
if (s_led_set_state == NULL) {
return 0;
}
sec_count = (uint16_t)(get_tick_diff(led->currentTime) / 1000u);
if ((led->runNum > 0) && (sec_count >= led->runNum)) {
s_led_set_state(led->ledMask, LED_OFF);
return 0;
}
s_led_set_state(led->ledMask, LED_ON);
return 1;
}
#if (BLINK_ENABLE)
/**
* @brief 闪烁；runNum 按完整周期计，0=一直闪
* @param led 配置
* @return 1=还在闪，0=到点灭
*/
static uint8_t led_blinking_update(LED_Config_t *led)
{
uint32_t run_cycle;
uint16_t blink_count;
uint32_t sec_left;
if (s_led_set_state == NULL) {
return 0;
}
run_cycle = led->blinkParams.onTime + led->blinkParams.offTime;
if (run_cycle == 0) {
return 0;
}
blink_count = (uint16_t)(get_tick_diff(led->currentTime) / run_cycle);
sec_left = get_tick_diff(led->currentTime) % run_cycle;
if ((led->runNum > 0) && (blink_count >= led->runNum)) {
s_led_set_state(led->ledMask, LED_OFF);
return 0;
}
if (sec_left <= led->blinkParams.onTime) {
s_led_set_state(led->ledMask, led->blinkParams.orDer ? LED_OFF : LED_ON);
} else {
s_led_set_state(led->ledMask, led->blinkParams.orDer ? LED_ON : LED_OFF);
}
return 1;
}
#endif
#if (ALTERNATING_BLINK_ENABLE)
/**
* @brief 两组灯按时间片轮流亮
* @param led 配置
* @return 1=还在跑，0=到点灭
*/
static uint8_t led_alternating_update(LED_Config_t *led)
{
uint16_t blink_count;
uint32_t sec_left;
uint32_t time_slice;
size_t i;
if (s_led_set_state == NULL) {
return 0;
}
if (led->alternatingBlinkParams.Cycle == 0) {
return 0;
}
blink_count = (uint16_t)(get_tick_diff(led->currentTime)
/ led->alternatingBlinkParams.Cycle);
sec_left = get_tick_diff(led->currentTime) % led->alternatingBlinkParams.Cycle;
if ((led->runNum > 0) && (blink_count >= led->runNum)) {
s_led_set_state(led->ledMask, LED_OFF);
return 0;
}
time_slice = led->alternatingBlinkParams.Cycle / ALTERNAT_GROUP;
s_led_set_state(led->ledMask, LED_OFF);
for (i = 0; i < ALTERNAT_GROUP; i++) {
if ((sec_left > (time_slice * i)) && (sec_left <= (time_slice * (i + 1)))) {
s_led_set_state(led->alternatingBlinkParams.Group[i], LED_ON);
break;
}
}
return 1;
}
#endif
apps/usr_app/led.h
+124
View File
@@ -0,0 +1,124 @@
/******************************************************************************
* @file led.h
* @brief LED 事件框架：按通道掩码独立开关，红绿可同时亮
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现按通道掩码独立开关的 LED 事件框架
******************************************************************************/
#ifndef __LED_H__
#define __LED_H__
#include <stdint.h>
#include <string.h>
/*============================================================================*/
/* 宏定义 */
/*============================================================================*/
#define BLINK_ENABLE 1
#define ALTERNATING_BLINK_ENABLE 1
#define BREATH_ENABLE 0
#define RUNNING_ENABLE 0
#define MARQUEE_ENABLE 0
#define LED_ON 1
#define LED_OFF 0
#define LED_CHANNEL(user_led) (1u << (user_led))
#define ledPrintf(level, fmt, ...) ((void)0)
/*============================================================================*/
/* 类型 */
/*============================================================================*/
typedef enum {
LED_LIGHT = 0, /**< 常亮 */
LED_BLINKING, /**< 闪烁 */
LED_ALTERNATING_BLINK /**< 红绿交替 */
} LED_State_t;
typedef enum {
LED_EVENT_NONE = 0,
LED_EVENT_STANDBY, /**< 待机绿灯常亮 */
LED_EVENT_CHARGE, /**< 充电红灯常亮 */
LED_EVENT_CHARGE_FULL, /**< 充满绿灯常亮 */
LED_EVENT_LOWBAT, /**< 低电红闪 */
LED_EVENT_PAIRING, /**< 配对绿快闪 */
LED_EVENT_MODE, /**< 切模式绿闪两下 */
LED_EVENT_PAIR_OK, /**< 配对成功常绿若干秒 */
LED_EVENT_PAIR_FAIL, /**< 配对失败红绿交替 */
LED_EVENT_OTA, /**< OTA：红绿交替闪，直到升级结束/复位 */
LED_EVENT_EMPTY, /**< 电量 5% 关机：关绿灯，红灯闪 5 下 */
LED_EVENT_MAX
} LED_Event_t;
/**
* 同优先级会互相覆盖；红绿要共存必须放在不同优先级，且 handler 返回 0
*/
typedef enum {
PRIORITY_1 = 0, /**< 待机绿灯 */
PRIORITY_2, /**< 低电红闪 */
PRIORITY_3, /**< 充电红 / 充满绿 */
PRIORITY_4, /**< 配对 / 切模式 / 配对结果 / OTA / 5% 关机红闪 */
PRIORITY_MAX
} LED_EventPriority_t;
#if (BLINK_ENABLE)
typedef struct {
uint8_t orDer; /**< 1=先灭后亮，0=先亮后灭 */
uint32_t onTime; /**< 亮时间 ms */
uint32_t offTime; /**< 灭时间 ms */
} LED_BlinkParams_t;
#endif
#if (ALTERNATING_BLINK_ENABLE)
#define ALTERNAT_GROUP 2
typedef struct {
uint16_t Group[ALTERNAT_GROUP]; /**< 交替两组的通道掩码 */
uint32_t Cycle; /**< 一整轮交替周期 ms */
} LED_AlternatingBlinkParams_t;
#endif
typedef struct {
LED_State_t state;
uint16_t ledMask; /**< 本事件只动这些通道，其它灯不受影响 */
uint16_t runNum; /**< 0=无限；常亮按秒计，闪烁按周期计 */
uint32_t currentTime;
#if (BLINK_ENABLE)
LED_BlinkParams_t blinkParams;
#endif
#if (ALTERNATING_BLINK_ENABLE)
LED_AlternatingBlinkParams_t alternatingBlinkParams;
#endif
} LED_Config_t;
typedef struct {
LED_Event_t event;
LED_EventPriority_t priority;
LED_Config_t config;
uint8_t (*ledEventHandler)(LED_Config_t *config);
} LED_EventTableItem_t;
typedef void (*LED_SetState_t)(uint16_t led, uint8_t state);
typedef uint32_t (*TIME_Get_t)(void);
/*============================================================================*/
/* 外部接口 */
/*============================================================================*/
void LED_SetStateInit(LED_SetState_t setState);
void SET_TimeGetInit(TIME_Get_t getTime);
void LED_EventTableInit(LED_EventTableItem_t ledEvent[]);
void LED_EventAdd(LED_Event_t ledEvent);
void LED_EventDelete(LED_Event_t ledEvent);
void LED_EventAllDelete(void);
void LED_EventHandle(void);
uint8_t LED_IsEventActive(void);
uint8_t LED_IsEventExist(LED_Event_t ledEvent);
uint8_t LED_Update(LED_Config_t *led);
#endif /* __LED_H__ */
apps/usr_app/led_manager.c
+277
View File
@@ -0,0 +1,277 @@
/******************************************************************************
* @file led_manager.c
* @brief CBC2 灯事件：充电红与待机绿走不同通道，可同时亮
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现红绿独立通道灯事件表
******************************************************************************/
#include "led_manager.h"
#include "system/includes.h"
#include "bsp_hw.h"
#include "board_pin.h"
static uint8_t led_keep_handler(LED_Config_t *led_config);
static uint8_t led_standby_handler(LED_Config_t *led_config);
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);
static uint8_t led_empty_handler(LED_Config_t *led_config);
/**
* @brief 只改掩码里的通道，其它灯保持原样
* @param led 通道掩码
* @param state LED_ON / LED_OFF
* @return 无
*/
static void set_led_multi(uint16_t led, uint8_t state)
{
if (led & LED_CHANNEL(LED_CH_RED)) {
bsp_led_red_set(state);
}
if (led & LED_CHANNEL(LED_CH_GREEN)) {
bsp_led_green_set(state);
}
}
/**
* @brief 常亮/闪烁一直跑：返回 0，让其它通道的事件继续执行
* @param led_config 配置
* @return 0
*/
static uint8_t led_keep_handler(LED_Config_t *led_config)
{
(void)LED_Update(led_config);
return 0; /* 返回 0：不独占，其它通道的事件还能继续跑 */
}
/**
* @brief 待机绿灯；BOARD_LED_STANDBY_ON=0 时亮满 runNum 秒后删事件
* @param led_config 配置
* @return 0
*/
static uint8_t led_standby_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_STANDBY); /* runNum 到点（限时待机绿）后删事件 */
}
return 0;
}
/**
* @brief 配对绿快闪（无限）
* @param led_config 配置
* @return 0
*/
static uint8_t led_pairing_handler(LED_Config_t *led_config)
{
(void)LED_Update(led_config);
return 0;
}
/**
* @brief 切模式闪完两下后删事件
* @param led_config 配置
* @return 0
*/
static uint8_t led_mode_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_MODE); /* 闪完两下后删，绿灯还给待机/配对 */
}
return 0;
}
/**
* @brief 配对成功常绿若干秒后删事件
* @param led_config 配置
* @return 0
*/
static uint8_t led_pair_ok_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_PAIR_OK);
}
return 0;
}
/**
* @brief 配对失败红绿交替完后删事件
* @param led_config 配置
* @return 0
*/
static uint8_t led_pair_fail_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_PAIR_FAIL);
return 0;
}
/* 红绿都占用，拦住充电红，避免交替被冲掉 */
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 空电关机红闪：拦住其它灯，绿灯已关，只剩红灯闪 5 下
* @param led_config 配置
* @return 1=还在闪（拦住更低优先级），0=闪完已删事件
*/
static uint8_t led_empty_handler(LED_Config_t *led_config)
{
if (LED_Update(led_config) == 0) {
LED_EventDelete(LED_EVENT_EMPTY); /* 闪完 5 下后删，灯保持灭直到真正掉电 */
return 0;
}
return 1;
}
/**
* @brief 注册回调并装载 CBC2 事件表（GPIO 已在 bsp_hw_init）
* @return 无
*/
void user_led_init(void)
{
static LED_EventTableItem_t led_event_category[LED_EVENT_MAX] = {
[LED_EVENT_STANDBY] = {
/* 待机绿灯常亮，可与充电红共存 */
.event = LED_EVENT_STANDBY,
.priority = PRIORITY_1,
.config.ledMask = LED_CHANNEL(LED_CH_GREEN),
.config.state = LED_LIGHT,
#if BOARD_LED_STANDBY_ON
.config.runNum = 0, /* 0=一直亮 */
#else
.config.runNum = (uint16_t)((BOARD_LED_POWER_ON_MS + 999u) / 1000u),
#endif
.ledEventHandler = led_standby_handler,
},
[LED_EVENT_LOWBAT] = {
/* 低电红闪 */
.event = LED_EVENT_LOWBAT,
.priority = PRIORITY_2,
.config.ledMask = LED_CHANNEL(LED_CH_RED),
.config.state = LED_BLINKING,
.config.blinkParams.orDer = 0,
.config.blinkParams.onTime = BOARD_LED_LOWBAT_ON_MS,
.config.blinkParams.offTime = (BOARD_LED_LOWBAT_PERIOD_MS - BOARD_LED_LOWBAT_ON_MS),
.config.runNum = 0,
.ledEventHandler = led_keep_handler,
},
[LED_EVENT_CHARGE] = {
/* 充电红常亮，与待机绿不同通道 */
.event = LED_EVENT_CHARGE,
.priority = PRIORITY_2,
.config.ledMask = LED_CHANNEL(LED_CH_RED),
.config.state = LED_LIGHT,
.config.runNum = 0,
.ledEventHandler = led_keep_handler,
},
[LED_EVENT_CHARGE_FULL] = {
/* 充满绿常亮（与充电红同优先级，互斥覆盖） */
.event = LED_EVENT_CHARGE_FULL,
.priority = PRIORITY_2,
.config.ledMask = LED_CHANNEL(LED_CH_GREEN),
.config.state = LED_LIGHT,
.config.runNum = 0,
.ledEventHandler = led_keep_handler,
},
[LED_EVENT_PAIRING] = {
/* 配对绿快闪 */
.event = LED_EVENT_PAIRING,
.priority = PRIORITY_3,
.config.ledMask = LED_CHANNEL(LED_CH_GREEN),
.config.state = LED_BLINKING,
.config.blinkParams.orDer = 0,
.config.blinkParams.onTime = BOARD_LED_FAST_ON_MS,
.config.blinkParams.offTime = BOARD_LED_FAST_OFF_MS,
.config.runNum = 0,
.ledEventHandler = led_pairing_handler,
},
[LED_EVENT_MODE] = {
/* 切模式绿闪两下 */
.event = LED_EVENT_MODE,
.priority = PRIORITY_4,
.config.ledMask = LED_CHANNEL(LED_CH_GREEN),
.config.state = LED_BLINKING,
.config.blinkParams.orDer = 1,
.config.blinkParams.onTime = BOARD_LED_MODE_ON_MS,
.config.blinkParams.offTime = BOARD_LED_MODE_OFF_MS,
.config.runNum = BOARD_LED_MODE_BLINK_N,
.ledEventHandler = led_mode_handler,
},
[LED_EVENT_PAIR_OK] = {
/* 配对成功常绿若干秒 */
.event = LED_EVENT_PAIR_OK,
.priority = PRIORITY_3,
.config.ledMask = LED_CHANNEL(LED_CH_GREEN),
.config.state = LED_LIGHT,
.config.runNum = (uint16_t)((BOARD_LED_PAIR_OK_MS + 999u) / 1000u),
.ledEventHandler = led_pair_ok_handler,
},
[LED_EVENT_PAIR_FAIL] = {
/* 配对失败红绿交替 */
.event = LED_EVENT_PAIR_FAIL,
.priority = PRIORITY_3,
.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 = (uint16_t)((BOARD_LED_PAIR_FAIL_MS + (BOARD_LED_ALT_MS * 2u) - 1u)
/ (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_EVENT_EMPTY] = {
/* 电量 5%：关绿灯后只闪红灯 5 下，然后掉电 */
.event = LED_EVENT_EMPTY,
.priority = PRIORITY_4,
.config.ledMask = LED_CHANNEL(LED_CH_RED),
.config.state = LED_BLINKING,
.config.blinkParams.orDer = 0, /* 先亮后灭 */
.config.blinkParams.onTime = BOARD_LED_EMPTY_ON_MS,
.config.blinkParams.offTime = BOARD_LED_EMPTY_OFF_MS,
.config.runNum = BOARD_LED_EMPTY_BLINK_N,
.ledEventHandler = led_empty_handler,
},
};
LED_SetStateInit(set_led_multi);
SET_TimeGetInit((TIME_Get_t)timer_get_ms);
LED_EventTableInit(led_event_category);
bsp_led_all_off();
}
/**
* @brief 跑一轮 LED 事件
* @return 无
*/
void user_led_handle(void)
{
LED_EventHandle();
}
apps/usr_app/led_manager.h
+34
View File
@@ -0,0 +1,34 @@
/******************************************************************************
* @file led_manager.h
* @brief CBC2 红绿 LED 通道与事件表
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.0.0
* @history
* - V1.0.0, 2026.08.25, cyWu, 首次发布，实现红绿独立通道灯事件表
******************************************************************************/
#ifndef __LED_MANAGER_H__
#define __LED_MANAGER_H__
#include "led.h"
typedef enum {
LED_CH_RED = 0,
LED_CH_GREEN,
LED_CH_MAX
} LedChannel_t;
/**
* @brief 注册 GPIO 回调并装载 CBC2 事件表
* @return 无
*/
void user_led_init(void);
/**
* @brief 跑一轮 LED 事件
* @return 无
*/
void user_led_handle(void);
#endif /* __LED_MANAGER_H__ */
apps/usr_jb_proto/Protocol/jb_product.c
+5 -1
View File
@@ -127,7 +127,11 @@ int8_t jbEventProcess(jb_event_info_t *info, jb_data_point_t *ctrl)
/* ── DP2 手动模式 (raw) ── */
case DP_ID_HAND_MODE:
memcpy(gDevData.hand_mode, ctrl->hand_mode, 2);
// TODO: 根据 gDevData.hand_mode 执行动作 (长度 2 字节)
/* 薄适配：通知业务层；03=停，00=空闲 */
{
extern void usr_dp_hand_write(uint8_t cmd);
usr_dp_hand_write(ctrl->hand_mode[0]);
}
break;
/* ── DP3 绳索校准 (bool) ── */
apps/usr_jb_proto/usr_jb_main.c
+285 -12
View File
@@ -1,18 +1,62 @@
/******************************************************************************
* @file usr_jb_main.c
* @brief CBC2 业务组合根：只做“先后调用谁、谁通知谁”，不含具体业务算法
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V2.1.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.24, cyWu, 收口未接线模块；DP2 仅第 1 字节点动 1s
* - 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/按键改事件库，红绿可同时亮
* - V2.0.0, 2026.08.25, cyWu, 重构：电源/配对/开机/功能拆成独立模块，
* 本文件只剩初始化顺序、1ms 调度、模块间接线
* - V2.1.0, 2026.08.26, cyWu, 电机运转期间长期占用 1ms 硬件定时器中断，
* 配网连接后与 BLE 协议栈抢时序触发看门狗复位；
* 换向死区判定改用阈值检查而非精确计时，
* 取消专门的 1ms 高频档，全系统统一 20ms 节拍，
* 只保留"能不能休眠"这一个维度
*
* @note 协议生成文件 jb_product.c 不要填业务。APP 下行写 gDevData。
* usr_timer_loop 由 BLE 回调，勿再注册第二份。
* 具体业务逻辑请去对应模块找：
* app_power —— USB/充电/电量/深睡请求
* app_pair —— 配对会话计时
* app_boot —— 开机 3s/5s/12s 按键判定
* app_function —— DP0/DP1/DP2 与按键动作
* app_led —— 灯效
******************************************************************************/
#include "system/includes.h"
#include "app_config.h"
#include "app_main.h"
#include "app_task.h"
#include "user_cfg.h"
#include "vm.h"
#include "sys_time.h"
#include "jb_protocol.h"
#include "jb_product.h"
#include "jb_ringbuffer.h"
#include "jb_common.h"
#include "usr_le_product.h"
#include "usr_le_api.h"
#include "bsp_hw.h"
#include "app_power.h"
#include "app_pair.h"
#include "app_boot.h"
#include "app_function.h"
#include "app_mode.h"
#include "app_led.h"
#include "key_manager.h"
#include "asm/power/power_api.h"
/* 向 usr_le_code 库提供产品身份（换产品只改 jb_protocol.h 宏即可） */
#define LOG_TAG_CONST APP
#define LOG_TAG "[USR_JB]"
#define LOG_INFO_ENABLE
#include "debug.h"
/* 向 usr_le_code 提供产品身份（换产品只改 jb_protocol.h 宏即可） */
const uint8_t g_usr_le_prodcode[USR_LE_PRODCODE_LEN] = {
JB_CATEGORY_CODE[0], JB_CATEGORY_CODE[1],
JB_CATEGORY_CODE[2], JB_CATEGORY_CODE[3]
@@ -22,27 +66,256 @@ const uint8_t g_usr_le_pcode[USR_LE_PCODE_LEN] = {
JB_PRODUCT_CODE[3], JB_PRODUCT_CODE[4], JB_PRODUCT_CODE[5]
};
void usr_timer_1_ms();
static int jb_timer_id=0;
#define USR_TIMER_IDLE_MS 20 /**< 全局统一节拍：按键消抖、换向死区判定都按它对齐 */
void usr_jb_init()
/**
* @brief 业务节拍档位
* @note 全系统只用一种节拍周期（USR_TIMER_IDLE_MS），区别只在"能不能休眠"，
* 不存在专门的 1ms 高频档——之前为了电机换向死区（BOARD_MOTOR_REVERSE_MS）
* 单独开过 1ms 硬件定时器中断，配网连接后跟 BLE 协议栈自己的收发/ACK
* 处理抢时序，长时间叠加导致看门狗复位。
* 换向死区的判定是"距上次换向是否已过 switch_ms"这种阈值检查，不是
* 精确计时：用 20ms 节拍去查，查到时实际已经过了不少于 20ms，天然
* 满足"至少 1ms"的死区要求，只会让保护更充分，不会失效。所以死区
* 不需要专门的 1ms 精度，可以和其它业务共用同一个节拍。
*/
typedef enum {
USR_TICK_IDLE = 0, /**< 可休眠 */
USR_TICK_BLOCK_SLEEP /**< 禁止休眠（按键按住/玩法中/关机等待/电机运转，含换向死区）*/
} UsrTickMode_t;
/** 调度器状态，替代原来 2 个散落的 static */
typedef struct {
int timer_id;
UsrTickMode_t mode;
} UsrSchedulerCtx_t;
static UsrSchedulerCtx_t s_sched;
static void usr_timer_tick(void *priv);
static void usr_timer_rearm(UsrTickMode_t mode);
static void usr_log_boot_version(void);
/**
* @brief USB 插拔的联动：插入即停电机，拔出即软关并刷新系统电源图标
* @param evt app_power_tick_1ms 上报的边沿事件
* @return 无
*/
static void usr_on_power_evt(AppPowerEvt_t evt)
{
switch (evt) {
case APP_POWER_EVT_USB_IN:
app_function_stop_all();
log_info("usb in, motor stop\n");
break;
case APP_POWER_EVT_USB_OUT:
app_function_soft_off();
break;
default:
break;
}
}
/**
* @brief 深睡请求钩子：立刻停电机；空电路径挂红闪，按键关机则灯全灭
* @return 无
*/
static void usr_poweroff_request_hook(void)
{
app_function_stop_all();
if (app_power_empty_off_pending()) {
/* 电量到 5%：关绿灯，红灯闪 5 下，真正掉电等闪完 */
app_led_request_empty_off();
} else {
app_led_clear();
}
}
/**
* @brief 深睡请求钩子：50ms 到点，真正进入深睡
* @note 不走 sys_enter_soft_poweroff()：那是耳机 SDK 给"蓝牙耳机"设计的优雅关机流程
* （BLE 断连握手 + 任务切换到 idle + 尝试放关机音效），实测哪怕已经砍掉了灯效
* 动画和广播空转，走完还是要 2.5s 左右，供应商确认这对按键关机的玩具不正常。
* 本产品不用 DAC/音频（没有 dac_power_on 过），跳过 dac_power_off()——
* 它在从未打开过 DAC 的情况下会直接调 audio_dac_close() 关一个没开过的
* 句柄，没必要也没好处。跳过 BLE 优雅断连的代价是手机 App 端不会收到
* 断连通知，只能等连接超时（标准 BLE 行为，等同于直接拔电池，App 端会
* 自行处理，不影响下次重连配对）。
* @return 无
*/
static void usr_poweroff_finalize_hook(void)
{
bsp_hw_enter_sleep_io();
power_set_soft_poweroff();
}
/**
* @brief 按当前业务状态判断能不能休眠
* @note 换向死区（bsp_motor_is_busy 已把它算进"忙"）、点动、玩法、按键按住、
* 关机等待，统一都是"不能睡"，节拍周期都一样用 USR_TIMER_IDLE_MS，
* 不再区分要不要 1ms
* @return 本次应使用的档位
*/
static UsrTickMode_t usr_timer_pick_mode(void)
{
if (bsp_key_is_pressed() || app_power_poweroff_pending()
|| app_mode_get_active() || bsp_motor_is_busy()
|| app_function_is_hand_busy()) {
return USR_TICK_BLOCK_SLEEP;
}
return USR_TICK_IDLE;
}
/**
* @brief 切换业务定时器。priority=1 时系统无法 sleep；节拍周期恒为 USR_TIMER_IDLE_MS
* @param mode 目标档位
* @return 无
*/
static void usr_timer_rearm(UsrTickMode_t mode)
{
if (s_sched.timer_id) {
usr_timer_del((u16)s_sched.timer_id);
s_sched.timer_id = 0;
}
s_sched.mode = mode;
s_sched.timer_id = (int)usr_timer_add(NULL, usr_timer_tick, USR_TIMER_IDLE_MS,
(mode == USR_TICK_BLOCK_SLEEP) ? 1 : 0);
}
/**
* @brief 业务定时器：固定 USR_TIMER_IDLE_MS 一拍；忙时禁睡，空闲可睡
* @param priv 未使用
* @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)
{
uint16_t dt = USR_TIMER_IDLE_MS;
uint16_t i;
UsrTickMode_t want;
AppPowerEvt_t pwr_evt;
(void)priv;
for (i = 0; i < dt; i++) {
jbTimerIrq();
}
if (!app_power_poweroff_pending()) {
user_key_scan(dt);
user_key_handle(); /* 长按 3s 会在这里同步触发 app_power_request_poweroff() */
}
pwr_evt = app_power_tick_1ms(dt);
usr_on_power_evt(pwr_evt);
app_function_poll();
app_function_tick_1ms(dt);
/* 重新查询而非复用上面的判断：user_key_handle() 可能在本拍内刚请求关机，
* 要用最新状态决定这一拍还要不要播灯效，否则会多播一帧才熄灭。
* OTA / 空电红闪期间灯效优先：关机钩子不要把提示灯清掉。 */
if (app_led_is_ota() || app_led_is_empty_off()) {
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();//判断能不能休眠
if (want != s_sched.mode) {
usr_timer_rearm(want);//切换业务定时器
}
}
/**
* @brief 上电打印固件版本与编译时间，方便串口对应当前是哪一包
* @return 无
*/
static void usr_log_boot_version(void)
{
log_info("sw V%d.%d.%d hw V%d.%d.%d build %s %s\n",
JB_MCU_SW_VERSION_MAJOR, JB_MCU_SW_VERSION_MINOR, JB_MCU_SW_VERSION_PATCH,
JB_MCU_HW_VERSION_MAJOR, JB_MCU_HW_VERSION_MINOR, JB_MCU_HW_VERSION_PATCH,
__DATE__, __TIME__);
}
/**
* @brief 业务初始化（在 BLE 栈起来之前由 app_main 调用）
* @note 内部会等按键 3s/5s；不足 3s 直接深睡，不会启动业务定时器。
* 按键判定只摸 bsp_hw 的裸 GPIO，不经过协议栈/灯效表/电机状态机，
* 所以只有 bsp_hw_init() 需要排在它前面——一旦判定要睡回去，
* boot_sleep() 原地喂狗不再返回，后面这些初始化不会被浪费。
* @return 无
*/
void usr_jb_init(void)
{
usr_log_boot_version(); /* UART 已在 app_main 起来，按键判定前就能看到版本 */
bsp_hw_init();
app_boot_wait_key(); /* 深睡分支不会返回；返回即代表确定要开机 */
jbInit();
userInit();
if(jb_timer_id==0)jb_timer_id = sys_s_hi_timer_add(NULL, usr_timer_1_ms, TIMER_PERIOD_MS);
app_led_init();
if (usr_var.usr_goto_updata) {
/* 开机 12s 已进 OTA：灯表刚起来，立刻挂红绿交替 */
app_led_request_ota();
}
app_mode_init();
app_power_init();
app_power_set_hooks(usr_poweroff_request_hook, usr_poweroff_finalize_hook);
app_function_init();
user_key_init();
user_key_lock_if_held();
app_function_power_on_silent();
usr_timer_rearm(USR_TICK_IDLE);
log_info("timer idle %ums, sleep ok\n", (unsigned)USR_TIMER_IDLE_MS);
}
void usr_timer_1_ms()
/**
* @brief DP2 写入钩子（jb_product 薄适配调用，不在此驱电机）
* @param cmd 第 1 字节：0=空闲，1=顺时针，2=逆时针，3=停
* @return 无
*/
void usr_dp_hand_write(uint8_t cmd)
{
jbTimerIrq();
app_function_dp_hand_write(cmd);
}
void usr_jb_le_recieve_data(u8* data,u16 len)
/**
* @brief BLE 收到见宝载荷，送入协议环形缓冲
* @param data 载荷指针
* @param len 载荷长度，单位字节
* @return 无
*/
void usr_jb_le_recieve_data(u8 *data, u16 len)
{
jbPutData(data,len);
jbPutData(data, len);
}
void usr_timer_loop()///500ms
/**
* @brief 约 500ms：协议收包与 DP 上报（由 usr_le_code 回调，不要再注册一份）
* @return 无
*/
void usr_timer_loop(void)
{
userHandle();
jbProtocolHandle(&gDevData);
apps/usr_le_code/ble_proto.c
+245
View File
@@ -0,0 +1,245 @@
/**
* @file ble_proto.c
* @brief BLE-网关通信协议 V1.3 序列化 / 反序列化实现
*
* 结构：
* [Cmd:2][Reserved:4][gateway_int_cnt:1][gateway_int32[]:4*N]
* [device_int_len:2][device_str_len:2][device_bytes_len:2]
* [Payload][CRC16:2]
*
* CRC 计算范围：Cmd ~ Payload 末尾（整个包除 CRC 字段）
*/
#include "ble_proto.h"
#include <string.h>
/* -----------------------------------------------------------------------
* 内部辅助：Big Endian 读写
* --------------------------------------------------------------------- */
/** 写入 uint16_t（Big Endian） */
static inline void put_be16(uint8_t *p, uint16_t v)
{
p[0] = (uint8_t)(v >> 8);
p[1] = (uint8_t)(v & 0xFFu);
}
/** 写入 uint32_t（Big Endian） */
static inline void put_be32(uint8_t *p, uint32_t v)
{
p[0] = (uint8_t)(v >> 24);
p[1] = (uint8_t)((v >> 16) & 0xFFu);
p[2] = (uint8_t)((v >> 8) & 0xFFu);
p[3] = (uint8_t)( v & 0xFFu);
}
/** 读取 uint16_t（Big Endian） */
static inline uint16_t get_be16(const uint8_t *p)
{
return (uint16_t)(((uint16_t)p[0] << 8) | p[1]);
}
/** 读取 uint32_t（Big Endian） */
static inline uint32_t get_be32(const uint8_t *p)
{
return ((uint32_t)p[0] << 24)
| ((uint32_t)p[1] << 16)
| ((uint32_t)p[2] << 8)
| (uint32_t)p[3];
}
/* -----------------------------------------------------------------------
* CRC16（多项式 0x8005，初值 0xFFFF —— MODBUS 变体）
* --------------------------------------------------------------------- */
uint16_t ble_proto_crc16(const uint8_t *data, size_t len)
{
uint16_t crc = 0xFFFFu;
for (size_t i = 0; i < len; i++) {
crc ^= (uint16_t)data[i];
for (int bit = 0; bit < 8; bit++) {
if (crc & 0x0001u) {
crc = (crc >> 1) ^ 0xA001u;
} else {
crc >>= 1;
}
}
}
return crc;
}
/* -----------------------------------------------------------------------
* 序列化（pack）
* --------------------------------------------------------------------- */
int ble_proto_pack(const ble_proto_packet_t *pkt, uint8_t *buf, size_t buf_size)
{
if (!pkt || !buf) return BLE_PROTO_ERR_NULL;
/* ----- 参数合法性检查 ----- */
if (pkt->gateway_int_cnt > BLE_PROTO_GW_INT_MAX) return BLE_PROTO_ERR_GW_CNT;
if (pkt->device_int_len % 4 != 0) return BLE_PROTO_ERR_INT_ALIGN;
/* ----- 计算所需总长度 ----- */
size_t payload_len = (size_t)pkt->device_int_len
+ (size_t)pkt->device_str_len
+ (size_t)pkt->device_bytes_len;
size_t total = BLE_PROTO_HEADER_LEN /* Cmd(2) + Reserved(4) */
+ BLE_PROTO_GW_CNT_LEN /* gateway_int_cnt (1) */
+ (size_t)pkt->gateway_int_cnt * 4u /* gateway_int[] */
+ BLE_PROTO_DEV_PARAM_LEN /* 3 x device_*_len */
+ payload_len /* Payload */
+ BLE_PROTO_CRC_LEN; /* CRC16 */
if (buf_size < total) return BLE_PROTO_ERR_BUF_SMALL;
uint8_t *p = buf;
/* ----- Protocol Header ----- */
put_be16(p, pkt->cmd); p += 2;
put_be32(p, 0); p += 4; /* Reserved 固定填 0 */
/* ----- Gateway Parameter ----- */
*p++ = pkt->gateway_int_cnt; /* uint8 */
for (uint8_t i = 0; i < pkt->gateway_int_cnt; i++) {
put_be32(p, (uint32_t)pkt->gateway_int[i]);
p += 4;
}
/* ----- Device Parameter ----- */
put_be16(p, pkt->device_int_len); p += 2;
put_be16(p, pkt->device_str_len); p += 2;
put_be16(p, pkt->device_bytes_len); p += 2;
/* ----- Payload ----- */
if (pkt->device_int_len > 0 && pkt->int_data) {
for (uint16_t i = 0; i < pkt->device_int_len / 4u; i++) {
put_be32(p, (uint32_t)pkt->int_data[i]);
p += 4;
}
}
if (pkt->device_str_len > 0 && pkt->str_data) {
memcpy(p, pkt->str_data, pkt->device_str_len);
p += pkt->device_str_len;
}
if (pkt->device_bytes_len > 0 && pkt->bytes_data) {
memcpy(p, pkt->bytes_data, pkt->device_bytes_len);
p += pkt->device_bytes_len;
}
/* ----- CRC16（从 buf[0] 开始，到 Payload 末尾） ----- */
uint16_t crc = ble_proto_crc16(buf, (size_t)(p - buf));
put_be16(p, crc);
p += 2;
return (int)(p - buf);
}
/* -----------------------------------------------------------------------
* 反序列化（unpack）
* --------------------------------------------------------------------- */
int ble_proto_unpack(const uint8_t *buf, size_t len, ble_proto_packet_t *pkt)
{
if (!buf || !pkt) return BLE_PROTO_ERR_NULL;
/* 最小包长：Header(6) + gw_cnt(1) + dev_param(6) + CRC(2) = 15 */
const size_t min_len = BLE_PROTO_HEADER_LEN
+ BLE_PROTO_GW_CNT_LEN
+ BLE_PROTO_DEV_PARAM_LEN
+ BLE_PROTO_CRC_LEN;
if (len < min_len) return BLE_PROTO_ERR_LEN;
const uint8_t *p = buf;
/* ----- Protocol Header ----- */
pkt->cmd = get_be16(p); p += 2;
pkt->reserved = get_be32(p); p += 4;
/* ----- Gateway Parameter ----- */
pkt->gateway_int_cnt = *p++;
if (pkt->gateway_int_cnt > BLE_PROTO_GW_INT_MAX) return BLE_PROTO_ERR_GW_CNT;
/* 检查剩余字节是否足够容纳 gateway_int[] + dev_param + CRC */
size_t consumed = (size_t)(p - buf)
+ (size_t)pkt->gateway_int_cnt * 4u
+ BLE_PROTO_DEV_PARAM_LEN
+ BLE_PROTO_CRC_LEN;
if (len < consumed) return BLE_PROTO_ERR_LEN;
for (uint8_t i = 0; i < pkt->gateway_int_cnt; i++) {
pkt->gateway_int[i] = (int32_t)get_be32(p);
p += 4;
}
/* ----- Device Parameter ----- */
pkt->device_int_len = get_be16(p); p += 2;
pkt->device_str_len = get_be16(p); p += 2;
pkt->device_bytes_len = get_be16(p); p += 2;
if (pkt->device_int_len % 4 != 0) return BLE_PROTO_ERR_INT_ALIGN;
size_t payload_len = (size_t)pkt->device_int_len
+ (size_t)pkt->device_str_len
+ (size_t)pkt->device_bytes_len;
/* 验证总长度（含 CRC） */
if ((size_t)(p - buf) + payload_len + BLE_PROTO_CRC_LEN != len) {
return BLE_PROTO_ERR_LEN;
}
/* ----- CRC16 校验（从 buf[0] 到 CRC 前一字节） ----- */
uint16_t crc_calc = ble_proto_crc16(buf, len - BLE_PROTO_CRC_LEN);
uint16_t crc_recv = get_be16(buf + len - BLE_PROTO_CRC_LEN);
if (crc_calc != crc_recv) return BLE_PROTO_ERR_CRC;
/* ----- Payload（零拷贝，直接指向 buf 内部） ----- */
if (pkt->device_int_len > 0) {
pkt->int_data = (const int32_t *)p;
} else {
pkt->int_data = NULL;
}
p += pkt->device_int_len;
pkt->str_data = (pkt->device_str_len > 0) ? (const char *)p : NULL;
p += pkt->device_str_len;
pkt->bytes_data = (pkt->device_bytes_len > 0) ? p : NULL;
// printf("cmd = %d", pkt->cmd);
// printf("reserved = %d", pkt->reserved);
// printf("gateway_int_cnt = %d", pkt->gateway_int_cnt);
// printf("device_int_len = %d", pkt->device_int_len);
// printf("device_str_len = %d", pkt->device_str_len);
// printf("device_bytes_len = %d", pkt->device_bytes_len);
// /* int_data 指向 buf 内部，地址未必 4 字节对齐，
// * 不能直接解引用 int32_t*（对齐访问会触发硬件异常）；
// * 必须按字节读取，用 get_be32 还原数值 */
// if (pkt->int_data && pkt->device_int_len >= 4) {
// const uint8_t *ip = (const uint8_t *)pkt->int_data;
// printf("int_data = ");
// for (uint16_t i = 0; i < pkt->device_int_len / 4u; i++) {
// printf("%08X ", (unsigned int)get_be32(ip + (uint32_t)i * 4u));
// }
// printf("\n");
// }
// /* str_data / bytes_data 不保证有 '\0'，用 printf_buf 打印 hex */
// if (pkt->str_data && pkt->device_str_len > 0) {
// printf("str_data = ");
// for (size_t i = 0; i < pkt->device_str_len; i++) {
// printf("%02X ", *(pkt->str_data + i));
// }
// printf("\n");
// }
// if (pkt->bytes_data && pkt->device_bytes_len > 0) {
// printf("bytes_data = ");
// for (size_t i = 0; i < pkt->device_bytes_len; i++) {
// printf("%02X ", *(pkt->bytes_data + i));
// }
// printf("\n");
// }
// printf("crc = %04X", crc_recv);
// printf("\n");
return BLE_PROTO_OK;
}
apps/usr_le_code/ble_proto.h
+133
View File
@@ -0,0 +1,133 @@
/**
* @file ble_proto.h
* @brief BLE-网关通信协议 V1.3 序列化 / 反序列化接口
*
* 数据包结构（Big Endian）：
* [Cmd:2][Reserved:4]
* [gateway_int_cnt:1][gateway_int32[]:4*N]
* [device_int_len:2][device_str_len:2][device_bytes_len:2]
* [Payload: int_data | str_data | bytes_data]
* [CRC16:2]
*
* 当前协议头（固定 6 字节）：[Cmd:2][Reserved:4]
* （说明：本文件早期 V1.2 草案曾在 Cmd 后加入 8 字节时间戳 t，
* 现设备侧不再使用，已从线格式中彻底移除。）
*
* V1.1 变更（相对 V1.0）：
* - 删除 Magic、Version、Seq 字段
* - 新增 Reserved（uint32，固定填 0）
* - Cmd 移至偏移 0
* - gateway_int_cnt 由 uint16 调整为 uint8
* - CRC 计算范围：Cmd ~ Payload 末尾（整个包除 CRC 字段本身）
*/
#ifndef BLE_PROTO_H
#define BLE_PROTO_H
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/* -----------------------------------------------------------------------
* 协议常量
* --------------------------------------------------------------------- */
/** Header 固定长度：Cmd(2) + Reserved(4) = 6 Bytes */
#define BLE_PROTO_HEADER_LEN 6u
/** gateway_int_cnt 字段长度（uint8） */
#define BLE_PROTO_GW_CNT_LEN 1u
/** Device Parameter 固定长度：3 x uint16 = 6 Bytes */
#define BLE_PROTO_DEV_PARAM_LEN 6u
/** CRC16 字段长度 */
#define BLE_PROTO_CRC_LEN 2u
/** 最大 Gateway int32 参数个数（防御性上限，可按需修改） */
#define BLE_PROTO_GW_INT_MAX 16u
/** 最大 Payload 总长度（按实际业务调整） */
#define BLE_PROTO_PAYLOAD_MAX 2048u
/* -----------------------------------------------------------------------
* 报文数据包（解包后的逻辑结构）
* --------------------------------------------------------------------- */
typedef struct {
/* ----- Protocol Header ----- */
uint16_t cmd; /**< 协议命令（上报、控制、应答、OTA等） */
uint32_t reserved; /**< 保留字段，发送端固定填 0 */
/* ----- Gateway Parameter ----- */
uint8_t gateway_int_cnt; /**< Gateway int32 参数个数 */
int32_t gateway_int[BLE_PROTO_GW_INT_MAX]; /**< Gateway int32 参数列表 */
/* ----- Device Parameter ----- */
uint16_t device_int_len; /**< Payload 中 int 数据字节数（必须是 4 的整数倍） */
uint16_t device_str_len; /**< Payload 中 string 数据字节数（不含 '\0'） */
uint16_t device_bytes_len; /**< Payload 中 bytes 数据字节数 */
/* ----- Payload 数据指针（指向外部 buffer，不拥有所有权） ----- */
const int32_t *int_data; /**< Device Int 数据（pack 输入为主机序 int32 数组，ble_proto_pack 内部逐元素 put_be32 转 BE；unpack 输出为 buf 内原始 BE 字节，调用方须用 get_be32 读取，不可直接解引用） */
const char *str_data; /**< Device String 数据（不含 '\0'） */
const uint8_t *bytes_data; /**< Device Bytes 数据 */
} ble_proto_packet_t;
/* -----------------------------------------------------------------------
* 错误码
* --------------------------------------------------------------------- */
typedef enum {
BLE_PROTO_OK = 0,
BLE_PROTO_ERR_NULL = -1, /**< 空指针 */
BLE_PROTO_ERR_BUF_SMALL = -2, /**< 输出缓冲区不足 */
BLE_PROTO_ERR_CRC = -3, /**< CRC16 校验失败 */
BLE_PROTO_ERR_LEN = -4, /**< 长度字段非法 / 包长不足 */
BLE_PROTO_ERR_GW_CNT = -5, /**< gateway_int_cnt 超出上限 */
BLE_PROTO_ERR_INT_ALIGN = -6, /**< device_int_len 非 4 倍数 */
} ble_proto_err_t;
/* -----------------------------------------------------------------------
* 接口
* --------------------------------------------------------------------- */
/**
* @brief 序列化：将逻辑数据包打包成字节流
*
* @param[in] pkt 逻辑数据包（reserved 字段被忽略，固定填 0）
* @param[out] buf 输出缓冲区
* @param[in] buf_size 缓冲区大小（字节）
* @return 打包后实际字节数（>0），或 ble_proto_err_t 负值
*/
int ble_proto_pack(const ble_proto_packet_t *pkt, uint8_t *buf, size_t buf_size);
/**
* @brief 反序列化：将字节流解析为逻辑数据包
*
* @note pkt->int_data / str_data / bytes_data 指向 buf 内部，不复制数据。
* buf 的生命周期必须长于 pkt 的使用期。
* @note pkt->reserved 的值被读出但不做校验，接收端可直接忽略。
*
* @param[in] buf 输入字节流
* @param[in] len 字节流长度
* @param[out] pkt 解析结果
* @return BLE_PROTO_OK，或 ble_proto_err_t 负值
*/
int ble_proto_unpack(const uint8_t *buf, size_t len, ble_proto_packet_t *pkt);
/**
* @brief 计算 CRC16（MODBUS 变体，多项式 0x8005，初值 0xFFFF）
*
* @param[in] data 数据起始地址
* @param[in] len 数据字节数
* @return CRC16 值
*/
uint16_t ble_proto_crc16(const uint8_t *data, size_t len);
#ifdef __cplusplus
}
#endif
#endif /* BLE_PROTO_H */
apps/usr_le_code/bleproto.c
+529
View File
@@ -0,0 +1,529 @@
/****************************************************************************/
/* bleproto.c
*
* Copyright (C) 2024 四川迈科创智科技有限公司
*
****************************************************************************/
/****************************************************************************/
/* Included Files */
/****************************************************************************/
#include "bleproto.h"
/****************************************************************************/
/* Trace Definitions */
/****************************************************************************/
/****************************************************************************/
/* Pre-processor Definitions */
/****************************************************************************/
/****************************************************************************/
/* Private Types */
/****************************************************************************/
/****************************************************************************/
/* Private Function Prototypes */
/****************************************************************************/
/****************************************************************************/
/* Private Data */
/****************************************************************************/
/****************************************************************************/
/* Public Data */
/****************************************************************************/
/****************************************************************************/
/* Private Functions */
/****************************************************************************/
/****************************************************************************/
/* Public Functions */
/****************************************************************************/
const char *libbleproto_version(void)
{
return BLEPROTO_API_VERSION;
}
uint8_t bleproto_advdata_encode4bind(
uint8_t data[31],
int8_t txpower,
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE])
{
bleproto_adv_t adv = {0};
/* adv1 */
{
adv.adv1.length = 0x02;
adv.adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
adv.adv1.ad_data = 0x06;
}
/* adv2 */
// clang-format off
{
adv.adv2.length = 0x1B;
adv.adv2.ad_type = BLEPROTO_ADV_TYPE_SVC_DATA_UUID16;
adv.adv2.ad_data.service_data.uuid = BLEPROTO_ADV_SERVICE_UUID_TOBIND;
/* spec_data */
bleproto_adv_specdata_t *spec_data =
&adv.adv2.ad_data.service_data.spec_data;
spec_data->version = BLEPORTO_ADV_SERVICE_SPEC_DATA_VER;
spec_data->business = BELPROTO_ADV_SERVICE_SPEC_DATA_BUSINESS_NEARFIND;
spec_data->rfu[0] = 0;
spec_data->rfu[1] = 0;
spec_data->txpower = txpower;
spec_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
spec_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
memcpy(spec_data->manucode.value, manucode, BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
spec_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
spec_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
memcpy(spec_data->prodcode.value, prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
spec_data->separator = 0xFF;
memcpy(spec_data->selfdata, pcode, BLE_PROTO_ADV_LENGTH_PCODE);
// spec_data->selfdata[0] = 0X30;
// spec_data->selfdata[1] = 0X30;
// spec_data->selfdata[2] = 0X30;
// spec_data->selfdata[3] = 0X30;
// spec_data->selfdata[4] = 0X30;
// spec_data->selfdata[5] = 0X30;
}
// clang-format on
return bleproto_advdata_serialize(&adv, data, 31);
}
void bleproto_advdata_encode4heartbeat(
uint8_t data[31],
int8_t txpower,
uint8_t gwmac[6],
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE])
{
bleproto_adv_t adv = {0};
/* adv1 */
{
adv.adv1.length = 0x02;
adv.adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
adv.adv1.ad_data = 0x06;
}
/* adv2 */
// clang-format off
{
adv.adv2.length = 0x1B;
adv.adv2.ad_type = BLEPROTO_ADV_TYPE_MFG_DATA;
/* mfg_data */
bleproto_advdata_mfg_t *mfg_data = &adv.adv2.ad_data.mfg_data;
memcpy(mfg_data->siot, pcode, BLE_PROTO_ADV_LENGTH_PCODE);
#if 0
mfg_data->siot[0] = 'S';
mfg_data->siot[1] = 'I';
mfg_data->siot[2] = 'O';
mfg_data->siot[3] = 'T';
mfg_data->siot[4] = '-';
mfg_data->siot[5] = '1';
#endif
/* HEARTBEAT */
mfg_data->flag = BLEPROTO_ADV_FLAG_HEARTBEAT;
mfg_data->txpower = txpower;
memcpy(mfg_data->gwmac, gwmac, 6);
mfg_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
mfg_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
memcpy(mfg_data->manucode.value, manucode, BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
mfg_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
mfg_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
memcpy(mfg_data->prodcode.value, prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
}
// clang-format on
(void)bleproto_advdata_serialize(&adv, data, 31);
}
uint8_t bleproto_advdata_encode4reconn(
uint8_t data[31],
int8_t txpower,
uint8_t gwmac[6],
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE])
{
bleproto_adv_t adv = {0};
/* adv1 */
{
adv.adv1.length = 0x02;
adv.adv1.ad_type = BLEPROTO_ADV_TYPE_FLAGS;
adv.adv1.ad_data = 0x06;
}
/* adv2 */
// clang-format off
{
adv.adv2.length = 0x1B;
adv.adv2.ad_type = BLEPROTO_ADV_TYPE_MFG_DATA;
/* mfg_data */
bleproto_advdata_mfg_t *mfg_data = &adv.adv2.ad_data.mfg_data;
memcpy(mfg_data->siot, pcode, BLE_PROTO_ADV_LENGTH_PCODE);
#if 0
mfg_data->siot[0] = 'S';
mfg_data->siot[1] = 'I';
mfg_data->siot[2] = 'O';
mfg_data->siot[3] = 'T';
mfg_data->siot[4] = '-';
mfg_data->siot[5] = '1';
#endif
/* RECONNECT */
mfg_data->flag = BLEPROTO_ADV_FLAG_RECONNECT;
mfg_data->txpower = txpower;
memcpy(mfg_data->gwmac, gwmac, 6);
mfg_data->manucode.type = BLEPROTO_ADV_TLV_TYPE_MANUCODE;
mfg_data->manucode.length = BLEPROTO_ADV_TLV_LENGTH_MANUCODE;
memcpy(mfg_data->manucode.value, manucode, BLEPROTO_ADV_TLV_LENGTH_MANUCODE);
mfg_data->prodcode.type = BLEPROTO_ADV_TLV_TYPE_PRODCODE;
mfg_data->prodcode.length = BLEPROTO_ADV_TLV_LENGTH_PRODCODE;
memcpy(mfg_data->prodcode.value, prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
}
// clang-format on
return bleproto_advdata_serialize(&adv, data, 31);
}
int bleproto_advdata_decode(const uint8_t *data,
uint8_t len,
bleproto_adv_t *adv)
{
return bleproto_advdata_deserialize(data, len, adv);
}
int bleproto_appdata_encode(uint8_t *txbuf,
uint16_t size,
uint8_t packetlen,
bleproto_appdata_desc_t *desc)
{
int rc;
uint16_t txbuf_size = size;
/*
* appdata.data[] 在 SMALL 模式下约 2.3KB，供 JSON/OTA 编码中间缓冲。
* JB 55AA 透传可走 bleproto_appdata_wrap_raw，不必经本函数。
* 此处用 static，避免在调用方任务栈上临时分配。
*/
static bleproto_appdata_t s_enc_appdata;
bleproto_appdata_t *appdata = &s_enc_appdata;
/* header */
{
appdata->header = desc->header;
}
/* data */
if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_REQ)
{
switch (appdata->header.serviceid)
{
case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
rc = bleproto_encjson_deviceinfo_req(&desc->datast.deviceinfo_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
rc = bleproto_encjson_authsetup_req(&desc->datast.authsetup_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
rc = bleproto_encjson_authdelete_req(&desc->datast.authdelete_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD:
rc = bleproto_encjson_runcmd_req(&desc->datast.runcmd_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD:
rc = bleproto_encjson_reportcmd_req(&desc->datast.reportcmd_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_DOACTION:
rc = bleproto_encjson_doaction_req(&desc->datast.doaction_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
rc = bleproto_encjson_otanotify_req(&desc->datast.otanotify_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_OTADATA:
rc = bleproto_encjson_otadata_req(&desc->datast.otadata_req,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
rc = ble_proto_pack(&desc->datast.runcmd_v2_req, appdata->data, sizeof(appdata->data));
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
rc = ble_proto_pack(&desc->datast.reportcmd_v2_req, appdata->data, sizeof(appdata->data));
break;
case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
rc = ble_proto_pack(&desc->datast.otadata_v2_req, appdata->data, sizeof(appdata->data));
break;
default:
/* unkown serviceid */
return (-1);
}
}
else if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_RSP)
{
switch (appdata->header.serviceid)
{
case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
rc = bleproto_encjson_deviceinfo_rsp(&desc->datast.deviceinfo_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
rc = bleproto_encjson_authsetup_rsp(&desc->datast.authsetup_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
rc = bleproto_encjson_authdelete_rsp(&desc->datast.authdelete_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD:
rc = bleproto_encjson_runcmd_rsp(&desc->datast.runcmd_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD:
rc = bleproto_encjson_reportcmd_rsp(&desc->datast.reportcmd_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_DOACTION:
rc = bleproto_encjson_doaction_rsp(&desc->datast.doaction_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
rc = bleproto_encjson_otanotify_rsp(&desc->datast.otanotify_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_OTADATA:
rc = bleproto_encbin_otadata_rsp(&desc->datast.otadata_rsp,
appdata->data);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
rc = ble_proto_pack(&desc->datast.runcmd_v2_rsp, appdata->data, sizeof(appdata->data));
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
rc = ble_proto_pack(&desc->datast.reportcmd_v2_rsp, appdata->data, sizeof(appdata->data));
break;
case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
rc = ble_proto_pack(&desc->datast.otadata_v2_rsp, appdata->data, sizeof(appdata->data));
break;
default:
/* unkown serviceid */
return (-1);
}
}
else
{
/* unkown msgtype */
return (-1);
}
/* failed to encjson struct */
if (rc <= 0)
{
return (-1);
}
/* datalen */
appdata->header.datalen = (uint16_t)rc;
/* appdata_serialize */
return bleproto_appdata_serialize(appdata, packetlen, txbuf, txbuf_size);
}
int bleproto_appdata_decode(uint8_t *rxbuf,
uint16_t len,
bleproto_appdata_desc_t *desc)
{
int rc, rlen;
/*
* V2(ble_proto_unpack) 零拷贝：bytes_data 等指向 appdata.data。
* 若用栈局部变量，函数返回后指针悬空，usr_run_cmd_code_v2 会踩坏数据。
* 使用 static，保证 desc 内指针在下次 decode 前有效。
*/
static bleproto_appdata_t s_appdata;
bleproto_appdata_t *appdata = &s_appdata;
/* appdata_deserialize */
rlen = bleproto_appdata_deserialize(rxbuf, len, appdata);
if (rlen <= 0)
{
return (rlen);
}
/* header */
{
desc->header = appdata->header;
}
/* data */
if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_REQ)
{
switch (appdata->header.serviceid)
{
case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
rc = bleproto_decjson_deviceinfo_req(appdata->data,
appdata->header.datalen,
&desc->datast.deviceinfo_req);
break;
case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
rc = bleproto_decjson_authsetup_req(appdata->data,
appdata->header.datalen,
&desc->datast.authsetup_req);
break;
case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
rc = bleproto_decjson_authdelete_req(appdata->data,
appdata->header.datalen,
&desc->datast.authdelete_req);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD:
rc = bleproto_decjson_runcmd_req(appdata->data,
appdata->header.datalen,
&desc->datast.runcmd_req);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD:
rc = bleproto_decjson_reportcmd_req(appdata->data,
appdata->header.datalen,
&desc->datast.reportcmd_req);
break;
case E_BLEPROTO_SERVICE_ID_DOACTION:
rc = bleproto_decjson_doaction_req(appdata->data,
appdata->header.datalen,
&desc->datast.doaction_req);
break;
case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
rc = bleproto_decjson_otanotify_req(appdata->data,
appdata->header.datalen,
&desc->datast.otanotify_req);
break;
case E_BLEPROTO_SERVICE_ID_OTADATA:
rc = bleproto_decjson_otadata_req(appdata->data,
appdata->header.datalen,
&desc->datast.otadata_req);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
printf("runcmd_v2_req \n");
rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.runcmd_v2_req);
printf("runcmd_v2_req rc = %d \n", rc);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
printf("reportcmd_v2_req \n");
rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.reportcmd_v2_req);
printf("reportcmd_v2_req rc = %d \n", rc);
break;
case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
printf("otadata_v2_req \n");
rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.otadata_v2_req);
printf("otadata_v2_req rc = %d \n", rc);
break;
default:
/* unkown serviceid */
return (-1);
}
}
else if (appdata->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_RSP)
{
switch (appdata->header.serviceid)
{
case E_BLEPROTO_SERVICE_ID_DEVICEINFO:
rc =
bleproto_decjson_deviceinfo_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.deviceinfo_rsp);
break;
case E_BLEPROTO_SERVICE_ID_AUTHSETUP:
rc = bleproto_decjson_authsetup_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.authsetup_rsp);
break;
case E_BLEPROTO_SERVICE_ID_AUTHDELETE:
rc =
bleproto_decjson_authdelete_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.authdelete_rsp);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD:
rc = bleproto_decjson_runcmd_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.runcmd_rsp);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD:
rc = bleproto_decjson_reportcmd_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.reportcmd_rsp);
break;
case E_BLEPROTO_SERVICE_ID_DOACTION:
rc = bleproto_decjson_doaction_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.doaction_rsp);
break;
case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
rc = bleproto_decjson_otanotify_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.otanotify_rsp);
break;
case E_BLEPROTO_SERVICE_ID_OTADATA:
rc = bleproto_debin_otadata_rsp(appdata->data,
appdata->header.datalen,
&desc->datast.otadata_rsp);
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
printf("runcmd_v2_rsp \n");
rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.runcmd_v2_rsp);
printf("runcmd_v2_rsp rc = %d \n", rc);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2:
printf("reportcmd_v2_rsp \n");
rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.reportcmd_v2_rsp);
printf("reportcmd_v2_rsp rc = %d \n", rc);
break;
case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
printf("otadata_v2_rsp \n");
rc = ble_proto_unpack(appdata->data, appdata->header.datalen, &desc->datast.otadata_v2_rsp);
printf("otadata_v2_rsp rc = %d \n", rc);
break;
default:
/* unkown serviceid */
return (-1);
}
}
else
{
/* unkown msgtype */
return (-1);
}
/* failed to decjson struct */
if (rc < 0)
{
return (-1);
}
return (rlen);
}
/****************************************************************************/
/* */
/* End of file. */
/* */
/****************************************************************************/
apps/usr_le_code/bleproto.h
+53
View File
@@ -0,0 +1,53 @@
/****************************************************************************/
/* bleproto.h
*
* Copyright (C) 2021 四川迈科创智科技有限公司
*
****************************************************************************/
#ifndef BLEPROTO_H_INCLUDE
#define BLEPROTO_H_INCLUDE
/****************************************************************************/
/* Included Files */
/****************************************************************************/
/* api */
#include "bleproto_api.h"
/* thirdpart api */
#include "mjson.h"
/****************************************************************************/
/* Configure Definitions */
/****************************************************************************/
/****************************************************************************/
/* Pre-processor Definitions */
/****************************************************************************/
/****************************************************************************/
/* Public Types */
/****************************************************************************/
/****************************************************************************/
/* Public Data */
/****************************************************************************/
/****************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
/****************************************************************************/
/* Public Function Prototypes */
/****************************************************************************/
/****************************************************************************/
#ifdef __cplusplus
}
#endif
/****************************************************************************/
#endif /* BLEPROTO_H_INCLUDE */
/****************************************************************************/
/* */
/* End of file. */
/* */
/****************************************************************************/
apps/usr_le_code/bleproto_api.h
+303
View File
@@ -0,0 +1,303 @@
/****************************************************************************/
/* bleproto_api.h
*
* Copyright (C) 2021 四川迈科创智科技有限公司
*
****************************************************************************/
/**
* @page bleproto_api_guides API Guides
*
* @ingroup bleproto_api_guides
* @addtogroup bleproto_api bleproto
*
* wiki
* ====
* - https://gogos.mkcziot.com:13000/iot-device/cziot-sdk/src/master/doc/wiki/ble/mk蓝牙设备开发指南.md
*
* @{
*/
#ifndef BLEPROTO_API_H_INCLUDE
#define BLEPROTO_API_H_INCLUDE
/****************************************************************************/
/* Included Files */
/****************************************************************************/
/* system */
//#include <stdio.h>
/*#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>*/
/* group */
#include "bleproto_packer.h"
#include "ble_proto.h"
/****************************************************************************/
/* Configure Definitions */
/****************************************************************************/
/****************************************************************************/
/* Pre-processor Definitions */
/****************************************************************************/
/* api version */
#define BLEPROTO_API_VERSION "1.1.4"
/****************************************************************************/
/* Public Types */
/****************************************************************************/
/**
* @brief 应用数据描述
*/
typedef struct bleproto_appdata_desc {
/** 包头 */
bleproto_appdata_header_t header;
/**
* 根据
* - header.msgtype:请求(0=req)、响应(1=rsp)
* - header.serviceid @ref bleproto_service_id_e
* datast取对应的member
*
* 比如 header.msgtype = 0(请求req), header.serviceid = E_BLEPROTO_SERVICE_ID_DEVICEINFO
* datast 对应 deviceinfo_req
*/
union {
bleproto_deviceinfo_req_t deviceinfo_req;
bleproto_deviceinfo_rsp_t deviceinfo_rsp;
bleproto_authsetup_req_t authsetup_req;
bleproto_authsetup_rsp_t authsetup_rsp;
bleproto_authdelete_req_t authdelete_req;
bleproto_authdelete_rsp_t authdelete_rsp;
bleproto_runcmd_req_t runcmd_req;
bleproto_runcmd_rsp_t runcmd_rsp;
bleproto_reportcmd_req_t reportcmd_req;
bleproto_reportcmd_rsp_t reportcmd_rsp;
bleproto_doaction_req_t doaction_req;
bleproto_doaction_rsp_t doaction_rsp;
bleproto_otanotify_req_t otanotify_req;
bleproto_otanotify_rsp_t otanotify_rsp;
bleproto_otadata_req_t otadata_req;
bleproto_otadata_rsp_t otadata_rsp;
ble_proto_packet_t runcmd_v2_req;
ble_proto_packet_t runcmd_v2_rsp;
ble_proto_packet_t reportcmd_v2_req;
ble_proto_packet_t reportcmd_v2_rsp;
ble_proto_packet_t otadata_v2_req;
ble_proto_packet_t otadata_v2_rsp;
} datast;
} bleproto_appdata_desc_t;
/****************************************************************************/
/* Public Data */
/****************************************************************************/
/****************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
/****************************************************************************/
/* Public Function Prototypes */
/****************************************************************************/
/**
* @brief Get library version
*
* @return The string of library version
*/
const char *libbleproto_version(void);
/**
* @brief 序列化请求注册绑定广播数据(广播数据长度为31)
*
* @param[out] data - 序列化数据缓冲区, 固定为31个字节.
* @param[in] txpower - 蓝牙发射功率[-127,128]dBm
* @param[in] manucode - 厂商编码, 现在固定填0
* @param[in] pcode - 平台pcode, 比如pcode为AAABBB
* pcode[0] = 'A' = 0x41
* pcode[1] = 'A' = 0x41
* pcode[2] = 'A' = 0x41
* pcode[3] = 'B' = 0x42
* pcode[4] = 'B' = 0x42
* pcode[5] = 'B' = 0x42
* @param[in] prodcode - 产品型号, 比如 宠物喂食器 CBFD,
* prodcode[0] = 'C' = 0x43
* prodcode[1] = 'B' = 0x42
* prodcode[2] = 'F' = 0x46
* prodcode[3] = 'D' = 0x44
*/
uint8_t bleproto_advdata_encode4bind(
uint8_t data[31],
int8_t txpower,
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]);
/**
* @brief 序列化心跳广播数据(广播数据长度为31)
*
* @param[out] data - 序列化数据缓冲区, 固定为31个字节.
* @param[in] txpower - 蓝牙发射功率[-127,128]dBm
* @param[in] gwmac - 主控设备mac地址(子设备绑定到主控设备，authStep会下发主控设备的mac地址)，
* 例如mac地址 "11:22:33:44:55:66"
* gwmac[0] = 0x11
* gwmac[1] = 0x22
* gwmac[2] = 0x33
* gwmac[3] = 0x44
* gwmac[4] = 0x55
* gwmac[5] = 0x66
* @param[in] manucode - 厂商编码, 现在固定填0
* @param[in] pcode - 平台pcode, 比如pcode为AAABBB
* pcode[0] = 'A' = 0x41
* pcode[1] = 'A' = 0x41
* pcode[2] = 'A' = 0x41
* pcode[3] = 'B' = 0x42
* pcode[4] = 'B' = 0x42
* pcode[5] = 'B' = 0x42
* @param[in] prodcode - 产品型号, 比如 宠物喂食器 CBFD,
* prodcode[0] = 'C' = 0x43
* prodcode[1] = 'B' = 0x42
* prodcode[2] = 'F' = 0x46
* prodcode[3] = 'D' = 0x44
*/
void bleproto_advdata_encode4heartbeat(
uint8_t data[31],
int8_t txpower,
uint8_t gwmac[6],
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]);
/**
* @brief 序列化回连广播数据(广播数据长度为31)
*
* @param[out] data - 序列化数据缓冲区, 固定为31个字节.
* @param[in] txpower - 蓝牙发射功率[-127,128]dBm
* @param[in] gwmac - 主控设备mac地址(子设备绑定到主控设备，authStep会下发主控设备的mac地址)，
* 例如mac地址 "11:22:33:44:55:66"
* gwmac[0] = 0x11
* gwmac[1] = 0x22
* gwmac[2] = 0x33
* gwmac[3] = 0x44
* gwmac[4] = 0x55
* gwmac[5] = 0x66
* @param[in] manucode - 厂商编码, 现在固定填0
* @param[in] pcode - 平台pcode, 比如pcode为AAABBB
* pcode[0] = 'A' = 0x41
* pcode[1] = 'A' = 0x41
* pcode[2] = 'A' = 0x41
* pcode[3] = 'B' = 0x42
* pcode[4] = 'B' = 0x42
* pcode[5] = 'B' = 0x42
* @param[in] prodcode - 产品型号, 比如 宠物喂食器 CBFD,
* prodcode[0] = 'C' = 0x43
* prodcode[1] = 'B' = 0x42
* prodcode[2] = 'F' = 0x46
* prodcode[3] = 'D' = 0x44
*
* @return 小于0表示失败，大于0表示序列化后的长度(31)
*/
uint8_t bleproto_advdata_encode4reconn(
uint8_t data[31],
int8_t txpower,
uint8_t gwmac[6],
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE],
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE],
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]);
/**
* @brief 反序列化广播数据(广播数据长度为31)
*
* @param[in] data - 反序列化数据指针
* @param[in] len - 反序列化数据长度
* @param[out] adv - 广播数据结构体
*
* @return 小于0表示失败，大于0表示反序列化使用data的长度.
*/
int bleproto_advdata_decode(const uint8_t * data,
uint8_t len,
bleproto_adv_t *adv);
/**
* @brief 序列化应用数据结构体到txbuf
*
* @note packetlen说明
*
* ```c
* ble4.0 通常协商的mtu=27, packetlen = 27 - 4 - 3 = 20
* ble4.2 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
* ble5.0 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
* ```
*
* 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
* +----------------+
* | 1 | 第一包按照packetlen填满
* +----------------+
* | |
* | ... | 中间包按照packetlen填满
* | |
* +----------------+
* | N | 最后一包长度 = totallen - (packetlen * (N -1))
* +----------------+
*
* 需要按照每包的顺序发给对端
*
* @param[out] txbuf - 发送数据缓冲区指针
* @param[in] size - 发送数据缓冲器长度
* @param[in] packetlen - BLE GATT单包传输有效长度, 查看上面说明
* @param[in] desc - 应用数据结构体描述
*
* @return 小于0表示失败，大于0表示序列化后的长度
*/
int bleproto_appdata_encode(uint8_t * txbuf,
uint16_t size,
uint8_t packetlen,
bleproto_appdata_desc_t *desc);
/**
* @brief 反序列化rxbuf到应用数据结构体
*
*
* 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
* +----------------+
* | 1 | 第一包按照packetlen填满
* +----------------+
* | |
* | ... | 中间包按照packetlen填满
* | |
* +----------------+
* | N | 最后一包长度 = totallen - (packetlen * (N -1))
* +----------------+
*
* 因此接收到数据
* 1. 函数返回等于0，以为还有分包数据还没有接收完成，
* 接收到下包数据 append 在buf尾部，再调用函数的解析数据包
* 2. 函数返回大于0，表示收到数据解析了多少字节，需要将头上对应长度数据移除掉
* 3. 函数返回小于0，表示收到非法的数据包，无法解析
*
* @param[in] rxbuf - 接收缓冲区指针
* @param[in] len - 接收缓冲区数据长度.
* @param[out] desc - 应用数据结构体.
*
* @return 大于0表示解析成功, 返回当前解析了多少个字节,
* 等于0表示解析未完成, 只接受到分包的部分数据, 需要继续接收数据
* 小于0表示解析失败
*/
int bleproto_appdata_decode(uint8_t* rxbuf,
uint16_t len,
bleproto_appdata_desc_t *desc);
/****************************************************************************/
#ifdef __cplusplus
}
#endif
/****************************************************************************/
#endif /* BLEPROTO_API_H_INCLUDE */
/****************************************************************************/
/* */
/* End of file. */
/* */
/****************************************************************************/
apps/usr_le_code/bleproto_packer.c
+3054
View File
File diff suppressed because it is too large Load Diff
apps/usr_le_code/bleproto_packer.h
+702
View File
@@ -0,0 +1,702 @@
/****************************************************************************/
/* bleproto_packer.h
*
* Copyright (C) 2020 wanshijie wanshijie@126.com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
****************************************************************************/
/**
* @addtogroup bleproto_packer packer
* @ingroup bleproto_api
* @brief ble proto packer
*
* @{
*/
#ifndef BLEPROTO_PACKER_H_INCLUDE
#define BLEPROTO_PACKER_H_INCLUDE
/****************************************************************************/
/* Included Files */
/****************************************************************************/
#include "system/includes.h"
#if !defined(BLEPROTO_API_H_INCLUDE)
#error "Only 'bleproto/bleproto_api.h' can be included directly."
#endif /* BLEPROTO_API_H_INCLUDE */
/****************************************************************************/
/* Configure Definitions */
/****************************************************************************/
#define BLEPOROTO_RAM_LARGE 0 ///< 大內存模式
#define BLEPOROTO_RAM_MID 1 ///< 中等內存模式
#define BLEPOROTO_RAM_SMALL 2 ///< 小內存模式
/* default 內存模式 */
#ifndef BLEPOROTO_RAM_MODE
//#define BLEPOROTO_RAM_MODE BLEPOROTO_RAM_LARGE
//#define BLEPOROTO_RAM_MODE BLEPOROTO_RAM_MID
#define BLEPOROTO_RAM_MODE BLEPOROTO_RAM_SMALL
#endif /* BLEPOROTO_RAM_MODE */
/****************************************************************************/
/* Pre-processor Definitions */
/****************************************************************************/
///////////////////////////////////////////////////////////
// trace log define
///////////////////////////////////////////////////////////
#ifndef BLEPROTO_TRACE_ENABLE
#define BLEPROTO_TRACE_ENABLE 0//Jim
#endif /* BLEPROTO_TRACE_ENABLE */
/* trace default printf */
#ifndef BLEPROTO_TRACE_PRINTF
#define BLEPROTO_TRACE_PRINTF printf
#endif /* BLEPROTO_TRACE_PRINTF */
/* trace strfunc */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 19901L
#define BLEPROTO_TRACE_STRFUNC ((const char *)(__func__))
#else
#define BLEPROTO_TRACE_STRFUNC ((const char *)(__FUNCTION__))
#endif /* __STDC_VERSION__ */
/* trace file line */
#define BLEPROTO_TRACE_INTLINE ((int)(__LINE__))
#if BLEPROTO_TRACE_ENABLE
#define BLEPROTO_TRACE(lvl, ...) \
do { \
BLEPROTO_TRACE_PRINTF("[%s][%s:%d]", \
lvl, \
BLEPROTO_TRACE_STRFUNC, \
BLEPROTO_TRACE_INTLINE); \
BLEPROTO_TRACE_PRINTF(__VA_ARGS__); \
BLEPROTO_TRACE_PRINTF("\r\n"); \
} while (0)
#else
#define BLEPROTO_TRACE(lvl, ...) \
do { \
} while (0)
#endif /* FLOG_TRACE_ENABLE */
/* trace log error */
#ifndef BLEPROTO_T_E
#define BLEPROTO_T_E(...) BLEPROTO_TRACE("E", __VA_ARGS__)
#endif /* BLEPROTO_T_E */
/* trace log debug */
#ifndef BLEPROTO_T_D
#define BLEPROTO_T_D(...) BLEPROTO_TRACE("D", __VA_ARGS__)
#endif /* BLEPROTO_T_D */
/* printf log slient */
#ifndef BLEPROTO_T_S
#define BLEPROTO_T_S(...)
#endif /* BLEPROTO_T_S */
// clang-format off
///////////////////////////////////////////////////////////
// ADV
///////////////////////////////////////////////////////////
/** ADV Data Max Size. */
#define BLEPROTO_ADV_MAX_SZ 31
/** ADV Type: Flags. */
#define BLEPROTO_ADV_TYPE_FLAGS 0x01
/** ADV Type: Service Data - 16-bit UUID. */
#define BLEPROTO_ADV_TYPE_SVC_DATA_UUID16 0x16
/** ADV Type: Manufacturer Specific Data. */
#define BLEPROTO_ADV_TYPE_MFG_DATA 0xff
/** ADV service uuid */
#define BLEPROTO_ADV_SERVICE_UUID_TOBIND 0xFDEE
/** ADV service spec data version */
#define BLEPORTO_ADV_SERVICE_SPEC_DATA_VER 0x01
/** ADV service spec data business */
#define BELPROTO_ADV_SERVICE_SPEC_DATA_BUSINESS_NEARFIND 0x01
/* ADV TLV Type */
#define BLEPROTO_ADV_TLV_TYPE_MANUCODE 0x10
#define BLEPROTO_ADV_TLV_TYPE_PRODCODE 0x11
/* ADV TLV Len */
#define BLEPROTO_ADV_TLV_LENGTH_MANUCODE 4
#define BLEPROTO_ADV_TLV_LENGTH_PRODCODE 4
/* ADV PCDE */
#define BLE_PROTO_ADV_LENGTH_PCODE 6
/** ADV flag value */
#define BLEPROTO_ADV_FLAG_HEARTBEAT 0x00
#define BLEPROTO_ADV_FLAG_RECONNECT 0x01
///////////////////////////////////////////////////////////
// APPDATA
///////////////////////////////////////////////////////////
/** APPDATA header len 8bytes */
#define BLEPROTO_APPDATA_HEADR_LEN 8
/** APPDATA version */
#define BLEPROTO_APPDATA_VERSION 0
/** APPDATA data fmt */
#define BLEPROTO_APPDATA_DATAFMT_JSON 0
#define BLEPROTO_APPDATA_DATAFMT_RAW 1
/** APPDATA msg type */
#define BLEPROTO_APPDATA_MSGTYPE_REQ 0
#define BLEPROTO_APPDATA_MSGTYPE_RSP 1
#if (BLEPOROTO_RAM_MODE == BLEPOROTO_RAM_LARGE)
/** APPDATA OTA data max size */
#define BLEPROTO_APPDATA_OTADATA_SZ (1024*16)
/** APPDATA data max size */
#define BLEPROTO_APPDATA_DATA_MAX_SZ (BLEPROTO_APPDATA_OTADATA_SZ + 16 + 16)
/** APP tx buf max size */
#define BLEPROTO_TXRXBUF_MAX_SZ (BLEPROTO_APPDATA_DATA_MAX_SZ + 1024 * 2)
#elif (BLEPOROTO_RAM_MODE == BLEPOROTO_RAM_MID)
/** APPDATA OTA data max size */
#define BLEPROTO_APPDATA_OTADATA_SZ (1024*4)
/** APPDATA data max size */
#define BLEPROTO_APPDATA_DATA_MAX_SZ (BLEPROTO_APPDATA_OTADATA_SZ + 16 + 16)
/** APP tx buf max size */
#define BLEPROTO_TXRXBUF_MAX_SZ (BLEPROTO_APPDATA_DATA_MAX_SZ + 1024 * 2)
#else
/** APPDATA OTA data max size */
#define BLEPROTO_APPDATA_OTADATA_SZ (1024+1024+256)
/** APPDATA data max size */
#define BLEPROTO_APPDATA_DATA_MAX_SZ (BLEPROTO_APPDATA_OTADATA_SZ + 16 + 16)
/** APP tx buf max size */
//#define BLEPROTO_TXRXBUF_MAX_SZ (BLEPROTO_APPDATA_DATA_MAX_SZ + 1024 * 2)
#endif /* BLEPOROTO_RAM_MODE */
// clang-format on
/****************************************************************************/
/* Public Types */
/****************************************************************************/
/**
* @brief 厂商编码-manucode(manufacturer code) TLV desc.
*/
typedef struct bleproto_adv_manucode {
// clang-format off
uint8_t type; ///< 厂商编码T, @ref BLEPROTO_ADV_TLV_TYPE_MANUCODE
uint8_t length; ///< 厂商编码L, @ref BLEPROTO_ADV_TLV_LEN_MANUCODE
uint8_t value[BLEPROTO_ADV_TLV_LENGTH_MANUCODE]; ///< 厂商信息V, 现在固定填写0x00000000
// clang-format off
} bleproto_adv_manucode_t;
/**
* @brief 产品型号-prodcode(product code) TLV desc.
*/
typedef struct bleproto_adv_prodcode {
// clang-format off
uint8_t type; ///< 产品型号T, @ref BLEPROTO_ADV_TLV_TYPE_PRODCODE
uint8_t length; ///< 产品型号L, @ref BLEPROTO_ADV_TLV_LENGTH_PRODCODE
uint8_t value[BLEPROTO_ADV_TLV_LENGTH_PRODCODE]; ///< 产品型号V, 平台定义,需要转换成ASCII码值
// clang-format on
} bleproto_adv_prodcode_t;
/**
* @brief 请求配对广播的Spec Data结构.
*/
typedef struct bleproto_adv_specdata {
// clang-format off
uint8_t version; ///< 蓝牙广播协议版本, 当前1 @ref BLEPORTO_ADV_SERVICE_SPEC_DATA_VER
uint8_t business; ///< 设备发现模式, 固定填写0x01,表示靠近发现 @ref BELPROTO_ADV_SERVICE_SPEC_DATA_BUSINESS_NEARFIND
uint8_t rfu[2]; ///< 保留
int8_t txpower; ///< 蓝牙发射功率[-127,128]dBm
bleproto_adv_manucode_t manucode; ///< 厂商编码
bleproto_adv_prodcode_t prodcode; ///< 产品型号
uint8_t separator; ///< 分隔符, 固定填写0xFF
uint8_t selfdata[6]; ///< 自定义数据
// clang-format on
} bleproto_adv_specdata_t;
/**
* @brief 请求注册广播数据.
*/
typedef struct bleproto_advdata_service {
// clang-format off
uint16_t uuid; ///< 服务uuid16 @ref BLEPROTO_ADV_SERVICE_UUID_TOBIND
bleproto_adv_specdata_t spec_data;///< 协议数据(24bytes)
// clang-format on
} bleproto_advdata_service_t;
/**
* @brief 心跳广播, 回连广播数据.
*/
typedef struct bleproto_advdata_mfg {
// clang-format off
uint8_t siot[6]; ///< 固定填写SIOT-1
uint8_t flag; ///< 0表示心跳，1表示请求回连 @ref BLEPROTO_ADV_FLAG_HEARTBEAT or @ref BLEPROTO_ADV_FLAG_RECONNECT
int8_t txpower; ///< 蓝牙发射功率[-127,128]dBm
uint8_t gwmac[6]; ///< gwmac "11:22:33:44:55:66", gwmac[6] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }
bleproto_adv_manucode_t manucode; ///< 厂商编码
bleproto_adv_prodcode_t prodcode; ///< 产品型号
// clang-format on
} bleproto_advdata_mfg_t;
/**
* @brief AD Structure1结构.
*/
typedef struct bleproto_adv1 {
// clang-format off
/**
* 表示AD Type与AD Data的总长度,
* 此处取值固定为0x02
*/
uint8_t length;
/**
* 表示该广播数据代表的含义
* 此处取值固定为0x01 @ref BLEPROTO_ADV_TYPE_FLAGS
*/
uint8_t ad_type;
/**
* 固定为0x06，表示LE通用可发现模式，且不支持BR/EDR
* 表示蓝牙设备的物理连接能力,
* bit0：LE受限可发现模式。
* bit1：LE通用可发现模式。
* bit2：不支持BR/EDR。
* bit3：对Same Device Capable（控制器）同时支持BLE和BR/EDR。
* bit4：对Same Device Capable（主机）同时支持BLE和BR/EDR。
* bit5~7：预留
*/
uint8_t ad_data;
// clang-format on
} bleproto_adv1_t;
/**
* @brief AD Structure2结构.
*/
typedef struct bleproto_adv2 {
// clang-format off
/**
* 表示AD Type与AD Data的总长度,
* 此处取值固定为0x1B = 27
*/
uint8_t length;
/** 广播数据代表的含义
* BLEPROTO_ADV_TYPE_SVC_DATA_UUID16 - 0x16表示蓝牙服务数据(bleproto_advdata_service_t),
* BLEPROTO_ADV_TYPE_MFG_DATA - 0xFF表示厂商数据(bleproto_advdata_mfg_t)
*/
uint8_t ad_type;
/** adv data */
union {
bleproto_advdata_service_t service_data; ///< 蓝牙服务数据(请求注册广播时携带)
bleproto_advdata_mfg_t mfg_data; ///< 厂商数据(心跳广播，回连广播时携带)
} ad_data;
// clang-format on
} bleproto_adv2_t;
/**
* @brief 广播数据总结构
*/
typedef struct bleproto_adv {
bleproto_adv1_t adv1; ///< ADV Structure1
bleproto_adv2_t adv2; ///< ADV Structure2
} bleproto_adv_t;
/**
* @brief 应用协议报文头(8字节)
*/
typedef struct bleproto_appdata_header {
// clang-format off
uint8_t version : 3; ///< byte0[2:0]:蓝牙BLE应用层协议的版本号，当前为0,根据业务演进递增 @ref BLEPROTO_APPDATA_VERSION
uint8_t datafmt : 1; ///< byte0[3:3]:数据格式, 当前只支持JSON字符串格式，取值固定为0, @ref BLEPROTO_APPDATA_DATAFMT_JSON
uint8_t msgtype : 4; ///< byte0[7:4]:消息类型, 包括：请求(0=req)、响应(1=rsp), @ref BLEPROTO_APPDATA_MSGTYPE_REQ
uint8_t msgid : 4; ///< byte1[3:0]:消息序号, 单调递增
uint8_t encrypt : 1; ///< byte1[4:4]:数据加密方式, 当前固定填写0，表示不加密
uint8_t reserve : 3; ///< byte1[7:5]:保留
uint8_t totalframe; ///< byte2 :总包数, 范围 1~255, 0x01：不分包时，取值为1, 0x02~0xFF：分包时，取值为≥2
uint8_t frameseq; ///< byte3 :分包包序号, 0x00：不分包时取值为0, 0x01~0xFF: 分包时, 取值为从1开始依次递增
uint8_t framelen; ///< byte4 :该包数据长度
uint8_t serviceid; ///< byte5 :应用数据服务id @ref bleproto_service_id_e
uint16_t datalen; ///< byte6-7 :应用数据总长度
// clang-format on
} bleproto_appdata_header_t;
/**
* @brief 应用数据
*/
typedef struct bleproto_appdata {
bleproto_appdata_header_t header;
uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ];
} bleproto_appdata_t;
/**
* @brief service id定义
*/
typedef uint8_t bleproto_service_id_e;
enum {
E_BLEPROTO_SERVICE_ID_UNSPECIFIED = 0, ///< 保留
E_BLEPROTO_SERVICE_ID_DEVICEINFO = 1, ///< deviceInfo
E_BLEPROTO_SERVICE_ID_AUTHSETUP = 2, ///< authSetup
E_BLEPROTO_SERVICE_ID_AUTHDELETE = 3, ///< authDelete
E_BLEPROTO_SERVICE_ID_RUNCMD = 4, ///< runCmd
E_BLEPROTO_SERVICE_ID_REPORTCMD = 5, ///< reportCmd
E_BLEPROTO_SERVICE_ID_DOACTION = 6, ///< doAction
E_BLEPROTO_SERVICE_ID_OTANOTIFY = 7, ///< otaNotify
E_BLEPROTO_SERVICE_ID_OTADATA = 8, ///< otaData
E_BLEPROTO_SERVICE_ID_RUNCMD_V2 = 20, ///< runCmdV2
E_BLEPROTO_SERVICE_ID_REPORTCMD_V2 = 21, ///< reportCmdV2
E_BLEPROTO_SERVICE_ID_OTADATA_V2 = 22, ///< otaDataV2
};
/**
* @brief ycmd 定义
*/
#define YCMD_INT32_MAX_COUNT 32
#define YCMD_STRING_MAX_COUNT 16
#define YCMD_STRING_MAX_SIZE 32
#define YCMD_BYTES_MAX_COUNT 8
typedef struct bleproto_ycmd {
int32_t cmd_id;
uint16_t arg_int32_count;
int32_t arg_int32[YCMD_INT32_MAX_COUNT];
uint16_t arg_string_count;
char arg_string[YCMD_STRING_MAX_COUNT][YCMD_STRING_MAX_SIZE];
uint16_t arg_bytes_count;
uint8_t arg_bytes[YCMD_BYTES_MAX_COUNT];
uint64_t t;
} bleproto_ycmd_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_DEVICEINFO
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_deviceinfo_req {
uint64_t t; ///< utcms时间戳
int gmtoff; ///< 时区偏移，单位秒，例如东八区(8x60x60=28800秒)
} bleproto_deviceinfo_req_t;
typedef struct bleproto_deviceinfo_rsp {
// clang-format off
char hwv[16]; ///< 硬件版本号
char swv[16]; ///< 软件版本号
uint8_t prototype; ///< 协议类型,固定填写为4,表示Ble设备
uint32_t hbcycle; ///< 设备心跳广播心跳周期,ms
uint8_t longcon; ///< 是否长链接, 1=长链接,0=短链接
// clang-format on
} bleproto_deviceinfo_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_AUTHSETUP
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_authsetup_req {
// clang-format off
uint8_t gwmac[6]; ///< 主控mac地址, 设备需要保存
char devid[36 + 1]; ///< 主控分配的子设备id, 设备需要保存
char authcode[32 + 1]; ///< 主控分配的子设备认证码, 设备需要保存
uint8_t paired_flag;
// clang-format on
} bleproto_authsetup_req_t;
typedef struct bleproto_authsetup_rsp {
int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
} bleproto_authsetup_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_AUTHDELETE
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_authdelete_req {
char authcode[32 + 1]; ///< 子设备认证码
} bleproto_authdelete_req_t;
typedef struct bleproto_authdelete_rsp {
uint8_t gwmac[6]; ///< 绑定主控设备的mac地址
int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
} bleproto_authdelete_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_RUNCMD
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_runcmd_req {
bleproto_ycmd_t ycmd; ///< Request Ycmd
} bleproto_runcmd_req_t;
typedef struct bleproto_runcmd_rsp {
bleproto_ycmd_t ycmd; ///< Response Ycmd
} bleproto_runcmd_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_REPORTCMD
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_reportcmd_req {
bleproto_ycmd_t ycmd; ///< Ycmd
} bleproto_reportcmd_req_t;
typedef struct bleproto_reportcmd_rsp {
int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
} bleproto_reportcmd_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_DOACTION
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_doaction_req {
int action; ///< 0:重启, 1:指示,收到命令设备指示灯闪烁或者音频发音
} bleproto_doaction_req_t;
typedef struct bleproto_doaction_rsp {
int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
} bleproto_doaction_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_OTANOTIFY
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_otanotify_req {
int id; ///< file_id
char version[16]; ///< 版本号
uint32_t size; ///< 固件大小
char md5[32 + 1]; ///< 固件的md5值
} bleproto_otanotify_req_t;
typedef struct bleproto_otanotify_rsp {
int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
} bleproto_otanotify_rsp_t;
//////////////////////////////////////////////////////////////////////
// E_BLEPROTO_SERVICE_ID_OTADATA
//////////////////////////////////////////////////////////////////////
typedef struct bleproto_otadata_req {
int id; ///< file_id
int32_t offset; ///< 要读取数据的偏移
uint32_t maxsize; ///< 每次最大读取的大小
} bleproto_otadata_req_t;
typedef struct bleproto_otadata_rsp {
int32_t errcode; ///< 返回码，0表示成功, 其他表示失败
int id; ///< file_id
int32_t offset; ///< 当前读取到的数据偏移
uint32_t len; ///< 当次读取数据的大小
/**
* 固件数据指针（不内嵌大数组，避免 bleproto_appdata_desc_t 膨胀到 2KB+）
* - decode：指向 appdata 内部缓冲（零拷贝），下次 decode 前有效
* - encode：由调用方提供可读缓冲
*/
const uint8_t *data;
} bleproto_otadata_rsp_t;
/****************************************************************************/
/* Public Data */
/****************************************************************************/
/****************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
/****************************************************************************/
/* Public Function Prototypes */
/****************************************************************************/
/**
* @brief 序列化广播数据(广播数据长度为31)
*
* @param[in] adv - 广播数据结构体.
* @param[out] data - 序列化数据缓冲区, 固定为31个字节.
* @param[in] size - 序列化数据缓冲区长度
*
* @return 小于0表示失败，大于0表示序列化后的长度(31)
*/
int bleproto_advdata_serialize(bleproto_adv_t *adv,
uint8_t * data,
uint8_t size);
/**
* @brief 反序列化广播数据(广播数据长度为31)
*
* @param[in] data - 反序列化数据指针
* @param[in] len - 反序列化数据长度
* @param[out] adv - 广播数据结构体
*
* @return 小于0表示失败，大于0表示反序列化使用data的长度(31)
*/
int bleproto_advdata_deserialize(const uint8_t * data,
uint8_t len,
bleproto_adv_t *adv);
/**
* @brief 计算序列化应用数据长度
*
* @note packetlen说明
*
* ```c
* ble4.0 通常协商的mtu=27, packetlen = 27 - 4 - 3 = 20
* ble4.2 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
* ble5.0 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
* ```
*
* @param[in] appdata - 应用数据结构体
* @param[in] packetlen - BLE GATT单包传输有效长度, 查看上面说明
* @param[out] outlen - 计算返回总长度，每个包都含有包头
*
* @return 成功返回0，其他值表示失败
*/
int bleproto_appdata_serialize_len(bleproto_appdata_t *appdata,
uint8_t packetlen,
uint16_t * outlen);
/**
* @brief 序列化应用数据
*
* @note packetlen说明
*
* ```c
* ble4.0 通常协商的mtu=27, packetlen = 27 - 4 - 3 = 20
* ble4.2 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
* ble5.0 通常协商的mtu=251, packelen = 251 - 4 - 3 = 244
* ```
*
* 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
* +----------------+
* | 1 | 第一包按照packetlen填满
* +----------------+
* | |
* | ... | 中间包按照packetlen填满
* | |
* +----------------+
* | N | 最后一包长度 = totallen - (packetlen * (N -1))
* +----------------+
*
* 需要按照每包的顺序发给对端
*
* @param[in] appdata - 应用数据结构体
* @param[in] packetlen - BLE GATT单包传输有效长度, 查看上面说明
* @param[out] buf - 数据缓冲区指针
* @param[in] size - 数据缓冲区大小
*
* @return 小于0表示失败，大于0表示序列化后的长度
*/
int bleproto_appdata_serialize(bleproto_appdata_t *appdata,
uint8_t packetlen,
uint8_t * buf,
uint16_t size);
/**
* @brief 将已打包好的 payload 包装成单帧 appdata（不分包）
* @param txbuf 输出缓冲
* @param txbuf_size 输出缓冲大小
* @param header 应用层头（datalen/totalframe/frameseq 由本函数填写）
* @param payload 已序列化的 service 数据；可为 NULL（payload_len==0）
* @param payload_len payload 长度，须 <=255（单帧 pthis_frame_len 为 u8）
* @return >0 总字节数；<0 失败
* @note 小包场景（JB 55AA 透传等）用此接口，避免 bleproto_appdata_t 大缓冲
*/
int bleproto_appdata_wrap_raw(uint8_t *txbuf,
uint16_t txbuf_size,
const bleproto_appdata_header_t *header,
const uint8_t *payload,
uint16_t payload_len);
/**
* @brief 反序列化应用数据
*
*
* 如果报文数据长度超过 BLE GATT单包传输有效长度，需要按照文档方式分包，
* +----------------+
* | 1 | 第一包按照packetlen填满
* +----------------+
* | |
* | ... | 中间包按照packetlen填满
* | |
* +----------------+
* | N | 最后一包长度 = totallen - (packetlen * (N -1))
* +----------------+
*
* 因此接收到数据
* 1. 函数返回等于0，以为还有分包数据还没有接收完成，
* 接收到下包数据 append 在buf尾部，再调用函数的解析数据包
* 2. 函数返回大于0，表示收到数据解析了多少字节，需要将头上对应长度数据移除掉
* 3. 函数返回小于0，表示收到非法的数据包，无法解析
*
* @param[in] buf - 数据缓冲区指针.
* @param[in] len - 数据缓冲区长度.
* @param[out] app_data - 应用数据结构体.
*
* @return 大于0表示解析成功, 返回当前解析了多少个字节,
* 等于0表示解析未完成, 只接受到分包的部分数据, 需要继续接收数据
* 小于0表示解析失败
*/
int bleproto_appdata_deserialize(uint8_t * buf,
uint16_t len,
bleproto_appdata_t *appdata);
////////////////////////////////////////////////////////////////////////
// encjson 序列化, 成功返回json序列化的长度，失败返回小于0
// decjson 反序列化, 成功返回0, 其他值表示失败
////////////////////////////////////////////////////////////////////////
// clang-format off
int bleproto_encjson_ycmd(const bleproto_ycmd_t *ycmd, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_decjson_ycmd(const uint8_t *data, uint16_t len, bleproto_ycmd_t *ycmd);
// clang-format on
////////////////////////////////////////////////////////////////////////
// encjson 序列化, 成功返回json序列化的长度，失败返回小于0
// decjson 反序列化, 成功返回0, 其他值表示失败
////////////////////////////////////////////////////////////////////////
// clang-format off
int bleproto_encjson_deviceinfo_req(const bleproto_deviceinfo_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_deviceinfo_rsp(const bleproto_deviceinfo_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_authsetup_req(const bleproto_authsetup_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_authsetup_rsp(const bleproto_authsetup_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_authdelete_req(const bleproto_authdelete_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_authdelete_rsp(const bleproto_authdelete_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_runcmd_req(const bleproto_runcmd_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_runcmd_rsp(const bleproto_runcmd_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_reportcmd_req(const bleproto_reportcmd_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_reportcmd_rsp(const bleproto_reportcmd_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_doaction_req(const bleproto_doaction_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_doaction_rsp(const bleproto_doaction_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_otanotify_req(const bleproto_otanotify_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encjson_otanotify_rsp(const bleproto_otanotify_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
// otadata 序列化请求走json，回复走二进制
int bleproto_encjson_otadata_req(const bleproto_otadata_req_t *req, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_encbin_otadata_rsp(const bleproto_otadata_rsp_t *rsp, uint8_t data[BLEPROTO_APPDATA_DATA_MAX_SZ]);
int bleproto_decjson_deviceinfo_req(const uint8_t *data, uint16_t len, bleproto_deviceinfo_req_t *req);
int bleproto_decjson_deviceinfo_rsp(const uint8_t *data, uint16_t len, bleproto_deviceinfo_rsp_t *rsp);
int bleproto_decjson_authsetup_req(const uint8_t *data, uint16_t len, bleproto_authsetup_req_t *req);
int bleproto_decjson_authsetup_rsp(const uint8_t *data, uint16_t len, bleproto_authsetup_rsp_t *rsp);
int bleproto_decjson_authdelete_req(const uint8_t *data, uint16_t len, bleproto_authdelete_req_t *req);
int bleproto_decjson_authdelete_rsp(const uint8_t *data, uint16_t len, bleproto_authdelete_rsp_t *rsp);
int bleproto_decjson_runcmd_req(const uint8_t *data, uint16_t len, bleproto_runcmd_req_t *req);
int bleproto_decjson_runcmd_rsp(const uint8_t *data, uint16_t len, bleproto_runcmd_rsp_t *rsp);
int bleproto_decjson_reportcmd_req(const uint8_t *data, uint16_t len, bleproto_reportcmd_req_t *req);
int bleproto_decjson_reportcmd_rsp(const uint8_t *data, uint16_t len, bleproto_reportcmd_rsp_t *rsp);
int bleproto_decjson_doaction_req(const uint8_t *data, uint16_t len, bleproto_doaction_req_t *req);
int bleproto_decjson_doaction_rsp(const uint8_t *data, uint16_t len, bleproto_doaction_rsp_t *rsp);
int bleproto_decjson_otanotify_req(const uint8_t *data, uint16_t len, bleproto_otanotify_req_t *req);
int bleproto_decjson_otanotify_rsp(const uint8_t *data, uint16_t len, bleproto_otanotify_rsp_t *rsp);
//otadata 反序列化请求走json，回复走二进制
int bleproto_decjson_otadata_req(const uint8_t *data, uint16_t len, bleproto_otadata_req_t *req);
int bleproto_debin_otadata_rsp(const uint8_t *data, uint16_t len, bleproto_otadata_rsp_t *rsp);
// clang-format on
/****************************************************************************/
#ifdef __cplusplus
}
#endif
/****************************************************************************/
#endif /* BLEPROTO_PACKER_H_INCLUDE */
/****************************************************************************/
/**
* @} (end addtogroup bleproto_packer)
*/
/****************************************************************************/
/* */
/* End of file. */
/* */
/****************************************************************************/
apps/usr_le_code/lib/libusr_le_code.a
BIN
View File
Binary file not shown.
apps/usr_le_code/thirdpart/mjson/mjson.c
+1066
View File
File diff suppressed because it is too large Load Diff
apps/usr_le_code/thirdpart/mjson/mjson.h
+220
View File
@@ -0,0 +1,220 @@
// Copyright (c) 2018-2020 Cesanta Software Limited
// All rights reserved
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#ifndef MJSON_H
#define MJSON_H
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#ifndef MJSON_ENABLE_PRINT
#define MJSON_ENABLE_PRINT 1
#endif
#ifndef MJSON_ENABLE_RPC
#define MJSON_ENABLE_RPC 1
#endif
#ifndef MJSON_ENABLE_BASE64
#define MJSON_ENABLE_BASE64 1
#endif
#ifndef MJSON_ENABLE_MERGE
#define MJSON_ENABLE_MERGE 1
#endif
#ifndef MJSON_ENABLE_PRETTY
#define MJSON_ENABLE_PRETTY 1
#endif
#ifndef MJSON_ENABLE_NEXT
#define MJSON_ENABLE_NEXT 1
#endif
#ifndef MJSON_RPC_LIST_NAME
#define MJSON_RPC_LIST_NAME "rpc.list"
#endif
#ifndef MJSON_DYNBUF_CHUNK
#define MJSON_DYNBUF_CHUNK 256 // Allocation granularity for print_dynamic_buf
#endif
#ifndef MJSON_REALLOC
#define MJSON_REALLOC realloc
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define MJSON_ERROR_INVALID_INPUT (-1)
#define MJSON_ERROR_TOO_DEEP (-2)
#define MJSON_TOK_INVALID 0
#define MJSON_TOK_KEY 1
#define MJSON_TOK_STRING 11
#define MJSON_TOK_NUMBER 12
#define MJSON_TOK_TRUE 13
#define MJSON_TOK_FALSE 14
#define MJSON_TOK_NULL 15
#define MJSON_TOK_ARRAY 91
#define MJSON_TOK_OBJECT 123
#define MJSON_TOK_IS_VALUE(t) ((t) > 10 && (t) < 20)
typedef int (*mjson_cb_t)(int event, const char *buf, int offset, int len,
void *fn_data);
#ifndef MJSON_MAX_DEPTH
#define MJSON_MAX_DEPTH 20
#endif
int mjson(const char *buf, int len, mjson_cb_t cb, void *ud);
int mjson_find(const char *buf, int len, const char *jp, const char **tp,
int *tl);
int mjson_get_number(const char *buf, int len, const char *path, double *v);
int mjson_get_bool(const char *buf, int len, const char *path, int *v);
int mjson_get_string(const char *buf, int len, const char *path, char *to,
int n);
int mjson_get_hex(const char *buf, int len, const char *path, char *to, int n);
#if MJSON_ENABLE_NEXT
int mjson_next(const char *buf, int len, int offset, int *key_offset,
int *key_len, int *val_offset, int *val_len, int *vale_type);
#endif
#if MJSON_ENABLE_BASE64
int mjson_get_base64(const char *buf, int len, const char *path, char *dst,
int dst_len);
int mjson_base64_dec(const char *src, int src_len, char *dst, int dst_len);
#endif
#if MJSON_ENABLE_PRINT
typedef int (*mjson_print_fn_t)(const char *buf, int len, void *fn_data);
typedef int (*mjson_vprint_fn_t)(mjson_print_fn_t fn, void *, va_list *);
struct mjson_fixedbuf {
char *ptr;
int size, len;
};
int mjson_printf(mjson_print_fn_t fn, void *fn_data, const char *fmt, ...);
int mjson_vprintf(mjson_print_fn_t fn, void *fn_data, const char *fmt,
va_list *ap);
int mjson_print_str(mjson_print_fn_t fn, void *fn_data, const char *buf,
int len);
int mjson_print_int(mjson_print_fn_t fn, void *fn_data, int value,
int is_signed);
int mjson_print_long(mjson_print_fn_t fn, void *fn_data, long value,
int is_signed);
int mjson_print_buf(mjson_print_fn_t fn, void *fn_data, const char *buf,
int len);
int mjson_print_dbl(mjson_print_fn_t fn, void *fn_data, double d, int width);
int mjson_print_null(const char *ptr, int len, void *fn_data);
int mjson_print_fixed_buf(const char *ptr, int len, void *fn_data);
int mjson_print_dynamic_buf(const char *ptr, int len, void *fn_data);
int mjson_snprintf(char *buf, size_t len, const char *fmt, ...);
char *mjson_aprintf(const char *fmt, ...);
#if MJSON_ENABLE_PRETTY
int mjson_pretty(const char *s, int n, const char *pad, mjson_print_fn_t fn,
void *fn_data);
#endif
#if MJSON_ENABLE_MERGE
int mjson_merge(const char *s, int n, const char *s2, int n2,
mjson_print_fn_t fn, void *fn_data);
#endif
#endif // MJSON_ENABLE_PRINT
#if MJSON_ENABLE_RPC
void jsonrpc_init(mjson_print_fn_t response_cb, void *fn_data);
int mjson_globmatch(const char *s1, int n1, const char *s2, int n2);
struct jsonrpc_request {
struct jsonrpc_ctx *ctx;
const char *frame; // Points to the whole frame
int frame_len; // Frame length
const char *params; // Points to the "params" in the request frame
int params_len; // Length of the "params"
const char *id; // Points to the "id" in the request frame
int id_len; // Length of the "id"
const char *method; // Points to the "method" in the request frame
int method_len; // Length of the "method"
mjson_print_fn_t fn; // Printer function
void *fn_data; // Printer function data
void *userdata; // Callback's user data as specified at export time
};
struct jsonrpc_method {
const char *method;
int method_sz;
void (*cb)(struct jsonrpc_request *);
struct jsonrpc_method *next;
};
// Main RPC context, stores current request information and a list of
// exported RPC methods.
struct jsonrpc_ctx {
struct jsonrpc_method *methods;
mjson_print_fn_t response_cb;
void *response_cb_data;
};
// Registers function fn under the given name within the given RPC context
#define jsonrpc_ctx_export(ctx, name, fn) \
do { \
static struct jsonrpc_method m = {(name), sizeof(name) - 1, (fn), 0}; \
m.next = (ctx)->methods; \
(ctx)->methods = &m; \
} while (0)
void jsonrpc_ctx_init(struct jsonrpc_ctx *ctx, mjson_print_fn_t response_cb,
void *response_cb_data);
void jsonrpc_return_error(struct jsonrpc_request *r, int code,
const char *message, const char *data_fmt, ...);
void jsonrpc_return_success(struct jsonrpc_request *r, const char *result_fmt,
...);
void jsonrpc_ctx_process(struct jsonrpc_ctx *ctx, const char *req, int req_sz,
mjson_print_fn_t fn, void *fn_data, void *userdata);
extern struct jsonrpc_ctx jsonrpc_default_context;
extern void jsonrpc_list(struct jsonrpc_request *r);
#define jsonrpc_export(name, fn) \
jsonrpc_ctx_export(&jsonrpc_default_context, (name), (fn))
#define jsonrpc_process(buf, len, fn, fnd, ud) \
jsonrpc_ctx_process(&jsonrpc_default_context, (buf), (len), (fn), (fnd), (ud))
#define JSONRPC_ERROR_INVALID -32700 /* Invalid JSON was received */
#define JSONRPC_ERROR_NOT_FOUND -32601 /* The method does not exist */
#define JSONRPC_ERROR_BAD_PARAMS -32602 /* Invalid params passed */
#define JSONRPC_ERROR_INTERNAL -32603 /* Internal JSON-RPC error */
#endif // MJSON_ENABLE_RPC
#ifdef __cplusplus
}
#endif
#endif // MJSON_H
apps/usr_le_code/usr_le_adv.c
+340
View File
@@ -0,0 +1,340 @@
/******************************************************************************
* @file usr_le_adv.c
* @brief BLE 广播 / 配对 / OTA 广播切换
* @author cyWu <1917507415@qq.com>
* @date 2026.08.19
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.03, cyWu, 首次发布
* - V1.1.0, 2026.08.19, cyWu, 对齐模组注释与助手；保留 SOC 上电绑广播策略
******************************************************************************/
#include "system/includes.h"
#include "app_config.h"
#include "app_main.h"
#include "vm.h"
#include "bleproto.h"
#include "bleproto_api.h"
#include "usr_le_product.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[LE_ADV]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#include "debug.h"
/******************************************************************************
* 广播相关三个标志（务必区分）：
*
* 1) usr_auth_data.paired_flag —— 配网结果（存 VM，掉电保持）
* - 0：未配网
* - 1：已配网（三元组已保存）
*
* 2) usr_var.usr_goto_pair —— 是否主动进入配网流程（RAM，掉电丢失）
* - 0：非配网流程
* - 1：app_main 上电 / usr_goto_pair_mode() 触发，发【绑定广播】
*
* 3) usr_var.usr_adv_flag —— 广播内容是否需要刷新到协议栈（一次性）
* - 1：usr_ble_adv_updata() 会重新 set adv data 并 enable
* - 0：本周期不刷新
*
* SOC 决策表（与模组不同：未配网也发绑定广播，便于上电配网）：
* usr_goto_pair==1 → 绑定广播
* paired_flag==0 → 绑定广播
* paired_flag==1 → 回连广播
******************************************************************************/
extern u8 muti_adv_data[31];
extern u8 muti_adv_data_len;
/* 定义在 usr_le_recieve.c，模块内共用，不对外导出 */
extern bleproto_authsetup_req_t usr_auth_data;
extern u16 usr_get_conn_service(void);
extern int muti_make_set_adv_data(u8 *data, u8 data_len);
extern int muti_make_set_adv_data_updata(void);
extern void usr_set_adv_interval(u16 val);
extern u16 usr_get_adv_interval(void);
extern void ble_multi_trans_disconnect(void);
extern void ble_trans_module_enable(u8 flag);
extern void usr_timer_loop(void);
extern u8 usr_get_ota_status(void);
extern void usr_ota_exit(void);
void usr_ble_adv_init(void);
void usr_ble_adv_updata(void);
static int le_timer_handle = 0;
/**
* @brief BLE 是否已连接
* @return 1=已连接，0=未连接
*/
uint8_t usr_ble_is_connected(void)
{
return (usr_get_conn_service() != 0) ? 1u : 0u;
}
/**
* @brief 从 VM 读取配对信息到 usr_auth_data
* @note 失败则清零，并将 paired_flag 置 0 写回
*/
void usr_get_pair_info(void)
{
int ret;
ret = syscfg_read(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
if (ret <= 0)
{
memset(&usr_auth_data, 0x00, sizeof(usr_auth_data));
usr_auth_data.paired_flag = 0;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
}
}
/**
* @brief 标记已配网并保存三元组到 VM
* @note AUTHSETUP 成功后调用，paired_flag = 1
*/
void usr_write_pair_info(void)
{
usr_auth_data.paired_flag = 1;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
}
/**
* @brief 清除配对信息并延时复位
*/
void usr_clear_pair_info(void)
{
printf("usr_clear_pair_info_reset\n");
memset(&usr_auth_data, 0x00, sizeof(usr_auth_data));
usr_auth_data.paired_flag = 0;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
sys_timeout_add(NULL, cpu_reset, 600);
}
/**
* @brief 清除配对信息但不复位（用于重新配网）
*/
void usr_clear_pair_info_noreset(void)
{
printf("usr_clear_pair_info_noreset\n");
memset(&usr_auth_data, 0x00, sizeof(usr_auth_data));
usr_auth_data.paired_flag = 0;
syscfg_write(CFG_USER_PAIR_INFO, (u8 *)&usr_auth_data, sizeof(usr_auth_data));
}
/**
* @brief 进入配网模式：清配对 + 置 usr_goto_pair + 发绑定广播
*/
void usr_goto_pair_mode(void)
{
ble_multi_trans_disconnect();
usr_clear_pair_info_noreset();
usr_var.usr_goto_pair = 1;
os_time_dly(5);
usr_ble_adv_init();
}
/**
* @brief 断开 BLE 并停止广播（复位/重启前）
*/
void usr_ble_disconnect_and_stop_adv(void)
{
printf("usr_ble_disconnect_and_stop_adv\n");
ble_multi_trans_disconnect();
usr_var.usr_goto_pair = 0;
usr_var.usr_adv_flag = 0;
ble_trans_module_enable(0);
}
/**
* @brief 按当前标志刷新广播策略并启动周期更新
* @note 见文件头「三个标志」；SOC 未配网也发绑定广播
*/
void usr_ble_adv_init(void)
{
int8_t txpower = 0;
uint8_t manucode[BLEPROTO_ADV_TLV_LENGTH_MANUCODE] = {0};
uint8_t prodcode[BLEPROTO_ADV_TLV_LENGTH_PRODCODE];
uint8_t gmac[6] = {0};
uint8_t pcode[BLE_PROTO_ADV_LENGTH_PCODE];
/* 产品身份由应用层 g_usr_le_* 提供（见 usr_jb_main.c） */
memcpy(prodcode, g_usr_le_prodcode, BLEPROTO_ADV_TLV_LENGTH_PRODCODE);
memcpy(pcode, g_usr_le_pcode, BLE_PROTO_ADV_LENGTH_PCODE);
usr_set_adv_interval(80);
if (usr_var.usr_ota_succ_flag)
{
return;
}
if (usr_var.usr_goto_pair)
{
/* app_main 上电已置 usr_goto_pair=1 并清配对信息，此处发绑定广播供网关配网 */
usr_clear_pair_info_noreset();
printf("goto pair bind adv, paired_flag=%d\n", usr_auth_data.paired_flag);
muti_adv_data_len = bleproto_advdata_encode4bind(muti_adv_data, txpower,
manucode, pcode, prodcode);
usr_var.usr_adv_flag = 1;
}
else
{
usr_get_pair_info();
if (usr_auth_data.paired_flag == 0)
{
/* SOC：未配网也发绑定广播（模组此处为不广播） */
muti_adv_data_len = bleproto_advdata_encode4bind(muti_adv_data, txpower,
manucode, pcode, prodcode);
usr_var.usr_adv_flag = 0;
}
else
{
memcpy(gmac, usr_auth_data.gwmac, 6);
muti_adv_data_len = bleproto_advdata_encode4reconn(muti_adv_data, txpower, gmac,
manucode, pcode, prodcode);
usr_var.usr_adv_flag = 1;
}
}
usr_ble_adv_updata();
if (le_timer_handle == 0)
{
le_timer_handle = sys_timer_add(NULL, usr_ble_adv_updata, 500);
}
}
/**
* @brief 获取是否已配网
* @return 1=已配网，0=未配网
*/
u8 usr_get_pair_flag(void)
{
return usr_auth_data.paired_flag;
}
/**
* @brief 周期处理广播刷新（由 500ms 定时器调用）
* @note 仅当 usr_adv_flag==1 时：停广播 → 写入 muti_adv_data → 再开广播
*/
void usr_ble_adv_updata(void)
{
static u16 usr_goto_slow_adv = 0;
if (usr_var.usr_adv_flag)
{
ble_trans_module_enable(0);
usr_var.usr_adv_flag = 0;
muti_make_set_adv_data(muti_adv_data, muti_adv_data_len);
printf("###muti_adv_data = ");
printf_buf(muti_adv_data, muti_adv_data_len);
ble_trans_module_enable(1);
}
if (!usr_ble_is_connected())
{
/* 未连接：回连快广播（80）持续约 60s（500ms×120）后切慢广播 */
if (usr_get_adv_interval() == 80)
{
if ((usr_var.usr_goto_pair == 0) && usr_auth_data.paired_flag)
{
if (usr_var.usr_ota_succ_flag == 0)
{
usr_goto_slow_adv++;
printf("usr_goto_slow_adv = %d\n", usr_goto_slow_adv);
}
if (usr_goto_slow_adv >= 120)
{
usr_goto_slow_adv = 0;
usr_set_adv_interval(80 * 10);
usr_var.usr_adv_flag = 1;
}
}
}
else
{
usr_goto_slow_adv = 0;
}
}
else
{
usr_goto_slow_adv = 0;
}
if (usr_get_ota_status() == 0)
{
if (!usr_ble_is_connected())
{
if (usr_var.usr_ota_succ_flag == 0)
{
usr_ota_exit();
}
}
}
/* 协议层周期处理（上报/应答） */
usr_timer_loop();
}
void usr_soft_off(void)
{
sys_enter_soft_poweroff(NULL);
}
void usr_ble_adv_updata_OTA(void)
{
ble_trans_module_enable(0);
usr_var.usr_adv_flag = 0;
extern u8 usr_mac_addr[6];
extern int le_controller_set_mac(void *addr);
usr_mac_addr[0] = usr_mac_addr[0] + 1;
le_controller_set_mac(usr_mac_addr);
muti_make_set_adv_data_updata();
printf("###muti_adv_data = ");
printf_buf(muti_adv_data, muti_adv_data_len);
ble_trans_module_enable(1);
}
void usr_ota_process(void)
{
static u8 cnt = 0;
if (cnt == 0)
{
ble_multi_trans_disconnect();
}
if (!usr_ble_is_connected())
{
cnt++;
if (cnt == 2)
{
usr_ble_adv_updata_OTA();
}
if (cnt >= 60)
{
cnt = 0;
cpu_reset();
}
}
else
{
cnt = 1;
}
}
/**
* @brief 旧版 RCSP/JSON OTA 入口；产品 JB 0x30/0x32 路径不要调用
*/
void usr_app_ota_init(void)
{
usr_var.usr_goto_updata = 1;
if (usr_var.ota_timer == 0)
{
usr_var.ota_timer = sys_timer_add(NULL, usr_ota_process, 1000);
}
}
apps/usr_le_code/usr_le_api.h
+8 -3
View File
@@ -1,15 +1,16 @@
/******************************************************************************
* @file usr_le_api.h
* @brief usr_le_code 静态库对外应用 API（配网 / 配对 / OTA）
* @brief usr_le_code 对外应用 API（配网 / 配对 / OTA）
* @author cyWu <1917507415@qq.com>
* @date 2026.08.03
* @version V1.0.1
* @version V1.0.2
* @history
* - V1.0.0, 2026.08.03, cyWu, 首次发布
* - V1.0.1, 2026.08.19, cyWu, 收敛公开 API，移除 BLE 栈钩子声明
* - V1.0.2, 2026.08.25, cyWu, 改为源码编译，去掉静态库
*
* @note usr_ble_adv_init / usr_le_data_recieve 为 BLE/RCSP 协议栈链接钩子，
* 由库内部实现并导出符号，不作为应用层公开接口。
* 由 usr_le_code 内部实现并导出符号，不作为应用层公开接口。
******************************************************************************/
#ifndef __USR_LE_API_H__
@@ -24,16 +25,19 @@ extern "C" {
/**
* @brief 进入配对/配网模式
* @note 断开当前连接、清除配对信息（不复位），重新发绑定广播
* @return 无
*/
void usr_goto_pair_mode(void);
/**
* @brief 清除配对信息但不复位
* @return 无
*/
void usr_clear_pair_info_noreset(void);
/**
* @brief 清除配对信息并延时复位
* @return 无
*/
void usr_clear_pair_info(void);
@@ -46,6 +50,7 @@ uint8_t usr_get_pair_flag(void);
/**
* @brief 启动应用侧 OTA 流程
* @note 置位 usr_goto_updata，并创建 1s 周期定时器驱动断连与 OTA 广播切换
* @return 无
*/
void usr_app_ota_init(void);
apps/usr_le_code/usr_le_product.h
+1 -1
View File
@@ -1,6 +1,6 @@
/******************************************************************************
* @file usr_le_product.h
* @brief usr_le_code 产品身份配置接口（由应用层提供符号，库内不写死）
* @brief usr_le_code 产品身份配置接口（由应用层提供符号，模块内不写死）
* @author cyWu <1917507415@qq.com>
* @date 2026.08.03
* @version V1.0.0
apps/usr_le_code/usr_le_recieve.c
+377
View File
@@ -0,0 +1,377 @@
/******************************************************************************
* @file usr_le_recieve.c
* @brief BLE 收包入口：bleproto 解析后分发配网 / 对时 / JB 协议 / 组应答
* @author cyWu <1917507415@qq.com>
* @date 2026.08.19
* @version V1.1.0
* @history
* - V1.0.0, 2026.08.03, cyWu, 首次发布
* - V1.1.0, 2026.08.19, cyWu, 对齐模组结构；废弃 JSON OTA；修 AUTHDELETE serviceid
******************************************************************************/
#include "system/includes.h"
#include "app_config.h"
#include "app_main.h"
#include "vm.h"
#include "bleproto.h"
#include "bleproto_api.h"
#include "ble_proto.h"
#include "usr_rtc.h"
#include "usr_le_api.h"
#include "jb_protocol.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[USR_LE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#include "debug.h"
/* 拼 GATT 分包：业务包 ≈ bleproto头 + V2 开销 + JB 帧(<=128)，1024 足够 */
#define USR_LE_RX_BUF_LEN 1024
#define USR_LE_V2_WRAP_OVERHEAD 32u /* V2 头开销，JB 帧最大 128 → 约 160 */
#define USR_LE_V2_CMD_REPORT 100u /* REPORTCMD_V2 内层 cmd */
#define USR_LE_V2_CMD_RUN 110u /* RUNCMD_V2 内层 cmd */
#define USR_LE_JB_CMD_OFF 4u /* 55 AA | LEN_H LEN_L | CMD */
static int encode_len = 0;
static u8 txbuf[384] = {0};
static u8 rxbuf[USR_LE_RX_BUF_LEN] = {0};
static u8 s_last_runcmd_msgid = 0; /* RUNCMD_V2 应答须回填最近 msgid */
bleproto_authsetup_req_t usr_auth_data;
extern void usr_ble_send_data(u8 *data, u16 len);
extern u8 usr_ble_is_notify_ready(void);
extern void usr_write_pair_info(void);
extern void usr_clear_pair_info(void);
extern void usr_jb_le_recieve_data(u8 *data, u16 len);
extern int8_t jbReportAckCheck(u16 cmd, u8 gateway_int_cnt, int32_t gateway_int0);
static void usr_data_ana(bleproto_appdata_desc_t *desc);
static void usr_run_cmd_code_v2(ble_proto_packet_t *runcmd_par, u8 usr_msg_id);
/**
* @brief 填 bleproto 应答头
* @param out 输出 desc
* @param in 请求 desc（取 msgid）
* @param serviceid 服务号
*/
static void usr_le_fill_rsp_header(bleproto_appdata_desc_t *out,
const bleproto_appdata_desc_t *in,
uint8_t serviceid)
{
out->header.version = 0;
out->header.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
out->header.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP;
out->header.msgid = in->header.msgid;
out->header.encrypt = 0;
out->header.serviceid = serviceid;
}
/**
* @brief 编码并经 BLE 发出
* @param desc 已填好的应答
*/
static void usr_le_encode_and_send(bleproto_appdata_desc_t *desc)
{
encode_len = bleproto_appdata_encode(txbuf, sizeof(txbuf), sizeof(txbuf), desc);
if (encode_len > 0)
{
printf("encode_len = %d\n", encode_len);
usr_ble_send_data(txbuf, encode_len);
}
else
{
printf("encode_len fail %d\n", encode_len);
}
}
/**
* @brief 是否走网关主动上报（REPORTCMD_V2）
* @param jb_cmd 55AA 命令字
* @return 1=主动上报，0=RUNCMD 应答
*/
static uint8_t usr_le_is_gateway_report_cmd(uint8_t jb_cmd)
{
return (jb_cmd == CMD_REPORT ||
jb_cmd == CMD_OTA_COMPLETE ||
jb_cmd == CMD_OTA_STOP_MCU)
? 1u
: 0u;
}
/**
* @brief BLE 收包入口
* @param data 收包数据
* @param len 数据长度
*/
void usr_le_data_recieve(u8 *data, u16 len)
{
static u16 usr_len = 0;
/* desc 含 ycmd 等 union，放 static，避免每次收包在栈上开大块 */
static bleproto_appdata_desc_t s_rx_desc;
int rc_result = 0;
if (!data || len == 0)
{
return;
}
if ((u32)usr_len + len > sizeof(rxbuf))
{
printf("### rxbuf overflow, usr_len=%u len=%u, reset\n", usr_len, len);
usr_len = 0;
return;
}
memcpy(&rxbuf[usr_len], data, len);
usr_len += len;
rc_result = bleproto_appdata_decode(rxbuf, usr_len, &s_rx_desc);
if (rc_result < 0)
{
printf("### invild pack\n");
usr_len = 0;
}
else if (rc_result == 0)
{
printf("### keep recieving\n");
}
else
{
printf("### pack recieved ok\n");
usr_len = 0;
usr_data_ana(&s_rx_desc);
}
}
/**
* @brief 解析 bleproto 服务并分发
* @param desc 已 decode 的包
*/
static void usr_data_ana(bleproto_appdata_desc_t *desc)
{
static bleproto_appdata_desc_t s_encode_desc;
memset(&s_encode_desc, 0, sizeof(s_encode_desc));
printf("desc serviceid=%d msgtype=%d\n",
desc->header.serviceid, desc->header.msgtype);
if (desc->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_REQ)
{
switch (desc->header.serviceid)
{
case E_BLEPROTO_SERVICE_ID_DEVICEINFO: {
bleproto_deviceinfo_req_t *req = &desc->datast.deviceinfo_req;
bleproto_deviceinfo_rsp_t *rsp = &s_encode_desc.datast.deviceinfo_rsp;
/* 网关从子设备连上开始计时，每 12 小时经 DEVICEINFO 同步一次 */
usr_rtc_set_from_unix(req->t, (int32_t)req->gmtoff);
usr_le_fill_rsp_header(&s_encode_desc, desc, E_BLEPROTO_SERVICE_ID_DEVICEINFO);
rsp->hbcycle = 1000;
strcpy(rsp->swv, "V1.0.0.00");
strcpy(rsp->hwv, "V1.0.0.00");
rsp->longcon = 1;
rsp->prototype = 4;
usr_le_encode_and_send(&s_encode_desc);
break;
}
case E_BLEPROTO_SERVICE_ID_AUTHSETUP: {
bleproto_authsetup_rsp_t *au_rsp = &s_encode_desc.datast.authsetup_rsp;
printf("E_BLEPROTO_SERVICE_ID_AUTHSETUP\n");
usr_le_fill_rsp_header(&s_encode_desc, desc, E_BLEPROTO_SERVICE_ID_AUTHSETUP);
au_rsp->errcode = 0;
memcpy(&usr_auth_data, &desc->datast.authsetup_req, sizeof(usr_auth_data));
if (usr_auth_data.paired_flag == 0)
{
usr_write_pair_info();
usr_var.usr_goto_pair = 0; // 新增：退出强制配网
printf("usr_auth_data %s %s ", usr_auth_data.authcode, usr_auth_data.devid);
printf_buf(usr_auth_data.gwmac, 6);
}
usr_le_encode_and_send(&s_encode_desc);
break;
}
case E_BLEPROTO_SERVICE_ID_AUTHDELETE: {
bleproto_authdelete_rsp_t *aude_rsp = &s_encode_desc.datast.authdelete_rsp;
printf("E_BLEPROTO_SERVICE_ID_AUTHDELETE\n");
usr_le_fill_rsp_header(&s_encode_desc, desc, E_BLEPROTO_SERVICE_ID_AUTHDELETE);
memcpy(aude_rsp->gwmac, usr_auth_data.gwmac, 6);
if (!memcmp(usr_auth_data.authcode, desc->datast.authdelete_req.authcode, 32))
{
aude_rsp->errcode = 0;
usr_clear_pair_info();
}
else
{
aude_rsp->errcode = 501;
}
usr_le_encode_and_send(&s_encode_desc);
break;
}
case E_BLEPROTO_SERVICE_ID_RUNCMD:
printf("E_BLEPROTO_SERVICE_ID_RUNCMD\n");
break;
case E_BLEPROTO_SERVICE_ID_RUNCMD_V2:
printf("E_BLEPROTO_SERVICE_ID_RUNCMD_V2\n");
usr_run_cmd_code_v2(&desc->datast.runcmd_v2_req, desc->header.msgid);
break;
case E_BLEPROTO_SERVICE_ID_OTANOTIFY:
case E_BLEPROTO_SERVICE_ID_OTADATA:
case E_BLEPROTO_SERVICE_ID_OTADATA_V2:
/* JSON OTA 已废弃，SOC 走 JB 0x30/0x32 */
printf("JSON OTA deprecated, use JB 0x30/0x32\n");
break;
default:
printf("err !!! default event desc->header.serviceid =%d\n",
desc->header.serviceid);
break;
}
return;
}
if (desc->header.msgtype == BLEPROTO_APPDATA_MSGTYPE_RSP)
{
switch (desc->header.serviceid)
{
case E_BLEPROTO_SERVICE_ID_REPORTCMD:
printf("E_BLEPROTO_SERVICE_ID_REPORTCMD errcode=%d\n",
desc->datast.reportcmd_rsp.errcode);
break;
case E_BLEPROTO_SERVICE_ID_REPORTCMD_V2: {
ble_proto_packet_t *rpt_ack = &desc->datast.reportcmd_v2_rsp;
printf("REPORTCMD_V2 cmd=%u cnt=%u int0=%ld\n",
(unsigned)rpt_ack->cmd,
(unsigned)rpt_ack->gateway_int_cnt,
(long)((rpt_ack->gateway_int_cnt > 0) ? rpt_ack->gateway_int[0] : 0));
jbReportAckCheck(rpt_ack->cmd,
rpt_ack->gateway_int_cnt,
(rpt_ack->gateway_int_cnt > 0) ? rpt_ack->gateway_int[0] : -1);
break;
}
case E_BLEPROTO_SERVICE_ID_OTADATA:
printf("JSON OTA deprecated, use JB 0x32\n");
break;
default:
printf("unhandled RSP serviceid=%d\n", desc->header.serviceid);
break;
}
}
}
/**
* @brief APP RUNCMD_V2：55AA 字节流转交 JB 协议层
* @param runcmd_par 内层包
* @param usr_msg_id bleproto msgid
*/
static void usr_run_cmd_code_v2(ble_proto_packet_t *runcmd_par, u8 usr_msg_id)
{
u8 jb_frame[MAX_PACKAGE_LEN];
u16 copy_len;
if (!runcmd_par || !runcmd_par->bytes_data || runcmd_par->device_bytes_len == 0)
{
printf("usr_run_cmd_code_v2 invalid bytes, len=%u\n",
runcmd_par ? runcmd_par->device_bytes_len : 0);
return;
}
printf("runcmd_par id = %d, bytes_len = %u\n",
runcmd_par->cmd, runcmd_par->device_bytes_len);
copy_len = runcmd_par->device_bytes_len;
if (copy_len > sizeof(jb_frame))
{
printf("usr_run_cmd_code_v2 bytes too long %u\n", copy_len);
return;
}
memcpy(jb_frame, runcmd_par->bytes_data, copy_len);
s_last_runcmd_msgid = usr_msg_id;
usr_jb_le_recieve_data(jb_frame, copy_len);
}
/**
* @brief 将 JB 协议帧封装为 bleproto V2 后通过 BLE 发送
* @param data JB 协议原始帧（55 AA | LEN | CMD | ...）
* @param len 帧长度
* @note 主动上报(0x07/0x34/0x38) → REPORTCMD_V2；其余 → RUNCMD_V2 应答
* 对外符号名保持 ble_send_data，供 jb_protocol 调用
*/
void ble_send_data(u8 *data, u16 len)
{
ble_proto_packet_t pkt;
bleproto_appdata_header_t hdr;
u8 v2_buf[MAX_PACKAGE_LEN + USR_LE_V2_WRAP_OVERHEAD];
u8 jb_cmd;
u8 is_active_send;
int plen;
int elen;
if (!data || len < 5)
{
printf("ble_send_data invalid param, len=%d\n", len);
return;
}
if (len > MAX_PACKAGE_LEN)
{
printf("ble_send_data frame too long %u\n", len);
return;
}
if (!usr_ble_is_notify_ready())
{
printf("ble_send_data wait CCC cmd=0x%02X\n", data[USR_LE_JB_CMD_OFF]);
return;
}
jb_cmd = data[USR_LE_JB_CMD_OFF];
is_active_send = usr_le_is_gateway_report_cmd(jb_cmd);
memset(&pkt, 0, sizeof(pkt));
memset(&hdr, 0, sizeof(hdr));
hdr.version = 0;
hdr.datafmt = BLEPROTO_APPDATA_DATAFMT_JSON;
hdr.encrypt = 0;
if (is_active_send)
{
hdr.msgtype = BLEPROTO_APPDATA_MSGTYPE_REQ;
hdr.msgid = 0;
hdr.serviceid = E_BLEPROTO_SERVICE_ID_REPORTCMD_V2;
pkt.cmd = USR_LE_V2_CMD_REPORT;
pkt.gateway_int_cnt = 0;
}
else
{
hdr.msgtype = BLEPROTO_APPDATA_MSGTYPE_RSP;
hdr.msgid = s_last_runcmd_msgid;
hdr.serviceid = E_BLEPROTO_SERVICE_ID_RUNCMD_V2;
pkt.cmd = USR_LE_V2_CMD_RUN;
pkt.gateway_int_cnt = 2;
pkt.gateway_int[0] = 0;
pkt.gateway_int[1] = 0;
}
pkt.device_bytes_len = len;
pkt.bytes_data = data;
plen = ble_proto_pack(&pkt, v2_buf, sizeof(v2_buf));
if (plen <= 0)
{
printf("ble_send_data pack fail %d\n", plen);
return;
}
elen = bleproto_appdata_wrap_raw(txbuf, sizeof(txbuf), &hdr, v2_buf, (uint16_t)plen);
printf("ble_send_data jb_cmd=0x%02X active=%d encode_len=%d msgid=%d\n",
jb_cmd, is_active_send, elen, hdr.msgid);
if (elen <= 0)
{
return;
}
usr_ble_send_data(txbuf, elen);
printf_buf(txbuf, elen);
}
apps/usr_periph/board_pin.h
+119
View File
@@ -0,0 +1,119 @@
/******************************************************************************
* @file board_pin.h
* @brief CBC2 门夹弹力绳板级引脚、电平与时序（换板只改本文件）
* @author cyWu <1917507415@qq.com>
* @date 2026.08.27
* @version V1.5.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 分钟后自动关机门限
* - V1.5.0, 2026.08.27, cyWu, 运行中空电关机红闪 5 下时序宏
******************************************************************************/
#ifndef __BOARD_PIN_H__
#define __BOARD_PIN_H__
#include "asm/gpio.h"
/*============================================================================*/
/* 功能开关：某路硬件异常时可单独关掉，不影响配网 */
/*============================================================================*/
#define BOARD_LED_ENABLE 1 /**< 1=红绿 LED */
#define BOARD_KEY_ENABLE 1 /**< 1=按键 PB1 */
#define BOARD_CHG_ENABLE 1 /**< 1=充电检测 PG8 + VPWR */
#define BOARD_MOTOR_ENABLE 1 /**< 1=电机 PA6/PC2 */
/*============================================================================*/
/* GPIO */
/*============================================================================*/
#define BOARD_MOTOR_INA_PIN IO_PORTA_06 /**< 电机 INA */
#define BOARD_MOTOR_INB_PIN IO_PORTC_02 /**< 电机 INB */
#define BOARD_LED_RED_PIN IO_PORTA_08 /**< 红灯 LED_PWR，低电平亮 */
#define BOARD_LED_GREEN_PIN IO_PORTA_07 /**< 绿灯 LED_CHG，低电平亮 */
#define BOARD_KEY_PIN IO_PORTB_01 /**< 按键，低电平按下 */
#define BOARD_CHG_PIN IO_PORTG_08 /**< ME4054 CHG，外部 2.2k 上拉 */
/* PA3 限位未贴件，空脚不初始化 */
#define BOARD_LED_ON_LEVEL 0 /**< LED 点亮电平：0=低亮 */
#define BOARD_KEY_ACTIVE_LEVEL 0 /**< 按键有效电平：0=按下为低 */
#define BOARD_CHG_CHARGING_LEVEL 0 /**< CHG 充电中为低 */
/**
* 收绳方向：1 = INA 高 / INB 低 为收绳（顺时针）
* 若实测方向反了，把本宏改为 0
*/
#define BOARD_MOTOR_IN_INA_HIGH 1
/*============================================================================*/
/* 电量 / 充电 */
/*============================================================================*/
#define BOARD_VBAT_FULL_MV 4120 /**< 100% */
#define BOARD_VBAT_EMPTY_MV 3200 /**< 0%，电量曲线下限（仅用于百分比换算） */
#define BOARD_VBAT_CHARGE_FULL_MV 4200 /**< 充电基准未记录时 100%（充电内阻压降，比放电阈值高）*/
#define BOARD_VBAT_CHARGE_EMPTY_MV 3400 /**< 充电基准未记录时 0% */
#define BOARD_VBAT_LOW_MV 3700 /**< 低电预警阈值：只闪红灯提示，不关机 */
#define BOARD_VBAT_LOW_HYST_MV 50 /**< 低电恢复回差 */
#define BOARD_VBAT_SHUTDOWN_MV 3250 /**< 约 5%，仅开机拦截用：关机状态下 app_battery 尚未运行，只能摸裸电压 */
#define BOARD_BATTERY_SHUTDOWN_PCT 5 /**< 运行中显示电量 <= 此值才自动关机，跟 APP 看到的百分比对齐 */
#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_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_EMPTY_BLINK_N 5 /**< 运行中电量到 5%：红灯闪烁次数 */
#define BOARD_LED_EMPTY_ON_MS 200 /**< 5% 关机提示：闪烁亮时间 */
#define BOARD_LED_EMPTY_OFF_MS 200 /**< 5% 关机提示：闪烁灭时间 */
#define BOARD_LED_EMPTY_OFF_WAIT_MS ((BOARD_LED_EMPTY_ON_MS + BOARD_LED_EMPTY_OFF_MS) \
* BOARD_LED_EMPTY_BLINK_N + 50u) /**< 闪完再掉电，多留 50ms 让 GPIO 落稳 */
#define BOARD_LED_FAST_ON_MS 100 /**< 配对绿快闪：亮 */
#define BOARD_LED_FAST_OFF_MS 100 /**< 配对绿快闪：灭 */
#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 /**< 低电红闪：亮 */
#define BOARD_LED_LOWBAT_PERIOD_MS 2000 /**< 低电红闪：周期 */
#define BOARD_LED_MODE_OFF_MS 150 /**< 切模式闪：灭 */
#define BOARD_LED_MODE_ON_MS 150 /**< 切模式闪：亮 */
#define BOARD_LED_MODE_BLINK_N 2 /**< 切模式闪次数 */
#define BOARD_LED_STANDBY_ON 1 /**< 1=待机绿灯常亮；0=亮完 BOARD_LED_POWER_ON_MS 后灭（对比电流） */
#define BOARD_LED_POWER_ON_MS 3000 /**< BOARD_LED_STANDBY_ON=0 时的开机绿灯时长 */
/*============================================================================*/
/* 电机 */
/*============================================================================*/
#define BOARD_MOTOR_REVERSE_MS 1 /**< 换向前先松开，防 H 桥直通 */
#define BOARD_HAND_PULSE_MS 1000 /**< 预留；手动 1/2 一直转到写 03 停止 */
#define BOARD_MOTOR_PWM_HZ 20000 /**< MCPWM 频率(Hz)，20k 避开可听啸叫 */
#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/bsp_hw.c
+519
View File
@@ -0,0 +1,519 @@
/******************************************************************************
* @file bsp_hw.c
* @brief CBC2 板级 GPIO / ADC：电机 H 桥、LED、按键、充电检测
* @author cyWu <1917507415@qq.com>
* @date 2026.08.24
* @version V1.5.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.24, cyWu, 停转反转刹车；去掉限位脚
* - V1.3.0, 2026.08.24, cyWu, 电机改 MCPWM 占空比降速
* - V1.4.0, 2026.08.24, cyWu, 增加按占空比驱动，供玩法变速
* - V1.5.0, 2026.08.25, cyWu, 空闲关闭 MCPWM 时钟
* - V1.6.0, 2026.08.25, cyWu, 去掉停转反接刹车，改自由滑行停止，避免刹车
* 电流冲击拉垮供电轨触发 LVD 复位
******************************************************************************/
#include "system/includes.h"
#include "asm/gpio.h"
#include "asm/adc_api.h"
#include "asm/charge.h"
#include "asm/mcpwm.h"
#include "bsp_hw.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[BSP_HW]"
#define LOG_ERROR_ENABLE
#define LOG_INFO_ENABLE
#include "debug.h"
static uint8_t s_initialized;
/** 电机状态，替代原来散落的 7 个 static */
typedef struct {
BspMotorDir_t dir; /**< 当前实际方向 */
BspMotorDir_t pending; /**< 换向死区结束后要切到的方向 */
uint16_t duty; /**< 当前实际占空比 */
uint16_t pending_duty; /**< 换向死区结束后要用的占空比 */
uint16_t switch_ms; /**< 换向死区剩余时长，0=空闲/不在换向中 */
u32 switch_t0; /**< 换向死区起始时间戳 */
uint8_t pwm_clk_on; /**< 1=MCPWM 时钟已打开 */
} BspMotorCtx_t;
static BspMotorCtx_t s_motor;
extern u32 timer_get_ms(void);
#if (BOARD_LED_ENABLE || BOARD_MOTOR_ENABLE)
/**
* @brief 配置 GPIO 为推挽输出
* @param pin GPIO 编号
* @param value 输出初值
* @return 无
*/
static void bsp_pin_output(u32 pin, int value)
{
gpio_set_pull_up(pin, 0);
gpio_set_pull_down(pin, 0);
gpio_set_die(pin, 1);
gpio_direction_output(pin, value);
}
#endif
#if (BOARD_KEY_ENABLE || BOARD_CHG_ENABLE)
/**
* @brief 配置 GPIO 为数字输入（可内部上拉）
* @param pin GPIO 编号
* @param pull_up 1=内部上拉，0=不上拉
* @return 无
*/
static void bsp_pin_input(u32 pin, int pull_up)
{
gpio_direction_output(pin, 1);
gpio_set_direction(pin, 1);
gpio_set_pull_down(pin, 0);
gpio_set_pull_up(pin, pull_up ? 1 : 0);
gpio_set_die(pin, 1);
}
#endif
#if BOARD_MOTOR_ENABLE
/**
* @brief 初始化 INA/INB 两路 MCPWM，初始占空比 0（停转）
* @return 无
*/
static void bsp_motor_pwm_init(void)
{
struct pwm_platform_data pwm;
gpio_set_pull_up(BOARD_MOTOR_INA_PIN, 0);
gpio_set_pull_down(BOARD_MOTOR_INA_PIN, 0);
gpio_set_die(BOARD_MOTOR_INA_PIN, 1);
gpio_set_pull_up(BOARD_MOTOR_INB_PIN, 0);
gpio_set_pull_down(BOARD_MOTOR_INB_PIN, 0);
gpio_set_die(BOARD_MOTOR_INB_PIN, 1);
pwm.pwm_aligned_mode = pwm_edge_aligned;
pwm.frequency = BOARD_MOTOR_PWM_HZ;
pwm.duty = 0;
pwm.l_pin = (u8) - 1;
pwm.complementary_en = 0;
pwm.pwm_ch_num = pwm_ch0;
pwm.h_pin = BOARD_MOTOR_INA_PIN;
mcpwm_init(&pwm);
pwm.pwm_ch_num = pwm_ch1;
pwm.h_pin = BOARD_MOTOR_INB_PIN;
mcpwm_init(&pwm);
mcpwm_set_duty(pwm_ch0, 0);
mcpwm_set_duty(pwm_ch1, 0);
s_motor.pwm_clk_on = 1;
log_info("motor pwm %uHz duty=%u/10000\n",
(unsigned)BOARD_MOTOR_PWM_HZ, (unsigned)BOARD_MOTOR_PWM_DUTY);
}
/**
* @brief 打开 MCPWM 并绑回 INA/INB
* @return 无
*/
static void bsp_motor_pwm_clock_on(void)
{
if (s_motor.pwm_clk_on) {
return;
}
mcpwm_open(pwm_ch0);
mcpwm_open(pwm_ch1);
gpio_och_sel_output_signal(BOARD_MOTOR_INA_PIN, OUTPUT_CH_SIGNAL_MC_PWM0_H);
gpio_och_sel_output_signal(BOARD_MOTOR_INB_PIN, OUTPUT_CH_SIGNAL_MC_PWM1_H);
gpio_set_direction(BOARD_MOTOR_INA_PIN, 0);
gpio_set_direction(BOARD_MOTOR_INB_PIN, 0);
s_motor.pwm_clk_on = 1;
}
/**
* @brief 关闭 MCPWM 时钟，INA/INB 拉低（待机必关）
* @return 无
*/
static void bsp_motor_pwm_clock_off(void)
{
mcpwm_set_duty(pwm_ch0, 0);
mcpwm_set_duty(pwm_ch1, 0);
if (s_motor.pwm_clk_on) {
mcpwm_close(pwm_ch0);
mcpwm_close(pwm_ch1);
gpio_och_disable_output_signal(BOARD_MOTOR_INA_PIN, OUTPUT_CH_SIGNAL_MC_PWM0_H);
gpio_och_disable_output_signal(BOARD_MOTOR_INB_PIN, OUTPUT_CH_SIGNAL_MC_PWM1_H);
JL_MCPWM->MCPWM_CON0 = 0;
s_motor.pwm_clk_on = 0;
}
gpio_direction_output(BOARD_MOTOR_INA_PIN, 0);
gpio_direction_output(BOARD_MOTOR_INB_PIN, 0);
}
/**
* @brief 立刻改 INA/INB PWM。运转脚输出 duty，另一脚 0%；STOP=两路 0%
* @param dir 目标方向
* @param duty 占空比 0~10000
* @return 无
*/
static void bsp_motor_gpio(BspMotorDir_t dir, uint16_t duty)
{
u16 ina_duty = 0;
u16 inb_duty = 0;
if (duty > 10000) {
duty = 10000;
}
if (dir == BSP_MOTOR_IN) {
if (BOARD_MOTOR_IN_INA_HIGH) {
ina_duty = duty;
} else {
inb_duty = duty;
}
} else if (dir == BSP_MOTOR_OUT) {
if (BOARD_MOTOR_IN_INA_HIGH) {
inb_duty = duty;
} else {
ina_duty = duty;
}
}
if ((ina_duty == 0) && (inb_duty == 0)) {
/* 换向死区(BOARD_MOTOR_REVERSE_MS)、刹车瞬间也会短暂占空比为 0，
* 但马上（1~30ms 内）还要再驱动，不能当成“真空闲”去关时钟：
* 频繁 close/open MCPWM 外设比单纯调占空比激进得多，玩法换向越快
* 关得越勤，有卡死风险。这里只清占空比（两脚拉低，电气效果一样），
* 真正的空闲关时钟统一交给 bsp_hw_sleep_pwm_off()——它在系统真的
* 要进轻睡前才调用，并且会先查 bsp_motor_is_busy()。 */
mcpwm_set_duty(pwm_ch0, 0);
mcpwm_set_duty(pwm_ch1, 0);
return;
}
bsp_motor_pwm_clock_on();
mcpwm_set_duty(pwm_ch0, ina_duty);
mcpwm_set_duty(pwm_ch1, inb_duty);
}
#endif
/**
* @brief 初始化 GPIO / 充电 ADC
* @return BSP_HW_OK=成功
*/
BspHw_Ret_t bsp_hw_init(void)
{
if (s_initialized) {
return BSP_HW_OK;
}
#if BOARD_LED_ENABLE
bsp_pin_output(BOARD_LED_RED_PIN, !BOARD_LED_ON_LEVEL);
bsp_pin_output(BOARD_LED_GREEN_PIN, !BOARD_LED_ON_LEVEL);
#endif
#if BOARD_KEY_ENABLE
bsp_pin_input(BOARD_KEY_PIN, 1);
#endif
#if BOARD_CHG_ENABLE
/* PORTG 作数字输入必须开 dieh，否则读不到 ME4054 CHG */
gpio_disable_fun_output_port(BOARD_CHG_PIN);
gpio_set_pull_up(BOARD_CHG_PIN, 0);
gpio_set_pull_down(BOARD_CHG_PIN, 0);
gpio_set_die(BOARD_CHG_PIN, 1);
gpio_set_dieh(BOARD_CHG_PIN, 1);
gpio_direction_input(BOARD_CHG_PIN);
adc_add_sample_ch(AD_CH_LDO5V);
adc_set_sample_freq(AD_CH_LDO5V, 500);
#endif
#if BOARD_MOTOR_ENABLE
bsp_motor_pwm_init();
s_motor.dir = BSP_MOTOR_STOP;
s_motor.pending = BSP_MOTOR_STOP;
s_motor.duty = 0;
s_motor.pending_duty = 0;
s_motor.switch_ms = 0;
#if BOARD_MOTOR_PWM_IDLE_CLOSE
bsp_motor_pwm_clock_off();
#endif
#endif
s_initialized = 1;
log_info("hw init led=%d key=%d chg=%d motor=%d\n",
BOARD_LED_ENABLE, BOARD_KEY_ENABLE, BOARD_CHG_ENABLE,
BOARD_MOTOR_ENABLE);
return BSP_HW_OK;
}
/**
* @brief 查询板级硬件是否已初始化
* @return BSP_HW_OK=已初始化，BSP_HW_ERR_NOT_INIT=未初始化
*/
BspHw_Ret_t bsp_hw_get_status(void)
{
return s_initialized ? BSP_HW_OK : BSP_HW_ERR_NOT_INIT;
}
/**
* @brief 红灯开关
* @param on 1=亮，0=灭
* @return 无
*/
void bsp_led_red_set(uint8_t on)
{
#if BOARD_LED_ENABLE
gpio_direction_output(BOARD_LED_RED_PIN, on ? BOARD_LED_ON_LEVEL : !BOARD_LED_ON_LEVEL);
#else
(void)on;
#endif
}
/**
* @brief 绿灯开关
* @param on 1=亮，0=灭
* @return 无
*/
void bsp_led_green_set(uint8_t on)
{
#if BOARD_LED_ENABLE
gpio_direction_output(BOARD_LED_GREEN_PIN, on ? BOARD_LED_ON_LEVEL : !BOARD_LED_ON_LEVEL);
#else
(void)on;
#endif
}
/**
* @brief 红绿灯全灭
* @return 无
*/
void bsp_led_all_off(void)
{
bsp_led_red_set(0);
bsp_led_green_set(0);
}
/**
* @brief 设置电机方向。STOP 时直接切断驱动，自由滑行到停（不做反接刹车）
* @param dir 收绳 / 放绳 / 停转
* @return 无
*/
void bsp_motor_set(BspMotorDir_t dir)
{
bsp_motor_set_pwm(dir, (dir == BSP_MOTOR_STOP) ? 0 : BOARD_MOTOR_PWM_DUTY);
}
/**
* @brief 设置电机方向与 PWM 占空比
* @param dir 收绳 / 放绳 / 停转
* @param duty 占空比 0~10000；STOP 时按 0 处理
* @return 无
*/
void bsp_motor_set_pwm(BspMotorDir_t dir, uint16_t duty)
{
#if !BOARD_MOTOR_ENABLE
(void)dir;
(void)duty;
return;
#else
if (duty > 10000) {
duty = 10000;
}
if (dir == BSP_MOTOR_STOP) {
duty = 0;
}
/* 同向只改占空比：直接改 PWM，不走换向死区 */
if (dir == s_motor.dir && s_motor.switch_ms == 0) {
if (duty == s_motor.duty) {
return;
}
s_motor.duty = duty;
s_motor.pending = dir;
s_motor.pending_duty = duty;
bsp_motor_gpio(dir, duty);
return;
}
/* 停转：直接切断驱动，让电机自由滑行到停，不做反接刹车——反接刹车电流比
* 正常驱动大（电池要同时顶住反向驱动电流和电机反电动势），实测会把供电轨
* 拉低触发 LVD 复位。哪怕正在换向死区里，也直接取消死区改成停。 */
if (dir == BSP_MOTOR_STOP) {
s_motor.switch_ms = 0;
s_motor.dir = BSP_MOTOR_STOP;
s_motor.pending = BSP_MOTOR_STOP;
s_motor.duty = 0;
s_motor.pending_duty = 0;
bsp_motor_gpio(BSP_MOTOR_STOP, 0);
return;
}
/* 换向：先松开再输出，避免 H 桥直通 */
if (s_motor.dir != BSP_MOTOR_STOP && dir != s_motor.dir) {
bsp_motor_gpio(BSP_MOTOR_STOP, 0);
s_motor.pending = dir;
s_motor.pending_duty = duty;
s_motor.switch_ms = BOARD_MOTOR_REVERSE_MS;
s_motor.switch_t0 = timer_get_ms();
s_motor.dir = BSP_MOTOR_STOP;
s_motor.duty = 0;
return;
}
s_motor.switch_ms = 0;
s_motor.dir = dir;
s_motor.pending = dir;
s_motor.duty = duty;
s_motor.pending_duty = duty;
bsp_motor_gpio(dir, duty);
#endif
}
/**
* @brief 推进换向死区计时，按真实毫秒计时；死区结束后切到目标方向/占空比
* @return 无
*/
void bsp_motor_switch_tick(void)
{
#if !BOARD_MOTOR_ENABLE
return;
#else
if (s_motor.switch_ms == 0) {
return;
}
if ((timer_get_ms() - s_motor.switch_t0) < s_motor.switch_ms) {
return;
}
s_motor.switch_ms = 0;
s_motor.dir = s_motor.pending;
s_motor.duty = s_motor.pending_duty;
bsp_motor_gpio(s_motor.dir, s_motor.duty);
#endif
}
/**
* @brief 读取按键电平
* @return 1=按下，0=未按下
*/
uint8_t bsp_key_is_pressed(void)
{
#if BOARD_KEY_ENABLE
return (uint8_t)(gpio_read(BOARD_KEY_PIN) == BOARD_KEY_ACTIVE_LEVEL);
#else
return 0;
#endif
}
/**
* @brief 读取 ME4054 CHG 脚：充电中为低
* @return 1=充电中，0=未充电
*/
uint8_t bsp_chg_is_low(void)
{
#if BOARD_CHG_ENABLE
return (uint8_t)(gpio_read(BOARD_CHG_PIN) == BOARD_CHG_CHARGING_LEVEL);
#else
return 0;
#endif
}
/**
* @brief 读取电池电压
* @return 电池电压，单位 mV
*/
uint16_t bsp_vbat_mv(void)
{
return (uint16_t)(adc_get_voltage(AD_CH_VBAT) * 4);
}
/**
* @brief 读取 5V 口电压，用于判断 USB
* @return VPWR 电压，单位 mV
*/
uint16_t bsp_vpwr_mv(void)
{
return (uint16_t)(adc_get_voltage(AD_CH_LDO5V) * 4);
}
/**
* @brief USB 是否在位（以 ADC 为主，比较器为辅）
* @return 1=插入，0=未插入
*/
uint8_t bsp_vpwr_is_online(void)
{
#if BOARD_CHG_ENABLE
uint16_t mv = bsp_vpwr_mv();
/* 以 ADC 为准：拔电后比较器可能仍为 1，但电压已经掉到几百 mV */
if (mv >= BOARD_VPWR_ONLINE_MV) {
return 1;
}
if (mv <= BOARD_VPWR_OFF_MV) {
return 0;
}
if (get_ldo5v_online_hw() || get_lvcmp_det()) {
return 1;
}
return 0;
#else
return 0;
#endif
}
/**
* @brief 轻睡前关掉空闲电机 PWM（电机忙碌时不关，避免玩法被掐断）
* @return 无
*/
void bsp_hw_sleep_pwm_off(void)
{
#if BOARD_MOTOR_ENABLE && BOARD_MOTOR_PWM_IDLE_CLOSE
if (!s_initialized) {
return;
}
if (bsp_motor_is_busy()) {
return;
}
bsp_motor_pwm_clock_off();
#endif
}
/**
* @brief 电机是否还在转或处于换向死区
* @return 1=忙碌，0=已停且 PWM 已关
*/
uint8_t bsp_motor_is_busy(void)
{
#if !BOARD_MOTOR_ENABLE
return 0;
#else
if (s_motor.switch_ms) {
return 1;
}
if (s_motor.dir != BSP_MOTOR_STOP) {
return 1;
}
if (s_motor.pending != BSP_MOTOR_STOP) {
return 1;
}
return 0;
#endif
}
/**
* @brief 进深睡前把电机 PWM 关掉并拉低，灯全灭
* @return 无
*/
void bsp_hw_enter_sleep_io(void)
{
bsp_motor_set(BSP_MOTOR_STOP);
#if BOARD_MOTOR_ENABLE
s_motor.switch_ms = 0;
s_motor.dir = BSP_MOTOR_STOP;
s_motor.pending = BSP_MOTOR_STOP;
s_motor.duty = 0;
bsp_motor_pwm_clock_off();
#endif
bsp_led_all_off();
}
apps/usr_periph/bsp_hw.h
+137
View File
@@ -0,0 +1,137 @@
/******************************************************************************
* @file bsp_hw.h
* @brief CBC2 板级硬件：电机 / LED / 按键 / 充电 / 电量
* @author cyWu <1917507415@qq.com>
* @date 2026.08.25
* @version V1.6.0
* @history
* - V1.0.0, 2026.08.21, cyWu, 首次发布
* - V1.1.0, 2026.08.24, cyWu, 停转改为反转刹车；去掉未贴件限位
* - V1.3.0, 2026.08.24, cyWu, 电机改 MCPWM 50% 占空比降速
* - V1.4.0, 2026.08.24, cyWu, 增加按占空比驱动，供玩法变速
* - V1.5.0, 2026.08.25, cyWu, 空闲关闭 MCPWM 时钟，避免待机空转耗电
* - V1.6.0, 2026.08.25, cyWu, 去掉停转反接刹车，改自由滑行停止，避免刹车
* 电流冲击拉垮供电轨触发 LVD 复位
******************************************************************************/
#ifndef __BSP_HW_H__
#define __BSP_HW_H__
#include <stdint.h>
#include "board_pin.h"
typedef enum {
BSP_HW_OK = 0,
BSP_HW_ERR_PARAM,
BSP_HW_ERR_NOT_INIT
} BspHw_Ret_t;
typedef enum {
BSP_MOTOR_STOP = 0, /**< 滑行停（INA/INB 都低） */
BSP_MOTOR_IN, /**< 收绳（顺时针，见 BOARD_MOTOR_IN_INA_HIGH） */
BSP_MOTOR_OUT /**< 放绳 */
} BspMotorDir_t;
/**
* @brief 初始化 GPIO / 充电 ADC
* @return BSP_HW_OK=成功
*/
BspHw_Ret_t bsp_hw_init(void);
/**
* @brief 查询是否已初始化
* @return BSP_HW_OK=已初始化，BSP_HW_ERR_NOT_INIT=未初始化
*/
BspHw_Ret_t bsp_hw_get_status(void);
/**
* @brief 红灯开关
* @param on 1=亮，0=灭
* @return 无
*/
void bsp_led_red_set(uint8_t on);
/**
* @brief 绿灯开关
* @param on 1=亮，0=灭
* @return 无
*/
void bsp_led_green_set(uint8_t on);
/**
* @brief 红绿灯全灭
* @return 无
*/
void bsp_led_all_off(void);
/**
* @brief 设置电机方向。STOP 时直接切断驱动，自由滑行到停（不做反接刹车）
* @note 占空比用 BOARD_MOTOR_PWM_DUTY（手动点动）
* @param dir 收绳 / 放绳 / 停转
* @return 无
*/
void bsp_motor_set(BspMotorDir_t dir);
/**
* @brief 设置电机方向与 PWM 占空比
* @param dir 收绳 / 放绳 / 停转
* @param duty 占空比 0~10000（0%~100%）；STOP 时忽略
* @return 无
*/
void bsp_motor_set_pwm(BspMotorDir_t dir, uint16_t duty);
/**
* @brief 推进换向死区计时，按真实毫秒计时；死区结束后切到目标方向/占空比
* @return 无
*/
void bsp_motor_switch_tick(void);
/**
* @brief 电机是否还在转或处于换向死区
* @return 1=忙碌，0=已停且 PWM 已关
*/
uint8_t bsp_motor_is_busy(void);
/**
* @brief 读取按键
* @return 1=按下，0=未按下
*/
uint8_t bsp_key_is_pressed(void);
/**
* @brief 读取 ME4054 CHG：充电中为低
* @return 1=充电中，0=未充电
*/
uint8_t bsp_chg_is_low(void);
/**
* @brief 读取电池电压
* @return 电池电压，单位 mV
*/
uint16_t bsp_vbat_mv(void);
/**
* @brief 读取 5V 口电压，用于判断 USB
* @return VPWR 电压，单位 mV
*/
uint16_t bsp_vpwr_mv(void);
/**
* @brief USB 是否在位（以 ADC 为主，比较器为辅）
* @return 1=插入，0=未插入
*/
uint8_t bsp_vpwr_is_online(void);
/**
* @brief 轻睡前关掉空闲电机 PWM（电机忙碌时不关）
* @return 无
*/
void bsp_hw_sleep_pwm_off(void);
/**
* @brief 进深睡前把电机 PWM 关掉并拉低，灯全灭
* @return 无
*/
void bsp_hw_enter_sleep_io(void);
#endif /* __BSP_HW_H__ */
apps/usr_periph/usr_rtc.c
+13 -10
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, 精简公共接口与缓存逻辑
******************************************************************************/
@@ -64,7 +64,7 @@ static void usr_rtc_save_tz(int32_t tz_s);
/**
* @brief 打开 rtc 设备并加载时区
* @return UsrRtc_Ret_t
* @return USR_RTC_OK=成功，USR_RTC_ERR_NOT_INIT=设备打开失败或 RTC 未使能
*/
UsrRtc_Ret_t usr_rtc_init(void)
{
@@ -101,7 +101,7 @@ UsrRtc_Ret_t usr_rtc_init(void)
/**
* @brief 获取当前本地时间
* @param t 成功时赋值；失败不改动
* @return 1/0
* @return 1=已对时且读成功，0=未初始化/未对时/参数非法
*/
uint8_t usr_rtc_get_time(struct sys_time *t)
{
@@ -127,7 +127,7 @@ uint8_t usr_rtc_get_time(struct sys_time *t)
* @brief UTC 秒 + 时区 → 本地日历写入 RTC
* @param unix_utc UTC 秒
* @param tz_s 时区偏移秒
* @return UsrRtc_Ret_t
* @return USR_RTC_OK=成功，USR_RTC_ERR_NOT_INIT=未初始化，USR_RTC_ERR_PARAM=参数非法，USR_RTC_ERR_INVALID=年份非法
*/
UsrRtc_Ret_t usr_rtc_set_from_unix(uint64_t unix_utc, int32_t tz_s)
{
@@ -184,7 +184,7 @@ UsrRtc_Ret_t usr_rtc_set_from_unix(uint64_t unix_utc, int32_t tz_s)
/**
* @brief 写硬件日历
* @param t 本地日历
* @return UsrRtc_Ret_t
* @return USR_RTC_OK=成功，USR_RTC_ERR_PARAM=参数非法，USR_RTC_ERR_NOT_INIT=未初始化
*/
static UsrRtc_Ret_t usr_rtc_write(const struct sys_time *t)
{
@@ -216,7 +216,7 @@ static UsrRtc_Ret_t usr_rtc_write(const struct sys_time *t)
/**
* @brief 是否闰年
* @param year 公历年
* @return 1/0
* @return 1=闰年，0=平年
*/
static uint8_t usr_rtc_is_leap(uint16_t year)
{
@@ -235,7 +235,7 @@ static uint8_t usr_rtc_is_leap(uint16_t year)
* @brief 某月天数
* @param year 年
* @param month 月 1~12
* @return 天数，非法月返回 0
* @return 该月天数；非法月份返回 0
*/
static uint8_t usr_rtc_days_in_month(uint16_t year, uint8_t month)
{
@@ -256,7 +256,7 @@ static uint8_t usr_rtc_days_in_month(uint16_t year, uint8_t month)
/**
* @brief 年份是否在合法窗口
* @param year 年
* @return 1/0
* @return 1=合法，0=非法
*/
static uint8_t usr_rtc_year_ok(uint16_t year)
{
@@ -266,8 +266,9 @@ static uint8_t usr_rtc_year_ok(uint16_t year)
/**
* @brief UTC 秒 + 时区 → 本地日历
* @param unix_utc UTC 秒
* @param tz_s 时区偏移
* @param t 输出
* @param tz_s 时区偏移秒
* @param t 输出本地日历
* @return 无
*/
static void usr_rtc_unix_to_calendar(uint32_t unix_utc, int32_t tz_s,
struct sys_time *t)
@@ -324,6 +325,7 @@ static void usr_rtc_unix_to_calendar(uint32_t unix_utc, int32_t tz_s,
/**
* @brief 从 VM 加载时区
* @return 无
*/
static void usr_rtc_load_tz(void)
{
@@ -350,6 +352,7 @@ static void usr_rtc_load_tz(void)
/**
* @brief 时区写入 VM
* @param tz_s 时区偏移秒
* @return 无
*/
static void usr_rtc_save_tz(int32_t tz_s)
{
apps/usr_periph/usr_rtc.h
+4 -5
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 返回本地日历
******************************************************************************/
@@ -40,9 +40,8 @@ typedef enum {
/*============================================================================*/
/**
* @brief 打开 "rtc" 设备并加载时区
* @return UsrRtc_Ret_t
* @note app_main 启动时调用一次即可
* @brief 打开 rtc 设备并加载时区
* @return USR_RTC_OK=成功，USR_RTC_ERR_NOT_INIT=设备打开失败或 RTC 未使能
*/
UsrRtc_Ret_t usr_rtc_init(void);
@@ -57,7 +56,7 @@ uint8_t usr_rtc_get_time(struct sys_time *t);
* @brief App/网关 DEVICEINFO：UTC 秒 + 时区写入 RTC
* @param unix_utc UTC Unix 秒；0 无效
* @param tz_s 时区偏移秒（东八区 28800）
* @return UsrRtc_Ret_t
* @return USR_RTC_OK=成功，USR_RTC_ERR_NOT_INIT=未初始化，USR_RTC_ERR_PARAM=参数非法，USR_RTC_ERR_INVALID=年份非法
*/
UsrRtc_Ret_t usr_rtc_set_from_unix(uint64_t unix_utc, int32_t tz_s);
build.bat
+30
View File
@@ -0,0 +1,30 @@
@echo off
chcp 65001 >nul
cd /d "%~dp0"
setlocal EnableDelayedExpansion
REM JieLi make / mkdir_win / rm / fixbat live in tools\utils, not in system PATH
set "PATH=%~dp0tools\utils;%PATH%"
REM USB burn: default nokey. build.bat key / build.bat nokey
set "JL_BURN_KEY=0"
set "MAKE_ARGS="
for %%A in (%*) do (
if /i "%%~A"=="key" (
set "JL_BURN_KEY=1"
) else if /i "%%~A"=="nokey" (
set "JL_BURN_KEY=0"
) else (
set "MAKE_ARGS=!MAKE_ARGS! %%~A"
)
)
if "!JL_BURN_KEY!"=="1" (
echo [build] USB burn: WITH key
) else (
echo [build] USB burn: NO key
)
make !MAKE_ARGS!
exit /b !errorlevel!
cpu/br28/sdk.ld
+2079
View File
File diff suppressed because it is too large Load Diff
cpu/br28/sdk_used_list.used
+30
View File
@@ -0,0 +1,30 @@
sdfile_vfs_ops
sbc_decoder
msbc_decoder
sbc_hwaccel
cvsd_decoder
pcm_decoder
mp3_decoder
cpu/br28/tools/aac.bin
View File
cpu/br28/tools/aec.bin
View File
cpu/br28/tools/aptx.bin
View File
cpu/br28/tools/download.bat
+48
View File
@@ -0,0 +1,48 @@
@echo off
Setlocal enabledelayedexpansion
@echo ********************************************************************************
@echo SDK BR28
@echo ********************************************************************************
@echo %date%
cd /d %~dp0
set OBJDUMP=C:\JL\pi32\bin\llvm-objdump.exe
set OBJCOPY=C:\JL\pi32\bin\llvm-objcopy.exe
set ELFFILE=sdk.elf
set bankfiles=
set LZ4_PACKET=.\lz4_packet.exe
REM %OBJDUMP% -D -address-mask=0x1ffffff -print-dbg $1.elf > $1.lst
%OBJCOPY% -O binary -j .text %ELFFILE% text.bin
%OBJCOPY% -O binary -j .data %ELFFILE% data.bin
%OBJCOPY% -O binary -j .data_code %ELFFILE% data_code.bin
%OBJCOPY% -O binary -j .overlay_aec %ELFFILE% aec.bin
%OBJCOPY% -O binary -j .overlay_aac %ELFFILE% aac.bin
%OBJCOPY% -O binary -j .overlay_aptx %ELFFILE% aptx.bin
%OBJCOPY% -O binary -j .common %ELFFILE% common.bin
for /L %%i in (0,1,20) do (
%OBJCOPY% -O binary -j .overlay_bank%%i %ELFFILE% bank%%i.bin
set bankfiles=!bankfiles! bank%%i.bin 0x0
)
%LZ4_PACKET% -dict text.bin -input common.bin 0 aec.bin 0 aac.bin 0 !bankfiles! -o bank.bin
%OBJDUMP% -section-headers -address-mask=0x1ffffff %ELFFILE%
REM %OBJDUMP% -t %ELFFILE% > symbol_tbl.txt
copy /b text.bin + data.bin + mov_slot.bin + data_code.bin + aec.bin + aac.bin + psr_data_code.bin app.bin
del !bankfiles! common.bin text.bin data.bin bank.bin
copy eq_cfg_hw_less.bin eq_cfg_hw.bin
call download/earphone/download_app_ota.bat
cpu/br28/tools/download/earphone/download_app_ota.bat
+54 -16
View File
@@ -10,10 +10,57 @@ copy ..\..\ota.bin .
copy ..\..\anc_coeff.bin .
copy ..\..\anc_gains.bin .
..\..\isd_download.exe ..\..\isd_config.ini -tonorflash -dev br28 -boot 0x120000 -div8 -wait 300 -uboot ..\..\uboot.boot -app ..\..\app.bin -res ..\..\cfg_tool.bin tone.cfg p11_code.bin -uboot_compress
set "ISD_CMD=..\..\isd_download.exe ..\..\isd_config.ini -dev br28 -boot 0x120000 -div8 -wait 300 -uboot ..\..\uboot.boot -app ..\..\app.bin -res ..\..\cfg_tool.bin tone.cfg p11_code.bin -uboot_compress"
:: -format all -key RS-5B88.key
::-reboot 2500
REM JL_BURN_KEY=1/key : USB flash keyed image; still generate nokey files
REM default / 0 / nokey : USB flash nokey image; still generate keyed files
set "NOKEY_FLASH="
set "KEY_FLASH="
if /i "%JL_BURN_KEY%"=="1" goto :usb_key
if /i "%JL_BURN_KEY%"=="key" goto :usb_key
if /i "%JL_BURN_KEY%"=="yes" goto :usb_key
set "NOKEY_FLASH=-tonorflash"
echo [download] USB burn: NO key
goto :do_isd
:usb_key
set "KEY_FLASH=-tonorflash"
echo [download] USB burn: WITH key
:do_isd
REM ---- nokey image ----
%ISD_CMD% %NOKEY_FLASH%
if exist jl_isd.fw copy /y jl_isd.fw jl_isd_nokey.fw >nul
..\..\ufw_maker.exe -fw_to_ufw jl_isd.fw
if exist jl_isd.ufw (
copy /y jl_isd.ufw update.ufw >nul
copy /y jl_isd.ufw update_nokey.ufw >nul
del jl_isd.ufw
)
if exist db_update_data.bin copy /y db_update_data.bin db_update_data_nokey.bin >nul
REM ---- keyed image ----
if exist RS-5B88.key (
%ISD_CMD% %KEY_FLASH% -key RS-5B88.key
REM isd_download returns -11 when USB is offline; image is still generated
if exist jl_isd.fw copy /y jl_isd.fw jl_isd_key.fw >nul
..\..\ufw_maker.exe -fw_to_ufw jl_isd.fw
if exist jl_isd.ufw (
copy /y jl_isd.ufw update_key.ufw >nul
del jl_isd.ufw
)
if exist db_update_data.bin copy /y db_update_data.bin db_update_data_key.bin >nul
) else (
if /i not "%KEY_FLASH%"=="" (
echo [download] ERROR: RS-5B88.key not found, cannot USB-burn keyed image
exit /b 1
)
)
REM keep default names as nokey for tools that still look for jl_isd.fw
if exist jl_isd_nokey.fw copy /y jl_isd_nokey.fw jl_isd.fw >nul
if exist update_nokey.ufw copy /y update_nokey.ufw update.ufw >nul
if exist db_update_data_nokey.bin copy /y db_update_data_nokey.bin db_update_data.bin >nul
@rem delete temp files
if exist *.mp3 del *.mp3
@@ -22,15 +69,6 @@ if exist *.TAB del *.TAB
if exist *.res del *.res
if exist *.sty del *.sty
..\..\ufw_maker.exe -fw_to_ufw jl_isd.fw
copy jl_isd.ufw update.ufw
del jl_isd.ufw
@rem generate config ufw (disabled)
::ufw_maker.exe -chip AC800X %ADD_KEY% -output config.ufw -res bt_cfg.cfg
::IF EXIST jl_696x.bin del jl_696x.bin
if exist script.ver del script.ver
if exist tone.cfg del tone.cfg
if exist p11_code.bin del p11_code.bin
@@ -39,9 +77,9 @@ if exist anc_coeff.bin del anc_coeff.bin
if exist anc_gains.bin del anc_gains.bin
@rem common isd_download flags
@rem -format vm
@rem -format cfg
@rem -format 0x3f0-2
@rem -format vm erase VM area
@rem -format cfg erase BT CFG area
@rem -format 0x3f0-2 erase 2 sectors from 0x3f0 (1st arg hex/dec, 2nd must be decimal)
ping /n 2 127.1>null
IF EXIST null del null
IF EXIST null del null
cpu/br28/tools/eq_cfg_hw.bin
BIN
View File
Binary file not shown.
cpu/br28/tools/isd_config.ini
+81
View File
@@ -0,0 +1,81 @@
[EXTRA_CFG_PARAM]
BR22_TWS_DB = YES;
FLASH_SIZE = 0x100000;
BR22_TWS_VERSION = 0;
FORCE_4K_ALIGN = YES;
SPECIAL_OPT = 0;
DB_UPDATE_DATA = YES;
CHIP_NAME = AC701N;
ENTRY = 0x6000100;
PID = AC701N;
VID = 0.01;
SDK_VERSION = JL701N_V1.6.1;
RESERVED_OPT = 0;
UFW_ELEMENT = 0x10 - 0x0, 0x1 - 0x0;
DOWNLOAD_MODEL = USB;
SERIAL_DEVICE_NAME = JlVirtualJtagSerial;
SERIAL_BARD_RATE = 1000000;
SERIAL_CMD_OPT = 2;
SERIAL_CMD_RATE = 100;
SERIAL_CMD_RES = 0;
SERIAL_INIT_BAUD_RATE = 9600;
LOADER_BAUD_RATE = 1000000;
LOADER_ASK_BAUD_RATE = 1000000;
BEFORE_LOADER_WAIT_TIME = 150;
SERIAL_SEND_KEY = YES;
[CHIP_VERSION]
SUPPORTED_LIST = P, B;
[SYS_CFG_PARAM]
SPI = 2_3_0_0;
UTTX = PB02;
UTBD = 1000000;
UTRX = -1;
RESET1 = PB01_16_0;
VLVD = 3;
[FW_ADDITIONAL]
FILE_LIST = (file = ota.bin: type = 100);
[RESERVED_CONFIG]
BTIF_ADR = AUTO;
BTIF_LEN = 0x1000;
BTIF_OPT = 1;
PRCT_ADR = 0;
PRCT_LEN = CODE_LEN;
PRCT_OPT = 2;
VM_ADR = 0;
VM_LEN = 8K;
VM_OPT = 1;
[BURNER_CONFIG]
SIZE = 32;
docs/门夹弹力绳_需求文档.md
+131
View File
@@ -0,0 +1,131 @@
# 门夹弹力绳 需求文档（V1.1）
| 项目 | 内容 |
| --- | --- |
| 产品名称 | 门夹弹力绳（智能逗宠玩具） |
| 型号 | PICBC2 / CBC2 |
| 主控 | 杰理 AC7016C |
| 日期 | 2026-08-25 |
---
## 1. 产品简介
门夹弹力绳是一款智能逗宠玩具。设备夹在门板上，内部电机带动弹力绳收放，让绳端玩具按不同"玩法"动起来逗宠物玩。支持手机 App 通过远程控制，也支持按键本地操作。
---
## 2. 核心功能
### 2.1 开关机
| 操作 | 行为 |
| --- | --- |
| 深睡状态下按 3 秒 | 开机 |
| 深睡状态下按 5 秒 | 开机并进入配对模式 |
| 开机状态下按 3 秒 | 关机（深睡省电） |
| 插着充电线时上电 | 自动开机，不用按键 |
| 刚上电没按按键 | 保持深睡，不误开机 |
- 深睡状态下，按按键（3 秒/5 秒）或插充电线均可唤醒开机。
### 2.2 开关（App 控制）
- App 可开/关设备功能；关闭后电机停转，蓝牙不断开，可随时再开。
- 拔掉充电线会自动进入低功耗状态（电机停转、LED 关闭、蓝牙保持连接）。
### 2.3 自动玩法（6 种，App 或按键选择）
| 玩法 | 效果 |
| --- | --- |
| 停止复位 | 停转 |
| 弹力伪装 | 绳子慢慢放出去再慢慢收回来，来回一次 |
| 飞鸟俯冲 | 快速冲出去，再慢慢收回，模拟小鸟飞扑 |
| 云阶小陀螺 | 小幅度来回抖动，力度逐渐加大，像陀螺转动 |
| 起伏攻防战 | 慢慢逗弄两秒，突然猛收一下 |
| 微风拂动 | 轻轻动一下，歇两秒，像被风吹动 |
| 闪电快闪 | 快速连续来回抽动，动作急促 |
- 玩法会循环播放，直到切换或停止。
- 运行中可随时切换到其他玩法或停止。
### 2.4 手动控制（App 控制）
- App 可手动点动：控制电机**收绳**或**放绳**，松手/点停止后电机停止。
- 手动控制进行中，自动玩法暂停。
### 2.5 按键控制
| 操作 | 行为 |
| --- | --- |
| 短按（<1 秒） | 切换玩法：停 → 玩法1 → 玩法2 → … → 玩法6 → 停，循环 |
| 长按 3 秒 | 关机 |
| 充电中 / 配对中 | 按键无效 |
### 2.6 电量与充电
- 电量按电压换算：满电 4.2V = 100%，3.2V = 0%，电量自动上报 App 显示。
- **低电量**（电池电压低于 **3.7V**）：App 上报警告，指示灯红灯慢闪；持续 1 分钟未充电则自动关机保护电池。
- **电量极低**（低于 3.2V）：直接自动关机。
- **插入充电线**：电机立即停止、进入充电状态，只有红灯常亮，表示充电中，充满转绿灯常亮；充电期间不执行玩法，按键无效。
- **充电中拔掉充电线**：设备自动进入低功耗状态（电机停转、LED关闭、蓝牙保持连接），需按短按按键或 App 重新开启后才能使用。
- 电池：锂电池，USB 5V 充电，充满自动转灯。
### 2.7 指示灯
| 状态 | 灯效 |
| --- | --- |
| 正常待机 | 绿灯常亮 |
| 充电中 | 红灯常亮 |
| 充满 | 绿灯常亮 |
| 低电量 | 红灯慢闪 |
| 配对中 | 绿灯快闪 |
| 配对成功 | 绿灯常亮 3 秒 |
| 配对失败 | 红绿交替闪 3 秒 |
| 按键切玩法 | 绿灯闪两下 |
### 2.8 配对
- 首次使用：深睡状态长按 5 秒开机并进入配对，App 扫码连接即可。
- 配对窗口 120 秒：期间连接成功绿灯 3 秒；超时未连接保持开机，可重新配对。
- App 可解绑设备，解绑后设备清除配对信息，重新配对即可再次使用。
### 2.9 时间同步
- 设备带实时时钟，连接后自动与手机对时（时区跟随手机）。
### 2.10 固件升级（OTA）
- 支持 App 远程升级固件，升级协议已打通。
- 当前版本：固件 V1.0.0、硬件 V1.0.0。
- 实际升级流程（写入芯片、校验、版本判断）待开发。
---
## 3. 性能要求（功耗）
| 状态 | 要求 |
| --- | --- |
| 关机（深睡） | ≤ 8 uA |
| 待机（空闲，未接充电） | ≤ 300 uA |
| 待机 + 指示灯常亮 | ≤ 600 uA |
---
## 4. 待完善功能（当前仅预留，未实现）
| 功能 | 说明 |
| --- | --- |
| 绳索校准 | App 下发校准命令，用于校准绳子位置 |
| 绳索圈数设置 | App 设置圈数，用于限制收绳行程 |
| 勿扰模式 | App 开关，控制设备在某些时段不动作 |
| 手动力度/百分比 | 手动控制时调节收放力度，预留 |
| OTA 实际升级 | 协议已就绪，芯片写入逻辑待开发 |
---
## 5. 使用注意
- 设备空闲时自动进入低功耗省电模式，有操作时自动唤醒。
- 电机换向、停止均做过安全处理，避免损坏电机和电池。
- 换硬件板子时，只需改引脚配置文件，业务逻辑不变。
tools/pack_firmware.bat
+12
View File
@@ -0,0 +1,12 @@
@echo off
chcp 65001 >nul
cd /d "%~dp0"
powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0pack_firmware.ps1"
if errorlevel 1 (
echo.
echo pack failed.
pause
exit /b 1
)
echo.
pause
tools/pack_firmware.ps1
+168
View File
@@ -0,0 +1,168 @@
# pack_firmware.ps1
# Extract JieLi burn files and zip as Project_Version_Date.
# ASCII only: Windows PowerShell 5.1 mis-parses UTF-8 without BOM.
#
# Usage:
# .\build.bat - build + download.bat + pack
# make pack - pack only
# tools\pack_firmware.bat
[CmdletBinding()]
param(
[string]$ProjectName = "PICBC2",
[string]$SdkRoot = ""
)
$ErrorActionPreference = "Stop"
$exitCode = 0
try {
if ([string]::IsNullOrWhiteSpace($SdkRoot)) {
$SdkRoot = Split-Path -Parent $PSScriptRoot
}
$VersionHeader = Join-Path $SdkRoot "apps\usr_jb_proto\Protocol\jb_product.h"
$DownloadDir = Join-Path $SdkRoot "cpu\br28\tools\download\earphone"
$ReleaseRoot = Join-Path $SdkRoot "release"
function Read-FwVersion {
param([string]$HeaderPath)
if (-not (Test-Path -LiteralPath $HeaderPath)) {
throw "version header not found: $HeaderPath"
}
$text = Get-Content -LiteralPath $HeaderPath -Raw -Encoding UTF8
$major = $null
$minor = $null
$patch = $null
if ($text -match '(?m)^\s*#define\s+JB_MCU_SW_VERSION_MAJOR\s+(\d+)') {
$major = $Matches[1]
}
if ($text -match '(?m)^\s*#define\s+JB_MCU_SW_VERSION_MINOR\s+(\d+)') {
$minor = $Matches[1]
}
if ($text -match '(?m)^\s*#define\s+JB_MCU_SW_VERSION_PATCH\s+(\d+)') {
$patch = $Matches[1]
}
if (($null -eq $major) -or ($null -eq $minor) -or ($null -eq $patch)) {
throw "cannot parse JB_MCU_SW_VERSION_* from $HeaderPath"
}
return "V$major.$minor.$patch"
}
$PackItems = @(
@{ Name = "jl_isd_nokey.fw"; Fallback = "jl_isd.fw"; Suffix = "_nokey_burner.fw"; Required = $true; NoteKey = "burner_nokey" },
@{ Name = "update_nokey.ufw"; Fallback = "update.ufw"; Suffix = "_nokey_app_ota.ufw"; Required = $false; NoteKey = "app_nokey" },
@{ Name = "db_update_data_nokey.bin"; Fallback = "db_update_data.bin"; Suffix = "_nokey_gateway_ota.bin"; Required = $false; NoteKey = "gw_nokey" },
@{ Name = "jl_isd_key.fw"; Fallback = ""; Suffix = "_key_burner.fw"; Required = $false; NoteKey = "burner_key" },
@{ Name = "update_key.ufw"; Fallback = ""; Suffix = "_key_app_ota.ufw"; Required = $false; NoteKey = "app_key" },
@{ Name = "db_update_data_key.bin"; Fallback = ""; Suffix = "_key_gateway_ota.bin"; Required = $false; NoteKey = "gw_key" }
)
$NoteZh = @{}
$notesFile = Join-Path $PSScriptRoot "pack_notes_zh.txt"
Get-Content -LiteralPath $notesFile -Encoding UTF8 | ForEach-Object {
if ($_ -match '^([^|]+)\|(.*)$') {
$NoteZh[$Matches[1].Trim()] = $Matches[2].Trim()
}
}
Write-Host "========================================"
Write-Host " pack firmware"
Write-Host "========================================"
$version = Read-FwVersion -HeaderPath $VersionHeader
$dateStr = Get-Date -Format "yyMMddHHmm"
$pkgName = "${ProjectName}_${version}_${dateStr}"
Write-Host "project : $ProjectName"
Write-Host "version : $version (from jb_product.h)"
Write-Host "date : $dateStr"
Write-Host "source : $DownloadDir"
Write-Host ""
if (-not (Test-Path -LiteralPath $DownloadDir)) {
throw "download dir not found, compile the project first: $DownloadDir"
}
$copied = @()
foreach ($item in $PackItems) {
$src = Join-Path $DownloadDir $item.Name
if (-not (Test-Path -LiteralPath $src) -and $item.Fallback) {
$src = Join-Path $DownloadDir $item.Fallback
}
if (Test-Path -LiteralPath $src) {
$item.Src = $src
$item.Dest = $pkgName + $item.Suffix
$copied += $item
continue
}
if ($item.Required) {
throw "missing required file: $($item.Name); please build the firmware first."
}
Write-Host "[skip] $($item.Name) not generated"
}
if ($copied.Count -eq 0) {
throw "no firmware files found in $DownloadDir"
}
$pkgDir = Join-Path $ReleaseRoot $pkgName
if (Test-Path -LiteralPath $pkgDir) {
Remove-Item -LiteralPath $pkgDir -Recurse -Force
}
New-Item -ItemType Directory -Path $pkgDir -Force | Out-Null
foreach ($item in $copied) {
Copy-Item -LiteralPath $item.Src -Destination (Join-Path $pkgDir $item.Dest) -Force
$size = (Get-Item -LiteralPath $item.Src).Length
Write-Host ("[copy] {0,-28} -> {1} ({2} bytes)" -f (Split-Path $item.Src -Leaf), $item.Dest, $size)
}
$fileList = New-Object System.Collections.Generic.List[string]
foreach ($item in $copied) {
$note = $NoteZh[$item.NoteKey]
[void]$fileList.Add((" {0}" -f $item.Dest))
[void]$fileList.Add((" {0}" -f $note))
}
$tplPath = Join-Path $PSScriptRoot "pack_readme_zh.txt"
$readme = Get-Content -LiteralPath $tplPath -Raw -Encoding UTF8
$readme = $readme.Replace("{{PKG_NAME}}", $pkgName)
$readme = $readme.Replace("{{PROJECT}}", $ProjectName)
$readme = $readme.Replace("{{VERSION}}", $version)
$readme = $readme.Replace("{{DATE}}", (Get-Date -Format "yyyy-MM-dd HH:mm:ss"))
$readme = $readme.Replace("{{FILE_LIST}}", ($fileList -join "`r`n"))
$readme = $readme -replace "`n", "`r`n"
$readme = $readme -replace "`r`r`n", "`r`n"
[System.IO.File]::WriteAllText(
(Join-Path $pkgDir "README.txt"),
$readme,
[System.Text.UTF8Encoding]::new($true)
)
$zipPath = Join-Path $ReleaseRoot "$pkgName.zip"
if (Test-Path -LiteralPath $zipPath) {
Remove-Item -LiteralPath $zipPath -Force
}
Compress-Archive -Path (Join-Path $pkgDir "*") -DestinationPath $zipPath -CompressionLevel Optimal
Write-Host ""
Write-Host "folder : $pkgDir"
Write-Host "zip : $zipPath"
Write-Host "done."
Write-Host "========================================"
} catch {
Write-Host ""
Write-Host "pack failed: $($_.Exception.Message)"
$exitCode = 1
}
exit $exitCode
tools/pack_notes_zh.txt
+6
View File
@@ -0,0 +1,6 @@
burner_nokey|不带 Key：产线批量烧录器镜像（调试、未加密芯片）
app_nokey|不带 Key：手机 APP / 小程序 OTA（UFW）
gw_nokey|不带 Key：55AA 服务器 OTA / 网关 OTA（杰理双备份包）
burner_key|带 Key：产线批量烧录器镜像（烧录器需配置同一把 key）
app_key|带 Key：手机 APP / 小程序 OTA（UFW）
gw_key|带 Key：55AA 服务器 OTA / 网关 OTA（杰理双备份包）
tools/pack_readme_zh.txt
+20
View File
@@ -0,0 +1,20 @@
包名 : {{PKG_NAME}}
项目 : {{PROJECT}}
版本 : {{VERSION}}
日期 : {{DATE}}
文件说明：
{{FILE_LIST}}
使用说明：
1. 批量烧录器：打开 *_burner.fw。
2. 杰理 UFW 通道（部分 APP / 小程序）：上传 *_app_ota.ufw。
3. 走本协议 55AA 的服务器 OTA（APP / 小程序 / 网关都一样）：上传 *_gateway_ota.bin。
Type=0x02（BLE），不要传 ufw / fw / 普通 app.bin。
4. 杰理网关若单独吃双备份包：同样用 *_gateway_ota.bin。
不带 Key（*_nokey_*）：调试、未加密芯片。
带 Key（*_key_*）：加密镜像，烧录器 / 升级工具必须配置同一把 key（RS-5B88）。
本包不包含 .key 文件，请不要把工厂 key 发给终端用户。
本机 USB：.\build.bat 默认烧 nokey；.\build.bat key 烧带 Key。两套文件都会打包。
tools/package_release.py
+6 -21
View File
@@ -107,27 +107,8 @@ SKIP_PATH_PREFIXES: List[str] = [
# remove_extra : 额外删除的相对路径（相对模块根）
# keep_extra : 额外强制保留的相对路径（文件或目录，相对模块根）
# ---------------------------------------------------------------------------
MODULE_CONFIG: Dict[str, dict] = {
"apps/usr_le_code": {
"public_headers": [
"usr_le_api.h",
"usr_le_product.h",
],
"remove_patterns": [
"*.c",
"*.cpp",
"*.cc",
],
"remove_internal_headers": True,
"prune_empty_dirs": True,
"remove_extra": [
"build_lib.bat",
],
"keep_extra": [
"lib/",
],
},
}
# 本产品工程 usr_le_code 已改为源码编译，交付时不再抽成 .a
MODULE_CONFIG: Dict[str, dict] = {}
# =============================================================================
@@ -405,6 +386,7 @@ def sanitize_release_makefile(release_dir: Path) -> None:
"""
@brief 调整 Release 副本中的 Makefile：仅链接预编译 libusr_le_code.a
开发工程 Makefile 不动；客户包不得再尝试用已删除源码重建库
本产品工程已改为源码直编，无 USR_LE_SRC_FILES 时直接跳过
@param release_dir Release 根目录
"""
makefile = release_dir / "Makefile"
@@ -413,6 +395,9 @@ def sanitize_release_makefile(release_dir: Path) -> None:
return
text = makefile.read_text(encoding="utf-8")
if "USR_LE_SRC_FILES" not in text:
print("[INFO] Makefile already compiles usr_le_code from source, skip sanitize")
return
# 1) 去掉源码列表与 OBJS，仅保留预编译库路径
text2, n1 = re.subn(