存档

.vscode/settings.json

@@ -23,6 +23,8 @@
         "avctp_user.h": "c",
         "string.h": "c",
         "dev_manager.h": "c",
-        "bt_tws.h": "c"
+        "bt_tws.h": "c",
+        "skiing_tracker.h": "c",
+        "xtell.h": "c"
     }
 }

apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c

@@ -546,6 +546,8 @@ static int att_write_callback(hci_con_handle_t connection_handle, uint16_t att_h
             app_recieve_callback(0, buffer, buffer_size);
         }
         //		JL_rcsp_auth_recieve(data, len);
+        extern void le_user_app_send_event(size_t command, unsigned char* data, size_t size);
+        le_user_app_send_event(ATT_CHARACTERISTIC_ae01_01_VALUE_HANDLE, buffer, buffer_size);
         break;
 
 

apps/earphone/xtell_Sensor/A_hide/7/skiing_tracker.c

@@ -0,0 +1,276 @@
+/*
+    简化的滑雪追踪器：
+    - 直接读取六轴数据
+    - 分离重力分量
+    - 直接积分求速度和距离
+*/
+#include "skiing_tracker.h"
+#include "../sensor/SC7U22.h"
+#include <math.h>
+#include <string.h>
+
+#define ENABLE_XLOG 1
+#ifdef xlog
+#undef xlog
+#endif
+#if ENABLE_XLOG
+    #define xlog(format, ...) printf("[XT:%s] " format, __func__, ##__VA_ARGS__)
+#else
+    #define xlog(format, ...) ((void)0)
+#endif
+
+#define G_ACCELERATION 9.81f
+#define DEG_TO_RAD (3.14159265f / 180.0f)
+
+// 运动检测阈值 (m/s^2)。当水平加速度的模长大于此值时，认为处于运动状态。
+#define MOTION_THRESHOLD 0.2f
+
+static skiing_tracker_t my_skiing_tracker;
+#ifdef XTELL_TEST
+BLE_KS_send_data_t KS_data;
+debug_t debug1;
+debug_t debug2;
+#endif
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//实现
+/**
+ * @brief  初始化滑雪追踪器
+ *
+ * @param tracker
+ */
+void skiing_tracker_init(skiing_tracker_t *tracker)
+{
+    if (!tracker) {
+        return;
+    }
+    memset(tracker, 0, sizeof(skiing_tracker_t));
+    tracker->state = SKIING_STATE_STATIC;
+}
+
+/**
+ * @brief 将设备坐标系下的加速度转换为世界坐标系
+ * @param acc_device 设备坐标系下的加速度 [x, y, z]
+ * @param angle 姿态角 [pitch, roll, yaw]，单位: 度
+ * @param acc_world 输出：世界坐标系下的加速度 [x, y, z]
+ */
+static void transform_acc_to_world_frame(const float *acc_device, const float *angle, float *acc_world)
+{
+    // 驱动输出的角度与标准航空定义相反，需要取反才能用于标准旋转矩阵。
+    float pitch = -angle[0] * DEG_TO_RAD;
+    float roll  = -angle[1] * DEG_TO_RAD;
+
+    float cp = cosf(pitch);
+    float sp = sinf(pitch);
+    float cr = cosf(roll);
+    float sr = sinf(roll);
+
+    float ax = acc_device[0];
+    float ay = acc_device[1];
+    float az = acc_device[2];
+
+    // 使用经过验证的、正确的身体坐标系到世界坐标系的旋转矩阵 (基于 Y-X 旋转顺序)
+    acc_world[0] = cp * ax + sp * sr * ay + sp * cr * az;
+    acc_world[1] = 0  * ax + cr * ay      - sr * az;
+    acc_world[2] = -sp * ax + cp * sr * ay + cp * cr * az;
+}
+
+void clear_speed(void){
+    my_skiing_tracker.state = SKIING_STATE_STATIC;
+    memset(my_skiing_tracker.velocity, 0, sizeof(my_skiing_tracker.velocity));
+    my_skiing_tracker.speed = 0;
+}
+
+void start_detection(void){
+    my_skiing_tracker.state = SKIING_STATE_STATIC;
+    memset(my_skiing_tracker.velocity, 0, sizeof(my_skiing_tracker.velocity));
+    my_skiing_tracker.distance = 0;
+    my_skiing_tracker.speed = 0;
+}
+
+void stop_detection(void){
+    my_skiing_tracker.state = SKINNG_STOP_DETECTION;
+    memset(my_skiing_tracker.velocity, 0, sizeof(my_skiing_tracker.velocity));
+    my_skiing_tracker.speed = 0;
+}
+
+
+/**
+ * @brief 主更新函数
+ *
+ * @param tracker
+ * @param acc_g 三轴加速度，g
+ * @param gyr_dps 三轴陀螺仪，dps (当前简化版本未使用)
+ * @param angle 欧拉角
+ * @param dt 采样时间间隔，会用来积分求速度
+ */
+void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_dps, float *angle, float dt)
+{
+    if (!tracker || !acc_g || !angle || dt <= 0) {
+        return;
+    }
+    //停止检测
+    if(my_skiing_tracker.state == SKINNG_STOP_DETECTION)
+        return;
+
+    // --- 数据预处理 ---
+    float acc_device_ms2[3];
+    acc_device_ms2[0] = acc_g[0] * G_ACCELERATION;
+    acc_device_ms2[1] = acc_g[1] * G_ACCELERATION;
+    acc_device_ms2[2] = acc_g[2] * G_ACCELERATION;
+
+    // --- 坐标转换 & 移除重力 ---
+    // 1. 将设备坐标系下的总加速度转换到世界坐标系
+    transform_acc_to_world_frame(acc_device_ms2, angle, tracker->acc_world);
+    // 2. 在世界坐标系下，减去Z轴的重力分量，得到线性加速度
+    tracker->acc_world[2] -= G_ACCELERATION;
+
+    // --- 运动状态判断与计算 ---
+    // 计算水平方向的线性加速度模长
+    float acc_horizontal_mag = sqrtf(tracker->acc_world[0] * tracker->acc_world[0] +
+                                     tracker->acc_world[1] * tracker->acc_world[1]);
+
+    if (acc_horizontal_mag > MOTION_THRESHOLD) {
+        // 加速
+        tracker->state = SKIING_STATE_SKIING;
+        
+        // 积分计算速度（只考虑水平方向，避免垂直方向漂移）
+        tracker->velocity[0] += tracker->acc_world[0] * dt;
+        tracker->velocity[1] += tracker->acc_world[1] * dt;
+        tracker->velocity[2] = 0; // 垂直速度强制为0
+
+        // --- 更新速率和距离 ---
+        // 只基于水平速度计算速率
+        tracker->speed = sqrtf(tracker->velocity[0] * tracker->velocity[0] +
+                            tracker->velocity[1] * tracker->velocity[1]);
+        // 累加距离
+        tracker->distance += tracker->speed * dt;
+
+        return;
+
+    } else {
+        //匀速
+        tracker->distance += tracker->speed * dt;
+
+        return;
+    }
+
+    
+}
+
+// 获取当前 RTC 时间戳
+time_t get_rtc_timestamp(void) {
+    static void *rtc_hdl = NULL;
+    struct sys_time rtc_time = {0};
+    dev_ioctl(rtc_hdl, IOCTL_GET_SYS_TIME, (u32)&rtc_time);
+
+    return rtc_sys_time_to_timestamp(&rtc_time);
+}
+
+ /**
+  * @brief 传感器数据采集与处理任务，外部每10ms调用一次，如果需要更新时间间隔，也需要同步更新宏“ DELTA_TIME ”
+  * 
+  * @param acc_data_buf 三轴加速度原始数据
+  * @param gyr_data_buf 三轴陀螺仪原始数据
+  * @return BLE_send_data_t 
+  */
+BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data_buf) {
+    
+    static int initialized = 0;
+    static int calibration_done = 0;
+
+    static signed short combined_raw_data[6];
+    static float final_angle_data[3];   // 计算得到的欧若拉角
+    static float calibrated_acc_g[3];   // 转换后的加速度计数据
+    static float calibrated_gyr_dps[3]; // 转换后的陀螺仪数据
+
+    float delta_time = DELTA_TIME + 0.03f; //观察得到实际上调用间隔会多30ms
+    BLE_send_data_t BLE_send_data;
+
+    // xlog("===========start\n");
+
+    if (!initialized) {
+        skiing_tracker_init(&my_skiing_tracker);
+        initialized = 1;
+        printf("Skiing Tracker Initialized. Waiting for sensor calibration...\n");
+    }
+
+    memcpy(&combined_raw_data[0], acc_data_buf, 3 * sizeof(signed short));
+    memcpy(&combined_raw_data[3], gyr_data_buf, 3 * sizeof(signed short));
+
+    unsigned char status;
+    if (!calibration_done) {  //第1次启动，开启零漂检测
+        status = SL_SC7U22_Angle_Output(1, combined_raw_data, final_angle_data, 0);
+        if (status == 1) {
+            calibration_done = 1;
+            printf("Sensor calibration successful! Skiing mode is active.\n");
+        }
+    } else {
+        // printf("Calculate the time interval =============== start\n");
+        status = SL_SC7U22_Angle_Output(0, combined_raw_data, final_angle_data, 0);
+        // printf("Calculate the time interval =============== end\n");
+    }
+
+    if (status == 1) {
+        // 加速度 LSB to g
+        calibrated_acc_g[0] = (float)combined_raw_data[0] / 8192.0f;
+        calibrated_acc_g[1] = (float)combined_raw_data[1] / 8192.0f;
+        calibrated_acc_g[2] = (float)combined_raw_data[2] / 8192.0f;
+
+        // 陀螺仪 LSB to dps (度/秒)
+        // ±2000dps量程下，转换系数约为 0.061
+        calibrated_gyr_dps[0] = (float)combined_raw_data[3] * 0.061f;
+        calibrated_gyr_dps[1] = (float)combined_raw_data[4] * 0.061f;
+        calibrated_gyr_dps[2] = (float)combined_raw_data[5] * 0.061f;
+
+        skiing_tracker_update(&my_skiing_tracker, calibrated_acc_g, calibrated_gyr_dps, final_angle_data, delta_time);
+
+        // static int count = 0;
+        // if(count >= 10){
+        //     printf("State: %d, Speed: %.2f m/s, Distance: %.2f m\n",
+        //     my_skiing_tracker.state,
+        //     my_skiing_tracker.speed,
+        //     my_skiing_tracker.distance);
+        //     printf("calibrated_acc_g: %.2f, %.2f, %.2f\n",
+        //     calibrated_acc_g[0],
+        //     calibrated_acc_g[1],
+        //     calibrated_acc_g[2]);
+        //     count = 0;
+        // } else {
+        //     count++;
+        // }
+  
+        BLE_send_data.sensor_state = status;
+        BLE_send_data.skiing_state = my_skiing_tracker.state;
+        for (int i = 0; i < 3; i++) {
+            #ifndef XTELL_TEST
+            BLE_send_data.acc_original[i] = (int)acc_data_buf[i];
+            BLE_send_data.gyr_original[i] = (int)gyr_data_buf[i];
+            #endif
+            #if KS_BLE
+            KS_data.acc_KS[i] = (int)(calibrated_acc_g[i] * G_ACCELERATION * 100); //cm/s^s
+            KS_data.gyr_KS_dps[i] = (int)calibrated_gyr_dps[i];
+            KS_data.angle_KS[i] = (int)final_angle_data[i];
+            #endif
+        }
+        BLE_send_data.speed_cms = (int)(my_skiing_tracker.speed * 100);
+        BLE_send_data.distance_cm = (int)(my_skiing_tracker.distance * 100);
+        // 
+    } else if (status == 0) {
+        memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
+        BLE_send_data.sensor_state = status;
+        #if KS_BLE
+        memset(&KS_data, 0, sizeof(BLE_send_data_t));
+        #endif
+        // printf("Sensor is calibrating...\n");
+    } else {
+        memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
+        BLE_send_data.sensor_state = status;
+        #if KS_BLE
+        memset(&KS_data, 0, sizeof(BLE_send_data_t));
+        #endif
+        // printf("Angle calculation error or calibration not finished.\n");
+    }
+
+    // xlog("end++++++++++++++\n");
+    return BLE_send_data;
+}

apps/earphone/xtell_Sensor/A_hide/7/skiing_tracker.h

@@ -0,0 +1,67 @@
+#ifndef SKIING_TRACKER_H
+#define SKIING_TRACKER_H
+
+#include "../xtell.h"
+// 定义滑雪者可能的状态
+typedef enum {
+    SKIING_STATE_STATIC,        // 静止
+    SKIING_STATE_SKIING,        // 正在滑雪
+    SKINNG_STOP_DETECTION,       // 停止检测
+} skiing_state_t;
+#define DELTA_TIME 0.01f
+
+
+// 追踪器数据结构体
+typedef struct {
+    // 公开数据
+    float velocity[3];          // 当前速度 (x, y, z)，单位: m/s
+    float distance;             // 总滑行距离，单位: m
+    float speed;                // 当前速率 (标量)，单位: m/s
+    skiing_state_t state;       // 当前滑雪状态
+
+    // 内部计算使用的私有成员
+    float acc_world[3];         // 在世界坐标系下的线性加速度
+} skiing_tracker_t;
+
+//ble发送的数据
+typedef struct __attribute__((packed)){   //该结构体取消内存对齐
+    char sensor_state;
+    char skiing_state;
+    int speed_cms;        //求出的速度，cm/s
+    int distance_cm;      //求出的距离，cm
+    #ifndef XTELL_TEST
+    int acc_original[3];  //直接读取传感器得到的原始三轴加速度
+    int gyr_original[3];  //直接读取传感器得到的原始三轴陀螺仪
+    #endif
+}BLE_send_data_t;
+
+typedef struct{
+    int acc_KS[3];      //卡尔曼后，LSB转换后的  三轴加速度数据（cm/s^2）
+    int gyr_KS_dps[3];    //卡尔曼后，LSB to dps 三轴陀螺仪数据
+    int angle_KS[3];      //卡尔曼后，计算得到的欧若拉角数据
+}BLE_KS_send_data_t;
+
+#ifdef XTELL_TEST
+typedef struct{
+    float acc_variance;   //三轴加速度方差之和
+    float gyr_variance;   //三轴陀螺仪方差之和
+    float acc_magnitude;  //三轴加速度模长
+    float gyr_magnitude;  //三轴陀螺仪模长
+}debug_t;
+#endif
+/**
+ * @brief 初始化滑雪追踪器
+ *
+ * @param tracker 指向 skiing_tracker_t 结构体的指针
+ */
+void skiing_tracker_init(skiing_tracker_t *tracker);
+
+ /**
+  * @brief 传感器数据采集与处理任务，外部每10ms调用一次，如果需要更新时间间隔，也需要同步更新宏“ DELTA_TIME ”
+  * 
+  * @param acc_data_buf 三轴加速度原始数据
+  * @param gyr_data_buf 三轴陀螺仪原始数据
+  * @return BLE_send_data_t 
+  */
+BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data_buf) ;
+#endif // SKIING_TRACKER_H

apps/earphone/xtell_Sensor/A_hide/8/skiing_tracker.c

@@ -1,8 +1,15 @@
 /*
-    动态ZUPT+卡尔曼
-        多了加速度死区、摩擦力速度衰减、高通滤波
-        原地摆动产生的速度、距离变化还是没法消除
-        水平移动、斜坡移动效果貌似还行
+    动态ZUPT+卡尔曼+巴特沃斯一阶滤波器
+    针对启动滑雪和停止滑雪，设置不同阈值
+    启动滑雪和ZUPT更新的陀螺仪方差阈值分开设置
+        - 启动滑雪的陀螺仪阈值会更宽松一些
+    原地旋转和ZUPT更新的加速度方差阈值分开设置
+        - 原地旋转的加速度阈值更宽松
+    能够从静止状态到变化状态，去根据阈值来判断这个“变化”：进入滑行状态 / 只是原地摆动
+        - 但是还是不够灵敏
+    
+    添加了滑雪过程中转弯判断，参数待调
+        
 */
 #include "skiing_tracker.h"
 #include "../sensor/SC7U22.h"
@@ -12,33 +19,55 @@
 #define G_ACCELERATION 9.81f
 #define DEG_TO_RAD (3.14159265f / 180.0f)
 
-// --- 算法阈值定义 ---
-//两个判断是否静止的必要条件
-// 动态零速更新(ZUPT)阈值
-// 提高阈值，让“刹车”更灵敏，以便在波浪式前进等慢速漂移时也能触发零速更新
+// --- ZUPT ---
+//两个判断是否静止的必要条件：动态零速更新(ZUPT)阈值
+// 加速方差阈值，提高阈值，让“刹车”更灵敏，以便在波浪式前进等慢速漂移时也能触发零速更新
 #define ZUPT_ACC_VARIANCE_THRESHOLD 0.2f
 // 陀螺仪方差阈值
 #define ZUPT_GYR_VARIANCE_THRESHOLD 5.0f
 
-// 旋转/摆动检测阈值：角速度总模长大于此值(度/秒)，认为正在进行非滑雪的旋转或摆动 -- 没法完全消除
-#define ROTATION_GYR_MAG_THRESHOLD 45.0f
-// 启动滑雪阈值：加速度模长与重力的差值大于此值，认为开始运动
-// 降低阈值，让“油门”更灵敏，以便能捕捉到真实的慢速启动
+// --- 启动滑雪阈值 --- 
+// 加速度模长与重力的差值大于此值，认为开始运动；降低阈值，让“油门”更灵敏，以便能捕捉到真实的慢速启动
 #define START_SKIING_ACC_THRESHOLD 0.5f
+// 陀螺仪方差阈值，以允许启动瞬间的正常抖动，但仍能过滤掉混乱的、非滑雪的晃动。
+#define SKIING_GYR_VARIANCE_THRESHOLD 15.0f
+
+// --- 原地旋转抖动 --- 
+// 用于原地旋转判断的加速度方差阈值。此值比ZUPT阈值更宽松，
+// 以允许原地旋转时身体的正常晃动，但仍能与真实滑行时的剧烈加速度变化区分开。
+#define ROTATING_ACC_VARIANCE_THRESHOLD 0.8f
+// 旋转/摆动检测阈值：角速度总模长大于此值(度/秒)，认为正在进行非滑雪的旋转或摆动
+#define ROTATION_GYR_MAG_THRESHOLD 120.0f  
+
+// --- 滑雪转弯动 --- 
+// 加速度方差阈值，大于此值，滑雪过程可能发生了急转弯
+#define WHEEL_ACC_VARIANCE_THRESHOLD 7.0f  
+// 旋转/摆动检测阈值：角速度总模长大于此值(度/秒)，认为滑雪过程中进行急转弯
+#define WHEEL_GYR_MAG_THRESHOLD 220.0f   // 150.0f 到 250.0f之间进行调整
 
 // --- 用于消除积分漂移的滤波器和阈值 ---
 // 高通滤波器系数 (alpha)。alpha 越接近1，滤除低频(直流偏移)的效果越强，但可能滤掉真实的慢速运动。
-// alpha = RC / (RC + dt)，
-#define HPF_ALPHA 0.95f
+// alpha = RC / (RC + dt)，参考RC电路而来
+#define HPF_ALPHA 0.995  
+
 // 加速度死区阈值 (m/s^2)。低于此阈值的加速度被认为是噪声，不参与积分。
 // 设得太高会忽略真实的慢速启动，设得太低则无法有效抑制噪声。
-#define ACC_DEAD_ZONE_THRESHOLD 0.1f
+#define ACC_DEAD_ZONE_THRESHOLD 0.05f   
 
 // --- 模拟摩擦力，进行速度衰减 ---
-#define SPEED_ATTENUATION 0.98f  
+#define SPEED_ATTENUATION 1.0f  //暂不模拟  
 
+#ifdef XTELL_TEST
+BLE_KS_send_data_t KS_data;
+debug_t debug1;
+debug_t debug2;
+#endif
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//实现
 /**
- * @brief 初始化滑雪追踪器
+ * @brief  初始化滑雪追踪器
+ * 
+ * @param tracker 
  */
 void skiing_tracker_init(skiing_tracker_t *tracker)
 {
@@ -87,13 +116,16 @@ static void transform_acc_to_world_frame(const float *acc_device, const float *a
 
 /**
  * @brief 计算缓冲区内三轴数据的方差之和
+ * 
+ * @param buffer 传进来的三轴数据：陀螺仪/加速度
+ * @return float 返回方差和
  */
 static float calculate_variance(float buffer[VARIANCE_BUFFER_SIZE][3])
 {
     float mean[3] = {0};
     float variance[3] = {0};
 
-    // 1. 计算均值
+    // 计算均值
     for (int i = 0; i < VARIANCE_BUFFER_SIZE; i++) {
         mean[0] += buffer[i][0];
         mean[1] += buffer[i][1];
@@ -103,7 +135,7 @@ static float calculate_variance(float buffer[VARIANCE_BUFFER_SIZE][3])
     mean[1] /= VARIANCE_BUFFER_SIZE;
     mean[2] /= VARIANCE_BUFFER_SIZE;
 
-    // 2. 计算方差
+    // 计算方差
     for (int i = 0; i < VARIANCE_BUFFER_SIZE; i++) {
         variance[0] += (buffer[i][0] - mean[0]) * (buffer[i][0] - mean[0]);
         variance[1] += (buffer[i][1] - mean[1]) * (buffer[i][1] - mean[1]);
@@ -118,8 +150,13 @@ static float calculate_variance(float buffer[VARIANCE_BUFFER_SIZE][3])
 }
 
 
+
 /**
  * @brief 状态机更新
+ * 
+ * @param tracker 
+ * @param acc_device_ms2 三轴加速度，m/s^2
+ * @param gyr_dps 三轴陀螺仪，dps
  */
 static void update_state_machine(skiing_tracker_t *tracker, const float *acc_device_ms2, const float *gyr_dps)
 {
@@ -134,49 +171,60 @@ static void update_state_machine(skiing_tracker_t *tracker, const float *acc_dev
     float gyr_variance = calculate_variance(tracker->gyr_buffer); // 计算陀螺仪方差
     float gyr_magnitude = sqrtf(gyr_dps[0]*gyr_dps[0] + gyr_dps[1]*gyr_dps[1] + gyr_dps[2]*gyr_dps[2]);
     float acc_magnitude = sqrtf(acc_device_ms2[0]*acc_device_ms2[0] + acc_device_ms2[1]*acc_device_ms2[1] + acc_device_ms2[2]*acc_device_ms2[2]);
+    #ifdef XTELL_TEST
+    debug1.acc_variance =acc_variance;
+    debug1.gyr_variance =gyr_variance;
+    debug1.gyr_magnitude=gyr_magnitude;
+    debug1.acc_magnitude=acc_magnitude - G_ACCELERATION;
+    #endif
+    
+    // --- 状态切换逻辑 (按优先级) ---
 
-    // --- 状态切换逻辑---
+    // 优先级1：动态零速更新 (ZUPT) - 最严格和最优先的“刹车”
+    if (acc_variance < ZUPT_ACC_VARIANCE_THRESHOLD && gyr_variance < ZUPT_GYR_VARIANCE_THRESHOLD) {
+        tracker->state = SKIING_STATE_STATIC;
+        // 速度清零，抑制漂移
+        memset(tracker->velocity, 0, sizeof(tracker->velocity));
+        tracker->speed = 0.0f;
+        // 关键：当检测到静止时，必须重置高通滤波器的状态
+        memset(tracker->acc_world_unfiltered_prev, 0, sizeof(tracker->acc_world_unfiltered_prev));
+        memset(tracker->acc_world_filtered, 0, sizeof(tracker->acc_world_filtered));
+        return;
+    }
 
-    // 原地旋转/摆动检测
-    // 增加一个关键前提：只在当前不处于滑雪状态时，才检测原地旋转。
-    // 这可以防止滑雪过程中的高速转弯被误判为原地旋转。
-    // 暂时没办法完全消除
-    if (gyr_magnitude > ROTATION_GYR_MAG_THRESHOLD && tracker->state != SKIING_STATE_SKIING) {
+    if(tracker->state == SKIING_STATE_SKIING && gyr_magnitude > WHEEL_GYR_MAG_THRESHOLD && acc_variance > WHEEL_ACC_VARIANCE_THRESHOLD){
+        //TODO：可以考虑清掉速度消除积分带来的漂移
         tracker->state = SKIING_STATE_ROTATING;
         return;
     }
 
-    // 动态零速更新 (ZUPT) 
-    // 必须同时满足加速度和角速度都稳定，才能判断为“真静止”，以区分匀速运动
-    if (acc_variance < ZUPT_ACC_VARIANCE_THRESHOLD && gyr_variance < ZUPT_GYR_VARIANCE_THRESHOLD) {
-        tracker->state = SKIING_STATE_STATIC;
-        // 速度清零，抑制漂移
-       memset(tracker->velocity, 0, sizeof(tracker->velocity));
-       tracker->speed = 0.0f;
-       //当检测到静止时，必须重置高通滤波器的状态，否则下次启动时会有跳变
-       memset(tracker->acc_world_unfiltered_prev, 0, sizeof(tracker->acc_world_unfiltered_prev));
-       memset(tracker->acc_world_filtered, 0, sizeof(tracker->acc_world_filtered));
-       return;
-   }
-
-    // 从静止/旋转状态启动
-    if (tracker->state == SKIING_STATE_STATIC || tracker->state == SKIING_STATE_ROTATING) {
-        // 最终版启动逻辑：必须同时满足“有足够大的线性加速度”和“旋转不剧烈”两个条件
-        // 新增 gyr_magnitude 判断，防止原地旋转产生的离心加速度被误判为启动
-        if (fabsf(acc_magnitude - G_ACCELERATION) > START_SKIING_ACC_THRESHOLD &&
-            gyr_variance < ZUPT_GYR_VARIANCE_THRESHOLD &&
-            gyr_magnitude < ROTATION_GYR_MAG_THRESHOLD) {
-            tracker->state = SKIING_STATE_SKIING;
-            return;
-        }
+    // 优先级2：原地旋转 - 特殊的、非滑雪的运动状态
+    // 条件：角速度很大，同时线性加速度的晃动在一个“中等”范围内。
+    if (tracker->state == SKIING_STATE_STATIC && gyr_magnitude > ROTATION_GYR_MAG_THRESHOLD && acc_variance < ROTATING_ACC_VARIANCE_THRESHOLD) {
+        tracker->state = SKIING_STATE_ROTATING;
+        return;
     }
-    // 最后的 fall-through 逻辑已移除，以修复原地旋转被错误判断为滑雪的bug。
-    // 如果不满足任何状态切换条件，状态将保持不变，直到ZUPT或启动条件被满足。
+
+    // 优先级3：启动滑雪 - “油门”
+    // 条件：有足够大的线性加速度，同时陀螺仪的抖动在一个“合理”（而非“完全静止”）的范围内。
+    if (fabsf(acc_magnitude - G_ACCELERATION) > START_SKIING_ACC_THRESHOLD && gyr_variance < SKIING_GYR_VARIANCE_THRESHOLD) {
+        tracker->state = SKIING_STATE_SKIING;
+        return;
+    }
+
+    // 如果不满足任何启动或停止条件，则保持当前状态（滑雪中）
+    // 如果当前是静止或旋转，但没有满足启动条件，则状态会保持，直到满足ZUPT或旋转条件。
 }
 
 
 /**
  * @brief 主更新函数
+ * 
+ * @param tracker 
+ * @param acc_g 三轴加速度，g
+ * @param gyr_dps 三轴陀螺仪，dps
+ * @param angle 欧若拉角
+ * @param dt 采样时间间隔，会用来积分求速度
  */
 void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_dps, float *angle, float dt)
 {
@@ -226,6 +274,9 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
             // 垂直方向的速度暂时不积分，极易受姿态误差影响而漂移
             // tracker->velocity[2] += tracker->acc_world_filtered[2] * dt;
         }
+        #ifdef XTELL_TEST
+        debug2.acc_magnitude = acc_horizontal_mag;
+        #endif
         // 如果加速度小于阈值，则不更新速度，相当于速度保持不变（或受下一步的阻尼影响而衰减）
 
     } else {
@@ -244,8 +295,15 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
 }
 
 
-// 传感器数据采集与处理任务
-void sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data_buf) {
+
+ /**
+  * @brief 传感器数据采集与处理任务，外部每10ms调用一次，如果需要更新时间间隔，也需要同步更新宏“ DELTA_TIME ”
+  * 
+  * @param acc_data_buf 三轴加速度原始数据
+  * @param gyr_data_buf 三轴陀螺仪原始数据
+  * @return BLE_send_data_t 
+  */
+BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data_buf) {
     static skiing_tracker_t my_skiing_tracker;
     static int initialized = 0;
     static int calibration_done = 0;
@@ -255,7 +313,11 @@ void sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data
     static float calibrated_acc_g[3];   // 转换后的加速度计数据
     static float calibrated_gyr_dps[3]; // 转换后的陀螺仪数据
 
-    const float delta_time = 0.01f;
+    const float delta_time = DELTA_TIME + 0.03f;
+    BLE_send_data_t BLE_send_data;
+    
+
+
 
     if (!initialized) {
         skiing_tracker_init(&my_skiing_tracker);
@@ -274,6 +336,7 @@ void sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data
             printf("Sensor calibration successful! Skiing mode is active.\n");
         }
     } else {
+        // printf("Calculate the time interval =============== start\n");
         status = SL_SC7U22_Angle_Output(0, combined_raw_data, final_angle_data, 0);
     }
 
@@ -291,22 +354,51 @@ void sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data
 
         skiing_tracker_update(&my_skiing_tracker, calibrated_acc_g, calibrated_gyr_dps, final_angle_data, delta_time);
 
-        // 打印逻辑保持不变
-        static int count = 0;
-        if(count < 10){
-            count++;
-            return;
-        } else {
-            count = 0;
+        // static int count = 0;
+        // if(count >= 10){
+        //     printf("State: %d, Speed: %.2f m/s, Distance: %.2f m\n",
+        //     my_skiing_tracker.state,
+        //     my_skiing_tracker.speed,
+        //     my_skiing_tracker.distance);
+        //     printf("calibrated_acc_g: %.2f, %.2f, %.2f\n",
+        //     calibrated_acc_g[0],
+        //     calibrated_acc_g[1],
+        //     calibrated_acc_g[2]);
+        //     count = 0;
+        // } else {
+        //     count++;
+        // }
+  
+        BLE_send_data.sensor_state = status;
+        BLE_send_data.skiing_state = my_skiing_tracker.state;
+        for (int i = 0; i < 3; i++) {
+            #ifndef XTELL_TEST
+            BLE_send_data.acc_original[i] = (int)acc_data_buf[i];
+            BLE_send_data.gyr_original[i] = (int)gyr_data_buf[i];
+            #endif
+            #if KS_BLE
+            KS_data.acc_KS[i] = (int)(calibrated_acc_g[i] * G_ACCELERATION * 100); //cm/s^s
+            KS_data.gyr_KS_dps[i] = (int)calibrated_gyr_dps[i];
+            KS_data.angle_KS[i] = (int)final_angle_data[i];
+            #endif
         }
-        printf("State: %d, Speed: %.2f m/s, Distance: %.2f m\n",
-               my_skiing_tracker.state,
-               my_skiing_tracker.speed,
-               my_skiing_tracker.distance);
-
+        BLE_send_data.speed_cms = (int)(my_skiing_tracker.speed * 100);
+        BLE_send_data.distance_cm = (int)(my_skiing_tracker.distance * 100);
+        // printf("Calculate the time interval =============== end\n");
     } else if (status == 0) {
+        memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
+        BLE_send_data.sensor_state = status;
+        #if KS_BLE
+        memset(&KS_data, 0, sizeof(BLE_send_data_t));
+        #endif
         // printf("Sensor is calibrating...\n");
     } else {
+        memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
+        BLE_send_data.sensor_state = status;
+        #if KS_BLE
+        memset(&KS_data, 0, sizeof(BLE_send_data_t));
+        #endif
         // printf("Angle calculation error or calibration not finished.\n");
     }
+    return BLE_send_data;
 }

apps/earphone/xtell_Sensor/A_hide/8/skiing_tracker.h

@@ -0,0 +1,82 @@
+#ifndef SKIING_TRACKER_H
+#define SKIING_TRACKER_H
+
+#include "../xtell.h"
+// 定义滑雪者可能的状态
+typedef enum {
+    SKIING_STATE_STATIC,        // 静止或动态稳定
+    SKIING_STATE_SKIING,        // 正在滑雪
+    SKIING_STATE_ROTATING,      // 正在原地旋转 (新增)
+    SKIING_STATE_FALLEN,        // 已摔倒
+    SKIING_STATE_UNKNOWN        // 未知状态
+} skiing_state_t;
+
+#define VARIANCE_BUFFER_SIZE 5 // 用于计算方差的数据窗口大小 (5个样本 @ 100Hz = 50ms)，减小延迟，提高实时性
+#define DELTA_TIME 0.01f
+
+
+// 追踪器数据结构体
+typedef struct {
+    // 公开数据
+    float velocity[3];          // 当前速度 (x, y, z)，单位: m/s
+    float distance;             // 总滑行距离，单位: m
+    float speed;                // 当前速率 (标量)，单位: m/s
+    skiing_state_t state;       // 当前滑雪状态
+
+    // 内部计算使用的私有成员
+    float acc_world[3];         // 在世界坐标系下的加速度
+
+    // --- 内部计算使用的私有成员 ---
+    // 用于动态零速更新和旋转检测的缓冲区
+    float acc_buffer[VARIANCE_BUFFER_SIZE][3]; // 加速度数据窗口
+    float gyr_buffer[VARIANCE_BUFFER_SIZE][3]; // 角速度数据窗口
+    int buffer_index;                          // 缓冲区当前索引
+    int buffer_filled;                         // 缓冲区是否已填满的标志
+
+    // 用于高通滤波器（巴特沃斯一阶滤波器）的私有成员，以消除加速度的直流偏置
+    float acc_world_filtered[3];  //过滤过的
+    float acc_world_unfiltered_prev[3];  //上一次没过滤的
+} skiing_tracker_t;
+
+//ble发送的数据
+typedef struct __attribute__((packed)){   //该结构体取消内存对齐
+    char sensor_state;
+    char skiing_state;
+    int speed_cms;        //求出的速度，cm/s
+    int distance_cm;      //求出的距离，cm
+    #ifndef XTELL_TEST
+    int acc_original[3];  //直接读取传感器得到的原始三轴加速度
+    int gyr_original[3];  //直接读取传感器得到的原始三轴陀螺仪
+    #endif
+}BLE_send_data_t;
+
+typedef struct{
+    int acc_KS[3];      //卡尔曼后，LSB转换后的  三轴加速度数据（cm/s^2）
+    int gyr_KS_dps[3];    //卡尔曼后，LSB to dps 三轴陀螺仪数据
+    int angle_KS[3];      //卡尔曼后，计算得到的欧若拉角数据
+}BLE_KS_send_data_t;
+
+#ifdef XTELL_TEST
+typedef struct{
+    float acc_variance;   //三轴加速度方差之和
+    float gyr_variance;   //三轴陀螺仪方差之和
+    float acc_magnitude;  //三轴加速度模长
+    float gyr_magnitude;  //三轴陀螺仪模长
+}debug_t;
+#endif
+/**
+ * @brief 初始化滑雪追踪器
+ *
+ * @param tracker 指向 skiing_tracker_t 结构体的指针
+ */
+void skiing_tracker_init(skiing_tracker_t *tracker);
+
+ /**
+  * @brief 传感器数据采集与处理任务，外部每10ms调用一次，如果需要更新时间间隔，也需要同步更新宏“ DELTA_TIME ”
+  * 
+  * @param acc_data_buf 三轴加速度原始数据
+  * @param gyr_data_buf 三轴陀螺仪原始数据
+  * @return BLE_send_data_t 
+  */
+BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data_buf) ;
+#endif // SKIING_TRACKER_H

apps/earphone/xtell_Sensor/README.md

@@ -0,0 +1,38 @@
+# 时间间隔
+
+目前测试代码如下：
+
+```c
+create_process(&test_id, "test",NULL, test, (int)(DELTA_TIME*1000));
+```
+
+对于test函数的调用时间设置的是10ms调用一次，test代码如下：
+
+```c
+void test(){
+    signed short acc_data_buf[3] = {0};
+    signed short gyr_data_buf[3] = {0};
+    signed short acc_gyro_input[6] = {0};
+    float Angle_output[3] = {0};
+    SL_SC7U22_RawData_Read(acc_data_buf,gyr_data_buf);
+    BLE_send_data = sensor_processing_task(acc_data_buf, gyr_data_buf);
+    //----省略-----
+    //一些ble数据发送
+
+    memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
+    memset(&data, 0, 50);
+    // xlog("end============\n");
+
+}
+```
+
+sensor_processing_task当中就进行了计算，包括卡尔曼等，在timer设置成10ms的情况下，实际上test函数（或者是sensor_processing_task函数），距离上次调用到本次调用，实际间隔为40ms
+
+计算距离不能直接采用timers设置的时间间隔作为dt来求距离，实际每次计算求速度的时间应该是40ms
+
+
+
+
+
+
+

apps/earphone/xtell_Sensor/calculate/skiing_tracker.c

@@ -1,12 +1,6 @@
 /*
-    动态ZUPT+卡尔曼+巴特沃斯一阶滤波器
-    针对启动滑雪和停止滑雪，设置不同阈值
-    启动滑雪和ZUPT更新的陀螺仪方差阈值分开设置
-        - 启动滑雪的陀螺仪阈值会更宽松一些
-    原地旋转和ZUPT更新的加速度方差阈值分开设置
-        - 原地旋转的加速度阈值更宽松
-    能够从静止状态到变化状态，去根据阈值来判断这个“变化”：进入滑行状态 / 只是原地摆动
-        - 但是还是不够灵敏
+    虽然sensor_processing_task是10ms调用一次
+    但是实际上上一次调用该函数的时间点和下一次调用该函数的时间点，会相差40ms
         
 */
 #include "skiing_tracker.h"
@@ -17,43 +11,79 @@
 #define G_ACCELERATION 9.81f
 #define DEG_TO_RAD (3.14159265f / 180.0f)
 
-// --- 算法阈值定义 ---
+// --- ZUPT ---
 //两个判断是否静止的必要条件：动态零速更新(ZUPT)阈值
 // 加速方差阈值，提高阈值，让“刹车”更灵敏，以便在波浪式前进等慢速漂移时也能触发零速更新
 #define ZUPT_ACC_VARIANCE_THRESHOLD 0.2f
 // 陀螺仪方差阈值
 #define ZUPT_GYR_VARIANCE_THRESHOLD 5.0f
 
+// --- 启动滑雪阈值 --- 
+// 加速度模长与重力的差值大于此值，认为开始运动；降低阈值，让“油门”更灵敏，以便能捕捉到真实的慢速启动
+#define START_SKIING_ACC_THRESHOLD 0.5f
+// 陀螺仪方差阈值，以允许启动瞬间的正常抖动，但仍能过滤掉混乱的、非滑雪的晃动。
+#define SKIING_GYR_VARIANCE_THRESHOLD 15.0f
+
+// --- 滑雪过程 ---
+//加速度 模长，低于此值视为 在做匀速运动
+#define SKIING_ACC_MAG_THRESHOLD 0.5f
+//陀螺仪 模长，高于此值视为 摔倒了
+#define FALLEN_GRY_MAG_THRESHOLD 1000.0f   //未确定
+
+// --- 原地旋转抖动 --- 
 // 用于原地旋转判断的加速度方差阈值。此值比ZUPT阈值更宽松，
 // 以允许原地旋转时身体的正常晃动，但仍能与真实滑行时的剧烈加速度变化区分开。
 #define ROTATING_ACC_VARIANCE_THRESHOLD 0.8f
-// 用于启动滑雪判断的陀螺仪方差阈值。此值比ZUPT阈值更宽松，
-// 以允许启动瞬间的正常抖动，但仍能过滤掉混乱的、非滑雪的晃动。
-#define SKIING_GYR_VARIANCE_THRESHOLD 15.0f
-
-
 // 旋转/摆动检测阈值：角速度总模长大于此值(度/秒)，认为正在进行非滑雪的旋转或摆动
-#define ROTATION_GYR_MAG_THRESHOLD 90.0f  //测试记录：45.0f、90.0f
-// 启动滑雪阈值：加速度模长与重力的差值大于此值，认为开始运动
-// 降低阈值，让“油门”更灵敏，以便能捕捉到真实的慢速启动
-#define START_SKIING_ACC_THRESHOLD 0.5f
+#define ROTATION_GYR_MAG_THRESHOLD 120.0f  
+
+// --- 滑雪转弯动 --- 
+// 加速度方差阈值，大于此值，滑雪过程可能发生了急转弯
+#define WHEEL_ACC_VARIANCE_THRESHOLD 7.0f  
+// 旋转/摆动检测阈值：角速度总模长大于此值(度/秒)，认为滑雪过程中进行急转弯
+#define WHEEL_GYR_MAG_THRESHOLD 220.0f   // 150.0f 到 250.0f之间进行调整
 
 // --- 用于消除积分漂移的滤波器和阈值 ---
 // 高通滤波器系数 (alpha)。alpha 越接近1，滤除低频(直流偏移)的效果越强，但可能滤掉真实的慢速运动。
-// alpha = RC / (RC + dt)，
-#define HPF_ALPHA 0.95f  // 换算大概就是衰减频率低于约 0.84 Hz 的信号
-                         // 任何比“大约1秒钟变化一次”还要慢的运动，其加速度信号也会被部分衰减。
-                         // 而滑雪时的快速转弯、加减速等动作，其频率远高于 0.84 Hz，它们的信号会被保留下来。
+// alpha = RC / (RC + dt)，参考RC电路而来
+#define HPF_ALPHA 0.995  
+
 // 加速度死区阈值 (m/s^2)。低于此阈值的加速度被认为是噪声，不参与积分。
 // 设得太高会忽略真实的慢速启动，设得太低则无法有效抑制噪声。
-#define ACC_DEAD_ZONE_THRESHOLD 0.15f   
+#define ACC_DEAD_ZONE_THRESHOLD 0.05f   
 
 // --- 模拟摩擦力，进行速度衰减 ---
-#define SPEED_ATTENUATION 0.98f  
+#define SPEED_ATTENUATION 1.0f  //暂不模拟  
 
+#ifdef XTELL_TEST
+BLE_KS_send_data_t KS_data;
+debug_t debug1;
+debug_t debug2;
+#endif
 
+static skiing_tracker_t my_skiing_tracker;
 //////////////////////////////////////////////////////////////////////////////////////////////////
 //实现
+
+void clear_speed(void){
+    my_skiing_tracker.state = STATIC;
+    memset(my_skiing_tracker.velocity, 0, sizeof(my_skiing_tracker.velocity));
+    my_skiing_tracker.speed = 0;
+}
+
+void start_detection(void){
+    my_skiing_tracker.state = STATIC;
+    memset(my_skiing_tracker.velocity, 0, sizeof(my_skiing_tracker.velocity));
+    my_skiing_tracker.distance = 0;
+    my_skiing_tracker.speed = 0;
+}
+
+void stop_detection(void){
+    my_skiing_tracker.state = STOP_DETECTION;
+    memset(my_skiing_tracker.velocity, 0, sizeof(my_skiing_tracker.velocity));
+    my_skiing_tracker.speed = 0;
+}
+
 /**
  * @brief  初始化滑雪追踪器
  * 
@@ -66,7 +96,7 @@ void skiing_tracker_init(skiing_tracker_t *tracker)
     }
     // 使用memset一次性清零整个结构体，包括新增的缓冲区
     memset(tracker, 0, sizeof(skiing_tracker_t));
-    tracker->state = SKIING_STATE_STATIC;
+    tracker->state = STATIC;
 }
 
 /**
@@ -144,7 +174,7 @@ static float calculate_variance(float buffer[VARIANCE_BUFFER_SIZE][3])
 /**
  * @brief 状态机更新
  * 
- * @param tracker 
+ * @param tracker 传入同步修改后传出
  * @param acc_device_ms2 三轴加速度，m/s^2
  * @param gyr_dps 三轴陀螺仪，dps
  */
@@ -152,7 +182,7 @@ static void update_state_machine(skiing_tracker_t *tracker, const float *acc_dev
 {
     // 缓冲区未填满时，不进行状态判断，默认为静止
     if (!tracker->buffer_filled) {
-        tracker->state = SKIING_STATE_STATIC;
+        tracker->state = STATIC;
         return;
     }
 
@@ -162,37 +192,118 @@ static void update_state_machine(skiing_tracker_t *tracker, const float *acc_dev
     float gyr_magnitude = sqrtf(gyr_dps[0]*gyr_dps[0] + gyr_dps[1]*gyr_dps[1] + gyr_dps[2]*gyr_dps[2]);
     float acc_magnitude = sqrtf(acc_device_ms2[0]*acc_device_ms2[0] + acc_device_ms2[1]*acc_device_ms2[1] + acc_device_ms2[2]*acc_device_ms2[2]);
 
+    #ifdef XTELL_TEST
+    debug1.acc_variance =acc_variance;
+    debug1.gyr_variance =gyr_variance;
+    debug1.gyr_magnitude=gyr_magnitude;
+    debug1.acc_magnitude=fabsf(acc_magnitude - G_ACCELERATION);
+    #endif
+    
+#if 0
+    //正在滑雪
+    if(tracker->state == NO_CONSTANT_SPEED ) {
+        //摔倒了
+        if(gyr_magnitude > FALLEN_GRY_MAG_THRESHOLD){  
+            tracker->state = FALLEN;
+            return;
+        }
+        //可能进入了匀速状态
+        if(gyr_magnitude > SKIING_GYR_MAG_THRESHOLD && acc_magnitude < SKIING_ACC_MAG_THRESHOLD){
+            tracker->state = CONSTANT_SPEED;
+            return;
+        }
+        //急转弯
+        if(gyr_magnitude > WHEEL_GYR_MAG_THRESHOLD && acc_variance > WHEEL_ACC_VARIANCE_THRESHOLD){
+            //TODO：可以考虑清掉速度消除积分带来的漂移
+            tracker->state = WHEEL;
+            return;
+        }
+    }
 
     // --- 状态切换逻辑 (按优先级) ---
-
-    // 优先级1：动态零速更新 (ZUPT) - 最严格和最优先的“刹车”
+    // 优先级1：静止
     if (acc_variance < ZUPT_ACC_VARIANCE_THRESHOLD && gyr_variance < ZUPT_GYR_VARIANCE_THRESHOLD) {
-        tracker->state = SKIING_STATE_STATIC;
+        tracker->state = STATIC;
         // 速度清零，抑制漂移
         memset(tracker->velocity, 0, sizeof(tracker->velocity));
         tracker->speed = 0.0f;
-        // 关键：当检测到静止时，必须重置高通滤波器的状态
         memset(tracker->acc_world_unfiltered_prev, 0, sizeof(tracker->acc_world_unfiltered_prev));
         memset(tracker->acc_world_filtered, 0, sizeof(tracker->acc_world_filtered));
         return;
     }
 
+   
+
     // 优先级2：原地旋转 - 特殊的、非滑雪的运动状态
     // 条件：角速度很大，同时线性加速度的晃动在一个“中等”范围内。
-    if (gyr_magnitude > ROTATION_GYR_MAG_THRESHOLD && acc_variance < ROTATING_ACC_VARIANCE_THRESHOLD) {
-        tracker->state = SKIING_STATE_ROTATING;
+    if (tracker->state == STATIC && gyr_magnitude > ROTATION_GYR_MAG_THRESHOLD && acc_variance < ROTATING_ACC_VARIANCE_THRESHOLD) {
+        tracker->state = ROTATING;
         return;
     }
 
     // 优先级3：启动滑雪 - “油门”
     // 条件：有足够大的线性加速度，同时陀螺仪的抖动在一个“合理”（而非“完全静止”）的范围内。
     if (fabsf(acc_magnitude - G_ACCELERATION) > START_SKIING_ACC_THRESHOLD && gyr_variance < SKIING_GYR_VARIANCE_THRESHOLD) {
-        tracker->state = SKIING_STATE_SKIING;
+        tracker->state = NO_CONSTANT_SPEED;
         return;
     }
 
     // 如果不满足任何启动或停止条件，则保持当前状态（滑雪中）
     // 如果当前是静止或旋转，但没有满足启动条件，则状态会保持，直到满足ZUPT或旋转条件。
+#else
+
+    // 无论当前是什么状态，静止总是最高优先级
+    if (acc_variance < ZUPT_ACC_VARIANCE_THRESHOLD && gyr_variance < ZUPT_GYR_VARIANCE_THRESHOLD) {
+        tracker->state = STATIC;
+        // 速度清零，抑制漂移
+        memset(tracker->velocity, 0, sizeof(tracker->velocity));
+        tracker->speed = 0.0f;
+        memset(tracker->acc_world_unfiltered_prev, 0, sizeof(tracker->acc_world_unfiltered_prev));
+        memset(tracker->acc_world_filtered, 0, sizeof(tracker->acc_world_filtered));
+        return;
+    }
+
+    switch (tracker->state) {
+        case STATIC:
+            //不break，会往下执行，判断是否进入非匀速状态
+        case ROTATING: // 从静止或原地旋转可以启动
+            if (fabsf(acc_magnitude - G_ACCELERATION) > START_SKIING_ACC_THRESHOLD && gyr_variance < SKIING_GYR_VARIANCE_THRESHOLD) {
+                tracker->state = NO_CONSTANT_SPEED;
+            } else if (gyr_magnitude > ROTATION_GYR_MAG_THRESHOLD && acc_variance < ROTATING_ACC_VARIANCE_THRESHOLD) {
+                tracker->state = ROTATING;
+            }
+            break;
+        case NO_CONSTANT_SPEED:  //非匀速状态
+            if (gyr_magnitude > FALLEN_GRY_MAG_THRESHOLD) {
+                tracker->state = FALLEN;  //摔倒
+            } else if (gyr_magnitude > WHEEL_GYR_MAG_THRESHOLD && acc_variance > WHEEL_ACC_VARIANCE_THRESHOLD) {
+                tracker->state = WHEEL;  //转弯
+            } else if (fabsf(acc_magnitude - G_ACCELERATION) < SKIING_ACC_MAG_THRESHOLD) {
+                tracker->state = CONSTANT_SPEED;  //匀速
+            }
+            break;
+
+        case CONSTANT_SPEED:  //匀速状态
+            if (fabsf(acc_magnitude - G_ACCELERATION) > START_SKIING_ACC_THRESHOLD) { 
+                tracker->state = NO_CONSTANT_SPEED;
+            }
+            //TODO：可以添加进入转弯或摔倒的判断
+            break;
+
+        case WHEEL:
+            // 从转弯状态，检查转弯是否结束
+            // 如果角速度和加速度方差都降下来了，就回到普通滑行状态
+            if (gyr_magnitude < WHEEL_GYR_MAG_THRESHOLD * 0.8f && acc_variance < WHEEL_ACC_VARIANCE_THRESHOLD * 0.8f) { // 乘以一个滞后系数避免抖动
+                tracker->state = NO_CONSTANT_SPEED;
+            }
+            break;
+
+        case FALLEN:
+            // TODO：回到 STATIC
+            break;
+    }
+#endif
+
 }
 
 
@@ -210,6 +321,8 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
     if (!tracker || !acc_g || !gyr_dps || !angle || dt <= 0) {
         return;
     }
+    if(my_skiing_tracker.state == STOP_DETECTION)
+        return;
 
     // --- 数据预处理和缓冲 ---
     float acc_device_ms2[3];
@@ -230,22 +343,20 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
     // --- 更新状态机 ---
     update_state_machine(tracker, acc_device_ms2, gyr_dps);
 
+    // 坐标转换 & 移除重力
+    transform_acc_to_world_frame(acc_device_ms2, angle, tracker->acc_world);
+    tracker->acc_world[2] -= G_ACCELERATION;
+
+    // 对世界坐标系下的加速度进行高通滤波，消除直流偏置和重力残差
+    for (int i = 0; i < 3; i++) {
+        tracker->acc_world_filtered[i] = HPF_ALPHA * (tracker->acc_world_filtered[i] + tracker->acc_world[i] - tracker->acc_world_unfiltered_prev[i]);
+        tracker->acc_world_unfiltered_prev[i] = tracker->acc_world[i];
+    }
+    // 应用加速度死区，忽略微小抖动和噪声
+    float acc_horizontal_mag = sqrtf(tracker->acc_world_filtered[0] * tracker->acc_world_filtered[0] +
+                                        tracker->acc_world_filtered[1] * tracker->acc_world_filtered[1]);
     // --- 根据状态进行计算 ---
-    if (tracker->state == SKIING_STATE_SKIING) {
-        // 坐标转换 & 移除重力
-        transform_acc_to_world_frame(acc_device_ms2, angle, tracker->acc_world);
-        tracker->acc_world[2] -= G_ACCELERATION;
-
-        // 对世界坐标系下的加速度进行高通滤波，消除直流偏置和重力残差
-        for (int i = 0; i < 3; i++) {
-            tracker->acc_world_filtered[i] = HPF_ALPHA * (tracker->acc_world_filtered[i] + tracker->acc_world[i] - tracker->acc_world_unfiltered_prev[i]);
-            tracker->acc_world_unfiltered_prev[i] = tracker->acc_world[i];
-        }
-
-        // 应用加速度死区，忽略微小抖动和噪声
-        float acc_horizontal_mag = sqrtf(tracker->acc_world_filtered[0] * tracker->acc_world_filtered[0] +
-                                         tracker->acc_world_filtered[1] * tracker->acc_world_filtered[1]);
-
+    if (tracker->state == NO_CONSTANT_SPEED) {
         if (acc_horizontal_mag > ACC_DEAD_ZONE_THRESHOLD) {
             // 只有当水平加速度足够大时，才进行速度积分
             tracker->velocity[0] += tracker->acc_world_filtered[0] * dt;
@@ -253,9 +364,26 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
             // 垂直方向的速度暂时不积分，极易受姿态误差影响而漂移
             // tracker->velocity[2] += tracker->acc_world_filtered[2] * dt;
         }
+        #ifdef XTELL_TEST
+        debug2.acc_magnitude = acc_horizontal_mag;
+        #endif
         // 如果加速度小于阈值，则不更新速度，相当于速度保持不变（或受下一步的阻尼影响而衰减）
+         
+        // --- 更新速率和距离 ---
+        // 只基于水平速度计算速率和距离
+        tracker->speed = sqrtf(tracker->velocity[0] * tracker->velocity[0] +
+                            tracker->velocity[1] * tracker->velocity[1]);
+        tracker->distance += tracker->speed * dt;
+        
 
-    } else {
+    }else if(tracker->state == CONSTANT_SPEED){ //匀速
+        #ifdef XTELL_TEST
+        debug2.acc_magnitude = acc_horizontal_mag;
+        #endif
+        //保持上次的速度不变。只更新距离
+        tracker->distance += tracker->speed * dt;
+        
+    }else{
         // 在静止或旋转状态下，速度已经在状态机内部被清零
         // 额外增加速度衰减，模拟摩擦力，进一步抑制漂移
         tracker->velocity[0] *= SPEED_ATTENUATION;
@@ -263,11 +391,7 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
         tracker->velocity[2] = 0; // 垂直速度强制归零
     }
 
-    // --- 更新速率和距离 ---
-    // 只基于水平速度计算速率和距离
-    tracker->speed = sqrtf(tracker->velocity[0] * tracker->velocity[0] +
-                           tracker->velocity[1] * tracker->velocity[1]);
-    tracker->distance += tracker->speed * dt;
+   
 }
 
 
@@ -280,7 +404,7 @@ void skiing_tracker_update(skiing_tracker_t *tracker, float *acc_g, float *gyr_d
   * @return BLE_send_data_t 
   */
 BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short * gyr_data_buf) {
-    static skiing_tracker_t my_skiing_tracker;
+    
     static int initialized = 0;
     static int calibration_done = 0;
 
@@ -289,12 +413,9 @@ BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short
     static float calibrated_acc_g[3];   // 转换后的加速度计数据
     static float calibrated_gyr_dps[3]; // 转换后的陀螺仪数据
 
-    const float delta_time = DELTA_TIME;
+    const float delta_time = DELTA_TIME + 0.03f;
     BLE_send_data_t BLE_send_data;
-    BLE_KS_send_data_t KS_data;
-
-
-
+    
     if (!initialized) {
         skiing_tracker_init(&my_skiing_tracker);
         initialized = 1;
@@ -330,13 +451,16 @@ BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short
 
         skiing_tracker_update(&my_skiing_tracker, calibrated_acc_g, calibrated_gyr_dps, final_angle_data, delta_time);
 
-        // 打印逻辑保持不变
         // static int count = 0;
         // if(count >= 10){
         //     printf("State: %d, Speed: %.2f m/s, Distance: %.2f m\n",
         //     my_skiing_tracker.state,
         //     my_skiing_tracker.speed,
         //     my_skiing_tracker.distance);
+        //     printf("calibrated_acc_g: %.2f, %.2f, %.2f\n",
+        //     calibrated_acc_g[0],
+        //     calibrated_acc_g[1],
+        //     calibrated_acc_g[2]);
         //     count = 0;
         // } else {
         //     count++;
@@ -350,7 +474,7 @@ BLE_send_data_t sensor_processing_task(signed short * acc_data_buf, signed short
             BLE_send_data.gyr_original[i] = (int)gyr_data_buf[i];
             #endif
             #if KS_BLE
-            KS_data.acc_KS_g[i] = (int)calibrated_acc_g[i];
+            KS_data.acc_KS[i] = (int)(calibrated_acc_g[i] * G_ACCELERATION * 100); //cm/s^s
             KS_data.gyr_KS_dps[i] = (int)calibrated_gyr_dps[i];
             KS_data.angle_KS[i] = (int)final_angle_data[i];
             #endif

apps/earphone/xtell_Sensor/calculate/skiing_tracker.h

@@ -4,11 +4,14 @@
 #include "../xtell.h"
 // 定义滑雪者可能的状态
 typedef enum {
-    SKIING_STATE_STATIC,        // 静止或动态稳定
-    SKIING_STATE_SKIING,        // 正在滑雪
-    SKIING_STATE_ROTATING,      // 正在原地旋转 (新增)
-    SKIING_STATE_FALLEN,        // 已摔倒
-    SKIING_STATE_UNKNOWN        // 未知状态
+    STATIC,                   // 静止或动态稳定
+    NO_CONSTANT_SPEED,        // 正在滑雪，非匀速
+    CONSTANT_SPEED,           // 正在滑雪，匀速
+    ROTATING,                 // 正在原地旋转
+    WHEEL,                    // 转弯
+    FALLEN,                   // 已摔倒
+    STOP_DETECTION,           // 停止检测
+    UNKNOWN                   // 未知状态
 } skiing_state_t;
 
 #define VARIANCE_BUFFER_SIZE 5 // 用于计算方差的数据窗口大小 (5个样本 @ 100Hz = 50ms)，减小延迟，提高实时性
@@ -51,11 +54,19 @@ typedef struct __attribute__((packed)){   //该结构体取消内存对齐
 }BLE_send_data_t;
 
 typedef struct{
-    int acc_KS_g[3];      //卡尔曼后，LSB to g 三轴加速度数据
+    int acc_KS[3];      //卡尔曼后，LSB转换后的  三轴加速度数据（cm/s^2）
     int gyr_KS_dps[3];    //卡尔曼后，LSB to dps 三轴陀螺仪数据
     int angle_KS[3];      //卡尔曼后，计算得到的欧若拉角数据
 }BLE_KS_send_data_t;
 
+#ifdef XTELL_TEST
+typedef struct{
+    float acc_variance;   //三轴加速度方差之和
+    float gyr_variance;   //三轴陀螺仪方差之和
+    float acc_magnitude;  //三轴加速度模长
+    float gyr_magnitude;  //三轴陀螺仪模长
+}debug_t;
+#endif
 /**
  * @brief 初始化滑雪追踪器
  *

apps/earphone/xtell_Sensor/send_data.c

@@ -137,16 +137,114 @@ void ble_send_data(signed short *acc_gyro_input, float *Angle_output){
     send_data_to_ble_client(&buffer,len);
 }
 
+
 // 从环形缓冲区读取数据并发送
 void send_sensor_data_task(void) {
     // printf("xtell_ble_send\n");
 }
 
+#ifdef XTELL_TEST
 void test(){
     signed short acc_data_buf[3] = {0};
     signed short gyr_data_buf[3] = {0};
     signed short acc_gyro_input[6] = {0};
     float Angle_output[3] = {0};
+    // xlog("============start\n");
+
+    SL_SC7U22_RawData_Read(acc_data_buf,gyr_data_buf);
+
+    BLE_send_data = sensor_processing_task(acc_data_buf, gyr_data_buf);
+    u8 data[50];
+    data[0] = 0xBB;
+    data[1] = 0xBE;
+    data[2] = 0x01;
+    data[3] = sizeof(BLE_send_data_t); //后续包的数据长度
+    // send_data_to_ble_client(&data,sizeof(BLE_send_data_t)+4);
+    memcpy(&data[4], &BLE_send_data, sizeof(BLE_send_data_t));
+
+    static int count = 0;
+    if(count >=10){ 
+        count = 0;
+        
+        char* division = "==========\n";
+        send_data_to_ble_client(division,strlen(division));
+
+        char log_buffer[100]; // 100个字符应该足够了
+
+        // 使用 snprintf 进行格式化
+        int num_chars_written = snprintf(
+            log_buffer,                      // 目标缓冲区
+            sizeof(log_buffer),              // 目标缓冲区的最大容量
+            "s %d, %dcm/s, %dcm\n", // 格式化字符串
+            BLE_send_data.skiing_state,      // 第一个 %d 的参数
+            BLE_send_data.speed_cms,         // 第二个 %d 的参数
+            BLE_send_data.distance_cm        // 第三个 %d 的参数
+        );
+        send_data_to_ble_client(&log_buffer,strlen(log_buffer));
+
+        extern BLE_KS_send_data_t KS_data;
+        memset(&log_buffer, 0, 100);
+        num_chars_written = snprintf(
+            log_buffer,                      
+            sizeof(log_buffer),              
+            "Acc:%d, %d, %d\n", 
+            KS_data.acc_KS[0],KS_data.acc_KS[1],KS_data.acc_KS[2]       
+        );  // cm/s^2      
+        send_data_to_ble_client(&log_buffer,strlen(log_buffer));
+
+        memset(&log_buffer, 0, 100);
+        num_chars_written = snprintf(
+            log_buffer,                      
+            sizeof(log_buffer),              
+            "Gyr_dps:%d, %d, %d\n", 
+            KS_data.gyr_KS_dps[0],      
+            KS_data.gyr_KS_dps[1],      
+            KS_data.gyr_KS_dps[2]       
+        );
+        send_data_to_ble_client(&log_buffer,strlen(log_buffer));
+
+        memset(&log_buffer, 0, 100);
+        num_chars_written = snprintf(
+            log_buffer,                      
+            sizeof(log_buffer),              
+            "angle: %d, %d, %d\n", 
+            KS_data.angle_KS[0],      
+            KS_data.angle_KS[1],      
+            KS_data.angle_KS[2]       
+        );
+        send_data_to_ble_client(&log_buffer,strlen(log_buffer));
+
+        extern debug_t debug1;
+        extern debug_t debug2;
+        memset(&log_buffer, 0, 100);
+        num_chars_written = snprintf(
+            log_buffer,                      
+            sizeof(log_buffer),              
+            "debug:%.2f,%.2f,%.2f(%.2f),%.2f\n", 
+            debug1.acc_variance, 
+            debug1.gyr_variance, 
+            debug1.acc_magnitude,
+            debug2.acc_magnitude,   //滤波后的加速度
+            debug1.gyr_magnitude  
+        );
+        send_data_to_ble_client(&log_buffer,strlen(log_buffer));
+        
+    xlog("Call interval\n");
+    }
+    count++;
+
+    memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
+    memset(&data, 0, 50);
+    // xlog("end============\n");
+
+}
+#else
+
+void BLE_send_data(){
+    signed short acc_data_buf[3] = {0};
+    signed short gyr_data_buf[3] = {0};
+    signed short acc_gyro_input[6] = {0};
+    float Angle_output[3] = {0};
 
     SL_SC7U22_RawData_Read(acc_data_buf,gyr_data_buf);
 
@@ -162,41 +260,15 @@ void test(){
     static int count = 0;
     if(count >=10){ 
         count = 0;
-        #ifdef XTELL_TEST
-        xlog("BLE_send_data_t:%d\n",sizeof(BLE_send_data_t));
-        xlog("ACC_X:%d, ACC_Y:%d, ACC_Z:%d, GYR_X:%.d, GYR_Y:%d, GYR_Z:%d", 
-            acc_data_buf[0],acc_data_buf[1],acc_data_buf[2],gyr_data_buf[0],gyr_data_buf[1],gyr_data_buf[2]
-            );
-        printf("State: %d, Speed: %d cm/s, Distance: %d cm\n",
-            BLE_send_data.skiing_state,
-            BLE_send_data.speed_cms,
-            BLE_send_data.distance_cm);
-
-        char log_buffer[100]; // 100个字符应该足够了
-
-        // 使用 snprintf 进行格式化
-        int num_chars_written = snprintf(
-            log_buffer,                      // 目标缓冲区
-            sizeof(log_buffer),              // 目标缓冲区的最大容量
-            "State: %d, Speed: %d cm/s, Distance: %d cm\n", // 格式化字符串
-            BLE_send_data.skiing_state,      // 第一个 %d 的参数
-            BLE_send_data.speed_cms,         // 第二个 %d 的参数
-            BLE_send_data.distance_cm        // 第三个 %d 的参数
-        );
-        send_data_to_ble_client(&log_buffer,strlen(log_buffer));
-        // xlog("Pitch:%.2f, Roll:%.2f, Yaw:%.2f\n",
-            // Angle_output[0],Angle_output[1],Angle_output[2]
-            // );
-        #else
         send_data_to_ble_client(&data,sizeof(BLE_send_data_t)+4);
-        #endif
     }
     count++;
 
     memset(&BLE_send_data, 0, sizeof(BLE_send_data_t));
     memset(&data, 0, 50);
-
 }
+#endif
+
 void gsensor_test(){
 
     sys_timer_del(gsensor_id);
@@ -231,5 +303,9 @@ void xtell_task_create(void){
 
     // create_process(&gsensor_id, "gsensor",NULL, gsensor_test, 1000);
     create_process(&test_id, "test",NULL, test, (int)(DELTA_TIME*1000));
+    // while(1){
+    //     test();
+    //     os_time_dly((int)(DELTA_TIME*1000));
+    // }
     
 }

apps/earphone/xtell_Sensor/xtell.h

@@ -1,7 +1,7 @@
 #ifndef XTELL_H
 #define XTELL_H
 
-#define KS_BLE 0
+#define KS_BLE 1
 #define XTELL_TEST 1
 
 

apps/earphone/xtell_Sensor/xtell_handler.c

@@ -44,7 +44,7 @@
 #include "bt_background.h"
 #include "default_event_handler.h"
 #include "debug.h"
-
+#include "system/event.h"
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //宏定义
 #define LOG_TAG_CONST       EARPHONE
@@ -171,6 +171,69 @@ static int state_machine(struct application *app, enum app_state state, struct i
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //handle
 
+
+void le_user_app_send_event(size_t command, unsigned char* data, size_t size)
+{
+    // 中断->事件
+    static unsigned char buffer[512];
+    if(data && size && size <= sizeof(buffer)) {
+        // 拷贝到缓存，避免转发事件的时候，地址发送改变。
+        memcpy(buffer, data, size);
+        struct sys_event event;
+        event.type = SYS_APP_USER_EVENT;
+        event.u.app.command = command;
+        event.u.app.buffer = buffer;
+        event.u.app.size = size;
+        sys_event_notify(&event);
+    }
+}
+
+void le_user_app_event_handler(struct sys_event* event){
+
+    switch (event->type) {
+        // 打印接收到的数据
+        printf("BLE data\n");
+        put_buf(event->u.app.buffer, event->u.app.size);
+        case SYS_APP_USER_EVENT:
+            if (event->u.app.buffer[0] == 0xBE && event->u.app.buffer[1] == 0xBB) {
+                if(event->u.app.buffer[2] == 0x01){      //后面的数据长度 1
+                    switch (event->u.app.buffer[3]){
+                        case 0x01:
+                            extern void start_detection(void);
+                            start_detection();
+                            char* send_tmp = "start_detection\n";
+                            send_data_to_ble_client(send_tmp,strlen(send_tmp));
+                            break;
+                        case 0x02:
+                            extern void stop_detection(void);
+                            stop_detection();
+                            send_tmp = "stop_detection\n";
+                            send_data_to_ble_client(send_tmp,strlen(send_tmp));
+                            break;
+                        case 0x03:
+                            extern void clear_speed(void);
+                            clear_speed();
+                            send_tmp = "Reset speed and distances to zero\n";
+                            send_data_to_ble_client(send_tmp,strlen(send_tmp));
+                            
+                            break;
+                        default:
+                            break;
+                        
+                    }
+                }
+            }
+        break;
+
+        default:
+        xlog("%d\n",event->type);
+        break;
+    }
+
+
+}
+
+
 static void play_poweron_ok_timer(void *priv)
 {
     app_var.wait_timer_do = 0;
@@ -355,9 +418,11 @@ static int bt_connction_status_event_handler(struct bt_event *bt)
 }
 
 
-
 static int event_handler(struct application *app, struct sys_event *event)
 {
+
+    le_user_app_event_handler(event);
+
     if (SYS_EVENT_REMAP(event)) {
         g_printf("****SYS_EVENT_REMAP**** \n");
         return 0;

cpu/br28/tools/sdk.elf.resolution.txt

@@ -1926,6 +1926,7 @@ objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_mod
 -r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,little_endian_read_16,l
 -r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,att_get_ccc_config,l
 -r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,att_set_ccc_config,l
+-r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,le_user_app_send_event,l
 -r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,putchar,l
 -r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,set_app_connect_type,l
 -r=objs/apps/common/third_party_profile/jieli/JL_rcsp/bt_trans_data/le_rcsp_adv_module.c.o,JL_rcsp_auth_reset,l
@@ -6286,6 +6287,13 @@ objs/apps/earphone/xtell_Sensor/xtell_app_main.c.o
 -r=objs/apps/earphone/xtell_Sensor/xtell_app_main.c.o,app_var,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_app_main.c.o,config_update_mode,l
 objs/apps/earphone/xtell_Sensor/xtell_handler.c.o
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,le_user_app_send_event,pl
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,sys_event_notify,l
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,le_user_app_event_handler,pl
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,start_detection,l
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,send_data_to_ble_client,l
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,stop_detection,l
+-r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,clear_speed,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,printf,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,clk_set,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,clk_get,l
@@ -6317,7 +6325,6 @@ objs/apps/earphone/xtell_Sensor/xtell_handler.c.o
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,sys_timeout_add,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,clear_current_poweron_memory_search_index,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,strcmp,l
--r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,send_data_to_ble_client,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,earphone_change_pwr_mode,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,ui_update_status,l
 -r=objs/apps/earphone/xtell_Sensor/xtell_handler.c.o,tone_get_status,l
@@ -6342,9 +6349,9 @@ objs/apps/earphone/xtell_Sensor/send_data.c.o
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,test,pl
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,SL_SC7U22_RawData_Read,l
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,sensor_processing_task,l
--r=objs/apps/earphone/xtell_Sensor/send_data.c.o,printf,l
--r=objs/apps/earphone/xtell_Sensor/send_data.c.o,snprintf,l
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,strlen,l
+-r=objs/apps/earphone/xtell_Sensor/send_data.c.o,snprintf,l
+-r=objs/apps/earphone/xtell_Sensor/send_data.c.o,printf,l
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,gsensor_test,pl
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,sys_timer_del,l
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,xtell_task_create,pl
@@ -6358,6 +6365,9 @@ objs/apps/earphone/xtell_Sensor/send_data.c.o
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,gsensor_id,pl
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,test_id,pl
 -r=objs/apps/earphone/xtell_Sensor/send_data.c.o,BLE_send_data,pl
+-r=objs/apps/earphone/xtell_Sensor/send_data.c.o,KS_data,l
+-r=objs/apps/earphone/xtell_Sensor/send_data.c.o,debug1,l
+-r=objs/apps/earphone/xtell_Sensor/send_data.c.o,debug2,l
 objs/apps/earphone/xtell_Sensor/buffer/circle_buffer.c.o
 -r=objs/apps/earphone/xtell_Sensor/buffer/circle_buffer.c.o,circle_buffer_init,pl
 -r=objs/apps/earphone/xtell_Sensor/buffer/circle_buffer.c.o,circle_buffer_write,pl
@@ -6439,6 +6449,9 @@ objs/apps/earphone/xtell_Sensor/sensor/SC7U22.c.o
 -r=objs/apps/earphone/xtell_Sensor/sensor/SC7U22.c.o,Error_Accgyro,pl
 -r=objs/apps/earphone/xtell_Sensor/sensor/SC7U22.c.o,Sum_Avg_Accgyro,pl
 objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o
+-r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,clear_speed,pl
+-r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,start_detection,pl
+-r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,stop_detection,pl
 -r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,skiing_tracker_init,pl
 -r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,skiing_tracker_update,pl
 -r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,sqrtf,l
@@ -6448,6 +6461,9 @@ objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o
 -r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,cosf,l
 -r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,sinf,l
 -r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,puts,l
+-r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,debug2,pl
+-r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,KS_data,pl
+-r=objs/apps/earphone/xtell_Sensor/calculate/skiing_tracker.c.o,debug1,pl
 cpu/br28/liba/cpu.a.llvm.19376.crc16.c
 -r=cpu/br28/liba/cpu.a.llvm.19376.crc16.c,__crc16_mutex_init,pl
 -r=cpu/br28/liba/cpu.a.llvm.19376.crc16.c,os_mutex_create,l

include_lib/system/event.h

@@ -54,8 +54,7 @@
 #define SYS_TOUCHPAD_EVENT      0x0400
 #define SYS_ADT_EVENT           0x0800
 #define SYS_AUD_EVENT           0x1000
-
-
+#define SYS_APP_USER_EVENT           0x1000
 
 
 #define DEVICE_EVENT_FROM_AT_UART      (('A' << 24) | ('T' << 16) | ('U' << 8) | '\0')
@@ -271,6 +270,12 @@ struct touchpad_event {
     s8 y;
 };
 
+struct app_user_event {
+    unsigned char* buffer;
+    size_t command;
+    size_t size;
+};
+
 struct sys_event {
     u16 type;
     u8 consumed;
@@ -302,6 +307,7 @@ struct sys_event {
         struct matrix_key_event  matrix_key;
         struct touchpad_event touchpad;
         struct adt_event    adt;
+        struct app_user_event    app;
     } u;
 };