From 17e7a08987e6087c5fda3260afefe4aa3a2fd18d Mon Sep 17 00:00:00 2001
From: xue <2144439972@qq.com>
Date: Tue, 8 Jul 2025 14:15:39 +0800
Subject: [PATCH] =?utf8?q?=E6=B5=8B=E9=87=8F=E5=AE=8C=E6=88=90=E6=95=B0?=
 =?utf8?q?=E6=8D=AE=E5=A4=84=E7=90=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

---
 .../nativeui/bloodpressure/src/BPModel.cpp    | 1563 ++++++++---------
 1 file changed, 776 insertions(+), 787 deletions(-)

diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
index 140298670..642d5d73d 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
@@ -251,970 +251,959 @@ namespace OHOS
   // 测量结束状态处理
   void BPModel::BPControlStopMeasure()
   {
-    if (Time > 0 && Time < 30) // 一分钟后获取数据
+    if (lastData.last_check_sbp_value >= 140 || lastData.last_check_dbp_value >= 90) // 高血压：收缩压≥140 mmHg 或 舒张压≥90 mmHg。
     {
-
-      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 (lastData.last_check_sbp_value >= 140 || lastData.last_check_dbp_value >= 90) // 高血压：收缩压≥140 mmHg 或 舒张压≥90 mmHg。
-        {
-          BP_SetResultState(BPRESULT::HIGH_RESULT);
-          UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA);        // 存储到文件
-          UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据
-        }
-        else if (lastData.last_check_sbp_value < 90 || lastData.last_check_dbp_value < 60) // 低血压：收缩压＜90 mmHg 且 舒张压＜60 mmHg。
-        {
-          BP_SetResultState(BPRESULT::LOW_RESULT);
-          UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA);
-          UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA);
-        }
-        else if (lastData.last_check_sbp_value < 90 || lastData.last_check_dbp_value < 60) // 正常血压：收缩压（高压）＜120 mmHg 且 舒张压（低压）＜80 mmHg。
-        {
-          BP_SetResultState(BPRESULT::SUCCESS);
-          UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA);
-          UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA);
-        }
-        else // 数据异常
-        {
-          BP_SetResultState(BPRESULT::INVALID_DATA); // 无效数据，不存储
-        }
-      }
+      BP_SetResultState(BPRESULT::HIGH_RESULT);
+      UpdateHealthData(lastData, BP_STORAGE_TYPE::TODAY_DATA);        // 存储到文件
+      UpdateHealthData(lastData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据
     }
-  }
-    // 血压检测中状态处理
-    void BPModel::BPControlDetecting()
+    else if (lastData.last_check_sbp_value < 90 || lastData.last_check_dbp_value < 60) // 低血压：收缩压＜90 mmHg 且 舒张压＜60 mmHg。
     {
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间90秒
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
-      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                    "start detecting");
-      BP_START(); // 底层接口开启血压
-      custom_dbp = 0;
-      custom_sbp = 0;
+      BP_SetResultState(BPRESULT::LOW_RESULT);
+      UpdateHealthData(lastData, BP_STORAGE_TYPE::TODAY_DATA);
+      UpdateHealthData(lastData, BP_STORAGE_TYPE::LAST_MEASURE_DATA);
     }
-
-    // 首次校准状态处理
-    void BPModel::BPControlCalibratingFirstTime()
+    else if (lastData.last_check_sbp_value < 90 || lastData.last_check_dbp_value < 60) // 正常血压：收缩压（高压）＜120 mmHg 且 舒张压（低压）＜80 mmHg。
     {
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间90秒
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
-      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                    "start detecting");
-      BP_START(); // 底层接口开启血压
-      custom_dbp = 0;
-      custom_sbp = 0;
+      BP_SetResultState(BPRESULT::SUCCESS);
+      UpdateHealthData(lastData, BP_STORAGE_TYPE::TODAY_DATA);
+      UpdateHealthData(lastData, BP_STORAGE_TYPE::LAST_MEASURE_DATA);
     }
-
-    // 第二次校准状态处理
-    void BPModel::BPControlCalibratingSecondTime()
-    {
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间90秒
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
-      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                    "start detecting");
-      BP_START(); // 底层接口开启血压
-      custom_dbp = 0;
-      custom_sbp = 0;
-    }
-    // 校准分析状态处理
-    void BPModel::BPControlCalibratingAnalysis()
+    else // 数据异常
     {
+      BP_SetResultState(BPRESULT::INVALID_DATA); // 无效数据，不存储
     }
-    // 压力测量状态处理
-    void BPModel::BPControlStressMeasure()
-    {
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+  }
+  // 血压检测中状态处理
+  void BPModel::BPControlDetecting()
+  {
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间90秒
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                  "start detecting");
+    BP_START(); // 底层接口开启血压
+    custom_dbp = 0;
+    custom_sbp = 0;
+  }
 
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间
-    }
+  // 首次校准状态处理
+  void BPModel::BPControlCalibratingFirstTime()
+  {
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间90秒
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                  "start detecting");
+    BP_START(); // 底层接口开启血压
+    custom_dbp = 0;
+    custom_sbp = 0;
+  }
 
-    // 压力测量结束状态处理
-    void BPModel::BPControlStressMeasureEnd()
-    {
-      // 空实现：压力测量结束逻辑
-    }
-    // 压力分析状态处理
-    void BPModel::BPControlStressAnalysis()
-    {
-    }
-    // 疲劳度测量状态处理
-    void BPModel::BPControlFatigueMeasure()
-    {
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+  // 第二次校准状态处理
+  void BPModel::BPControlCalibratingSecondTime()
+  {
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间90秒
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                  "start detecting");
+    BP_START(); // 底层接口开启血压
+    custom_dbp = 0;
+    custom_sbp = 0;
+  }
+  // 校准分析状态处理
+  void BPModel::BPControlCalibratingAnalysis()
+  {
+  }
+  // 压力测量状态处理
+  void BPModel::BPControlStressMeasure()
+  {
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
 
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间
-    }
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间
+  }
 
-    // 疲劳度测量结束状态处理
-    void BPModel::BPControlFatigueMeasureEnd()
-    {
-      // 空实现：疲劳度测量结束逻辑
-    }
-    // 疲劳度分析状态处理
-    void BPModel::BPControlFatigueAnalysis()
-    {
-    }
-    // ECG测量状态处理
-    void BPModel::BPControlECGMeasure()
-    {
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+  // 压力测量结束状态处理
+  void BPModel::BPControlStressMeasureEnd()
+  {
+    // 空实现：压力测量结束逻辑
+  }
+  // 压力分析状态处理
+  void BPModel::BPControlStressAnalysis()
+  {
+  }
+  // 疲劳度测量状态处理
+  void BPModel::BPControlFatigueMeasure()
+  {
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
 
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间
-    }
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间
+  }
 
-    // ECG测量结束状态处理
-    void BPModel::BPControlECGMeasureEnd()
-    {
-      // 空实现：ECG测量结束逻辑
-    }
-    // ECG分析状态处理
-    void BPModel::BPControlECGAnalysis()
-    {
-    }
-    // ECG提醒状态处理
-    void BPModel::BPControlECGRemind()
-    {
-    }
-    // ECG结果状态处理
-    void BPModel::BPControlECGResult()
-    {
-    }
-    // 情绪测量状态处理
-    void BPModel::BPControlEMOMeasure()
-    {
-      BP_StartTimer();
-      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+  // 疲劳度测量结束状态处理
+  void BPModel::BPControlFatigueMeasureEnd()
+  {
+    // 空实现：疲劳度测量结束逻辑
+  }
+  // 疲劳度分析状态处理
+  void BPModel::BPControlFatigueAnalysis()
+  {
+  }
+  // ECG测量状态处理
+  void BPModel::BPControlECGMeasure()
+  {
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
 
-      if (Time != BP_CHECK_TIME_MAX)
-        Time = BP_CHECK_TIME_MAX; // 重置时间
-    }
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间
+  }
 
-    // 情绪测量结束状态处理
-    void BPModel::BPControlEMOMeasureEnd()
-    {
-      // 空实现：情绪测量结束逻辑
-    }
-    // 情绪分析状态处理
-    void BPModel::BPControlEMOAnalysis()
-    {
-    }
-    /////////////////////////////////////////////////////////
-    // 机器校准收缩压与舒张压的数值
-    void BPModel::BP_SetValue(BP_VALUE_TYPE type, bool set_value)
+  // ECG测量结束状态处理
+  void BPModel::BPControlECGMeasureEnd()
+  {
+    // 空实现：ECG测量结束逻辑
+  }
+  // ECG分析状态处理
+  void BPModel::BPControlECGAnalysis()
+  {
+  }
+  // ECG提醒状态处理
+  void BPModel::BPControlECGRemind()
+  {
+  }
+  // ECG结果状态处理
+  void BPModel::BPControlECGResult()
+  {
+  }
+  // 情绪测量状态处理
+  void BPModel::BPControlEMOMeasure()
+  {
+    BP_StartTimer();
+    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+
+    if (Time != BP_CHECK_TIME_MAX)
+      Time = BP_CHECK_TIME_MAX; // 重置时间
+  }
+
+  // 情绪测量结束状态处理
+  void BPModel::BPControlEMOMeasureEnd()
+  {
+    // 空实现：情绪测量结束逻辑
+  }
+  // 情绪分析状态处理
+  void BPModel::BPControlEMOAnalysis()
+  {
+  }
+  /////////////////////////////////////////////////////////
+  // 机器校准收缩压与舒张压的数值
+  void BPModel::BP_SetValue(BP_VALUE_TYPE type, bool set_value)
+  {
+    if (set_value)
     {
-      if (set_value)
+      if (type == BP_VALUE_TYPE::SBP)
       {
-        if (type == BP_VALUE_TYPE::SBP)
-        {
-          if (custom_sbp < 250)
-            custom_sbp++;
-        }
-        else if (type == BP_VALUE_TYPE::DBP)
-        {
-          if (custom_dbp < 150)
-            custom_dbp++;
-        }
+        if (custom_sbp < 250)
+          custom_sbp++;
       }
-      else
+      else if (type == BP_VALUE_TYPE::DBP)
       {
-        if (type == BP_VALUE_TYPE::SBP)
-        {
-          if (custom_sbp > 50)
-            custom_sbp--;
-        }
-        else if (type == BP_VALUE_TYPE::DBP)
-        {
-          if (custom_dbp > 30)
-            custom_dbp--;
-        }
+        if (custom_dbp < 150)
+          custom_dbp++;
       }
     }
-    uint8_t BPModel::GetValue(BP_VALUE_TYPE type)
+    else
     {
       if (type == BP_VALUE_TYPE::SBP)
-        return custom_sbp;
-      else
-        return custom_dbp;
+      {
+        if (custom_sbp > 50)
+          custom_sbp--;
+      }
+      else if (type == BP_VALUE_TYPE::DBP)
+      {
+        if (custom_dbp > 30)
+          custom_dbp--;
+      }
     }
-    void BPModel::BP_START(void)
-    {
-      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_START");
+  }
+  uint8_t BPModel::GetValue(BP_VALUE_TYPE type)
+  {
+    if (type == BP_VALUE_TYPE::SBP)
+      return custom_sbp;
+    else
+      return custom_dbp;
+  }
+  void BPModel::BP_START(void)
+  {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_START");
 #ifdef ENABLE_BN02
-      bp_start(BP);
+    bp_start(BP);
 #endif
-    }
-    void BPModel::BP_STOP(void)
-    {
+  }
+  void BPModel::BP_STOP(void)
+  {
 #ifdef ENABLE_BN02
-      bp_stop();
+    bp_stop();
 #endif
-    }
-    void BPModel::BP_GetData(uint8_t *sbp, uint8_t *dbp)
-    {
+  }
+  void BPModel::BP_GetData(uint8_t *sbp, uint8_t *dbp)
+  {
 #ifdef ENABLE_BN02
-      if (sbp && dbp)
-      {
-        int temp_sbp = 0, temp_dbp = 0;
-        bp_get_data(&temp_sbp, &temp_dbp);
-
-        // 添加范围检查，避免数据截断
-        if (temp_sbp >= 0 && temp_sbp <= UINT8_MAX)
-        {
-          *sbp = static_cast<uint8_t>(temp_sbp);
-        }
-        else
-        {
-          *sbp = 0; // 默认值
-        }
-
-        if (temp_dbp >= 0 && temp_dbp <= UINT8_MAX)
-        {
-          *dbp = static_cast<uint8_t>(temp_dbp);
-        }
-        else
-        {
-          *dbp = 0;
-        }
-      }
-#endif
-    }
-
-    std::map<uint8_t, std::pair<uint8_t, uint8_t>> BPModel::GetBPValueMap()
+    if (sbp && dbp)
     {
-      return bp_check_value_map;
-    }
+      int temp_sbp = 0, temp_dbp = 0;
+      bp_get_data(&temp_sbp, &temp_dbp);
 
-    /*
-      显示内容映射 （60~210）这个数据只是显示一个趋势 不代表什么，为了显示效果
-    */
-    uint8_t BPModel::mapValue(uint8_t value)
-    {
-      // 确保输入值在0-255范围内
-      if (value < 0)
-        value = 0;
-      if (value > 255)
-        value = 255;
-
-      // 线性映射公式：output = (input - input_min) * (output_max - output_min) / (input_max - input_min) + output_min
-      return (value - 0) * (210 - 60) / (255 - 0) + 60;
-    }
-
-    void BPModel::mapDataArray(uint8_t value)
-    {
-      value = mapValue(value);
+      // 添加范围检查，避免数据截断
+      if (temp_sbp >= 0 && temp_sbp <= UINT8_MAX)
+      {
+        *sbp = static_cast<uint8_t>(temp_sbp);
+      }
+      else
+      {
+        *sbp = 0; // 默认值
+      }
 
-      // 使用固定大小的vector，通过索引循环覆盖旧数据
-      static size_t index = 0;
-      if (bp_check_value_vector.size() < MAX_SHOW_CHECK_NUM)
+      if (temp_dbp >= 0 && temp_dbp <= UINT8_MAX)
       {
-        bp_check_value_vector.push_back(value);
+        *dbp = static_cast<uint8_t>(temp_dbp);
       }
       else
       {
-        bp_check_value_vector[index] = value;
-        index = (index + 1) % MAX_SHOW_CHECK_NUM;
+        *dbp = 0;
       }
     }
+#endif
+  }
+
+  std::map<uint8_t, std::pair<uint8_t, uint8_t>> BPModel::GetBPValueMap()
+  {
+    return bp_check_value_map;
+  }
 
-    // 获取过程值数据
-    std::vector<uint8_t> BPModel::GetBPCheckDataArray()
+  /*
+    显示内容映射 （60~210）这个数据只是显示一个趋势 不代表什么，为了显示效果
+  */
+  uint8_t BPModel::mapValue(uint8_t value)
+  {
+    // 确保输入值在0-255范围内
+    if (value < 0)
+      value = 0;
+    if (value > 255)
+      value = 255;
+
+    // 线性映射公式：output = (input - input_min) * (output_max - output_min) / (input_max - input_min) + output_min
+    return (value - 0) * (210 - 60) / (255 - 0) + 60;
+  }
+
+  void BPModel::mapDataArray(uint8_t value)
+  {
+    value = mapValue(value);
+
+    // 使用固定大小的vector，通过索引循环覆盖旧数据
+    static size_t index = 0;
+    if (bp_check_value_vector.size() < MAX_SHOW_CHECK_NUM)
+    {
+      bp_check_value_vector.push_back(value);
+    }
+    else
     {
-      return bp_check_value_vector;
+      bp_check_value_vector[index] = value;
+      index = (index + 1) % MAX_SHOW_CHECK_NUM;
     }
+  }
 
- //nextday清空血压数据
+  // 获取过程值数据
+  std::vector<uint8_t> BPModel::GetBPCheckDataArray()
+  {
+    return bp_check_value_vector;
+  }
+
+  // nextday清空血压数据
   bool BPModel::CleanBPData(void)
   {
-    //进行图表清空；model数组清空
+    // 进行图表清空；model数组清空
     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CleanBPData success");
     return true;
-  }    //////////////////////////////////time处理////////////////////////////////////
-    // time到时的处理
-    void BPModel::BP_timer_callback_out()
-    {
+  } //////////////////////////////////time处理////////////////////////////////////
+  // time到时的处理
+  void BPModel::BP_timer_callback_out()
+  {
 
-      BP_StopTimer();
+    BP_StopTimer();
 
-      // 提前获取各视图实例
-      auto *bpMainView = BPMainView::GetInstance();
-      auto *bpDetectionView = BPDetectionView::GetInstance();
-      auto *stressMainView = StressMainView::GetInstance();
-      auto *stressAnalysisView = StressAnalysisView::GetInstance();
-      auto *fatigueMainView = FatigueMainView::GetInstance();
-      auto *fatigueAnalysisView = FatigueAnalysisView::GetInstance();
-      auto *emoView = EmoView::GetInstance();
-      auto *ecgView = EcgView::GetInstance();
-
-      // 处理血压校准相关状态
-      if (current_state == BPState::BP_CALIBRATING_FIRSTTIME ||
-          current_state == BPState::BP_CALIBRATING_SECONDTIME)
+    // 提前获取各视图实例
+    auto *bpMainView = BPMainView::GetInstance();
+    auto *bpDetectionView = BPDetectionView::GetInstance();
+    auto *stressMainView = StressMainView::GetInstance();
+    auto *stressAnalysisView = StressAnalysisView::GetInstance();
+    auto *fatigueMainView = FatigueMainView::GetInstance();
+    auto *fatigueAnalysisView = FatigueAnalysisView::GetInstance();
+    auto *emoView = EmoView::GetInstance();
+    auto *ecgView = EcgView::GetInstance();
+
+    // 处理血压校准相关状态
+    if (current_state == BPState::BP_CALIBRATING_FIRSTTIME ||
+        current_state == BPState::BP_CALIBRATING_SECONDTIME)
+    {
+      if (bpMainView)
       {
-        if (bpMainView)
-        {
-          bpMainView->ChangeView(current_state == BPState::BP_CALIBRATING_FIRSTTIME
-                                     ? BPUNDERCALIBRATIONVIEW
-                                     : BPSECUNDERCALIBRATIONVIEW,
-                                 BPCALIBRATIONMINDVIEW);
-        }
-        LastCalibrationTime = BPModel::GetCurrentTimeStr(); // 获取校准完成时的时间
-        BP_STOP();
-        BP_SetState(BPState::BP_IDLE);
+        bpMainView->ChangeView(current_state == BPState::BP_CALIBRATING_FIRSTTIME
+                                   ? BPUNDERCALIBRATIONVIEW
+                                   : BPSECUNDERCALIBRATIONVIEW,
+                               BPCALIBRATIONMINDVIEW);
+      }
+      LastCalibrationTime = BPModel::GetCurrentTimeStr(); // 获取校准完成时的时间
+      BP_STOP();
+      BP_SetState(BPState::BP_IDLE);
+      CalibrationFlag++;
+      return;
+    }
+    // 处理血压分析状态
+    if (current_state == BPState::BP_CALIBRATING_ANGLYSIS)
+    {
+      if (bpMainView)
+      {
+        bpMainView->ChangeView(BPRESULTANALYSISVIEW, BPCALIBRATIONPASSVIEW);
+      }
+      BP_SetState(BPState::BP_IDLE);
+      if (CalibrationFlag == 1)
         CalibrationFlag++;
-        return;
+      else
+        CalibrationFlag = 0;
+      return;
+    }
+    // 处理血压检测状态
+    if (current_state == BPState::BP_DETECTING)
+    {
+      if (bpDetectionView)
+      {
+        bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW);
       }
-      // 处理血压分析状态
-      if (current_state == BPState::BP_CALIBRATING_ANGLYSIS)
+      BP_STOP();                              // 停止检测
+      if (bp_resullt == BPRESULT::NOT_TESTED) // 未测量到数据
       {
-        if (bpMainView)
-        {
-          bpMainView->ChangeView(BPRESULTANALYSISVIEW, BPCALIBRATIONPASSVIEW);
-        }
-        BP_SetState(BPState::BP_IDLE);
-        if (CalibrationFlag == 1)
-          CalibrationFlag++;
-        else
-          CalibrationFlag = 0;
-        return;
+        BP_SetResultState(BPRESULT::TIMEOUT); // 测量超时
       }
-      // 处理血压检测状态
-      if (current_state == BPState::BP_DETECTING)
+      BP_SetState(BPState::BP_IDLE);
+      return;
+    }
+
+    // 处理压力检测与分析
+    if (current_state == BPState::STRESS_MEASURE)
+    {
+      if (stressMainView)
       {
-        if (bpDetectionView)
-        {
-          bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW);
-        }
-        BP_STOP();                              // 停止检测
-        if (bp_resullt == BPRESULT::NOT_TESTED) // 未测量到数据
-        {
-          BP_SetResultState(BPRESULT::TIMEOUT); // 测量超时
-        }
-        BP_SetState(BPState::BP_IDLE);
-        return;
+        stressMainView->ChangeView(STRESSUNDERMEASUREVIEW, STRESSANALYSISEVIEW);
+      }
+      BP_Control(BPState::STRESS_ANALYSIS);
+      if (stressAnalysisView)
+      {
+        stressAnalysisView->startorstopAnalysisAni(true);
       }
+      return;
+    }
+    if (current_state == BPState::STRESS_ANALYSIS)
+    {
+      if (stressMainView)
+      {
+        stressMainView->ChangeView(STRESSANALYSISEVIEW, STRESSRESULTVIEW);
+      }
+      BP_SetState(BPState::BP_IDLE);
+      if (stressAnalysisView)
+      {
+        stressAnalysisView->startorstopAnalysisAni(false);
+      }
+      return;
+    }
 
-      // 处理压力检测与分析
-      if (current_state == BPState::STRESS_MEASURE)
+    // 处理疲劳度检测与分析
+    if (current_state == BPState::FATIGUE_MEASURE)
+    {
+      if (fatigueMainView)
       {
-        if (stressMainView)
-        {
-          stressMainView->ChangeView(STRESSUNDERMEASUREVIEW, STRESSANALYSISEVIEW);
-        }
-        BP_Control(BPState::STRESS_ANALYSIS);
-        if (stressAnalysisView)
-        {
-          stressAnalysisView->startorstopAnalysisAni(true);
-        }
-        return;
+        fatigueMainView->ChangeView(FATIGUEUNDERMEASUREVIEW,
+                                    FATIGUEANALYSISEVIEW);
       }
-      if (current_state == BPState::STRESS_ANALYSIS)
+      BP_Control(BPState::FATIGUE_ANALYSIS);
+      if (fatigueAnalysisView)
       {
-        if (stressMainView)
-        {
-          stressMainView->ChangeView(STRESSANALYSISEVIEW, STRESSRESULTVIEW);
-        }
-        BP_SetState(BPState::BP_IDLE);
-        if (stressAnalysisView)
-        {
-          stressAnalysisView->startorstopAnalysisAni(false);
-        }
-        return;
+        fatigueAnalysisView->startorstopAnalysisAni(true);
+      }
+      return;
+    }
+    if (current_state == BPState::FATIGUE_ANALYSIS)
+    {
+      if (fatigueMainView)
+      {
+        fatigueMainView->ChangeView(FATIGUEANALYSISEVIEW, FATIGUERESULTVIEW);
+      }
+      BP_SetState(BPState::BP_IDLE);
+      if (fatigueAnalysisView)
+      {
+        fatigueAnalysisView->startorstopAnalysisAni(false);
       }
+      return;
+    }
 
-      // 处理疲劳度检测与分析
-      if (current_state == BPState::FATIGUE_MEASURE)
+    // 处理情绪检测与分析
+    if (current_state == BPState::EMO_MEASURE)
+    {
+      if (emoView)
       {
-        if (fatigueMainView)
-        {
-          fatigueMainView->ChangeView(FATIGUEUNDERMEASUREVIEW,
-                                      FATIGUEANALYSISEVIEW);
-        }
-        BP_Control(BPState::FATIGUE_ANALYSIS);
-        if (fatigueAnalysisView)
-        {
-          fatigueAnalysisView->startorstopAnalysisAni(true);
-        }
-        return;
+        EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTVIEW,
+                                                        EMOTIONTESTANALYSISVIEW);
       }
-      if (current_state == BPState::FATIGUE_ANALYSIS)
+      return;
+
+      if (current_state == BPState::EMO_ANALYSIS)
       {
-        if (fatigueMainView)
+        if (emoView)
         {
-          fatigueMainView->ChangeView(FATIGUEANALYSISEVIEW, FATIGUERESULTVIEW);
+          EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTANALYSISVIEW,
+                                                          EMOTIONTESTRESULTVIEW);
         }
         BP_SetState(BPState::BP_IDLE);
-        if (fatigueAnalysisView)
-        {
-          fatigueAnalysisView->startorstopAnalysisAni(false);
-        }
         return;
       }
 
-      // 处理情绪检测与分析
-      if (current_state == BPState::EMO_MEASURE)
+      // 处理ECG相关状态
+      if (ecgView)
       {
-        if (emoView)
+        if (current_state == BPState::ECG_REMIND)
         {
-          EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTVIEW,
-                                                          EMOTIONTESTANALYSISVIEW);
+          EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTREMINDERVIEW,
+                                                          ECGTESTINGVIEW);
+          return;
         }
-        return;
 
-        if (current_state == BPState::EMO_ANALYSIS)
+        if (current_state == BPState::ECG_MEASURE)
         {
-          if (emoView)
-          {
-            EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTANALYSISVIEW,
-                                                            EMOTIONTESTRESULTVIEW);
-          }
-          BP_SetState(BPState::BP_IDLE);
+          EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTINGVIEW,
+                                                          ECGTESTANALYSISVIEW);
           return;
         }
 
-        // 处理ECG相关状态
-        if (ecgView)
+        if (current_state == BPState::ECG_ANALYSIS)
+        {
+          EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTANALYSISVIEW,
+                                                          ECGTESTRESULTVIEW);
+          return;
+        }
+        if (current_state == BPState::ECG_RESULT)
         {
-          if (current_state == BPState::ECG_REMIND)
-          {
-            EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTREMINDERVIEW,
-                                                            ECGTESTINGVIEW);
-            return;
-          }
-
-          if (current_state == BPState::ECG_MEASURE)
-          {
-            EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTINGVIEW,
-                                                            ECGTESTANALYSISVIEW);
-            return;
-          }
-
-          if (current_state == BPState::ECG_ANALYSIS)
-          {
-            EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTANALYSISVIEW,
-                                                            ECGTESTRESULTVIEW);
-            return;
-          }
-          if (current_state == BPState::ECG_RESULT)
-          {
-
-            EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTRESULTVIEW,
-                                                            ECGRESETTESTOFSUCCVIEW);
-            BP_SetState(BPState::BP_IDLE);
-          }
+
+          EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTRESULTVIEW,
+                                                          ECGRESETTESTOFSUCCVIEW);
+          BP_SetState(BPState::BP_IDLE);
         }
       }
     }
-    // 每秒的处理
-    void BPModel::BP_timer_callback_proc(uint8_t data)
-    {
+  }
+  // 每秒的处理
+  void BPModel::BP_timer_callback_proc(uint8_t data)
+  {
 
-      // 根据状态处理
-      switch (current_state)
-      {
-      case BPState::BP_IDLE:
-        BP_StopTimer();
-        BP_SetState(BPState::BP_IDLE);
-        return;
+    // 根据状态处理
+    switch (current_state)
+    {
+    case BPState::BP_IDLE:
+      BP_StopTimer();
+      BP_SetState(BPState::BP_IDLE);
+      return;
 
-      case BPState::BP_DETECTING:
+    case BPState::BP_DETECTING:
+    {
+      BPDetectBeginView *view = BPDetectBeginView::GetInstance();
+      if (view)
       {
-        BPDetectBeginView *view = BPDetectBeginView::GetInstance();
-        if (view)
-        {
-          view->UpdateTimeText(data);
-        }
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
-        if (Time > 0 && Time < 30) // 一分钟后获取数据
-        {
-
-          BP_GetData(&custom_sbp, &custom_dbp);
-          if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
-          {
-            // 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);
-          }
-        }
-        break;
+        view->UpdateTimeText(data);
       }
-
-      case BPState::BP_CALIBRATING_FIRSTTIME:
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
+      if (Time > 0 && Time < 30) // 一分钟后获取数据
       {
-        BPUnderCalibrationView *view = BPUnderCalibrationView::GetInstance();
-        if (view)
+
+        BP_GetData(&custom_sbp, &custom_dbp);
+        if (bp_resullt == BPRESULT::NOT_TESTED && custom_sbp > 0 && custom_dbp > 0) // 检测到数据
         {
-          view->UpdateTimeText(data);
+          LAST_CHECK_DATA newData;
+          newData.timestamp = BPModel::GetCurrentTime();
+          newData.last_check_sbp_value = custom_sbp;
+          newData.last_check_dbp_value = custom_dbp;
+          lastData = newData;
+          // 测量完成
+          bp_resullt == BPRESULT::SUCCESS;
         }
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
-        if (Time > 0 && Time < 30) // 一分钟后获取数据
-        {
+      }
 
-          BP_GetData(&custom_sbp, &custom_dbp);
-          if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
-          {
-            LAST_CHECK_DATA newData;
-            newData.last_check_sbp_value = custom_sbp; // 测试数据
-            newData.last_check_dbp_value = custom_dbp;
-            newData.timestamp = BPModel::GetCurrentTime();
-            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
-          }
-        }
+      break;
+    }
 
-        break;
+    case BPState::BP_CALIBRATING_FIRSTTIME:
+    {
+      BPUnderCalibrationView *view = BPUnderCalibrationView::GetInstance();
+      if (view)
+      {
+        view->UpdateTimeText(data);
       }
-      case BPState::BP_CALIBRATING_SECONDTIME:
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
+      if (Time > 0 && Time < 30) // 一分钟后获取数据
       {
-        BPSecUnderCalibrationView *view =
-            BPSecUnderCalibrationView::GetInstance();
-        if (view)
-        {
-          view->UpdateTimeText(data);
-        }
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
-        if (Time > 0 && Time < 30) // 一分钟后获取数据
+
+        BP_GetData(&custom_sbp, &custom_dbp);
+        if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
         {
-          BP_GetData(&custom_sbp, &custom_dbp);
-          if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
-          {
-            LAST_CHECK_DATA newData;
-            newData.last_check_sbp_value = custom_sbp; // 测试数据
-            newData.last_check_dbp_value = custom_dbp;
-            newData.timestamp = BPModel::GetCurrentTime();
-            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
-          }
+          LAST_CHECK_DATA newData;
+          newData.last_check_sbp_value = custom_sbp; // 测试数据
+          newData.last_check_dbp_value = custom_dbp;
+          newData.timestamp = BPModel::GetCurrentTime();
+          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
         }
-        break;
       }
-      case BPState::ECG_MEASURE:
+
+      break;
+    }
+    case BPState::BP_CALIBRATING_SECONDTIME:
+    {
+      BPSecUnderCalibrationView *view =
+          BPSecUnderCalibrationView::GetInstance();
+      if (view)
+      {
+        view->UpdateTimeText(data);
+      }
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time);
+      if (Time > 0 && Time < 30) // 一分钟后获取数据
       {
-        EcgTestingView *view = EcgTestingView::GetInstance();
-        if (view)
+        BP_GetData(&custom_sbp, &custom_dbp);
+        if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
         {
-          view->UpdateTimeLabel(Time);
+          LAST_CHECK_DATA newData;
+          newData.last_check_sbp_value = custom_sbp; // 测试数据
+          newData.last_check_dbp_value = custom_dbp;
+          newData.timestamp = BPModel::GetCurrentTime();
+          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
         }
-        break;
       }
-
-      case BPState::STRESS_MEASURE:
-      case BPState::FATIGUE_MEASURE:
-      case BPState::EMO_MEASURE:
-      case BPState::STRESS_ANALYSIS:
-      case BPState::FATIGUE_ANALYSIS:
-      case BPState::ECG_ANALYSIS:
-      case BPState::EMO_ANALYSIS:
-      case BPState::BP_CALIBRATING_ANGLYSIS:
-      case BPState::ECG_REMIND:
-      case BPState::ECG_RESULT:
+      break;
+    }
+    case BPState::ECG_MEASURE:
+    {
+      EcgTestingView *view = EcgTestingView::GetInstance();
+      if (view)
       {
-        break;
+        view->UpdateTimeLabel(Time);
       }
+      break;
+    }
 
-      default:
-        BP_StopTimer();
-        // 显示错误界面提示
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "current_state is error!!");
-        return;
-      }
+    case BPState::STRESS_MEASURE:
+    case BPState::FATIGUE_MEASURE:
+    case BPState::EMO_MEASURE:
+    case BPState::STRESS_ANALYSIS:
+    case BPState::FATIGUE_ANALYSIS:
+    case BPState::ECG_ANALYSIS:
+    case BPState::EMO_ANALYSIS:
+    case BPState::BP_CALIBRATING_ANGLYSIS:
+    case BPState::ECG_REMIND:
+    case BPState::ECG_RESULT:
+    {
+      break;
+    }
+
+    default:
+      BP_StopTimer();
+      // 显示错误界面提示
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "current_state is error!!");
+      return;
     }
-    /////////////////////////////////////测量时间 定时器处理 不要修改//////////////////////////////////////////////////
+  }
+/////////////////////////////////////测量时间 定时器处理 不要修改//////////////////////////////////////////////////
 #if DECLARE_BP_TIMER
-    // 声明定时器变量
-    static osTimerId_t g_timer = nullptr;
-    /*定时器到期时的处理*/
-    static void BP_TimerCallbackProc(uint8_t data)
+  // 声明定时器变量
+  static osTimerId_t g_timer = nullptr;
+  /*定时器到期时的处理*/
+  static void BP_TimerCallbackProc(uint8_t data)
+  {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_TimerCallbackProc %d", Time);
+    // 倒计时
+    Time--;
+    // 到时的处理
+    if (Time < 0)
     {
-      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_TimerCallbackProc %d", Time);
-      // 倒计时
-      Time--;
-      // 到时的处理
-      if (Time < 0)
-      {
-        BPModel::GetInstance()->BP_timer_callback_out();
-        return;
-      }
-      BPModel::GetInstance()->BP_timer_callback_proc(Time);
+      BPModel::GetInstance()->BP_timer_callback_out();
+      return;
     }
-    /*
-     * @brief 回调函数
-     */
-    static void BP_TimerCallback(uint8_t data)
+    BPModel::GetInstance()->BP_timer_callback_proc(Time);
+  }
+  /*
+   * @brief 回调函数
+   */
+  static void BP_TimerCallback(uint8_t data)
+  {
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_TimerCallback %d", data);
+    GraphicService::GetInstance()->PostGraphicEvent(
+        std::bind(BP_TimerCallbackProc, data));
+  }
+
+  /*
+   *  @brief 开启定时器函数
+   *  @param interval 时间间隔，单位ms
+   */
+  void BPModel::BP_StartTimer(uint32_t interval)
+  {
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
+    /* -------------------------- 1.检查定时器是否已经存在，如果存在则返回
+     * ------------------------- */
+    if (g_timer != nullptr)
     {
-      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_TimerCallback %d", data);
-      GraphicService::GetInstance()->PostGraphicEvent(
-          std::bind(BP_TimerCallbackProc, data));
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
+      return;
     }
 
-    /*
-     *  @brief 开启定时器函数
-     *  @param interval 时间间隔，单位ms
-     */
-    void BPModel::BP_StartTimer(uint32_t interval)
+    /* --------------------------------- 2.创建定时器
+     * -------------------------------- */
+    g_timer = osTimerNew((osTimerFunc_t)BP_TimerCallback, osTimerPeriodic,
+                         nullptr, nullptr);
+    // 检查定时器创建是否成功
+    if (g_timer == nullptr)
     {
-      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
-      /* -------------------------- 1.检查定时器是否已经存在，如果存在则返回
-       * ------------------------- */
-      if (g_timer != nullptr)
-      {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
-        return;
-      }
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
+      return;
+    }
 
-      /* --------------------------------- 2.创建定时器
-       * -------------------------------- */
-      g_timer = osTimerNew((osTimerFunc_t)BP_TimerCallback, osTimerPeriodic,
-                           nullptr, nullptr);
-      // 检查定时器创建是否成功
-      if (g_timer == nullptr)
+    /* ----------------------------- 3.将毫秒转换为系统时钟节拍数
+     * ---------------------------- */
+    /* --------------------------------- 4.启动定时器
+     * -------------------------------- */
+    osStatus_t ret = osTimerStart(g_timer, interval);
+    /* -------------------- 5.检查定时器启动是否成功,如果启动失败，删除定时器并置为
+     * nullptr -------------------- */
+    if (ret != osOK)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                    "osTimerDelete failed, ret = %lx!!", ret);
+      if (g_timer != nullptr)
       {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
-        return;
+        ret = osTimerDelete(g_timer);
       }
-
-      /* ----------------------------- 3.将毫秒转换为系统时钟节拍数
-       * ---------------------------- */
-      /* --------------------------------- 4.启动定时器
-       * -------------------------------- */
-      osStatus_t ret = osTimerStart(g_timer, interval);
-      /* -------------------- 5.检查定时器启动是否成功,如果启动失败，删除定时器并置为
-       * nullptr -------------------- */
+      g_timer = nullptr;
+      return;
+    }
+  }
+  /*
+   * @brief 停止定时器
+   */
+  void BPModel::BP_StopTimer(void)
+  {
+    // 检查定时器是否存在
+    if (g_timer != nullptr)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StopTimer");
+      osTimerStop(g_timer);
+      // 删除定时器并置为 nullptr
+      osStatus_t ret = osTimerDelete(g_timer);
       if (ret != osOK)
       {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
                       "osTimerDelete failed, ret = %lx!!", ret);
-        if (g_timer != nullptr)
-        {
-          ret = osTimerDelete(g_timer);
-        }
-        g_timer = nullptr;
-        return;
-      }
-    }
-    /*
-     * @brief 停止定时器
-     */
-    void BPModel::BP_StopTimer(void)
-    {
-      // 检查定时器是否存在
-      if (g_timer != nullptr)
-      {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StopTimer");
-        osTimerStop(g_timer);
-        // 删除定时器并置为 nullptr
-        osStatus_t ret = osTimerDelete(g_timer);
-        if (ret != osOK)
-        {
-          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                        "osTimerDelete failed, ret = %lx!!", ret);
-        }
-        g_timer = nullptr;
       }
+      g_timer = nullptr;
     }
+  }
 
 #endif
 
-    /////////////////////////////////////获取数据 定时器处理 不要修改//////////////////////////////////////////////////
+/////////////////////////////////////获取数据 定时器处理 不要修改//////////////////////////////////////////////////
 #if DECLARE_BP_GETDATA
-    // 声明定时器变量
-    static osTimerId_t g_timer_get_data = nullptr;
-    /*定时器到期时的处理*/
-    static void BP_Timer_GetData_CallbackProc(uint8_t data)
-    {
-      // 取出48个数 添加到 显示数组
-      uint8_t sensorData[48] = {0};
+  // 声明定时器变量
+  static osTimerId_t g_timer_get_data = nullptr;
+  /*定时器到期时的处理*/
+  static void BP_Timer_GetData_CallbackProc(uint8_t data)
+  {
+    // 取出48个数 添加到 显示数组
+    uint8_t sensorData[48] = {0};
 #ifdef ENABLE_BN02
-      get_bp_ui_data(sensorData, 48); // 提取前48个字节
+    get_bp_ui_data(sensorData, 48); // 提取前48个字节
 #endif
 
-      for (uint8_t i = 0; i < 48; i++)
-      {
-        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Data[%d] = %d\n", i, sensorData[i]);
-        // 更新显示数组
-        BPModel::GetInstance()->mapDataArray(sensorData[i]);
-      }
+    for (uint8_t i = 0; i < 48; i++)
+    {
+      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Data[%d] = %d\n", i, sensorData[i]);
+      // 更新显示数组
+      BPModel::GetInstance()->mapDataArray(sensorData[i]);
+    }
 
-      // 更新UI 测试更新
-      BPDetectBeginView *view = BPDetectBeginView::GetInstance();
-      if (view)
-      {
-        view->UpdateChartData();
-      }
+    // 更新UI 测试更新
+    BPDetectBeginView *view = BPDetectBeginView::GetInstance();
+    if (view)
+    {
+      view->UpdateChartData();
     }
-    /*
-     * @brief 回调函数
-     */
-    static void BP_Timer_GetData_Callback(uint8_t data)
+  }
+  /*
+   * @brief 回调函数
+   */
+  static void BP_Timer_GetData_Callback(uint8_t data)
+  {
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_Timer_GetData_Callback %d", data);
+    GraphicService::GetInstance()->PostGraphicEvent(
+        std::bind(BP_Timer_GetData_CallbackProc, data));
+  }
+
+  /*
+   *  @brief 开启定时器函数
+   *  @param interval 时间间隔，单位ms
+   */
+  void BPModel::BP_Start_GetData_Timer(uint32_t interval)
+  {
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
+    if (g_timer_get_data != nullptr)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
+      return;
+    }
+    g_timer_get_data = osTimerNew((osTimerFunc_t)BP_Timer_GetData_Callback, osTimerPeriodic,
+                                  nullptr, nullptr);
+    if (g_timer_get_data == nullptr)
     {
-      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_Timer_GetData_Callback %d", data);
-      GraphicService::GetInstance()->PostGraphicEvent(
-          std::bind(BP_Timer_GetData_CallbackProc, data));
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
+      return;
     }
 
-    /*
-     *  @brief 开启定时器函数
-     *  @param interval 时间间隔，单位ms
-     */
-    void BPModel::BP_Start_GetData_Timer(uint32_t interval)
+    osStatus_t ret = osTimerStart(g_timer_get_data, interval);
+    if (ret != osOK)
     {
-      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                    "osTimerDelete failed, ret = %lx!!", ret);
       if (g_timer_get_data != nullptr)
       {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
-        return;
-      }
-      g_timer_get_data = osTimerNew((osTimerFunc_t)BP_Timer_GetData_Callback, osTimerPeriodic,
-                                    nullptr, nullptr);
-      if (g_timer_get_data == nullptr)
-      {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
-        return;
+        ret = osTimerDelete(g_timer_get_data);
       }
-
-      osStatus_t ret = osTimerStart(g_timer_get_data, interval);
+      g_timer_get_data = nullptr;
+      return;
+    }
+  }
+  /*
+   * @brief 停止定时器
+   */
+  void BPModel::BP_Stop_GetData_Timer(void)
+  {
+    // 检查定时器是否存在
+    if (g_timer_get_data != nullptr)
+    {
+      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)
       {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
                       "osTimerDelete failed, ret = %lx!!", ret);
-        if (g_timer_get_data != nullptr)
-        {
-          ret = osTimerDelete(g_timer_get_data);
-        }
-        g_timer_get_data = nullptr;
-        return;
       }
+      g_timer_get_data = nullptr;
     }
-    /*
-     * @brief 停止定时器
-     */
-    void BPModel::BP_Stop_GetData_Timer(void)
+  }
+#endif
+  /////////////////////////////////////////////////数据存储////////////////////////////////////////////////////////////
+  bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
+  {
+
+    // 判断文件夹是否存在
+    if (!CreateBPFolder())
     {
-      // 检查定时器是否存在
-      if (g_timer_get_data != nullptr)
-      {
-        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)
-        {
-          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                        "osTimerDelete failed, ret = %lx!!", ret);
-        }
-        g_timer_get_data = nullptr;
-      }
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateBPFolder file");
+      return false;
     }
-#endif
-    /////////////////////////////////////////////////数据存储////////////////////////////////////////////////////////////
-    bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
+    if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
     {
-
-      // 判断文件夹是否存在
-      if (!CreateBPFolder())
+      // 对于今日数据，需要检查是否为当天
+      if (!IsTimestampToday(data.timestamp))
       {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateBPFolder file");
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Data timestamp is not today");
         return false;
       }
-      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);
-      }
-      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "UpdateHealthData failed");
-      return false;
+      return save_bin_BP(data, StorageType);
     }
-    // 存储bin文件
-    bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
+    else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
     {
-      /* 存储 bin 文件 [协议使用] */
-
-      std::string binFilePath;
-      FILE *fp;
-      if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
-      {
-        binFilePath = GetBPDataPath();
-        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
-                      binFilePath.c_str());
-        fp = fopen(binFilePath.c_str(), "ab+"); // 追加模式
-      }
+      return save_bin_BP(data, StorageType);
+    }
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "UpdateHealthData failed");
+    return false;
+  }
+  // 存储bin文件
+  bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
+  {
+    /* 存储 bin 文件 [协议使用] */
 
-      else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
-      {
-        binFilePath = std::string(BP_LAST_DATA_PATH);
-        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
-                      binFilePath.c_str());
-        fp = fopen(binFilePath.c_str(), "wb+"); // 覆盖模式
-      }
-      if (fp == NULL)
-      {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                      "Failed to open binary file for writing");
-        return false;
-      }
+    std::string binFilePath;
+    FILE *fp;
+    if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
+    {
+      binFilePath = GetBPDataPath();
+      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
+                    binFilePath.c_str());
+      fp = fopen(binFilePath.c_str(), "ab+"); // 追加模式
+    }
 
-      // 写入数据
-      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;
-      }
+    else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
+    {
+      binFilePath = std::string(BP_LAST_DATA_PATH);
+      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
+                    binFilePath.c_str());
+      fp = fopen(binFilePath.c_str(), "wb+"); // 覆盖模式
+    }
+    if (fp == NULL)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                    "Failed to open binary file for writing");
+      return false;
+    }
 
-      fclose(fp);
-      // yznyzn
+    // 写入数据
+    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,
-                    "Saved BP data: timestamp = %d, SBP = %d, DBP = %d", data.timestamp,
-                    data.last_check_sbp_value,
-                    data.last_check_dbp_value);
-      return true;
+                    "Failed to write data to binary file");
+      fclose(fp);
+      return false;
     }
-    /*创建文件夹*/
-    bool BPModel::CreateBPFolder()
+
+    fclose(fp);
+    // yznyzn
+    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_DATA_PATH, &info) != 0)
     {
-      struct stat info;
-      if (stat(BP_DATA_PATH, &info) != 0)
+      if (mkdir(BP_DATA_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
       {
-        if (mkdir(BP_DATA_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
-        {
-          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "mkdir BP_JSON_PATH is error");
-          return false;
-        }
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "mkdir BP_JSON_PATH is error");
+        return false;
       }
+    }
 
+    return true;
+  }
+
+  bool BPModel::IsTimestampToday(uint32_t timestamp)
+  {
+    // 获取当前时间
+    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))
+    {
       return true;
     }
+    else
+    {
+      return false;
+    }
+  }
+  /*加载文件中数据*/
+  bool BPModel::LoadBP(BP_STORAGE_TYPE StorageType)
+  {
+    std::string binFilePath;
+    if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
+    {
+      lastCheckData.clear();         // 清空数组
+      binFilePath = GetBPDataPath(); // 文件路径
+    }
+    else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
+    {
+      binFilePath = std::string(BP_LAST_DATA_PATH);
+    }
 
-    bool BPModel::IsTimestampToday(uint32_t timestamp)
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str()); // 打开失败，今天没有测量记录则没有这个文件
+
+    std::ifstream ifs(binFilePath, std::ios::binary);
+    if (!ifs.is_open())
     {
-      // 获取当前时间
-      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))
-      {
-        return true;
-      }
-      else
-      {
-        return false;
-      }
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                    "Failed to open binary file for reading");
+      return false;
     }
-    /*加载文件中数据*/
-    bool BPModel::LoadBP(BP_STORAGE_TYPE StorageType)
+
+    LAST_CHECK_DATA data;
+    // 选取数据
+    while (true)
     {
-      std::string binFilePath;
-      if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
+      // 先读取时间戳
+      if (!ifs.read(reinterpret_cast<char *>(&data.timestamp), sizeof(data.timestamp)))
       {
-        lastCheckData.clear();         // 清空数组
-        binFilePath = GetBPDataPath(); // 文件路径
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                      "Failed to read heart rate value");
+        break; // 如果读取失败，退出循环
       }
-      else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
+
+      // 再读取SBP值
+      if (!ifs.read(reinterpret_cast<char *>(&data.last_check_sbp_value), sizeof(data.last_check_sbp_value)))
       {
-        binFilePath = std::string(BP_LAST_DATA_PATH);
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                      "Failed to read heart rate value");
+        break; // 如果读取失败，退出循环
       }
-
-      WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str()); // 打开失败，今天没有测量记录则没有这个文件
-
-      std::ifstream ifs(binFilePath, std::ios::binary);
-      if (!ifs.is_open())
+      // 再读取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 open binary file for reading");
-        return false;
+                      "Failed to read heart rate value");
+        break; // 如果读取失败，退出循环
       }
-
-      LAST_CHECK_DATA data;
-      // 选取数据
-      while (true)
+      // 如果时间为当天
+      if (StorageType == BP_STORAGE_TYPE::TODAY_DATA && IsTimestampToday(data.timestamp))
       {
-        // 先读取时间戳
-        if (!ifs.read(reinterpret_cast<char *>(&data.timestamp), sizeof(data.timestamp)))
-        {
-          WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                        "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 (StorageType == BP_STORAGE_TYPE::TODAY_DATA && IsTimestampToday(data.timestamp))
-        {
 
-          lastCheckData.push_back(data); // 存入数组中
+        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);
+        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; // 加载上次测量时间
-        }
       }
-      // 关闭文件
-      ifs.close();
-      return true;
+      else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
+      {
+        lastData = data; // 加载上次测量时间
+      }
     }
+    // 关闭文件
+    ifs.close();
+    return true;
+  }
 
-  } // namespace OHOS
+} // namespace OHOS
-- 
2.17.1