From: xue <2144439972@qq.com>
Date: Fri, 4 Jul 2025 09:14:11 +0000 (+0800)
Subject: 增加折线图与存储
X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=ce0e62e1f34e5b3a6f37f288f922d595da6fea49;p=mirrors%2FFD230.git

增加折线图与存储
---

diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPModel.h b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPModel.h
index 64132df1d..231221fe5 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPModel.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPModel.h
@@ -4,6 +4,9 @@
 
 #include <stdint.h>
 #include <string>
+#include <deque> 
+#include <vector>
+#include "map"
 
 #define SBP_VALUE 120
 #define DBP_VALUE 80
@@ -64,6 +67,13 @@ enum class BP_VALUE_TYPE {
   DBP,
 };
 
+struct LAST_CHECK_DATA {  
+  int16_t last_check_sbp_value;      // 上次检测收缩压值
+  int16_t last_check_dbp_value;      // 上次检测舒张压值
+  std::string timestamp;             // 时间戳  单位s
+};
+
+#define BP_CHECK_TIME_MAX_TEST 120   //测量所需时间
 #define BP_CHECK_TIME_MAX 30   //测量所需时间
 #define BP_ANLYSISI_TIME_MAX 5 //分析所需时间
 #define BP_REMIND_TIME_MAX 5   //提醒所需时间
@@ -83,7 +93,7 @@ public:
   // 控制血压检测
   void BP_Control(BPState state);
   void BP_SetValue(BP_VALUE_TYPE type, bool set_value);
-  int16_t GetValue(BP_VALUE_TYPE type);
+  int GetValue(BP_VALUE_TYPE type);
   void BP_timer_callback_out();
   void BP_timer_callback_proc(int data);
 
@@ -91,10 +101,34 @@ public:
   void BP_StartTimer(uint32_t interval = 1 * 1000); // 1s定时器
   void BP_StopTimer(void);
 
+  void BP_START(void);
+  void BP_STOP(void);
+  void BP_GetData(int *sbp,int *dbp);
+
+  std::map<int, std::pair<int, int>> GetBPValueMap(void);
+  void SetBPValueMap(int sbp,int dbp,int index);
+  int GetBPValueCnt(void);
+  int mapValue(int value);
+  void mapDataArray(int value);
+
+  /* --------------------------------- 最近检测数据 --------------------------------- */
+  #define BP_LAST_CHECK_FILE_PATH "/user/userdata/bp/bp_last_check.txt"
+  bool save_last_check_bp_data(LAST_CHECK_DATA data); 
+  bool load_last_check_bp_data(void);
+  bool get_last_check_bp_data(LAST_CHECK_DATA &data);
+  int get_last_check_data_num(void);
+  const uint8_t max_checkout_num = 30;
+  std::deque<LAST_CHECK_DATA> lastCheckData;          // 存储最近检测数据
+  /* -------------------------------------------------------------------------- */
+
+
 private:
   BPState current_state = BPState::BP_NORMAL;
-  int16_t custom_sbp = SBP_VALUE;
-  int16_t custom_dbp = DBP_VALUE;
+  int custom_sbp = SBP_VALUE;
+  int custom_dbp = DBP_VALUE;
+  std::map<int, std::pair<int, int>> bp_check_value_map;  //记录获取的sbp和dbp值
+  int bp_check_cnt = 0;                                   //记录获取的次数
+  std::vector<int> bp_check_value_vector;                 //测量值
 };
 } // namespace OHOS
 
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPSecUnderCalibrationView.h b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPSecUnderCalibrationView.h
index cda4a3164..784651c66 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPSecUnderCalibrationView.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPSecUnderCalibrationView.h
@@ -9,6 +9,7 @@
 #include "components/ui_view_group.h"
 #include "components/ui_scroll_view.h"
 #include "components/ui_label_button_ext.h"
+#include "components/ui_chart.h"
 namespace OHOS
 {
 
@@ -23,8 +24,9 @@ namespace OHOS
         bool AddButton();
         bool InitLable();
         bool Initbackground();
+        void InitChartView();
 
-        void UpdateTimeText(int data);
+        void UpdateTimeText(int data, std::vector<int> &input);
 
     private:
         UIImageView *background = nullptr;
@@ -34,6 +36,10 @@ namespace OHOS
         UILabelExt *timeLabel = nullptr;
         UILabel *timenumLabel = nullptr;
         UIViewGroup *group{nullptr};
+
+        Point testData[60];
+        UIChartDataSerial *dataSerial{nullptr};
+        UIChartPolyline *datachart = nullptr;
     };
 }
 
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPUnderCalibrationView.h b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPUnderCalibrationView.h
index 35c9a2c25..9adb9bf25 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPUnderCalibrationView.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPUnderCalibrationView.h
@@ -9,6 +9,7 @@
 #include "components/ui_view_group.h"
 #include "components/ui_scroll_view.h"
 #include "components/ui_label_button_ext.h"
+#include "components/ui_chart.h"
 namespace OHOS
 {
 
@@ -23,8 +24,9 @@ namespace OHOS
         bool AddButton();
         bool InitLable();
         bool Initbackground();
+        void InitChartView();
 
-        void UpdateTimeText(int data);
+        void UpdateTimeText(int data, std::vector<int> &input);
 
     private:
         UIImageView *background = nullptr;
@@ -33,6 +35,13 @@ namespace OHOS
         UILabelExt *remindLabel = nullptr;
         UILabelExt *timeLabel = nullptr;
         UILabel *timenumLabel = nullptr;
+
+        
+        Point testData[60];
+        UIChartDataSerial *dataSerial{nullptr};
+        UIChartPolyline *datachart = nullptr;
+
+        
         UIViewGroup *group{nullptr};
     };
 }
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectBeginView.h b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectBeginView.h
index 6e0d65815..9bf35d790 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectBeginView.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectBeginView.h
@@ -26,7 +26,7 @@ namespace OHOS
         bool Initbackground();
         void InitChartView();
     
-        void UpdateTimeText(int data);
+          void UpdateTimeText(int data, std::vector<int> &input);
 
     private:
         UIImageView *background = nullptr;
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectFirstView.h b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectFirstView.h
index ad445171a..6dfc14962 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectFirstView.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/detection/BPDetectFirstView.h
@@ -20,6 +20,7 @@ public:
   UIViewGroup *BPDetectFirstInit();
   void UpdateText(); //更新文本数据
   void InitChartView();
+  void WriteMapToPointArrays(const std::map<int, std::pair<int, int>> &bpMap);
 
 private:
   UILabelExt *DBPTitleLabel{nullptr};
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 bc485138c..79420461c 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp
@@ -33,6 +33,11 @@
 #include "custom_utils.h"
 #include "ppg_service.h"
 
+#ifdef ENABLE_BN02
+#include "bp_service.h"
+#include "bp_tcp_server.h"
+#endif
+
 /*
 ----------------------------
 收缩压：DBP
@@ -47,160 +52,205 @@
 3、低血压：收缩压＜90 mmHg 且 舒张压＜60 mmHg。
 ----------------------------
 */
-namespace OHOS {
+namespace OHOS
+{
 /**
  * @brief Constructor for the BPModel class.
  */
 #define MAX_UNWARE_COUNT 10
 #define MAX_VALID_SPO2_COUNT 30
 #define MAX_DISVALID_SPO2_COUNT 100
-static uint16 CalibrationFlag = 0;
-
-// 声明定时器变量
-static osTimerId_t g_timer = nullptr;
-static int Time = 30;
-
-BPModel::BPModel() {}
-BPModel::~BPModel() {}
-BPModel *BPModel::GetInstance(void) {
-  static BPModel instance;
-  return &instance;
-}
-// 获取当前时间戳字符串
-std::string BPModel::GetCurrentTimeStr() {
-  uint32_t timeStamp = 0;
-
-  if (uapi_get_timestampe_ss(&timeStamp) != ERRCODE_SUCC) {
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to get timestamp");
-    return "----/--/-- \n --/--";
+  static uint16 CalibrationFlag = 0;
+
+  // 声明定时器变量
+  static osTimerId_t g_timer = nullptr;
+  static int Time = 30;
+
+  BPModel::BPModel() {}
+  BPModel::~BPModel() {}
+  BPModel *BPModel::GetInstance(void)
+  {
+    static BPModel instance;
+    return &instance;
   }
+  // 获取当前时间戳字符串
+  std::string BPModel::GetCurrentTimeStr()
+  {
+    uint32_t timeStamp = 0;
+
+    if (uapi_get_timestampe_ss(&timeStamp) != ERRCODE_SUCC)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to get timestamp");
+      return "----/--/-- \n --/--";
+    }
 
-  // 将时间戳转换为 time_t 类型
-  time_t rawtime = static_cast<time_t>(timeStamp);
-  struct tm *timeinfo = localtime(&rawtime);
+    // 将时间戳转换为 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 "----/--/-- \n --/--";
-  }
+    if (timeinfo == NULL)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to convert time");
+      return "----/--/-- \n --/--";
+    }
 
-  // 格式化时间为字符串
-  char buffer[20]; // 格式: YYYY-MM-DD HH:MM
-  std::strftime(buffer, sizeof(buffer), "%Y-%m-%d  \n %H:%M", timeinfo);
-
-  return std::string(buffer);
-}
-/////////////////////////状态管理//////////////////////////////////////////
-int16_t BPModel::GetCalibrationFlag() { return CalibrationFlag; }
-void BPModel::SetCalibrationFlag(int value) { CalibrationFlag = value; }
-
-// 管理当前状态
-void BPModel::BP_SetState(BPState state) { current_state = state; }
-BPState BPModel::GetCurrentState() { return current_state; }
-
-// 进行传感器、定时器等控制
-void BPModel::BP_Control(BPState state) {
-  if (state == current_state) {
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
-                  "BP_Control: Already in current state");
-    return;
-  }
-  switch (state) {
-  case BPState::BP_NORMAL: {
-    /*
-     关闭定时器
-     关闭传感器
-     关闭常亮
-   */
-    BP_StopTimer();
-    ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON);
-    Time = BP_CHECK_TIME_MAX;
-    break;
-  }
-  case BPState::BP_CALIBRATING_FIRSTTIME:
-  case BPState::BP_CALIBRATING_SECONDTIME:
-  case BPState::STRESS_MEASURE:
-  case BPState::FATIGUE_MEASURE:
-  case BPState::ECG_MEASURE:
-  case BPState::EMO_MEASURE:
-  case BPState::BP_DETECTING: {
-    /*
-      开启定时器
-      开启传感器
-      开启常亮
-    */
-    BP_StartTimer();
-    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
-
-    if (Time != BP_CHECK_TIME_MAX)
-      Time = BP_CHECK_TIME_MAX; // 重置时间
-
-    break;
-  }
-  case BPState::BP_CALIBRATING_ANGLYSIS:
-  case BPState::STRESS_ANALYSIS:
-  case BPState::FATIGUE_ANALYSIS:
-  case BPState::ECG_ANALYSIS:
-  case BPState::EMO_ANALYSIS: {
-    BP_StartTimer();
-    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
-
-    if (Time != BP_ANLYSISI_TIME_MAX)
-      Time = BP_ANLYSISI_TIME_MAX; // 重置时间
-    break;
-  }
-  case BPState::ECG_REMIND:
-  case BPState::ECG_RESULT: {
-    BP_StartTimer();
-    ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
-
-    if (Time != BP_REMIND_TIME_MAX)
-      Time = BP_REMIND_TIME_MAX; // 重置时间
-    break;
+    // 格式化时间为字符串
+    char buffer[20]; // 格式: YYYY-MM-DD HH:MM
+    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d  \n %H:%M", timeinfo);
+
+    return std::string(buffer);
   }
+  /////////////////////////状态管理//////////////////////////////////////////
+  int16_t BPModel::GetCalibrationFlag() { return CalibrationFlag; }
+  void BPModel::SetCalibrationFlag(int value) { CalibrationFlag = value; }
+
+  // 管理当前状态
+  void BPModel::BP_SetState(BPState state) { current_state = state; }
+  BPState BPModel::GetCurrentState() { return current_state; }
+
+  // 进行传感器、定时器等控制
+  void BPModel::BP_Control(BPState state)
+  {
+    if (state == current_state)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                    "BP_Control: Already in current state");
+      return;
+    }
+    switch (state)
+    {
+    case BPState::BP_NORMAL:
+    {
+      /*
+       关闭定时器
+       关闭传感器
+       关闭常亮
+     */
+      BP_StopTimer();
+      ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON);
+      Time = BP_CHECK_TIME_MAX;
+      break;
+    }
+    case BPState::BP_CALIBRATING_SECONDTIME: // 测量与校准数据
+    case BPState::BP_CALIBRATING_FIRSTTIME:
+    case BPState::BP_DETECTING:
+    {
+      /*
+        开启定时器
+        开启传感器
+        开启常亮
+      */
+      bp_check_value_map.clear();
+      bp_check_value_vector.clear();
+      BP_StartTimer();
+      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+                    "开启测量");
+      // BP_START(); // 底层接口开启血压
 
-  default:
-    /*未知状态，全部状态重置*/
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_Control: Invalid state");
-    BP_SetState(BPState::BP_NORMAL);
-    BP_StopTimer();
-    Time = BP_CHECK_TIME_MAX;
-    return;
+      if (bp_check_cnt != 0)
+        bp_check_cnt = 0; // 重置计数
+      if (Time != BP_CHECK_TIME_MAX_TEST)
+        Time = BP_CHECK_TIME_MAX_TEST; // 重置时间120秒
+      break;
+    }
+
+    case BPState::STRESS_MEASURE:
+    case BPState::FATIGUE_MEASURE:
+    case BPState::ECG_MEASURE:
+    case BPState::EMO_MEASURE:
+    {
+      /*
+        开启定时器
+        开启传感器
+        开启常亮
+      */
+      BP_StartTimer();
+      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+
+      if (Time != BP_CHECK_TIME_MAX)
+        Time = BP_CHECK_TIME_MAX; // 重置时间
+
+      break;
+    }
+    case BPState::BP_CALIBRATING_ANGLYSIS:
+    case BPState::STRESS_ANALYSIS:
+    case BPState::FATIGUE_ANALYSIS:
+    case BPState::ECG_ANALYSIS:
+    case BPState::EMO_ANALYSIS:
+    {
+      BP_StartTimer();
+      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+
+      if (Time != BP_ANLYSISI_TIME_MAX)
+        Time = BP_ANLYSISI_TIME_MAX; // 重置时间
+      break;
+    }
+    case BPState::ECG_REMIND:
+    case BPState::ECG_RESULT:
+    {
+      BP_StartTimer();
+      ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+
+      if (Time != BP_REMIND_TIME_MAX)
+        Time = BP_REMIND_TIME_MAX; // 重置时间
+      break;
+    }
+
+    default:
+      /*未知状态，全部状态重置*/
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_Control: Invalid state");
+      BP_SetState(BPState::BP_NORMAL);
+      BP_StopTimer();
+      Time = BP_CHECK_TIME_MAX;
+      return;
+    }
+    // 更新状态
+    BP_SetState(state);
   }
-  // 更新状态
-  BP_SetState(state);
-}
-/////////////////////////////////////////////////////////
-// 机器校准收缩压与舒张压的数值
-void BPModel::BP_SetValue(BP_VALUE_TYPE type, bool set_value) {
-  if (set_value) {
-    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++;
-    }
-  } else {
-    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--;
+  /////////////////////////////////////////////////////////
+  // 机器校准收缩压与舒张压的数值
+  void BPModel::BP_SetValue(BP_VALUE_TYPE type, bool set_value)
+  {
+    if (set_value)
+    {
+      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++;
+      }
+    }
+    else
+    {
+      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--;
+      }
     }
   }
-}
-int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
-  if (type == BP_VALUE_TYPE::SBP)
-    return custom_sbp;
-  else
-    return custom_dbp;
-}
-//////////////////////////////////time处理////////////////////////////////////
-// time到时的处理
-  void BPModel::BP_timer_callback_out() {
-    
+  int BPModel::GetValue(BP_VALUE_TYPE type)
+  {
+    if (type == BP_VALUE_TYPE::SBP)
+      return custom_sbp;
+    else
+      return custom_dbp;
+  }
+  //////////////////////////////////time处理////////////////////////////////////
+  // time到时的处理
+  void BPModel::BP_timer_callback_out()
+  {
+
     BP_StopTimer();
 
     // 提前获取各视图实例
@@ -215,20 +265,25 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
 
     // 处理血压校准相关状态
     if (current_state == BPState::BP_CALIBRATING_FIRSTTIME ||
-        current_state == BPState::BP_CALIBRATING_SECONDTIME) {
-      if (bpMainView) {
+        current_state == BPState::BP_CALIBRATING_SECONDTIME)
+    {
+      if (bpMainView)
+      {
         bpMainView->ChangeView(current_state == BPState::BP_CALIBRATING_FIRSTTIME
-                                  ? BPUNDERCALIBRATIONVIEW
-                                  : BPSECUNDERCALIBRATIONVIEW,
-                              BPCALIBRATIONMINDVIEW);
+                                   ? BPUNDERCALIBRATIONVIEW
+                                   : BPSECUNDERCALIBRATIONVIEW,
+                               BPCALIBRATIONMINDVIEW);
       }
+      // BP_STOP();//停止测量---会关机
       BP_SetState(BPState::BP_NORMAL);
       CalibrationFlag++;
       return;
     }
     // 处理血压分析状态
-    if (current_state == BPState::BP_CALIBRATING_ANGLYSIS) {
-      if (bpMainView) {
+    if (current_state == BPState::BP_CALIBRATING_ANGLYSIS)
+    {
+      if (bpMainView)
+      {
         bpMainView->ChangeView(BPRESULTANALYSISVIEW, BPCALIBRATIONPASSVIEW);
       }
       BP_SetState(BPState::BP_NORMAL);
@@ -239,8 +294,10 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
       return;
     }
     // 处理血压检测状态
-    if (current_state == BPState::BP_DETECTING) {
-      if (bpDetectionView) {
+    if (current_state == BPState::BP_DETECTING)
+    {
+      if (bpDetectionView)
+      {
         bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW);
       }
       BP_SetState(BPState::BP_NORMAL);
@@ -248,60 +305,76 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
     }
 
     // 处理压力检测与分析
-    if (current_state == BPState::STRESS_MEASURE) {
-      if (stressMainView) {
+    if (current_state == BPState::STRESS_MEASURE)
+    {
+      if (stressMainView)
+      {
         stressMainView->ChangeView(STRESSUNDERMEASUREVIEW, STRESSANALYSISEVIEW);
       }
       BP_Control(BPState::STRESS_ANALYSIS);
-      if (stressAnalysisView) {
+      if (stressAnalysisView)
+      {
         stressAnalysisView->startorstopAnalysisAni(true);
       }
       return;
     }
-    if (current_state == BPState::STRESS_ANALYSIS) {
-      if (stressMainView) {
+    if (current_state == BPState::STRESS_ANALYSIS)
+    {
+      if (stressMainView)
+      {
         stressMainView->ChangeView(STRESSANALYSISEVIEW, STRESSRESULTVIEW);
       }
       BP_SetState(BPState::BP_NORMAL);
-      if (stressAnalysisView) {
+      if (stressAnalysisView)
+      {
         stressAnalysisView->startorstopAnalysisAni(false);
       }
       return;
     }
 
     // 处理疲劳度检测与分析
-    if (current_state == BPState::FATIGUE_MEASURE) {
-      if (fatigueMainView) {
+    if (current_state == BPState::FATIGUE_MEASURE)
+    {
+      if (fatigueMainView)
+      {
         fatigueMainView->ChangeView(FATIGUEUNDERMEASUREVIEW,
                                     FATIGUEANALYSISEVIEW);
       }
       BP_Control(BPState::FATIGUE_ANALYSIS);
-      if (fatigueAnalysisView) {
+      if (fatigueAnalysisView)
+      {
         fatigueAnalysisView->startorstopAnalysisAni(true);
       }
       return;
     }
-    if (current_state == BPState::FATIGUE_ANALYSIS) {
-      if (fatigueMainView) {
+    if (current_state == BPState::FATIGUE_ANALYSIS)
+    {
+      if (fatigueMainView)
+      {
         fatigueMainView->ChangeView(FATIGUEANALYSISEVIEW, FATIGUERESULTVIEW);
       }
       BP_SetState(BPState::BP_NORMAL);
-      if (fatigueAnalysisView) {
+      if (fatigueAnalysisView)
+      {
         fatigueAnalysisView->startorstopAnalysisAni(false);
       }
       return;
     }
 
     // 处理情绪检测与分析
-    if (current_state == BPState::EMO_MEASURE) {
-      if (emoView) {
+    if (current_state == BPState::EMO_MEASURE)
+    {
+      if (emoView)
+      {
         EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTVIEW,
                                                         EMOTIONTESTANALYSISVIEW);
       }
       return;
 
-      if (current_state == BPState::EMO_ANALYSIS) {
-        if (emoView) {
+      if (current_state == BPState::EMO_ANALYSIS)
+      {
+        if (emoView)
+        {
           EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTANALYSISVIEW,
                                                           EMOTIONTESTRESULTVIEW);
         }
@@ -310,25 +383,30 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
       }
 
       // 处理ECG相关状态
-      if (ecgView) {
-        if (current_state == BPState::ECG_REMIND) {
+      if (ecgView)
+      {
+        if (current_state == BPState::ECG_REMIND)
+        {
           EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTREMINDERVIEW,
                                                           ECGTESTINGVIEW);
           return;
         }
 
-        if (current_state == BPState::ECG_MEASURE) {
+        if (current_state == BPState::ECG_MEASURE)
+        {
           EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTINGVIEW,
                                                           ECGTESTANALYSISVIEW);
           return;
         }
 
-        if (current_state == BPState::ECG_ANALYSIS) {
+        if (current_state == BPState::ECG_ANALYSIS)
+        {
           EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTANALYSISVIEW,
                                                           ECGTESTRESULTVIEW);
           return;
         }
-        if (current_state == BPState::ECG_RESULT) {
+        if (current_state == BPState::ECG_RESULT)
+        {
 
           EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTRESULTVIEW,
                                                           ECGRESETTESTOFSUCCVIEW);
@@ -337,42 +415,115 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
       }
     }
   }
-  //每秒的处理
-  void BPModel::BP_timer_callback_proc(int data) {
+  // 每秒的处理
+  void BPModel::BP_timer_callback_proc(int data)
+  {
 
     // 根据状态处理
-    switch (current_state) {
+    switch (current_state)
+    {
     case BPState::BP_NORMAL:
       BP_StopTimer();
       BP_SetState(BPState::BP_NORMAL);
       return;
 
-    case BPState::BP_DETECTING: {
+    case BPState::BP_DETECTING:
+    {
       BPDetectBeginView *view = BPDetectBeginView::GetInstance();
-      if (view) {
-        view->UpdateTimeText(data);
+      if (view)
+      {
+        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 < 60) // 一分钟后获取数据
+      {
+        LAST_CHECK_DATA newData;
+        // BP_GetData(&custom_sbp, &custom_dbp);
+        newData.last_check_sbp_value = rand() % (210 - 60) + 60; // 测试数据
+        newData.last_check_dbp_value = rand() % (210 - 60) + 60;
+        newData.timestamp = BPModel::GetCurrentTimeStr();
+        SetBPValueMap(newData.last_check_sbp_value, newData.last_check_dbp_value, bp_check_cnt); // 传入map
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bp_check_cnt: %d ,SBP: %d, DBP: %d", bp_check_cnt, custom_sbp, custom_dbp);
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPValueMap        SBP: %d, DBP: %d", bp_check_value_map[bp_check_cnt].first, bp_check_value_map[bp_check_cnt].second);
+        bp_check_cnt++;
       }
       break;
     }
 
-    case BPState::BP_CALIBRATING_FIRSTTIME: {
+    case BPState::BP_CALIBRATING_FIRSTTIME:
+    {
       BPUnderCalibrationView *view = BPUnderCalibrationView::GetInstance();
-      if (view) {
-        view->UpdateTimeText(data);
+      if (view)
+      {
+        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 < 60) // 一分钟后获取数据
+      {
+        // BP_GetData(&custom_sbp, &custom_dbp);
+        // SetBPValueMap(custom_sbp, custom_dbp, bp_check_cnt); // 传入map
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bp_check_cnt: %d ,SBP: %d, DBP: %d", bp_check_cnt, custom_sbp, custom_dbp);
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPValueMap        SBP: %d, DBP: %d", bp_check_value_map[bp_check_cnt].first, bp_check_value_map[bp_check_cnt].second);
+        bp_check_cnt++;
       }
+
       break;
     }
-    case BPState::BP_CALIBRATING_SECONDTIME: {
+    case BPState::BP_CALIBRATING_SECONDTIME:
+    {
       BPSecUnderCalibrationView *view =
           BPSecUnderCalibrationView::GetInstance();
-      if (view) {
-        view->UpdateTimeText(data);
+      if (view)
+      {
+        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 < 60) // 一分钟后获取数据
+      {
+        // BP_GetData(&custom_sbp, &custom_dbp);
+        // SetBPValueMap(custom_sbp, custom_dbp, bp_check_cnt); // 传入map
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bp_check_cnt: %d ,SBP: %d, DBP: %d", bp_check_cnt, custom_sbp, custom_dbp);
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPValueMap        SBP: %d, DBP: %d", bp_check_value_map[bp_check_cnt].first, bp_check_value_map[bp_check_cnt].second);
+        bp_check_cnt++;
       }
+
       break;
     }
-    case BPState::ECG_MEASURE: {
+    case BPState::ECG_MEASURE:
+    {
       EcgTestingView *view = EcgTestingView::GetInstance();
-      if (view) {
+      if (view)
+      {
         view->UpdateTimeLabel(Time);
       }
       break;
@@ -387,7 +538,8 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
     case BPState::EMO_ANALYSIS:
     case BPState::BP_CALIBRATING_ANGLYSIS:
     case BPState::ECG_REMIND:
-    case BPState::ECG_RESULT: {
+    case BPState::ECG_RESULT:
+    {
       break;
     }
 
@@ -401,11 +553,13 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
   /////////////////////////////////////定时器处理 不要修改//////////////////////////////////////////////////
 
   /*定时器到期时的处理*/
-  static void BP_TimerCallbackProc(int data) {
+  static void BP_TimerCallbackProc(int data)
+  {
     // 倒计时
     Time--;
     // 到时的处理
-    if (Time < 0) {
+    if (Time < 0)
+    {
       BPModel::GetInstance()->BP_timer_callback_out();
       return;
     }
@@ -414,7 +568,8 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
   /*
    * @brief 回调函数
    */
-  static void BP_TimerCallback(int data) {
+  static void BP_TimerCallback(int data)
+  {
     WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_TimerCallback %d", data);
     GraphicService::GetInstance()->PostGraphicEvent(
         std::bind(BP_TimerCallbackProc, data));
@@ -424,11 +579,13 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
    *  @brief 开启定时器函数
    *  @param interval 时间间隔，单位ms
    */
-  void BPModel::BP_StartTimer(uint32_t interval) {
+  void BPModel::BP_StartTimer(uint32_t interval)
+  {
     WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
     /* -------------------------- 1.检查定时器是否已经存在，如果存在则返回
      * ------------------------- */
-    if (g_timer != nullptr) {
+    if (g_timer != nullptr)
+    {
       WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
       return;
     }
@@ -438,7 +595,8 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
     g_timer = osTimerNew((osTimerFunc_t)BP_TimerCallback, osTimerPeriodic,
                          nullptr, nullptr);
     // 检查定时器创建是否成功
-    if (g_timer == nullptr) {
+    if (g_timer == nullptr)
+    {
       WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
       return;
     }
@@ -452,10 +610,12 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
     osStatus_t ret = osTimerStart(g_timer, tick);
     /* -------------------- 5.检查定时器启动是否成功,如果启动失败，删除定时器并置为
      * nullptr -------------------- */
-    if (ret != osOK) {
+    if (ret != osOK)
+    {
       WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
                     "osTimerDelete failed, ret = %lx!!", ret);
-      if (g_timer != nullptr) {
+      if (g_timer != nullptr)
+      {
         ret = osTimerDelete(g_timer);
       }
       g_timer = nullptr;
@@ -465,14 +625,17 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
   /*
    * @brief 停止定时器
    */
-  void BPModel::BP_StopTimer(void) {
+  void BPModel::BP_StopTimer(void)
+  {
     // 检查定时器是否存在
-    if (g_timer != nullptr) {
+    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) {
+      if (ret != osOK)
+      {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
                       "osTimerDelete failed, ret = %lx!!", ret);
       }
@@ -480,4 +643,125 @@ int16_t BPModel::GetValue(BP_VALUE_TYPE type) {
     }
   }
 
+  void BPModel::BP_START(void)
+  {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_START");
+#ifdef ENABLE_BN02
+    bp_start(BP);
+#endif
+  }
+  void BPModel::BP_STOP(void)
+  {
+#ifdef ENABLE_BN02
+// bp_stop();
+#endif
+  }
+  void BPModel::BP_GetData(int *sbp, int *dbp)
+  {
+#ifdef ENABLE_BN02
+    bp_get_data(sbp, dbp);
+#endif
+  }
+
+  std::map<int, std::pair<int, int>> BPModel::GetBPValueMap()
+  {
+    return bp_check_value_map;
+  }
+
+  void BPModel::SetBPValueMap(int sbp, int dbp, int index)
+  {
+    bp_check_value_map[index] = {sbp, dbp};
+  }
+
+  int BPModel::GetBPValueCnt(void)
+  {
+    return bp_check_cnt;
+  }
+
+  int BPModel::mapValue(int 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(int value)
+  {
+    int mappedValue = mapValue(value);
+
+    bp_check_value_vector.push_back(mappedValue);
+  }
+
+  // 保存上次检测数据
+  bool BPModel::save_last_check_bp_data(LAST_CHECK_DATA data)
+  {
+    // 检查容量，最多存储30条日志
+    if (lastCheckData.size() >= max_checkout_num)
+    {
+      lastCheckData.pop_front(); // 超出限制，删除最旧的日志
+    }
+
+    // 保存新日志，将传入的完整检测数据添加到队列
+    lastCheckData.push_back(data);
+
+    // 将lastCheckData写入文件，覆盖写
+    std::ofstream outFile(BP_LAST_CHECK_FILE_PATH, std::ios::trunc);
+    if (!outFile)
+    {
+      return false; // 文件打开失败
+    }
+
+    // 遍历队列，将每条检测数据（包括收缩压、舒张压和时间戳）写入文件
+    for (const auto &Data : lastCheckData)
+    {
+      outFile << Data.last_check_sbp_value << " ";
+      outFile << Data.last_check_dbp_value << " ";
+      outFile << Data.timestamp << std::endl;
+    }
+    outFile.close();
+
+    return true;
+  }
+
+  // 加载上次检测数据
+  bool BPModel::load_last_check_bp_data(void)
+  {
+    std::ifstream inFile(BP_LAST_CHECK_FILE_PATH);
+    if (!inFile)
+    {
+      WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::load_last_check_bp_data");
+      return false; // 文件打开失败
+    }
+    // 读取文件内容，解析检测数据
+    LAST_CHECK_DATA data;
+    while (inFile >> data.last_check_sbp_value >> data.last_check_dbp_value >> data.timestamp)
+    {
+      lastCheckData.push_back(data);
+    }
+    return true;
+  }
+
+  bool BPModel::get_last_check_bp_data(LAST_CHECK_DATA &data)
+  {
+    // 获取队列中最后一次检测数据
+    if (lastCheckData.size() > 0)
+    {
+      data = lastCheckData.back();
+      return true;
+    }
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::get_last_check_bp_data is empty");
+    return false;
+  }
+
+  // 获取最近检测数据数量
+  int BPModel::get_last_check_data_num(void)
+  {
+    return lastCheckData.size();
+  }
+
 } // namespace OHOS
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPSecUnderCalibrationView.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPSecUnderCalibrationView.cpp
index e89475893..ac8298170 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPSecUnderCalibrationView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPSecUnderCalibrationView.cpp
@@ -71,14 +71,91 @@ namespace OHOS
             delete timenumLabel;
             timenumLabel = nullptr;
         }
+         if(dataSerial != nullptr)
+            {
+                datachart->ClearDataSerial();
+                delete dataSerial;
+                dataSerial = nullptr;
+            }
+            if(datachart != nullptr)
+            {
+                delete datachart;
+                datachart = nullptr;
+            }
     }
     /* -------------------------------------------------------------------------- */
-    void BPSecUnderCalibrationView::UpdateTimeText(int data)
+  void BPSecUnderCalibrationView::UpdateTimeText(int data, std::vector<int> &input)
     {
         if (timenumLabel != nullptr && data >= 0 && data <= BP_CHECK_TIME_MAX)
         {
             timenumLabel->SetText(std::to_string(data).c_str());
         }
+        int takeCount = 60;
+        int inputSize = input.size();
+        int actualCount = std::min({takeCount, inputSize});
+
+        if (actualCount <= 0)
+            return; // 无有效数据可赋值
+
+        // 计算input中起始索引
+        int startIndex = inputSize - actualCount;
+
+        // 赋值：将input最后actualCount个元素赋值给testData的前actualCount个位置
+        for (int i = 0; i < actualCount; ++i)
+        {
+            testData[i].y = input[startIndex + i];
+        }
+
+        // 更新图表数据
+        if (datachart && dataSerial)
+        {
+            dataSerial->ClearData();
+            dataSerial->AddPoints(testData, 60);
+            datachart->AddDataSerial(dataSerial);
+            RootView::GetInstance()->Invalidate();
+        }
+    }
+
+    void BPSecUnderCalibrationView::InitChartView()
+    {
+        /*
+           测试数据 100条
+       */
+        for (int i = 0; i < 60; i++)
+        {
+            testData[i].x = i;
+            testData[i].y = 100;
+        }
+
+        // 初始化图表控件
+        if (datachart == nullptr)
+        {
+            datachart = new UIChartPolyline();
+        }
+        datachart->SetPosition(56, 105);
+        datachart->Resize(317, 136);
+        datachart->SetViewId("uiChart");
+        datachart->SetStyle(STYLE_BACKGROUND_OPA, 0x00);
+
+        // 设置坐标轴为透明
+        UIXAxis &uiChartXAxis = datachart->GetXAxis();
+        UIYAxis &uiChartYAxis = datachart->GetYAxis();
+        uiChartXAxis.SetMarkNum(60);
+        uiChartXAxis.SetDataRange(0, 60);
+        uiChartXAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
+        uiChartYAxis.SetMarkNum(5);
+        uiChartYAxis.SetDataRange(60, 210);
+        uiChartYAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
+
+        // 设置数据曲线
+        dataSerial = new UIChartDataSerial();
+        dataSerial->SetMaxDataCount(60);
+        dataSerial->AddPoints(testData, 60);
+        dataSerial->SetFillColor(Color::GetColorFromRGBA(0x0b, 0xe4, 0x43, 0xff));
+        dataSerial->SetLineColor(Color::GetColorFromRGBA(0xf1, 0x0a, 0x0a, 0xff));
+        dataSerial->EnableGradient(false);
+        datachart->AddDataSerial(dataSerial);
+        datachart->SetGradientOpacity(0, 0);
     }
     /* -------------------------------------------------------------------------- */
     /***
@@ -95,10 +172,13 @@ namespace OHOS
         InitLabelExt(timeLabel, 165, 400, 300, 35, "timeLabel",STR_S, DEFAULT_VECTOR_FONT_FILENAME, 30);
         InitUILabel(timenumLabel, 133, 300, 200, 200, "timenumLabel", "30", DEFAULT_VECTOR_FONT_FILENAME, 100);
 
+         InitChartView();
+
         group->Add(calibrationLabel);
         group->Add(remindLabel);
         group->Add(timeLabel);
         group->Add(timenumLabel);
+        group->Add(datachart);
 
         return true;
     }
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPUnderCalibrationView.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPUnderCalibrationView.cpp
index c24f9ba3b..06c8e5894 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPUnderCalibrationView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPUnderCalibrationView.cpp
@@ -71,14 +71,91 @@ namespace OHOS
             delete timenumLabel;
             timenumLabel = nullptr;
         }
+         if(dataSerial != nullptr)
+            {
+                datachart->ClearDataSerial();
+                delete dataSerial;
+                dataSerial = nullptr;
+            }
+            if(datachart != nullptr)
+            {
+                delete datachart;
+                datachart = nullptr;
+            }
     }
     /* -------------------------------------------------------------------------- */
-    void BPUnderCalibrationView::UpdateTimeText(int data)
+    void BPUnderCalibrationView::UpdateTimeText(int data, std::vector<int> &input)
     {
         if (timenumLabel != nullptr && data >= 0 && data <= BP_CHECK_TIME_MAX)
         {
             timenumLabel->SetText(std::to_string(data).c_str());
         }
+        int takeCount = 60;
+        int inputSize = input.size();
+        int actualCount = std::min({takeCount, inputSize});
+
+        if (actualCount <= 0)
+            return; // 无有效数据可赋值
+
+        // 计算input中起始索引
+        int startIndex = inputSize - actualCount;
+
+        // 赋值：将input最后actualCount个元素赋值给testData的前actualCount个位置
+        for (int i = 0; i < actualCount; ++i)
+        {
+            testData[i].y = input[startIndex + i];
+        }
+
+        // 更新图表数据
+        if (datachart && dataSerial)
+        {
+            dataSerial->ClearData();
+            dataSerial->AddPoints(testData, 60);
+            datachart->AddDataSerial(dataSerial);
+            RootView::GetInstance()->Invalidate();
+        }
+    }
+
+    void BPUnderCalibrationView::InitChartView()
+    {
+        /*
+           测试数据 100条
+       */
+        for (int i = 0; i < 60; i++)
+        {
+            testData[i].x = i;
+            testData[i].y = 100;
+        }
+
+        // 初始化图表控件
+        if (datachart == nullptr)
+        {
+            datachart = new UIChartPolyline();
+        }
+        datachart->SetPosition(56, 105);
+        datachart->Resize(317, 136);
+        datachart->SetViewId("uiChart");
+        datachart->SetStyle(STYLE_BACKGROUND_OPA, 0x00);
+
+        // 设置坐标轴为透明
+        UIXAxis &uiChartXAxis = datachart->GetXAxis();
+        UIYAxis &uiChartYAxis = datachart->GetYAxis();
+        uiChartXAxis.SetMarkNum(60);
+        uiChartXAxis.SetDataRange(0, 60);
+        uiChartXAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
+        uiChartYAxis.SetMarkNum(5);
+        uiChartYAxis.SetDataRange(60, 210);
+        uiChartYAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
+
+        // 设置数据曲线
+        dataSerial = new UIChartDataSerial();
+        dataSerial->SetMaxDataCount(60);
+        dataSerial->AddPoints(testData, 60);
+        dataSerial->SetFillColor(Color::GetColorFromRGBA(0x0b, 0xe4, 0x43, 0xff));
+        dataSerial->SetLineColor(Color::GetColorFromRGBA(0xf1, 0x0a, 0x0a, 0xff));
+        dataSerial->EnableGradient(false);
+        datachart->AddDataSerial(dataSerial);
+        datachart->SetGradientOpacity(0, 0);
     }
     /* -------------------------------------------------------------------------- */
     /***
@@ -89,17 +166,20 @@ namespace OHOS
     {
 
         InitLabelExt(calibrationLabel, 83, 32, 300, 40, "calibration", STR_CALIBRATING, DEFAULT_VECTOR_FONT_FILENAME, 35);
-        InitLabelExt(remindLabel, 63, 278, 360, 35, "remind",STR_FIRST_CAL_KEEP_STILL, DEFAULT_VECTOR_FONT_FILENAME, 30);
+        InitLabelExt(remindLabel, 63, 278, 360, 35, "remind", STR_FIRST_CAL_KEEP_STILL, DEFAULT_VECTOR_FONT_FILENAME, 30);
         remindLabel->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
         remindLabel->SetTextColor(Color::Red());
         InitLabelExt(timeLabel, 165, 400, 300, 35, "timeLabel", STR_S, DEFAULT_VECTOR_FONT_FILENAME, 30);
 
         InitUILabel(timenumLabel, 133, 300, 200, 200, "timenumLabel", "30", DEFAULT_VECTOR_FONT_FILENAME, 100);
 
+        InitChartView();
+
         group->Add(calibrationLabel);
         group->Add(remindLabel);
         group->Add(timeLabel);
         group->Add(timenumLabel);
+        group->Add(datachart);
 
         return true;
     }
@@ -134,17 +214,20 @@ namespace OHOS
             WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "AlarmPopUpView::group null!");
             return nullptr;
         }
+         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bool BPUnderCalibrationView::InitView(1)");
         group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
         if (!Initbackground())
         {
             WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Initbackground error!");
             return nullptr;
         };
+         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bool BPUnderCalibrationView::InitView(2)");
         if (!InitLable())
         {
             WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "InitLable error!");
             return nullptr;
         };
+        
         WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bool BPUnderCalibrationView::InitView()");
 
         return group;
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectBeginView.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectBeginView.cpp
index c895f63d9..f05d26c85 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectBeginView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectBeginView.cpp
@@ -87,58 +87,73 @@ namespace OHOS
     }
     /* -------------------------------------------------------------------------- */
     // 倒计时更新时间文本
-    void BPDetectBeginView::UpdateTimeText(int data) {
-        if (timenumLabel != nullptr && data >= 0 && data <= BP_CHECK_TIME_MAX) {
+     void BPDetectBeginView::UpdateTimeText(int data, std::vector<int> &input)
+    {
+        if (timenumLabel != nullptr && data >= 0 && data <= BP_CHECK_TIME_MAX)
+        {
             timenumLabel->SetText(std::to_string(data).c_str());
         }
-        // 生成正常血压范围(60~200)的随机数更新数据
-        for (int i = 0; i < 100; i++) {
-            testData[i].y = rand() % (210 - 60) + 60;
+        int takeCount = 60;
+        int inputSize = input.size();
+        int actualCount = std::min({takeCount, inputSize});
+
+        if (actualCount <= 0)
+            return; // 无有效数据可赋值
+
+        // 计算input中起始索引
+        int startIndex = inputSize - actualCount;
+
+        // 赋值：将input最后actualCount个元素赋值给testData的前actualCount个位置
+        for (int i = 0; i < actualCount; ++i)
+        {
+            testData[i].y = input[startIndex + i];
         }
 
         // 更新图表数据
-        if (datachart && dataSerial) {
+        if (datachart && dataSerial)
+        {
             dataSerial->ClearData();
-            dataSerial->AddPoints(testData, 100);
+            dataSerial->AddPoints(testData, 60);
             datachart->AddDataSerial(dataSerial);
             RootView::GetInstance()->Invalidate();
         }
     }
 
-
     void BPDetectBeginView::InitChartView()
     {
-         /*
-            测试数据 100条
-        */
-        for (int i = 0; i < 100; i++) {
+        /*
+           测试数据 100条
+       */
+        for (int i = 0; i < 60; i++)
+        {
             testData[i].x = i;
-            testData[i].y = 100; 
+            testData[i].y = 100;
         }
 
-        //初始化图表控件
-        if (datachart == nullptr) {
+        // 初始化图表控件
+        if (datachart == nullptr)
+        {
             datachart = new UIChartPolyline();
         }
-        datachart->SetPosition(56, 105);        
-        datachart->Resize(317, 136);        
+        datachart->SetPosition(56, 105);
+        datachart->Resize(317, 136);
         datachart->SetViewId("uiChart");
         datachart->SetStyle(STYLE_BACKGROUND_OPA, 0x00);
 
-        //设置坐标轴为透明
-        UIXAxis& uiChartXAxis = datachart->GetXAxis();
-        UIYAxis& uiChartYAxis = datachart->GetYAxis();
-        uiChartXAxis.SetMarkNum(100);
-        uiChartXAxis.SetDataRange(0, 100);
-        uiChartXAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));    
+        // 设置坐标轴为透明
+        UIXAxis &uiChartXAxis = datachart->GetXAxis();
+        UIYAxis &uiChartYAxis = datachart->GetYAxis();
+        uiChartXAxis.SetMarkNum(60);
+        uiChartXAxis.SetDataRange(0, 60);
+        uiChartXAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
         uiChartYAxis.SetMarkNum(5);
         uiChartYAxis.SetDataRange(60, 210);
         uiChartYAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
 
-        //设置数据曲线
+        // 设置数据曲线
         dataSerial = new UIChartDataSerial();
-        dataSerial->SetMaxDataCount(100);
-        dataSerial->AddPoints(testData, 100);
+        dataSerial->SetMaxDataCount(60);
+        dataSerial->AddPoints(testData, 60);
         dataSerial->SetFillColor(Color::GetColorFromRGBA(0x0b, 0xe4, 0x43, 0xff));
         dataSerial->SetLineColor(Color::GetColorFromRGBA(0xf1, 0x0a, 0x0a, 0xff));
         dataSerial->EnableGradient(false);
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectFirstView.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectFirstView.cpp
index 22ec4edc2..27b7944de 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectFirstView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectFirstView.cpp
@@ -15,9 +15,9 @@
 namespace OHOS
 {
     static BPDetectFirstView *g_pBPDetectFirstView{nullptr};
-    static const char* image_bp = "/user/res/BPCalibration/measuring.bin";
-    static const char* image_bg_w = "/user/res/BPCalibration/W.bin";
-    static const char* image_bg_q = "/user/res/BPCalibration/Q.bin";
+    static const char *image_bp = "/user/res/BPCalibration/measuring.bin";
+    static const char *image_bg_w = "/user/res/BPCalibration/W.bin";
+    static const char *image_bg_q = "/user/res/BPCalibration/Q.bin";
 
     BPDetectFirstView::BPDetectFirstView()
     {
@@ -27,67 +27,67 @@ namespace OHOS
     BPDetectFirstView::~BPDetectFirstView()
     {
         WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPDetectFirstView::~BPDetectFirstView");
-        if(group)
+        if (group)
         {
-            group->RemoveAll(); 
-            if(DBPTitleLabel)
+            group->RemoveAll();
+            if (DBPTitleLabel)
             {
                 delete DBPTitleLabel;
                 DBPTitleLabel = nullptr;
             }
-            if(SBPTitleText)
+            if (SBPTitleText)
             {
                 delete SBPTitleText;
                 SBPTitleText = nullptr;
             }
-            if(DBPText)
+            if (DBPText)
             {
                 delete DBPText;
                 DBPText = nullptr;
             }
-            if(SBPText)
+            if (SBPText)
             {
                 delete SBPText;
                 SBPText = nullptr;
             }
-            if(timeLabel)
+            if (timeLabel)
             {
                 delete timeLabel;
                 timeLabel = nullptr;
             }
-            if(BPImageView)
+            if (BPImageView)
             {
                 delete BPImageView;
                 BPImageView = nullptr;
             }
-            if(BgWImageView)
+            if (BgWImageView)
             {
                 delete BgWImageView;
                 BgWImageView = nullptr;
             }
-            if(BgQImageView)
+            if (BgQImageView)
             {
                 delete BgQImageView;
                 BgQImageView = nullptr;
             }
-            if(CheckButton)
+            if (CheckButton)
             {
                 delete CheckButton;
                 CheckButton = nullptr;
             }
-            if(dbpSerial)
+            if (dbpSerial)
             {
                 bpchart->ClearDataSerial();
                 delete dbpSerial;
                 dbpSerial = nullptr;
             }
-            if(sbpSerial == nullptr)
+            if (sbpSerial == nullptr)
             {
                 bpchart->ClearDataSerial();
                 delete sbpSerial;
                 sbpSerial = nullptr;
             }
-            if(bpchart)
+            if (bpchart)
             {
                 delete bpchart;
                 bpchart = nullptr;
@@ -105,54 +105,84 @@ namespace OHOS
 
     void BPDetectFirstView::UpdateText()
     {
-        if(DBPText == nullptr || SBPText == nullptr || timeLabel == nullptr)
+        if (DBPText == nullptr || SBPText == nullptr || timeLabel == nullptr)
         {
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "DBPText or SBPText or timeLabel is null");
             return;
         }
-        //获取时间更新时间
-        std::string timeStr = BPModel::GetInstance()->GetCurrentTimeStr();
-        timeLabel->SetText(timeStr.c_str());
-        //获取上一次检测数据 ？ 待定
-        
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "11111");
+        // 获取上一次检测数据 ？ 待定
+        LAST_CHECK_DATA data;
+        if (BPModel::GetInstance()->get_last_check_bp_data(data))
+        {
+            // 获取时间更新时间
+            std::string timeStr = data.timestamp;
+            std::string dbpValue = std::to_string(data.last_check_dbp_value);
+            std::string sbpValue = std::to_string(data.last_check_sbp_value);
+            timeLabel->SetText(timeStr.c_str());
+            DBPText->SetText(dbpValue.c_str());
+            SBPText->SetText(sbpValue.c_str());
+        }
     }
 
+    void BPDetectFirstView::WriteMapToPointArrays(const std::map<int, std::pair<int, int>> &bpMap)
+    {
+        int dataCount = std::min(static_cast<int>(bpMap.size()), 24);
+
+        if (dataCount == 0)
+        {
+            for (int i = 0; i < 24; ++i)
+            {
+                // x坐标使用数组索引，y坐标使用map中的值
+                sbpData[i].x = i;
+                sbpData[i].y = 100; // SBP值
+
+                dbpData[i].x = i;
+                dbpData[i].y = 80; // DBP值
+            }
+            return;
+        }
+        auto it = bpMap.end();
+        std::advance(it, -dataCount);
+
+        // 填充数组
+        for (int i = 0; i < dataCount; ++i, ++it)
+        {
+            // x坐标使用数组索引，y坐标使用map中的值
+            sbpData[i].x = i;
+            sbpData[i].y = it->second.first; // SBP值
+
+            dbpData[i].x = i;
+            dbpData[i].y = it->second.second; // DBP值
+        }
+    }
     void BPDetectFirstView::InitChartView()
     {
-        /*
-            测试数据
-        */
-        Point testdbpData[24] = { {0,110},{1,108},{2,105},{3,102},{4,100},{5,105},{6,110},{7,115},{8,120},{9,125},
-        {10,130},{11,132},{12,128},{13,125},{14,122},{15,120},{16,122},{17,125},{18,120},{19,118},
-        {20,115},{21,112},{22,108},{23,105} };
-
-        Point testsbpData[24] = { {0,70},{1,68},{2,65},{3,62},{4,60},{5,62},{6,65},{7,68},{8,70},{9,72},
-        {10,75},{11,78},{12,76},{13,74},{14,72},{15,70},{16,72},{17,75},{18,73},{19,70},
-        {20,68},{21,65},{22,62},{23,63} };
-
-        //初始化图表控件
-        if (bpchart == nullptr) {
+        WriteMapToPointArrays(BPModel::GetInstance()->GetBPValueMap());
+        // 初始化图表控件
+        if (bpchart == nullptr)
+        {
             bpchart = new UIChartPolyline();
         }
-        bpchart->SetPosition(56, 205);        
-        bpchart->Resize(317, 136);        
+        bpchart->SetPosition(56, 205);
+        bpchart->Resize(317, 136);
         bpchart->SetViewId("uiChart");
         bpchart->SetStyle(STYLE_BACKGROUND_OPA, 0x00);
 
-        //设置坐标轴为透明
-        UIXAxis& uiChartXAxis = bpchart->GetXAxis();
-        UIYAxis& uiChartYAxis = bpchart->GetYAxis();
+        // 设置坐标轴为透明
+        UIXAxis &uiChartXAxis = bpchart->GetXAxis();
+        UIYAxis &uiChartYAxis = bpchart->GetYAxis();
         uiChartXAxis.SetMarkNum(24);
         uiChartXAxis.SetDataRange(0, 24);
-        uiChartXAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));    
+        uiChartXAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
         uiChartYAxis.SetMarkNum(5);
         uiChartYAxis.SetDataRange(60, 210);
         uiChartYAxis.SetLineColor(Color::GetColorFromRGBA(0x00, 0x00, 0x00, 0x00));
 
-        //设置dbp 和 sbp 数据曲线
+        // 设置dbp 和 sbp 数据曲线
         dbpSerial = new UIChartDataSerial();
         dbpSerial->SetMaxDataCount(24);
-        dbpSerial->AddPoints(testdbpData, 24);
+        dbpSerial->AddPoints(dbpData, 24);
         dbpSerial->SetFillColor(Color::GetColorFromRGBA(0x0b, 0xe4, 0x43, 0xff));
         dbpSerial->SetLineColor(Color::GetColorFromRGBA(0x4d, 0xf1, 0x0a, 0xff));
         dbpSerial->EnableGradient(false);
@@ -160,7 +190,7 @@ namespace OHOS
 
         sbpSerial = new UIChartDataSerial();
         sbpSerial->SetMaxDataCount(24);
-        sbpSerial->AddPoints(testsbpData, 24);
+        sbpSerial->AddPoints(sbpData, 24);
         sbpSerial->SetFillColor(Color::GetColorFromRGBA(0xff, 0xff, 0xff, 0xff));
         sbpSerial->SetLineColor(Color::GetColorFromRGBA(0x07, 0x88, 0xe8, 0xff));
         sbpSerial->EnableGradient(false);
@@ -168,7 +198,7 @@ namespace OHOS
         bpchart->SetGradientOpacity(0, 0);
         // bpchart->SetGradientType(UIChart::GRADIENT_TYPE_HOR);
     }
-   
+
     /***
      * @description:
      * @return 是否初始化成功
@@ -186,21 +216,19 @@ namespace OHOS
         InitUILabel(DBPText, 20, 120, 200, 60, "calibration", "108", DEFAULT_VECTOR_FONT_FILENAME, 50);
         InitUILabel(SBPText, 240, 120, 200, 60, "calibration", "68", DEFAULT_VECTOR_FONT_FILENAME, 50);
         InitUILabel(timeLabel, 133, 115, 200, 60, "calibration", "2025/06/18 \n 15:00", DEFAULT_VECTOR_FONT_FILENAME, 20);
-      
+
         InitImageView(BPImageView, 208, 10, 100, 100, "image_bp", image_bp);
         InitImageView(BgWImageView, 0, -75, 100, 100, "image_bg_w", image_bg_w);
         InitImageView(BgQImageView, 55, 196, 100, 100, "image_bg_q", image_bg_q);
 
-        InitButtonExt(CheckButton, 118, 360, 230, 80,  CLICK_BLOOD_PRESSURE,STR_CHECK, 30);
+        InitButtonExt(CheckButton, 118, 360, 230, 80, CLICK_BLOOD_PRESSURE, STR_CHECK, 30);
         CheckButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xffFF8A36); // 设置按键颜色
         UIView::OnClickListener *clickListener = (UIView::OnClickListener *)OHOS::BPDetectionPresenter::GetInstance();
-        CheckButton->SetOnClickListener(clickListener);//设置按键监听
+        CheckButton->SetOnClickListener(clickListener); // 设置按键监听
 
         DBPText->SetTextColor(Color::GetColorFromRGBA(0xFF, 0x35, 0x00, 0xFF));
         SBPText->SetTextColor(Color::GetColorFromRGBA(0xFF, 0x35, 0x00, 0xFF));
-
         InitChartView();
-
         group->Add(DBPTitleLabel);
         group->Add(SBPTitleText);
         group->Add(DBPText);
@@ -217,6 +245,4 @@ namespace OHOS
         return group;
     }
 
-
-    
 }