From: xue <2144439972@qq.com>
Date: Mon, 7 Jul 2025 09:49:45 +0000 (+0800)
Subject: Merge branch 'sdk602patch0911' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0... 
X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=24b1b8c1bed2237ccfcebb5218d8601e3d844bfa;p=mirrors%2FFD230.git

Merge branch 'sdk602patch0911' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230 into sdk602patch0911
---

24b1b8c1bed2237ccfcebb5218d8601e3d844bfa
diff --cc code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
index f74b5ac1c,6335c322b..cbf5b12c4
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
@@@ -101,33 -100,6 +101,40 @@@ namespace OHO
  
      return std::string(buffer);
    }
-   // 获取当前时间+路经字符串 // 格式: 文件路径+YYYY_MM_DD+文件名
-   std::string BPModel::GetCurrentTimePath()
++  // 获取今天血压数据路径 // 格式: 文件路径+YYYY_MM_DD+文件名
++  std::string BPModel::GetBPDataPath()
 +  {
 +    uint32_t timeStamp = 0;
 +
 +    if (uapi_get_timestampe_ss(&timeStamp) != ERRCODE_SUCC)
 +    {
 +      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to get timestamp");
 +      return "----/--/--";
 +    }
 +
 +    // 将时间戳转换为 time_t 类型
 +    time_t rawtime = static_cast<time_t>(timeStamp);
 +    struct tm *timeinfo = localtime(&rawtime);
 +
 +    if (timeinfo == NULL)
 +    {
 +      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to convert time");
 +      return "----/--/--";
 +    }
 +
 +    // 格式化时间为字符串
 +    char buffer[20]; // 格式: YYYY-MM-DD HH:MM
 +    std::strftime(buffer, sizeof(buffer), "%Y_%m_%d", timeinfo);
 +
-     return std::string(BP_JSON_PATH) + std::string(buffer) + "BP.bin";
++    std::string binFilePath;
++    //  统一处理文件路径获取
++
++    binFilePath = std::string(BP_JSON_PATH) + std::string(buffer) + ".bin";
++    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Loading today's blood pressure data");
++
++
++    return binFilePath;
 +  }
    std::string BPModel::GetCurrentTimeStr(uint64_t timeStamp)
    {
  
@@@ -377,11 -499,6 +384,11 @@@
        {
          bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW);
        }
-       BP_STOP(); // 停止检测
-       if(bp_resullt == BPRESULT::NOT_TESTED)//未测量到数据
++      BP_STOP();                              // 停止检测
++      if (bp_resullt == BPRESULT::NOT_TESTED) // 未测量到数据
 +      {
-          BP_SetResultState(BPRESULT::TIMEOUT);//测量超时
++        BP_SetResultState(BPRESULT::TIMEOUT); // 测量超时
 +      }
        BP_SetState(BPState::BP_NORMAL);
        return;
      }
@@@ -514,70 -631,22 +521,42 @@@
        BPDetectBeginView *view = BPDetectBeginView::GetInstance();
        if (view)
        {
 -        view->UpdateTimeText(data);
 +        int BPv = rand() % (210 - 60) + 60;
 +        mapDataArray(BPv);
 +        BPv = rand() % (210 - 60) + 60;
 +        mapDataArray(BPv);
 +        BPv = rand() % (210 - 60) + 60;
 +        mapDataArray(BPv);
 +        BPv = rand() % (210 - 60) + 60;
 +        mapDataArray(BPv);
 +        BPv = rand() % (210 - 60) + 60;
 +        mapDataArray(BPv);
 +        view->UpdateTimeText(data, bp_check_value_vector);
        }
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
--      if (Time > 0 && Time < 30) // 一分钟后获取数据
--      {
- 
-         BP_GetData(&custom_sbp, &custom_dbp);
-         if (bp_resullt == BPRESULT::NOT_TESTED && custom_sbp > 0 && custom_dbp > 0) // 检测到数据
-         {
-           LAST_CHECK_DATA newData;
-           newData.timestamp = BPModel::GetCurrentTime();
-           newData.last_check_sbp_value = custom_sbp;
-           newData.last_check_dbp_value = custom_dbp;
-           // 测量数据结果分析
-           if (newData.last_check_sbp_value >= 140 || newData.last_check_dbp_value >= 90) // 高血压：收缩压≥140 mmHg 或 舒张压≥90 mmHg。
-           {
-             BP_SetResultState(BPRESULT::HIGH_RESULT);
-             UpdateHealthData(newData); // 存储到文件
-           }
-           else if (newData.last_check_sbp_value < 90 || newData.last_check_dbp_value < 60) // 低血压：收缩压＜90 mmHg 且 舒张压＜60 mmHg。
-           {
-             BP_SetResultState(BPRESULT::LOW_RESULT);
-             UpdateHealthData(newData); 
-           }
-           else if (newData.last_check_sbp_value < 90 || newData.last_check_dbp_value < 60) // 正常血压：收缩压（高压）＜120 mmHg 且 舒张压（低压）＜80 mmHg。
-           {
-             BP_SetResultState(BPRESULT::SUCCESS);
-             UpdateHealthData(newData); 
-           }
-           else // 数据异常
-           {
-             BP_SetResultState(BPRESULT::INVALID_DATA); // 无效数据，不存储
-           }
  
 -        BP_GetData(&custom_sbp, &custom_dbp);
 -        if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
 +          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
 +        }
 +#if 1
 +        if (Time == 5)
          {
 -          // LAST_CHECK_DATA newData;
 -          // newData.last_check_sbp_value = custom_sbp; // 测试数据
 -          // newData.last_check_dbp_value = custom_dbp;
 -          // newData.timestamp = BPModel::GetCurrentTime();
 -          // save_last_check_bp_data(newData); // 保存数据
 -          // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
 +          LAST_CHECK_DATA newData;
 +          newData.timestamp = BPModel::GetCurrentTime();
 +          newData.last_check_sbp_value = 128; // 测试数据
 +          newData.last_check_dbp_value = 80;
-           UpdateHealthData(newData);
++          UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA);        // 存储到文件
++          UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据
 +        }
 +        if (Time == 20)
 +        {
 +          LAST_CHECK_DATA newData;
 +          newData.timestamp = BPModel::GetCurrentTime();
 +          newData.last_check_sbp_value = 199; // 测试数据
 +          newData.last_check_dbp_value = 30;
-           UpdateHealthData(newData);
++          UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA);        // 存储到文件
++          UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据
          }
 +#endif
        }
        break;
      }
@@@ -826,166 -864,57 +805,207 @@@
    }
  
    /*
 -   *  @brief 开启定时器函数
 -   *  @param interval 时间间隔，单位ms
 -   */
 -  void BPModel::BP_Start_GetData_Timer(uint32_t interval)
 +  1.存储到BP.bin
 +  2.每次测量成功存储一次data,追加ab+
 +  3.开机初始化读取文件，赋值到DBP，SBP
 +  4.每次更新，更新数组
 +  5.更新完毕，存储到文件
 +  */
 +
-   bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data)
++  bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
    {
 -    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
 -    if (g_timer_get_data != nullptr)
 +
 +    // 判断文件夹是否存在
 +    if (!CreateBPFolder())
      {
 -      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
 -      return;
 +      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateBPFolder file");
 +      return false;
      }
-     if (!save_bin_BP(data) || (!IsTimestampToday(data.timestamp)))
-     { // 存储bin文件[协议使用]
-       WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SaveBP failed");
-       return false;
 -    g_timer_get_data = osTimerNew((osTimerFunc_t)BP_Timer_GetData_Callback, osTimerPeriodic,
 -                         nullptr, nullptr);
 -    if (g_timer_get_data == nullptr)
++    // 对于校准时间，只需要时间戳，创建临时数据结构
++    if (StorageType == BP_STORAGE_TYPE::LAST_CALIBRATE_TIME)
+     {
 -      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
 -      return;
++      // 校准时间不需要血压值，设为0
++      calibrationData.last_check_sbp_value = 0;
++      calibrationData.last_check_dbp_value = 0;
++      return save_bin_BP(calibrationData, StorageType);
 +    }
-     return true;
++    // 其他类逻辑处理
++    else if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
++    {
++      // 对于今日数据，需要检查是否为当天
++      if (!IsTimestampToday(data.timestamp))
++      {
++        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Data timestamp is not today");
++        return false;
++      }
++      return save_bin_BP(data, StorageType);
+     }
++    else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
++    {
++      return save_bin_BP(data, StorageType);
++    }
++    return false;
 +  }
 +  // 存储bin文件
-   bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data)
++  bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
 +  {
 +    /* 存储 bin 文件 [协议使用] */
-     std::string binFilePath = GetCurrentTimePath();
++    std::string binFilePath = GetPath(StorageType);
 +    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
 +                  binFilePath.c_str());
-     FILE *fp = fopen(binFilePath.c_str(), "ab+");
+ 
 -    osStatus_t ret = osTimerStart(g_timer_get_data, interval);
 -    if (ret != osOK)
++    FILE *fp;
++    if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
++    {
++      fp = fopen(binFilePath.c_str(), "ab+"); // 追加模式
++    }
++
++    else
++    {
++      fp = fopen(binFilePath.c_str(), "wb+"); // 覆盖模式
++    }
 +    if (fp == NULL)
      {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 -                    "osTimerDelete failed, ret = %lx!!", ret);
 -      if (g_timer_get_data != nullptr)
 +                    "Failed to open binary file for writing");
 +      return false;
 +    }
 +
 +    // 写入数据
-     WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sizeof(HeartRateData) %d", sizeof(HeartRateData));
++    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sizeof(data) %d", sizeof(data));
 +    if ((fwrite(&data.timestamp, sizeof(data.timestamp), 1, fp) != 1) ||
 +        (fwrite(&data.last_check_sbp_value, sizeof(data.last_check_sbp_value), 1, fp) != 1) ||
 +        (fwrite(&data.last_check_dbp_value, sizeof(data.last_check_dbp_value), 1, fp) != 1))
 +    {
 +      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                    "Failed to write data to binary file");
 +      fclose(fp);
 +      return false;
 +    }
 +
 +    fclose(fp);
 +    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                  "Saved BP data: timestamp = %d, SBP = %d, DBP = %d", data.timestamp,
 +                  data.last_check_sbp_value,
 +                  data.last_check_dbp_value);
 +    return true;
 +  }
 +  /*创建文件夹*/
 +  bool BPModel::CreateBPFolder()
 +  {
 +    struct stat info;
 +    if (stat(BP_JSON_PATH, &info) != 0)
 +    {
 +      if (mkdir(BP_JSON_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
        {
 -        ret = osTimerDelete(g_timer_get_data);
 +        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "mkdir BP_JSON_PATH is error");
 +        return false;
        }
 -      g_timer_get_data = nullptr;
 -      return;
      }
 +
 +    return true;
    }
 -  /*
 -   * @brief 停止定时器
 -   */
 -  void BPModel::BP_Stop_GetData_Timer(void)
 +
 +  bool BPModel::IsTimestampToday(uint32_t timestamp)
    {
 -    // 检查定时器是否存在
 -    if (g_timer_get_data != nullptr)
 +    // 获取当前时间
 +    struct tm currentTm;
 +    time_t seconds;
 +    time(&seconds);
 +    localtime_r(&seconds, &currentTm);
 +    // 将给定时间戳转换为 tm 结构
 +    struct tm *timestampTm =
 +        localtime(reinterpret_cast<const time_t *>(&timestamp));
 +    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "当前年月日：%d-%d-%d",
 +                  currentTm.tm_year + 1900, currentTm.tm_mon + 1,
 +                  currentTm.tm_mday);
 +    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "给定时间戳：%d-%d-%d",
 +                  timestampTm->tm_year + 1900, timestampTm->tm_mon + 1,
 +                  timestampTm->tm_mday);
 +    // 比较年、月和日
 +    if ((currentTm.tm_year == timestampTm->tm_year &&
 +         currentTm.tm_mon == timestampTm->tm_mon &&
 +         currentTm.tm_mday == timestampTm->tm_mday))
      {
 -      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StopTimer");
 -      osTimerStop(g_timer_get_data);
 -      // 删除定时器并置为 nullptr
 -      osStatus_t ret = osTimerDelete(g_timer_get_data);
 -      if (ret != osOK)
 +      return true;
 +    }
 +    else
 +    {
 +      return false;
 +    }
 +  }
 +  /*加载文件中数据*/
-   bool BPModel::LoadBP()
++  bool BPModel::LoadBP(BP_STORAGE_TYPE StorageType)
 +  {
-     bp_check_value_vector.clear();                  // 清空数组
-     std::string binFilePath = GetCurrentTimePath(); // 文件夹+时间+文件名
++    if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
++    {
++      bp_check_value_vector.clear(); // 清空数组
++    }
++
++    std::string binFilePath = GetPath(StorageType); // 文件路径
 +
 +    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str()); // 打开失败，今天没有测量记录则没有这个文件
 +
 +    std::ifstream ifs(binFilePath, std::ios::binary);
 +    if (!ifs.is_open())
 +    {
 +      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                    "Failed to open binary file for reading");
 +      return false;
 +    }
 +
 +    LAST_CHECK_DATA data;
 +    // 选取数据
 +    while (true)
 +    {
 +      // 先读取时间戳
 +      if (!ifs.read(reinterpret_cast<char *>(&data.timestamp), sizeof(data.timestamp)))
        {
          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 -                      "osTimerDelete failed, ret = %lx!!", ret);
 +                      "Failed to read heart rate value");
 +        break; // 如果读取失败，退出循环
 +      }
 +
 +      // 再读取SBP值
 +      if (!ifs.read(reinterpret_cast<char *>(&data.last_check_sbp_value), sizeof(data.last_check_sbp_value)))
 +      {
 +        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                      "Failed to read heart rate value");
 +        break; // 如果读取失败，退出循环
 +      }
 +      // 再读取DBP值
 +      if (!ifs.read(reinterpret_cast<char *>(&data.last_check_dbp_value), sizeof(data.last_check_dbp_value)))
 +      {
 +        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                      "Failed to read heart rate value");
 +        break; // 如果读取失败，退出循环
 +      }
 +      // 如果时间为当天
-       if (IsTimestampToday(data.timestamp))
++      if (StorageType == BP_STORAGE_TYPE::TODAY_DATA && IsTimestampToday(data.timestamp))
 +      {
 +
 +        lastCheckData.push_back(data); // 存入数组中
 +#if 1
 +        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                      "timestamp:%d", data.timestamp);
 +        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                      "last_check_sbp_value:%d", data.last_check_sbp_value);
 +        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
 +                      "last_check_dbp_value:%d", data.last_check_dbp_value);
 +#endif
 +      }
++      else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
++      {
++        lastData = data; // 加载上次测量时间
++      }
++      else if (StorageType == BP_STORAGE_TYPE::LAST_CALIBRATE_TIME)
++      {
++        calibrationData.timestamp = data.timestamp; // 加载上次校准时间
+       }
 -      g_timer_get_data = nullptr;
      }
- 
++    // 关闭文件
++    ifs.close();
 +    return true;
    }
 -#endif
 +
  } // namespace OHOS