#include <stdint.h>
#include <string>
+#include <deque>
+#include <vector>
+#include "map"
#define SBP_VALUE 120
#define DBP_VALUE 80
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 //提醒所需时间
// 控制血压检测
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);
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
#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
{
bool AddButton();
bool InitLable();
bool Initbackground();
+ void InitChartView();
- void UpdateTimeText(int data);
+ void UpdateTimeText(int data, std::vector<int> &input);
private:
UIImageView *background = nullptr;
UILabelExt *timeLabel = nullptr;
UILabel *timenumLabel = nullptr;
UIViewGroup *group{nullptr};
+
+ Point testData[60];
+ UIChartDataSerial *dataSerial{nullptr};
+ UIChartPolyline *datachart = nullptr;
};
}
#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
{
bool AddButton();
bool InitLable();
bool Initbackground();
+ void InitChartView();
- void UpdateTimeText(int data);
+ void UpdateTimeText(int data, std::vector<int> &input);
private:
UIImageView *background = nullptr;
UILabelExt *remindLabel = nullptr;
UILabelExt *timeLabel = nullptr;
UILabel *timenumLabel = nullptr;
+
+
+ Point testData[60];
+ UIChartDataSerial *dataSerial{nullptr};
+ UIChartPolyline *datachart = nullptr;
+
+
UIViewGroup *group{nullptr};
};
}
bool Initbackground();
void InitChartView();
- void UpdateTimeText(int data);
+ void UpdateTimeText(int data, std::vector<int> &input);
private:
UIImageView *background = nullptr;
UIViewGroup *BPDetectFirstInit();
void UpdateText(); //更新文本数据
void InitChartView();
+ void WriteMapToPointArrays(const std::map<int, std::pair<int, int>> &bpMap);
private:
UILabelExt *DBPTitleLabel{nullptr};
#include "custom_utils.h"
#include "ppg_service.h"
+#ifdef ENABLE_BN02
+#include "bp_service.h"
+#include "bp_tcp_server.h"
+#endif
+
/*
----------------------------
收缩压：DBP
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();
// 提前获取各视图实例
// 处理血压校准相关状态
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);
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);
}
// 处理压力检测与分析
- 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);
}
}
// 处理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);
}
}
}
- //每秒的处理
- 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;
case BPState::EMO_ANALYSIS:
case BPState::BP_CALIBRATING_ANGLYSIS:
case BPState::ECG_REMIND:
- case BPState::ECG_RESULT: {
+ case BPState::ECG_RESULT:
+ {
break;
}
/////////////////////////////////////定时器处理 不要修改//////////////////////////////////////////////////
/*定时器到期时的处理*/
- 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;
}
/*
* @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));
* @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;
}
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;
}
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;
/*
* @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);
}
}
}
+ 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
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);
}
/* -------------------------------------------------------------------------- */
/***
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;
}
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);
}
/* -------------------------------------------------------------------------- */
/***
{
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;
}
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;
}
/* -------------------------------------------------------------------------- */
// 倒计时更新时间文本
- 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);
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()
{
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;
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);
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);
bpchart->SetGradientOpacity(0, 0);
// bpchart->SetGradientType(UIChart::GRADIENT_TYPE_HOR);
}
-
+
/***
* @description:
* @return 是否初始化成功
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);
return group;
}
-
-
}
projects / mirrors / FD230.git / commitdiff