From: Caisking <Casiking@zhihuishixun.com>
Date: Thu, 9 Oct 2025 09:33:39 +0000 (+0800)
Subject: 修复app无法读取gps轨迹的问题
X-Git-Tag: V1.0.9_20251128_194606_LN~274^2~1
X-Git-Url: http://git.snicker.com.cn/?a=commitdiff_plain;h=dc4940a2bc844ea660dc0b3208d45e5d9a8d408e;p=mirrors%2FFD230.git

修复app无法读取gps轨迹的问题
---

diff --git a/code/sdk/application/wearable/n9/nativeapp/nativeui/traing/src/TraingModel.cpp b/code/sdk/application/wearable/n9/nativeapp/nativeui/traing/src/TraingModel.cpp
index 388b4a2ad..30f0b26d7 100644
--- a/code/sdk/application/wearable/n9/nativeapp/nativeui/traing/src/TraingModel.cpp
+++ b/code/sdk/application/wearable/n9/nativeapp/nativeui/traing/src/TraingModel.cpp
@@ -2849,26 +2849,48 @@ void TraingModel::GetPointData() {
 // 添加经纬度数据集
 void TraingModel::AddGPSData(uint32_t timestamp, double latitude,
                              double longitude) {
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== AddGPSData函数调用开始 ===");
+  WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "输入参数: timestamp=%u, latitude=%.6f, longitude=%.6f", 
+                timestamp, latitude, longitude);
+                WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "当前GPS数据点数量: %zu", gpsData.size());
+  
   // 判断数据是否合理
   if (latitude < -90 || latitude > 90 || longitude < -180 || longitude > 180) {
     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                  "Invalid GPS data: lat=%.6f, lon=%.6f", latitude, longitude);
+                  "错误: GPS数据无效 - 纬度=%.6f (范围: -90~90), 经度=%.6f (范围: -180~180)", 
+                  latitude, longitude);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== AddGPSData函数调用结束(数据无效) ===");
     return;
   }
+  WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "GPS数据有效性检查通过");
 
   // 校验时间戳是否递增
   if (!gpsData.empty() && timestamp <= gpsData.back().timestamp) {
     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                  "Timestamp not increasing: current=%u, last=%u", timestamp,
-                  gpsData.back().timestamp);
+                  "错误: 时间戳未递增 - 当前=%u, 上一个=%u, 差值=%d", 
+                  timestamp, gpsData.back().timestamp, 
+                  (int)timestamp - (int)gpsData.back().timestamp);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== AddGPSData函数调用结束(时间戳错误) ===");
     return;
   }
+  WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "时间戳递增检查通过");
 
   // 添加数据
+  WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "准备添加GPS数据到容器...");
   gpsData.push_back({timestamp, latitude, longitude});
-  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                "Added GPS data #%zu: ts=%u, (%.6f, %.6f)", gpsData.size(),
-                timestamp, latitude, longitude);
+  WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,
+                "成功添加GPS数据 #%zu: 时间戳=%u, 坐标=(%.6f, %.6f)", 
+                gpsData.size(), timestamp, latitude, longitude);
+  
+  // 打印当前GPS数据统计信息
+  if (gpsData.size() > 1) {
+    double lat_diff = latitude - gpsData[gpsData.size()-2].latitude;
+    double lon_diff = longitude - gpsData[gpsData.size()-2].longitude;
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "与上一个点的距离差: 纬度差=%.6f, 经度差=%.6f", 
+                  lat_diff, lon_diff);
+  }
+  
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== AddGPSData函数调用结束 ===");
 }
 
 //保存canvas数据
@@ -3034,40 +3056,85 @@ std::string TraingModel::GetGPSDataPath(uint32_t timestamp) {
 bool TraingModel::GetGPSConnectState() { return gpsconnect; }
 //设置GPS连接状态
 void TraingModel::SetGPSConnectState(bool state) {
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS连接状态设置 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前GPS连接状态: %d, 新状态: %d", gpsconnect, state);
+  
   if (gpsconnect != state) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS连接状态发生变化: %d -> %d", gpsconnect, state);
     gpsconnect = state;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS连接状态已更新为: %d", gpsconnect);
+    
     //状态改变记录
     // SystemLogModel::GetInstance()->save_gps_status_log_type(gpsconnect);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS状态变化记录完成");
+  } else {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS连接状态未发生变化，保持: %d", gpsconnect);
   }
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS连接状态设置完成 ===");
 }
 //运动心率、gps开启准备
 void TraingModel::start_heart_gps() {
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS启动流程开始 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前GPS状态: gpsopen=%d", gpsopen);
+  
   if (gpsopen == false) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开始启动GPS定位服务...");
+    
     // 开启gps
 #if defined(SUPPORT_GNSS)
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "调用gnss_start()启动GPS服务");
     gnss_start();
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gnss_start()调用完成");
+#else
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "警告: SUPPORT_GNSS未定义，GPS服务不可用");
 #endif
+    
     //开启心率检测
 #ifdef SUPPORT_PPG_SERVICE
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "启动心率检测服务");
     ppg_hr_start();
+#else
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SUPPORT_PPG_SERVICE未定义，跳过心率检测");
 #endif
+    
     gpsopen = true;
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开启gps定位");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定位服务启动完成，gpsopen设置为true");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS启动流程结束 ===");
+  } else {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS已经处于开启状态，跳过启动流程");
   }
 }
 //运动心率、gps关闭
 void TraingModel::stop_heart_gps() {
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS关闭流程开始 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前GPS状态: gpsopen=%d", gpsopen);
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前GPS数据点数量: %zu", gpsData.size());
+  
   if (gpsopen == true) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开始关闭GPS定位服务...");
+    
     // 关闭gps
 #if defined(SUPPORT_GNSS)
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "调用gnss_stop()关闭GPS服务");
     gnss_stop();
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gnss_stop()调用完成");
+#else
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "警告: SUPPORT_GNSS未定义，GPS服务不可用");
 #endif
+    
     //关闭心率检测
 #ifdef SUPPORT_PPG_SERVICE
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "关闭心率检测服务");
     ppg_hr_stop();
+#else
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SUPPORT_PPG_SERVICE未定义，跳过心率检测关闭");
 #endif
+    
     gpsopen = false;
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "关闭gps定位");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定位服务关闭完成，gpsopen设置为false");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS关闭流程结束 ===");
+  } else {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS已经处于关闭状态，跳过关闭流程");
   }
 }
 
@@ -3086,39 +3153,66 @@ static void gnss_timer_callbackProc(int data) {
   /*
       GPS数据获取处理
   */
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器回调开始 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "定时器数据: %d", data);
+  
 #if defined(SUPPORT_GNSS)
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开始获取GPS全局数据...");
   gps_data_t send_gps_data = {0};
   gps_data_t *gps_data = getPGPSGlobaldata();
 
   if (gps_data == NULL) {
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gps_data == NULL");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: gps_data == NULL，GPS全局数据获取失败");
     return;
   }
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS全局数据获取成功");
 
   // 判断是否为第一次定位并复制GPS数据
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检查GPS时间戳: last_gps_time_ms=%llu", gps_data->last_gps_time_ms);
   if (gps_data->last_gps_time_ms > 0) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS时间戳有效，复制GPS数据");
     memcpy_s(&send_gps_data, sizeof(gps_data_t), gps_data, sizeof(gps_data_t));
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS数据复制完成，状态=%d, 纬度=%.6f, 经度=%.6f", 
+                  send_gps_data.status, send_gps_data.location.lat, send_gps_data.location.lng);
   } else {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS时间戳无效，跳过本次处理");
     return;
   }
 
   // 判断是否定位成功并设置连接状态
   bool isGpsConnected = (send_gps_data.status > 1);
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS连接状态检查: status=%d, isGpsConnected=%d", 
+                send_gps_data.status, isGpsConnected);
   TraingModel::GetInstance()->SetGPSConnectState(isGpsConnected);
 
   // 判断是否在运动或训练已结束
-  if (uapi_dev_runtime_get_train_status() == 0 ||
-      TraingModel::GetInstance()->GetSportState() == ExerciseState::End) {
+  int train_status = uapi_dev_runtime_get_train_status();
+  ExerciseState sport_state = TraingModel::GetInstance()->GetSportState();
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "运动状态检查: train_status=%d, sport_state=%d", 
+                train_status, (int)sport_state);
+  
+  if (train_status == 0 || sport_state == ExerciseState::End) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "运动已结束或未开始，跳过GPS数据添加");
     return;
   }
 
   // 如果定位成功，添加经纬度数据
   if (isGpsConnected) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定位成功，准备添加轨迹数据");
     uint32_t time = TraingModel::GetInstance()->get_current_time();
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前时间戳: %u", time);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "添加GPS数据: 纬度=%.6f, 经度=%.6f", 
+                  send_gps_data.location.lat, send_gps_data.location.lng);
     TraingModel::GetInstance()->AddGPSData(time, send_gps_data.location.lat,
                                            send_gps_data.location.lng);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS数据添加完成");
+  } else {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定位失败，跳过数据添加");
   }
+#else
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "警告: SUPPORT_GNSS未定义，GPS功能不可用");
 #endif
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器回调结束 ===");
 }
 
 /*
@@ -3135,59 +3229,87 @@ static void gnss_timer_callback(int data) {
  *  @param interval 时间间隔，单位ms
  */
 void TraingModel::gnss_start_timer(uint32_t interval) {
-  WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "TraingModel::gnss_start_timer");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器启动流程开始 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "定时器间隔: %u ms", interval);
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前定时器状态: %p", g_location_timer);
+  
   /* -------------------------- 1.检查位置服务定时器是否已经存在，如果存在则返回
    * ------------------------- */
   if (g_location_timer != nullptr) {
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Location Timer already exists!!");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: GPS定时器已存在，跳过创建");
     return;
   }
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器不存在，开始创建...");
 
   /* --------------------------------- 2.创建位置服务定时器
    * -------------------------------- */
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "调用osTimerNew创建GPS定时器...");
   g_location_timer = osTimerNew((osTimerFunc_t)gnss_timer_callback,
                                 osTimerPeriodic, nullptr, nullptr);
   // 检查定时器创建是否成功
   if (g_location_timer == nullptr) {
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Location Timer create failed!!");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: GPS定时器创建失败!!");
     return;
   }
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器创建成功: %p", g_location_timer);
 
   /* ----------------------------- 3.将毫秒转换为系统时钟节拍数
    * ---------------------------- */
   int tick = osMs2Tick(interval);
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "时间转换: %u ms -> %d ticks", interval, tick);
 
   /* --------------------------------- 4.启动位置服务定时器
    * -------------------------------- */
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "启动GPS定时器...");
   osStatus_t ret = osTimerStart(g_location_timer, tick);
   /* -------------------- 5.检查位置服务定时器启动是否成功,如果启动失败，删除定时器并置为
    * nullptr -------------------- */
   if (ret != osOK) {
     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                  "Location Timer start failed, ret = %lx!!", ret);
+                  "错误: GPS定时器启动失败, ret = %lx!!", ret);
     if (g_location_timer != nullptr) {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "删除失败的GPS定时器...");
       ret = osTimerDelete(g_location_timer);
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器删除结果: %lx", ret);
     }
     g_location_timer = nullptr;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器启动流程结束(失败) ===");
     return;
   }
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器启动成功");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器启动流程结束(成功) ===");
 }
 
 /*
  * @brief 停止位置服务定时器
  */
 void TraingModel::gnss_stop_timer(void) {
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器停止流程开始 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "当前定时器状态: %p", g_location_timer);
+  
   // 检查位置服务定时器是否存在
   if (g_location_timer != nullptr) {
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TraingModel::gnss_stop_timer");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器存在，开始停止流程...");
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "停止GPS定时器...");
     osTimerStop(g_location_timer);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器已停止");
+    
     // 删除定时器并置为 nullptr
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "删除GPS定时器...");
     osStatus_t ret = osTimerDelete(g_location_timer);
     if (ret != osOK) {
       WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                    "Location Timer delete failed, ret = %lx!!", ret);
+                    "错误: GPS定时器删除失败, ret = %lx!!", ret);
+    } else {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器删除成功");
     }
     g_location_timer = nullptr;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器指针已置空");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器停止流程结束 ===");
+  } else {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS定时器不存在，跳过停止流程");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== GPS定时器停止流程结束(无需停止) ===");
   }
 }
 
@@ -3358,13 +3480,22 @@ bool get_training_heart_path_(char *path, uint32_t time, uint32_t max_len) {
 
 //获取gps轨迹路径
 bool get_training_gps_path_(char *path, uint32_t time, uint32_t max_len) {
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== 获取GPS轨迹路径开始 ===");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "请求时间戳: %u, 最大路径长度: %u", time, max_len);
+  
   std::string str = OHOS::TraingModel::GetInstance()->GetGPSDataPath(time);
-  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "get_training_gps:%s\r\n",
-                str.c_str());
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "获取到的GPS路径: %s", str.c_str());
+  
   if (str.length() <= 3) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: GPS路径长度不足，长度: %zu", str.length());
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== 获取GPS轨迹路径结束(失败) ===");
     return false;
   }
+  
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS路径长度: %zu", str.length());
   memcpy_s(path, max_len, str.c_str(), str.length());
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS路径复制完成");
+  WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== 获取GPS轨迹路径结束(成功) ===");
   return true;
 }
 
@@ -3422,6 +3553,69 @@ char *struct_to_json_buf_malloc_(uint8_t day) {
   return json_format;
 }
 
+int read_gps_data_(char *path ,uint8_t *out_buf)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== 读取GPS数据开始 ===");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件路径: %s", path);
+    
+    FILE *fp= fopen(path,"rb+");
+    if(fp==NULL)
+    {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: 无法打开GPS文件");
+        return 0;
+    }
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件打开成功");
+    
+    uint32_t file_size=0;
+    fseek(fp, 0, SEEK_END);
+    file_size = ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件大小: %u 字节", file_size);
+
+    int len=0;
+    int point_count = 0;
+    OHOS::GPSData_t data={0};
+
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开始读取GPS轨迹点...");
+    while (1)
+    {
+        int read_size=fread(&data,1,sizeof(data),fp);
+        if(read_size==sizeof(data) )
+        {
+            point_count++;
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "读取GPS点 #%d: 时间戳=%u, 纬度=%.6f, 经度=%.6f", 
+                          point_count, data.timestamp, data.latitude, data.longitude);
+
+            int temp_data=data.timestamp;
+            memcpy_s(out_buf+len,4,&temp_data,sizeof(data.timestamp));
+            len+=4;
+
+            int temp_latitude=(int)(data.latitude *10000000);
+            memcpy_s(out_buf+len,4,&temp_latitude,sizeof(temp_latitude));
+            len+=4;
+
+            int temp_longitude=(int)(data.longitude*10000000);
+            memcpy_s(out_buf+len,4,&temp_longitude,sizeof(temp_longitude));
+            len+=4;
+            
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS点数据转换: 时间戳=%u, 纬度=%d, 经度=%d", 
+                          temp_data, temp_latitude, temp_longitude);
+        }
+        else 
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件读取结束，读取大小: %d", read_size);
+            break;
+        }
+    }
+
+    fclose(fp);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件关闭");
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "总共读取 %d 个GPS点，输出数据长度: %d 字节", point_count, len);
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== 读取GPS数据结束 ===");
+
+   return len;
+}
+
 extern bleInstruct_t_ bleInstruct_t;
 
 void ble_training_init(void) {
@@ -3429,6 +3623,7 @@ void ble_training_init(void) {
   bleInstruct_t.get_training_heart_path_cb = get_training_heart_path_;
   bleInstruct_t.get_training_gps_path_cb = get_training_gps_path_;
   bleInstruct_t.struct_to_json_buf_malloc = struct_to_json_buf_malloc_;
+  bleInstruct_t.read_gps_data_cb = read_gps_data_;
 }
 
 #ifdef __cplusplus
diff --git a/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.cpp b/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.cpp
index 0a187391f..de50f3799 100644
--- a/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.cpp
+++ b/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.cpp
@@ -111,9 +111,9 @@ uint8_t get_dial_num()
     return SAFE_CALL_PTR_NO_ARGS(bleInstruct_t.get_dial_num_cb);
 }
 
-int  read_GPS_DATA(char *path ,uint8_t *out_buf)
+int  read_gps_data(char *path ,uint8_t *out_buf)
 {
-    return SAFE_CALL_PTR(bleInstruct_t.read_GPS_DATA_cb, path, out_buf);
+    return SAFE_CALL_PTR(bleInstruct_t.read_gps_data_cb, path, out_buf);
 }
 
 bool ble_is_Alipay_bind(void)
diff --git a/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.h b/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.h
index 33729065b..a50b1d39e 100644
--- a/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.h
+++ b/code/sdk/zhihui/services/ble_service/blemoder/bleInstruct.h
@@ -408,13 +408,13 @@ errcode_t get_dial_file_path(char* input_dialname ,uint32_t input_size, char* ou
 
 uint16_t get_str_nodisplay_number(char *str, uint32_t max_len);
 
-int  read_GPS_DATA(char *path ,uint8_t *out_buf);
+int  read_gps_data(char *path ,uint8_t *out_buf);
 
 bool ble_bin_install(const char * data);
 typedef struct bleInstruct
 {
     uint16_t (*get_str_nodisplay_number_cb)(char *str, uint32_t max_len);
-    int  (*read_GPS_DATA_cb)(char *path ,uint8_t *out_buf);
+    int  (*read_gps_data_cb)(char *path ,uint8_t *out_buf);
     
     uint8_t (*get_dial_num_cb)(void);
     void (*set_ota_upgrade_cb)(void);
diff --git a/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c b/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c
index 83d602f80..9a1bf83ca 100644
--- a/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c
+++ b/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c
@@ -3673,34 +3673,51 @@ void GetGPSCmd(uint16_t cmd,uint8_t *data,uint16_t len,uint8_t *totalData,uint8_
      {
     if(Check_CRC(data,len,crcvalue))
 	{
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CRC校验通过");
         if(len==4)
         {
             uint32_t timetamp=0;
             memcpy_s((void*)&timetamp,4,data,4);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "请求GPS数据时间戳: %u", timetamp);
+            
             char path[128]={0};
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "获取GPS文件路径...");
             if(get_training_gps_path(path,timetamp,128))
             {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件路径: %s", path);
+                
                 FILE *fp= fopen(path,"rb+");
                 uint32_t file_size=0;
                 if(fp==NULL)
                 {
-                    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"打开文件失败 %s \r\n",path);
+                    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: 打开GPS文件失败 %s", path);
                     ble_data_type type_={0x02,0x4f,0,1,1};
                     send_big_data(type_,NULL,0);
+                    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "发送空GPS数据包");
                     return ;
                 }
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件打开成功");
+                
                 fseek(fp, 0, SEEK_END); // 将文件指针移动到文件末尾
                 file_size = ftell(fp);       // 获取当前文件指针位置，即文件大小
                 fseek(fp, 0, SEEK_SET); // 将文件指针移回文件开头
                 fclose(fp);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS文件大小: %u 字节", file_size);
 
                 int num=(ble_nus_max_data_len-18);
                 if(num>482)num=482;
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BLE数据包大小限制: %d", num);
 
                 char* buf = (char *)ym_malloc( file_size );
-                if(buf==NULL){fclose(fp); return ;}
+                if(buf==NULL){
+                    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: 内存分配失败");
+                    return ;
+                }
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "内存分配成功: %u 字节", file_size);
 
-                int data_size= read_GPS_DATA(path,buf);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开始读取GPS数据...");
+                int data_size= read_gps_data(path,buf);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS数据读取完成，数据大小: %d 字节", data_size);
             
                 uint32_t surplus_len=data_size;
                 uint32_t offset=0;
@@ -3708,6 +3725,7 @@ void GetGPSCmd(uint16_t cmd,uint8_t *data,uint16_t len,uint8_t *totalData,uint8_
                 uint32_t pack;
                 uint16_t pack_size=(ble_nus_max_data_len-18);
                 if(pack_size>482)pack_size=482;
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "数据分包大小: %d 字节", pack_size);
 
                 if(data_size%pack_size==0)
                 {
@@ -3717,11 +3735,16 @@ void GetGPSCmd(uint16_t cmd,uint8_t *data,uint16_t len,uint8_t *totalData,uint8_
                 {   
                     pack=data_size/pack_size+1;
                 }
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "总数据包数: %u", pack);
+                
                 uint32_t pack_id=1;
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "开始发送GPS数据包...");
                 while (surplus_len!=0)
                 {
                     if(surplus_len>=pack_size)
                     {
+                        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "发送数据包 %u/%u, 大小: %d, 偏移: %u", 
+                                      pack_id, pack, pack_size, offset);
                         surplus_len=surplus_len-pack_size;
 
                         ble_data_type type_={0x02,0x4f,data_size,pack,pack_id};
@@ -3730,37 +3753,46 @@ void GetGPSCmd(uint16_t cmd,uint8_t *data,uint16_t len,uint8_t *totalData,uint8_
                     }
                     else
                     {
-                    
+                        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "发送最后数据包 %u/%u, 大小: %u, 偏移: %u", 
+                                      pack_id, pack, surplus_len, offset);
                         ble_data_type type_={0x02,0x4f,data_size,pack,pack_id};
                         send_big_data(type_,(char *)buf+offset,surplus_len);
                         break;
                     }
                     pack_id++;
                 }
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GPS数据包发送完成");
 
-               
                 free(buf);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "内存释放完成");
 
             }
             else
             {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: 无法获取GPS文件路径");
                 ble_data_type type_={0x02,0x4f,0,1,1};
                 send_big_data(type_,NULL,0);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "发送空GPS数据包");
             }
         
         }
         else
         {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: 数据长度不是4字节，实际长度: %d", len);
             ble_data_type type_={0x02,0x4f,0,1,1};
             send_big_data(type_,NULL,0);
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "发送空GPS数据包");
         }  
     }
 	else
 	{
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "错误: CRC校验失败");
         ble_data_type type_={0x02,0x4f,0,1,1};
         send_big_data(type_,NULL,0);
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "发送空GPS数据包");
     }
 
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "=== BLE GPS命令处理结束 ===");
    //send_big_data(1,NULL,0,0,1,1,,2);
 }
    //send_big_data(1,NULL,0,0,1,1,0x4f,2);
@@ -4107,10 +4139,6 @@ void type2AE4Data(ble_read_data *buffer_handle,uint8_t *buf_cmd,uint8_t *data,ui
          case SET_APP_AI_TXT_CMD://app下发的AI数据
             SetAiResultCmd(typeID,data,datalen,totalData,crcvalue);
             break;
-        
-         case SYN_APP_GET_GPS_DATA_CMD://app获取GPS数据
-            GetGPSCmd(typeID,data,datalen,totalData,crcvalue);
-            break;
         case APP_SEND_CHATGPT_KEY_CMD:
             SaveChatGPTCmd(typeID,data,datalen,totalData,crcvalue);
             break;
@@ -6225,6 +6253,9 @@ void type2AE3Data(ble_read_data *buffer_handle,uint8_t *cmd_buf ,uint8_t *data,u
         case APP_GET_SOS_DATA_CMD:
             GetSOSDataCmd(cmd,data,datalen,totaldata,crcvalue);
             break;
+        case SYN_APP_GET_GPS_DATA_CMD://app获取GPS数据
+            GetGPSCmd(cmd,data,datalen,totaldata,crcvalue);
+            break;
         
         case GET_SPECIF_TYPE_FILE_CMD://获取指定类型文件目录 
         case AI_IS_READ_DATA_CMD: