From 54f5c8e78dd5b36b1d34ea89750a9cf0744bfa88 Mon Sep 17 00:00:00 2001 From: xue <2144439972@qq.com> Date: Tue, 8 Jul 2025 14:01:45 +0800 Subject: [PATCH] =?utf8?q?=E4=BC=98=E5=8C=96=E8=A1=80=E5=8E=8B=E6=8E=A7?= =?utf8?q?=E5=88=B6=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .../nativeui/bloodpressure/include/BPModel.h | 296 +-- .../bloodpressure/src/BPMainPresenter.cpp | 2 +- .../nativeui/bloodpressure/src/BPModel.cpp | 1634 +++++++++-------- .../src/detection/BPDetectionPresenter.cpp | 2 +- .../nativeui/ecg/src/EcgPresenter.cpp | 2 +- .../nativeui/emotion/src/EmoPresenter.cpp | 2 +- .../fatiguelevel/src/FatiguePresenter.cpp | 4 +- .../nativeui/settings/src/SettingModel.cpp | 2 +- .../nativeui/stress/src/StressPresenter.cpp | 4 +- 9 files changed, 1012 insertions(+), 936 deletions(-) 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 90db725d2..9c80ceee0 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPModel.h +++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/include/BPModel.h @@ -5,149 +5,169 @@ #include #include #include -#include +#include #include #include "map" #define SBP_VALUE 120 #define DBP_VALUE 80 - -namespace OHOS { -// 检测状态 -enum class BPState { - // 结束检测 - BP_End = 0, - // 第一次校准血压中 30s - BP_CALIBRATING_FIRSTTIME, - // 第二次校准血压中 30s - BP_CALIBRATING_SECONDTIME, - // 校准分析中 5s - BP_CALIBRATING_ANGLYSIS, - // 检测血压中 30s - BP_DETECTING, - // 压力测量中 - STRESS_MEASURE, - // 疲劳度测量中 - FATIGUE_MEASURE, - // ECG提示中 - ECG_REMIND, - // ECG测量中 - ECG_MEASURE, - // 情绪测量中 - EMO_MEASURE, - // 压力分析中 - STRESS_ANALYSIS, - // 疲劳度分析中 - FATIGUE_ANALYSIS, - // ECG分析中 - ECG_ANALYSIS, - // ECG结果中 - ECG_RESULT, - // 情绪分析中 - EMO_ANALYSIS, - // 普通状态 - BP_NORMAL, - // 暂停检测 - BP_PAUSE, - - BP_STATE_MAX, -}; -// 血压检测结果 -enum class BPRESULT { - NOT_TESTED = 0, // 未检测 - SUCCESS, // 检测成功 - NOT_WORN, // 未佩戴检测 - TIMEOUT, // 检测超时 - HIGH_RESULT, // 检测结果过高 - LOW_RESULT, // 检测结果过低 - INVALID_DATA // 无效数据 -}; - -enum class BP_VALUE_TYPE { - SBP = 0, - DBP, -}; - -struct LAST_CHECK_DATA { - uint64_t timestamp; // 时间戳 单位s - uint8_t last_check_sbp_value; // 上次检测收缩压值 - uint8_t last_check_dbp_value; // 上次检测舒张压值 - -}; - -#define BP_CHECK_TIME_MAX 90 //测量所需时间 -#define BP_ANLYSISI_TIME_MAX 5 //分析所需时间 -#define BP_REMIND_TIME_MAX 5 //提醒所需时间 -class BPModel { -public: - BPModel(); - ~BPModel(); - static BPModel *GetInstance(); - // 获取第几次校准 - int16_t GetCalibrationFlag(); - void SetCalibrationFlag(uint8_t value); - // 获取当前时间年月日时分字符串 - std::string GetCurrentTimeStr(); - std::string GetCurrentTimeStr(uint64_t timeStamp); - //获取当前时间戳 - uint32_t GetCurrentTime(); - std::string GetLastCalibrationTime(); - // 当前状态管理 - void BP_SetState(BPState state); - BPState GetCurrentState(); - // 控制血压检测 - void BP_Control(BPState state); - void BP_SetValue(BP_VALUE_TYPE type, bool set_value); - uint8_t GetValue(BP_VALUE_TYPE type); - void BP_timer_callback_out(); - void BP_timer_callback_proc(uint8_t data); - - /////////////////////////////////////////////// - void BP_StartTimer(uint32_t interval = 1 * 1000); // 1s定时器 - void BP_StopTimer(void); - void BP_Start_GetData_Timer(uint32_t interval = 1 * 300); // 300ms定时器 - void BP_Stop_GetData_Timer(void); - - void BP_START(void); - void BP_STOP(void); - void BP_GetData(uint8_t *sbp,uint8_t *dbp); - - std::map> GetBPValueMap(void); - void SetBPValueMap(uint8_t sbp,uint8_t dbp,uint8_t index); - uint8_t GetBPValueCnt(void); - uint8_t mapValue(uint8_t value); - void mapDataArray(uint8_t value); - //获取过程值数据 - std::vector GetBPCheckDataArray(void); - - - /* --------------------------------- 最近检测数据 --------------------------------- */ - #define BP_LAST_CHECK_FILE_PATH "/user/userdata/bp/bp_last_check.txt" - static constexpr const char *BP_DATA_PATH = "/user/userdata/health/bp/"; - 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); - uint8_t get_last_check_data_num(void); - const uint8_t max_checkout_num = 30; - std::deque lastCheckData; // 存储最近检测数据 - bool CreateBPFolder(); - // 存储bin文件 - bool save_bin_BP(const LAST_CHECK_DATA &data); - bool UpdateHealthData(const LAST_CHECK_DATA &data); - /* -------------------------------------------------------------------------- */ - bool CleanBPData(void); - - -private: - BPState current_state = BPState::BP_NORMAL; - uint8_t custom_sbp = SBP_VALUE; - uint8_t custom_dbp = DBP_VALUE; - std::map> bp_check_value_map; //记录获取的sbp和dbp值 - uint8_t bp_check_cnt = 0; //记录获取的次数 - std::vector bp_check_value_vector; //测量值 - std::string LastCalibrationTime; - uint8_t CalibrationFlag = 0; -}; +#define BP_STATE_NUM 20 +namespace OHOS +{ + // 检测状态 + static constexpr size_t StateMapperSize = BP_STATE_NUM; // 根据实际条目数修改 + // 血压测量状态枚举 + enum class BPState + { + BP_IDLE, // 空闲状态 + BP_End, // 测量结束 + BP_DETECTING, // 血压检测中 + BP_CALIBRATING_FIRSTTIME, // 首次校准 + BP_CALIBRATING_SECONDTIME, // 第二次校准 + BP_CALIBRATING_ANGLYSIS, // 校准分析中 + STRESS_MEASURE, // 压力测量中 + STRESS_MEASURE_END, // 压力测量结束 + STRESS_ANALYSIS, // 压力分析中 + FATIGUE_MEASURE, // 疲劳度测量中 + FATIGUE_MEASURE_END, // 疲劳度测量结束 + FATIGUE_ANALYSIS, // 疲劳度分析中 + ECG_MEASURE, // ECG测量中 + ECG_REMIND, // ECG提示中 + ECG_MEASURE_END, // ECG测量结束 + ECG_ANALYSIS, // ECG分析中 + ECG_RESULT, // ECG结果中 + EMO_MEASURE, // 情绪测量中 + EMO_MEASURE_END, // 情绪测量结束 + EMO_ANALYSIS, // 情绪分析中 + }; + // 血压检测结果 + enum class BPRESULT + { + NOT_TESTED = 0, // 未检测 + SUCCESS, // 检测成功 + NOT_WORN, // 未佩戴检测 + TIMEOUT, // 检测超时 + HIGH_RESULT, // 检测结果过高 + LOW_RESULT, // 检测结果过低 + INVALID_DATA // 无效数据 + }; + + enum class BP_VALUE_TYPE + { + SBP = 0, + DBP, + }; + + // 存储文件枚举 + enum class BP_STORAGE_TYPE + { + TODAY_DATA = 0, + LAST_MEASURE_DATA, + }; + + struct LAST_CHECK_DATA + { + uint64_t timestamp; // 时间戳 单位s + uint8_t last_check_sbp_value; // 上次检测收缩压值 + uint8_t last_check_dbp_value; // 上次检测舒张压值 + }; + +#define BP_CHECK_TIME_MAX 90 // 测量所需时间 +#define BP_ANLYSISI_TIME_MAX 5 // 分析所需时间 +#define BP_REMIND_TIME_MAX 5 // 提醒所需时间 + class BPModel + { + public: + BPModel(); + ~BPModel(); + static BPModel *GetInstance(); + // 获取第几次校准 + int16_t GetCalibrationFlag(); + void SetCalibrationFlag(uint8_t value); + // 获取当前时间年月日时分字符串 + std::string GetCurrentTimeStr(); + std::string GetCurrentTimeStr(uint64_t timeStamp); + // 获取当前时间戳 + uint32_t GetCurrentTime(); + std::string GetLastCalibrationTime(); + /* ---------------------------------状态处理 --------------------------------- */ + void BP_SetState(BPState state); + BPState GetCurrentState(); + void BP_SetResultState(BPRESULT state); + BPRESULT GettResultState(); + // 各种状态的处理函数声明 + void BPControlidleState(); + void BPControlStopMeasure(); + void BPControlDetecting(); + void BPControlCalibratingFirstTime(); + void BPControlCalibratingSecondTime(); + void BPControlStressMeasure(); + void BPControlStressMeasureEnd(); + void BPControlFatigueMeasure(); + void BPControlFatigueMeasureEnd(); + void BPControlECGMeasure(); + void BPControlECGMeasureEnd(); + void BPControlEMOMeasure(); + void BPControlEMOMeasureEnd(); + void BPControlCalibratingAnalysis(); + void BPControlStressAnalysis(); + void BPControlFatigueAnalysis(); + void BPControlECGRemind(); + void BPControlECGAnalysis(); + void BPControlECGResult(); + void BPControlEMOAnalysis(); + /* -------------------------------------------------------------------------- */ + + // 控制血压检测 + void BP_Control(BPState state); + void BP_SetValue(BP_VALUE_TYPE type, bool set_value); + uint8_t GetValue(BP_VALUE_TYPE type); + void BP_timer_callback_out(); + void BP_timer_callback_proc(uint8_t data); + + /* --------------------------------- 定时器处理 --------------------------------- */ + void BP_StartTimer(uint32_t interval = 1 * 1000); // 1s定时器 + void BP_StopTimer(void); + void BP_Start_GetData_Timer(uint32_t interval = 1 * 300); // 300ms定时器 + void BP_Stop_GetData_Timer(void); + /* -------------------------------------------------------------------------- */ + + void BP_START(void); + void BP_STOP(void); + void BP_GetData(uint8_t *sbp, uint8_t *dbp); + + std::map> GetBPValueMap(void); + void SetBPValueMap(uint8_t sbp, uint8_t dbp, uint8_t index); + uint8_t GetBPValueCnt(void); + uint8_t mapValue(uint8_t value); + void mapDataArray(uint8_t value); + bool CleanBPData(void); + // 获取过程值数据 + std::vector GetBPCheckDataArray(void); + + /* --------------------------------- 数据存储 --------------------------------- */ + static constexpr const char *BP_DATA_PATH = "/user/userdata/health/bp/"; + static constexpr const char *BP_LAST_DATA_PATH = "/user/userdata/health/bp/BPLast.bin"; + std::deque lastCheckData; // 存储最近检测数据 + std::string GetBPDataPath(); + bool CreateBPFolder(); + bool save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType); + bool UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType); + bool IsTimestampToday(uint32_t timestamp); + bool LoadBP(BP_STORAGE_TYPE StorageType); + /* -------------------------------------------------------------------------- */ + + private: + BPState current_state = BPState::BP_IDLE; + uint8_t custom_sbp = SBP_VALUE; + uint8_t custom_dbp = DBP_VALUE; + std::map> bp_check_value_map; // 记录获取的sbp和dbp值 + std::vector bp_check_value_vector; // 测量值-----没用了 + std::string LastCalibrationTime; + uint8_t CalibrationFlag = 0; + LAST_CHECK_DATA lastData; // 上一次测量的数据 + BPRESULT bp_resullt = BPRESULT::NOT_TESTED; // 测量状态 + }; } // namespace OHOS #endif diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPMainPresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPMainPresenter.cpp index 665d52abf..07bbc9129 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPMainPresenter.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPMainPresenter.cpp @@ -89,7 +89,7 @@ namespace OHOS void BPMainPresenter::OnStop(void) { // 重置状态 - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); } bool BPMainPresenter::OnDrag(UIView &view, const DragEvent &event) 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 3ac74473f..140298670 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/BPModel.cpp @@ -59,13 +59,11 @@ 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; +#define MAX_SHOW_CHECK_NUM 100 +#define DECLARE_BP_TIMER 1 +#define DECLARE_BP_GETDATA 1 - // 声明定时器变量 - static osTimerId_t g_timer = nullptr; - static int Time = 30; + static uint8_t Time = 30; BPModel::BPModel() {} BPModel::~BPModel() {} @@ -129,10 +127,9 @@ namespace OHOS std::string binFilePath; // 统一处理文件路径获取 - binFilePath = std::string(BP_JSON_PATH) + std::string(buffer) + ".bin"; + binFilePath = std::string(BP_DATA_PATH) + std::string(buffer) + ".bin"; WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Loading today's blood pressure data"); - return binFilePath; } std::string BPModel::GetCurrentTimeStr(uint64_t timeStamp) @@ -171,7 +168,7 @@ namespace OHOS } return time; } - + // 获取上次校准时间 std::string BPModel::GetLastCalibrationTime() { if (LastCalibrationTime.empty()) @@ -182,7 +179,7 @@ namespace OHOS } /////////////////////////状态管理////////////////////////////////////////// int16_t BPModel::GetCalibrationFlag() { return CalibrationFlag; } - void BPModel::SetCalibrationFlag(int value) { CalibrationFlag = value; } + void BPModel::SetCalibrationFlag(uint8_t value) { CalibrationFlag = value; } // 管理当前状态 void BPModel::BP_SetState(BPState state) { current_state = state; } @@ -191,42 +188,124 @@ namespace OHOS void BPModel::BP_SetResultState(BPRESULT state) { bp_resullt = state; } BPRESULT BPModel::GettResultState() { return bp_resullt; } - // 进行传感器、定时器等控制 + struct BPStateMapper + { + const BPState StateId; // 视图ID + void (BPModel::*func)(); // 对应的视图切换函数指针 + }; + // 初始化控制映射表（移除参数传递） + static const BPStateMapper StateMapper[] = { + {BPState::BP_IDLE, &BPModel::BPControlidleState}, + {BPState::BP_End, &BPModel::BPControlStopMeasure}, + {BPState::BP_DETECTING, &BPModel::BPControlDetecting}, + {BPState::BP_CALIBRATING_FIRSTTIME, &BPModel::BPControlCalibratingFirstTime}, + {BPState::BP_CALIBRATING_SECONDTIME, &BPModel::BPControlCalibratingSecondTime}, + {BPState::STRESS_MEASURE, &BPModel::BPControlStressMeasure}, + {BPState::STRESS_MEASURE_END, &BPModel::BPControlStressMeasureEnd}, + {BPState::FATIGUE_MEASURE, &BPModel::BPControlFatigueMeasure}, + {BPState::FATIGUE_MEASURE_END, &BPModel::BPControlFatigueMeasureEnd}, + {BPState::ECG_MEASURE, &BPModel::BPControlECGMeasure}, + {BPState::ECG_MEASURE_END, &BPModel::BPControlECGMeasureEnd}, + {BPState::EMO_MEASURE, &BPModel::BPControlEMOMeasure}, + {BPState::EMO_MEASURE_END, &BPModel::BPControlEMOMeasureEnd}, + {BPState::BP_CALIBRATING_ANGLYSIS, &BPModel::BPControlCalibratingAnalysis}, + {BPState::STRESS_ANALYSIS, &BPModel::BPControlStressAnalysis}, + {BPState::FATIGUE_ANALYSIS, &BPModel::BPControlFatigueAnalysis}, + {BPState::ECG_REMIND, &BPModel::BPControlECGRemind}, + {BPState::ECG_ANALYSIS, &BPModel::BPControlECGAnalysis}, + {BPState::ECG_RESULT, &BPModel::BPControlECGResult}, + {BPState::EMO_ANALYSIS, &BPModel::BPControlEMOAnalysis}, + }; + + // 使用控制映射表的示例函数（简化调用） void BPModel::BP_Control(BPState state) { - if (state == current_state) + // 遍历数组查找匹配项 + for (size_t i = 0; i < StateMapperSize; ++i) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "BP_Control: Already in current state"); - return; + const auto &entry = StateMapper[i]; + if (entry.StateId == state && entry.StateId != current_state) + { + // 调用成员函数 + (this->*(entry.func))(); + current_state = entry.StateId; // 更新当前状态 + break; + } } - switch (state) + /*未知状态，全部状态重置*/ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_Control: Invalid state"); + BP_SetState(BPState::BP_IDLE); + BP_StopTimer(); + Time = BP_CHECK_TIME_MAX; + BP_SetState(state); + } + // 空闲状态处理 + void BPModel::BPControlidleState() + { + BP_StopTimer(); + BP_Stop_GetData_Timer(); + ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON); + Time = BP_CHECK_TIME_MAX; + BP_STOP(); // 底层接口关闭血压 + } + // 测量结束状态处理 + void BPModel::BPControlStopMeasure() + { + if (Time > 0 && Time < 30) // 一分钟后获取数据 { - case BPState::BP_NORMAL: + + BP_GetData(&custom_sbp, &custom_dbp); + if (bp_resullt == BPRESULT::NOT_TESTED && custom_sbp > 0 && custom_dbp > 0) // 检测到数据 + { + LAST_CHECK_DATA newData; + newData.timestamp = BPModel::GetCurrentTime(); + newData.last_check_sbp_value = custom_sbp; + newData.last_check_dbp_value = custom_dbp; + // 测量数据结果分析 + if (lastData.last_check_sbp_value >= 140 || lastData.last_check_dbp_value >= 90) // 高血压：收缩压≥140 mmHg 或 舒张压≥90 mmHg。 + { + BP_SetResultState(BPRESULT::HIGH_RESULT); + UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); // 存储到文件 + UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据 + } + else if (lastData.last_check_sbp_value < 90 || lastData.last_check_dbp_value < 60) // 低血压：收缩压＜90 mmHg 且 舒张压＜60 mmHg。 + { + BP_SetResultState(BPRESULT::LOW_RESULT); + UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); + UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); + } + else if (lastData.last_check_sbp_value < 90 || lastData.last_check_dbp_value < 60) // 正常血压：收缩压（高压）＜120 mmHg 且 舒张压（低压）＜80 mmHg。 + { + BP_SetResultState(BPRESULT::SUCCESS); + UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); + UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); + } + else // 数据异常 + { + BP_SetResultState(BPRESULT::INVALID_DATA); // 无效数据，不存储 + } + } + } + } + // 血压检测中状态处理 + void BPModel::BPControlDetecting() { - /* - 关闭定时器 - 关闭传感器 - 关闭常亮 - */ - BP_StopTimer(); - ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON); - Time = BP_CHECK_TIME_MAX; - break; + if (Time != BP_CHECK_TIME_MAX) + Time = BP_CHECK_TIME_MAX; // 重置时间90秒 + BP_StartTimer(); + ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "start detecting"); + BP_START(); // 底层接口开启血压 + custom_dbp = 0; + custom_sbp = 0; } - case BPState::BP_CALIBRATING_SECONDTIME: // 测量与校准数据 - case BPState::BP_CALIBRATING_FIRSTTIME: - case BPState::BP_DETECTING: + + // 首次校准状态处理 + void BPModel::BPControlCalibratingFirstTime() { - /* - 开启定时器 - 开启传感器 - 开启常亮 - */ - if (bp_check_cnt != 0) - bp_check_cnt = 0; // 重置计数 - if (Time != BP_CHECK_TIME_MAX_TEST) - Time = BP_CHECK_TIME_MAX_TEST; // 重置时间90秒 + if (Time != BP_CHECK_TIME_MAX) + Time = BP_CHECK_TIME_MAX; // 重置时间90秒 BP_StartTimer(); ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, @@ -234,931 +313,908 @@ namespace OHOS BP_START(); // 底层接口开启血压 custom_dbp = 0; custom_sbp = 0; - break; } - case BPState::STRESS_MEASURE: - case BPState::FATIGUE_MEASURE: - case BPState::ECG_MEASURE: - case BPState::EMO_MEASURE: + // 第二次校准状态处理 + void BPModel::BPControlCalibratingSecondTime() + { + if (Time != BP_CHECK_TIME_MAX) + Time = BP_CHECK_TIME_MAX; // 重置时间90秒 + BP_StartTimer(); + ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "start detecting"); + BP_START(); // 底层接口开启血压 + custom_dbp = 0; + custom_sbp = 0; + } + // 校准分析状态处理 + void BPModel::BPControlCalibratingAnalysis() + { + } + // 压力测量状态处理 + void BPModel::BPControlStressMeasure() { - /* - 开启定时器 - 开启传感器 - 开启常亮 - */ BP_StartTimer(); ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 if (Time != BP_CHECK_TIME_MAX) Time = BP_CHECK_TIME_MAX; // 重置时间 + } - break; + // 压力测量结束状态处理 + void BPModel::BPControlStressMeasureEnd() + { + // 空实现：压力测量结束逻辑 + } + // 压力分析状态处理 + void BPModel::BPControlStressAnalysis() + { } - case BPState::BP_CALIBRATING_ANGLYSIS: - case BPState::STRESS_ANALYSIS: - case BPState::FATIGUE_ANALYSIS: - case BPState::ECG_ANALYSIS: - case BPState::EMO_ANALYSIS: + // 疲劳度测量状态处理 + void BPModel::BPControlFatigueMeasure() { BP_StartTimer(); ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 - if (Time != BP_ANLYSISI_TIME_MAX) - Time = BP_ANLYSISI_TIME_MAX; // 重置时间 - break; + if (Time != BP_CHECK_TIME_MAX) + Time = BP_CHECK_TIME_MAX; // 重置时间 + } + + // 疲劳度测量结束状态处理 + void BPModel::BPControlFatigueMeasureEnd() + { + // 空实现：疲劳度测量结束逻辑 + } + // 疲劳度分析状态处理 + void BPModel::BPControlFatigueAnalysis() + { } - case BPState::ECG_REMIND: - case BPState::ECG_RESULT: + // ECG测量状态处理 + void BPModel::BPControlECGMeasure() { BP_StartTimer(); ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 - if (Time != BP_REMIND_TIME_MAX) - Time = BP_REMIND_TIME_MAX; // 重置时间 - break; + if (Time != BP_CHECK_TIME_MAX) + Time = BP_CHECK_TIME_MAX; // 重置时间 } - default: - /*未知状态，全部状态重置*/ - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_Control: Invalid state"); - BP_SetState(BPState::BP_NORMAL); - BP_StopTimer(); - Time = BP_CHECK_TIME_MAX; - return; + // ECG测量结束状态处理 + void BPModel::BPControlECGMeasureEnd() + { + // 空实现：ECG测量结束逻辑 } - // 更新状态 - BP_SetState(state); - } - ///////////////////////////////////////////////////////// - // 机器校准收缩压与舒张压的数值 - void BPModel::BP_SetValue(BP_VALUE_TYPE type, bool set_value) - { - if (set_value) + // ECG分析状态处理 + void BPModel::BPControlECGAnalysis() { - if (type == BP_VALUE_TYPE::SBP) + } + // ECG提醒状态处理 + void BPModel::BPControlECGRemind() + { + } + // ECG结果状态处理 + void BPModel::BPControlECGResult() + { + } + // 情绪测量状态处理 + void BPModel::BPControlEMOMeasure() + { + BP_StartTimer(); + ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别 + + if (Time != BP_CHECK_TIME_MAX) + Time = BP_CHECK_TIME_MAX; // 重置时间 + } + + // 情绪测量结束状态处理 + void BPModel::BPControlEMOMeasureEnd() + { + // 空实现：情绪测量结束逻辑 + } + // 情绪分析状态处理 + void BPModel::BPControlEMOAnalysis() + { + } + ///////////////////////////////////////////////////////// + // 机器校准收缩压与舒张压的数值 + void BPModel::BP_SetValue(BP_VALUE_TYPE type, bool set_value) + { + if (set_value) { - if (custom_sbp < 250) - custom_sbp++; + if (type == BP_VALUE_TYPE::SBP) + { + if (custom_sbp < 250) + custom_sbp++; + } + else if (type == BP_VALUE_TYPE::DBP) + { + if (custom_dbp < 150) + custom_dbp++; + } } - else if (type == BP_VALUE_TYPE::DBP) + else { - if (custom_dbp < 150) - custom_dbp++; + if (type == BP_VALUE_TYPE::SBP) + { + if (custom_sbp > 50) + custom_sbp--; + } + else if (type == BP_VALUE_TYPE::DBP) + { + if (custom_dbp > 30) + custom_dbp--; + } } } - else + uint8_t BPModel::GetValue(BP_VALUE_TYPE type) { 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--; - } + return custom_sbp; + else + return custom_dbp; } - } - int BPModel::GetValue(BP_VALUE_TYPE type) - { - if (type == BP_VALUE_TYPE::SBP) - return custom_sbp; - else - return custom_dbp; - } - void BPModel::BP_START(void) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_START"); + void BPModel::BP_START(void) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_START"); #ifdef ENABLE_BN02 - bp_start(BP); + bp_start(BP); #endif - } - void BPModel::BP_STOP(void) - { + } + void BPModel::BP_STOP(void) + { #ifdef ENABLE_BN02 - bp_stop(); + bp_stop(); #endif - } -void BPModel::BP_GetData(uint8_t *sbp, uint8_t *dbp) - { - #ifdef ENABLE_BN02 - if (sbp && dbp) { - int temp_sbp = 0, temp_dbp = 0; - bp_get_data(&temp_sbp, &temp_dbp); - - // 添加范围检查，避免数据截断 - if (temp_sbp >= 0 && temp_sbp <= UINT8_MAX) { - *sbp = static_cast(temp_sbp); - } else { - *sbp = 0; // 默认值 - } - - if (temp_dbp >= 0 && temp_dbp <= UINT8_MAX) { - *dbp = static_cast(temp_dbp); - } else { - *dbp = 0; - } - } - #endif - } - - std::map> BPModel::GetBPValueMap() - { - return bp_check_value_map; - } + } + void BPModel::BP_GetData(uint8_t *sbp, uint8_t *dbp) + { +#ifdef ENABLE_BN02 + if (sbp && dbp) + { + int temp_sbp = 0, temp_dbp = 0; + bp_get_data(&temp_sbp, &temp_dbp); - /* - 显示内容映射 （60~210）这个数据只是显示一个趋势 不代表什么，为了显示效果 - */ - uint8_t BPModel::mapValue(uint8_t value) - { - // 确保输入值在0-255范围内 - if (value < 0) - value = 0; - if (value > 255) - value = 255; - - // 线性映射公式：output = (input - input_min) * (output_max - output_min) / (input_max - input_min) + output_min - return (value - 0) * (210 - 60) / (255 - 0) + 60; - } + // 添加范围检查，避免数据截断 + if (temp_sbp >= 0 && temp_sbp <= UINT8_MAX) + { + *sbp = static_cast(temp_sbp); + } + else + { + *sbp = 0; // 默认值 + } -void BPModel::mapDataArray(uint8_t value) -{ - value = mapValue(value); + if (temp_dbp >= 0 && temp_dbp <= UINT8_MAX) + { + *dbp = static_cast(temp_dbp); + } + else + { + *dbp = 0; + } + } +#endif + } - // 使用固定大小的vector，通过索引循环覆盖旧数据 - static size_t index = 0; - if (bp_check_value_vector.size() < MAX_SHOW_CHECK_NUM) + std::map> BPModel::GetBPValueMap() { - bp_check_value_vector.push_back(value); - } - else - { - bp_check_value_vector[index] = value; - index = (index + 1) % MAX_SHOW_CHECK_NUM; + return bp_check_value_map; } -} - //获取过程值数据 - std::vector BPModel::GetBPCheckDataArray() - { - return bp_check_value_vector; - } - - - /* - 1.存储到BP.bin，存储前先判断文件夹是否存在 - 2.每次测量成功存储一次data,追加ab+ - 3.开机初始化读取文件，赋值到DBP，SBP - 4.每次更新，更新数组 - 5.更新完毕，存储到文件 - - */ - // 保存上次检测数据 - bool BPModel::save_last_check_bp_data(LAST_CHECK_DATA data) - { - return true; - } - - // 加载上次检测数据 - bool BPModel::load_last_check_bp_data(void) - { - std::ifstream inFile(BP_LAST_CHECK_FILE_PATH); - if (!inFile) + /* + 显示内容映射 （60~210）这个数据只是显示一个趋势 不代表什么，为了显示效果 + */ + uint8_t BPModel::mapValue(uint8_t value) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::load_last_check_bp_data"); - return false; // 文件打开失败 + // 确保输入值在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; } - // 读取文件内容，解析检测数据 - LAST_CHECK_DATA data; - while (inFile >> data.last_check_sbp_value >> data.last_check_dbp_value >> data.timestamp) + + void BPModel::mapDataArray(uint8_t value) { - lastCheckData.push_back(data); + value = mapValue(value); + + // 使用固定大小的vector，通过索引循环覆盖旧数据 + static size_t index = 0; + if (bp_check_value_vector.size() < MAX_SHOW_CHECK_NUM) + { + bp_check_value_vector.push_back(value); + } + else + { + bp_check_value_vector[index] = value; + index = (index + 1) % MAX_SHOW_CHECK_NUM; + } } - return true; - } - bool BPModel::get_last_check_bp_data(LAST_CHECK_DATA &data) - { - // 获取队列中最后一次检测数据 - if (lastCheckData.size() > 0) + // 获取过程值数据 + std::vector BPModel::GetBPCheckDataArray() { - data = lastCheckData.back(); - return true; + return bp_check_value_vector; } - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::get_last_check_bp_data is empty"); - return false; - } - // 获取最近检测数据数量 - uint8_t BPModel::get_last_check_data_num(void) - { - return lastCheckData.size(); - } - - bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data) - { - - return true; - } - // 存储bin文件 - bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data) - { - return true; - } - /*创建文件夹*/ - bool BPModel::CreateBPFolder() - { - return true; - } - //nextday清空血压数据 + //nextday清空血压数据 bool BPModel::CleanBPData(void) { //进行图表清空；model数组清空 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CleanBPData success"); return true; - } - - //////////////////////////////////time处理//////////////////////////////////// - // time到时的处理 - void BPModel::BP_timer_callback_out() - { + } //////////////////////////////////time处理//////////////////////////////////// + // time到时的处理 + void BPModel::BP_timer_callback_out() + { - BP_StopTimer(); + BP_StopTimer(); - // 提前获取各视图实例 - auto *bpMainView = BPMainView::GetInstance(); - auto *bpDetectionView = BPDetectionView::GetInstance(); - auto *stressMainView = StressMainView::GetInstance(); - auto *stressAnalysisView = StressAnalysisView::GetInstance(); - auto *fatigueMainView = FatigueMainView::GetInstance(); - auto *fatigueAnalysisView = FatigueAnalysisView::GetInstance(); - auto *emoView = EmoView::GetInstance(); - auto *ecgView = EcgView::GetInstance(); - - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "current_state:%d", current_state); - // 处理血压校准相关状态 - if (current_state == BPState::BP_CALIBRATING_FIRSTTIME || - current_state == BPState::BP_CALIBRATING_SECONDTIME) - { - if (bpMainView) - { - bpMainView->ChangeView(current_state == BPState::BP_CALIBRATING_FIRSTTIME - ? BPUNDERCALIBRATIONVIEW - : BPSECUNDERCALIBRATIONVIEW, - BPCALIBRATIONMINDVIEW); - } - LastCalibrationTime = BPModel::GetCurrentTimeStr(); // 获取校准完成时的时间 - BP_SetState(BPState::BP_NORMAL); - CalibrationFlag++; - return; - } - // 处理血压分析状态 - if (current_state == BPState::BP_CALIBRATING_ANGLYSIS) - { - if (bpMainView) + // 提前获取各视图实例 + auto *bpMainView = BPMainView::GetInstance(); + auto *bpDetectionView = BPDetectionView::GetInstance(); + auto *stressMainView = StressMainView::GetInstance(); + auto *stressAnalysisView = StressAnalysisView::GetInstance(); + auto *fatigueMainView = FatigueMainView::GetInstance(); + auto *fatigueAnalysisView = FatigueAnalysisView::GetInstance(); + auto *emoView = EmoView::GetInstance(); + auto *ecgView = EcgView::GetInstance(); + + // 处理血压校准相关状态 + if (current_state == BPState::BP_CALIBRATING_FIRSTTIME || + current_state == BPState::BP_CALIBRATING_SECONDTIME) { - bpMainView->ChangeView(BPRESULTANALYSISVIEW, BPCALIBRATIONPASSVIEW); - } - BP_SetState(BPState::BP_NORMAL); - if (CalibrationFlag == 1) + if (bpMainView) + { + bpMainView->ChangeView(current_state == BPState::BP_CALIBRATING_FIRSTTIME + ? BPUNDERCALIBRATIONVIEW + : BPSECUNDERCALIBRATIONVIEW, + BPCALIBRATIONMINDVIEW); + } + LastCalibrationTime = BPModel::GetCurrentTimeStr(); // 获取校准完成时的时间 + BP_STOP(); + BP_SetState(BPState::BP_IDLE); CalibrationFlag++; - else - CalibrationFlag = 0; - return; - } - // 处理血压检测状态 - if (current_state == BPState::BP_DETECTING) - { - if (bpDetectionView) - { - bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW); - } - BP_STOP(); // 停止检测 - if (bp_resullt == BPRESULT::NOT_TESTED) // 未测量到数据 - { - BP_SetResultState(BPRESULT::TIMEOUT); // 测量超时 - } - BP_SetState(BPState::BP_NORMAL); - return; - } - - // 处理压力检测与分析 - if (current_state == BPState::STRESS_MEASURE) - { - if (stressMainView) - { - stressMainView->ChangeView(STRESSUNDERMEASUREVIEW, STRESSANALYSISEVIEW); - } - BP_Control(BPState::STRESS_ANALYSIS); - if (stressAnalysisView) - { - stressAnalysisView->startorstopAnalysisAni(true); + return; } - return; - } - if (current_state == BPState::STRESS_ANALYSIS) - { - if (stressMainView) + // 处理血压分析状态 + if (current_state == BPState::BP_CALIBRATING_ANGLYSIS) { - stressMainView->ChangeView(STRESSANALYSISEVIEW, STRESSRESULTVIEW); + if (bpMainView) + { + bpMainView->ChangeView(BPRESULTANALYSISVIEW, BPCALIBRATIONPASSVIEW); + } + BP_SetState(BPState::BP_IDLE); + if (CalibrationFlag == 1) + CalibrationFlag++; + else + CalibrationFlag = 0; + return; } - BP_SetState(BPState::BP_NORMAL); - if (stressAnalysisView) + // 处理血压检测状态 + if (current_state == BPState::BP_DETECTING) { - stressAnalysisView->startorstopAnalysisAni(false); + if (bpDetectionView) + { + bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW); + } + BP_STOP(); // 停止检测 + if (bp_resullt == BPRESULT::NOT_TESTED) // 未测量到数据 + { + BP_SetResultState(BPRESULT::TIMEOUT); // 测量超时 + } + BP_SetState(BPState::BP_IDLE); + return; } - return; - } - // 处理疲劳度检测与分析 - if (current_state == BPState::FATIGUE_MEASURE) - { - if (fatigueMainView) - { - fatigueMainView->ChangeView(FATIGUEUNDERMEASUREVIEW, - FATIGUEANALYSISEVIEW); - } - BP_Control(BPState::FATIGUE_ANALYSIS); - if (fatigueAnalysisView) + // 处理压力检测与分析 + if (current_state == BPState::STRESS_MEASURE) { - fatigueAnalysisView->startorstopAnalysisAni(true); - } - return; - } - if (current_state == BPState::FATIGUE_ANALYSIS) - { - if (fatigueMainView) - { - fatigueMainView->ChangeView(FATIGUEANALYSISEVIEW, FATIGUERESULTVIEW); + if (stressMainView) + { + stressMainView->ChangeView(STRESSUNDERMEASUREVIEW, STRESSANALYSISEVIEW); + } + BP_Control(BPState::STRESS_ANALYSIS); + if (stressAnalysisView) + { + stressAnalysisView->startorstopAnalysisAni(true); + } + return; } - BP_SetState(BPState::BP_NORMAL); - if (fatigueAnalysisView) + if (current_state == BPState::STRESS_ANALYSIS) { - fatigueAnalysisView->startorstopAnalysisAni(false); + if (stressMainView) + { + stressMainView->ChangeView(STRESSANALYSISEVIEW, STRESSRESULTVIEW); + } + BP_SetState(BPState::BP_IDLE); + if (stressAnalysisView) + { + stressAnalysisView->startorstopAnalysisAni(false); + } + return; } - return; - } - // 处理情绪检测与分析 - if (current_state == BPState::EMO_MEASURE) - { - if (emoView) + // 处理疲劳度检测与分析 + if (current_state == BPState::FATIGUE_MEASURE) { - EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTVIEW, - EMOTIONTESTANALYSISVIEW); + if (fatigueMainView) + { + fatigueMainView->ChangeView(FATIGUEUNDERMEASUREVIEW, + FATIGUEANALYSISEVIEW); + } + BP_Control(BPState::FATIGUE_ANALYSIS); + if (fatigueAnalysisView) + { + fatigueAnalysisView->startorstopAnalysisAni(true); + } + return; } - return; - - if (current_state == BPState::EMO_ANALYSIS) + if (current_state == BPState::FATIGUE_ANALYSIS) { - if (emoView) + if (fatigueMainView) + { + fatigueMainView->ChangeView(FATIGUEANALYSISEVIEW, FATIGUERESULTVIEW); + } + BP_SetState(BPState::BP_IDLE); + if (fatigueAnalysisView) { - EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTANALYSISVIEW, - EMOTIONTESTRESULTVIEW); + fatigueAnalysisView->startorstopAnalysisAni(false); } - BP_SetState(BPState::BP_NORMAL); return; } - // 处理ECG相关状态 - if (ecgView) + // 处理情绪检测与分析 + if (current_state == BPState::EMO_MEASURE) { - if (current_state == BPState::ECG_REMIND) + if (emoView) { - EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTREMINDERVIEW, - ECGTESTINGVIEW); - return; + EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTVIEW, + EMOTIONTESTANALYSISVIEW); } + return; - if (current_state == BPState::ECG_MEASURE) + if (current_state == BPState::EMO_ANALYSIS) { - EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTINGVIEW, - ECGTESTANALYSISVIEW); + if (emoView) + { + EmoPresenter::GetInstance()->ChangeViewOperator(EMOTIONTESTANALYSISVIEW, + EMOTIONTESTRESULTVIEW); + } + BP_SetState(BPState::BP_IDLE); return; } - if (current_state == BPState::ECG_ANALYSIS) - { - EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTANALYSISVIEW, - ECGTESTRESULTVIEW); - return; - } - if (current_state == BPState::ECG_RESULT) + // 处理ECG相关状态 + if (ecgView) { + if (current_state == BPState::ECG_REMIND) + { + EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTREMINDERVIEW, + ECGTESTINGVIEW); + return; + } + + if (current_state == BPState::ECG_MEASURE) + { + EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTINGVIEW, + ECGTESTANALYSISVIEW); + return; + } + + if (current_state == BPState::ECG_ANALYSIS) + { + EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTANALYSISVIEW, + ECGTESTRESULTVIEW); + return; + } + if (current_state == BPState::ECG_RESULT) + { - EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTRESULTVIEW, - ECGRESETTESTOFSUCCVIEW); - BP_SetState(BPState::BP_NORMAL); + EcgPresenter::GetInstance()->ChangeViewOperator(ECGTESTRESULTVIEW, + ECGRESETTESTOFSUCCVIEW); + BP_SetState(BPState::BP_IDLE); + } } } } - } - // 每秒的处理 - void BPModel::BP_timer_callback_proc(int data) - { - - // 根据状态处理 - switch (current_state) + // 每秒的处理 + void BPModel::BP_timer_callback_proc(uint8_t data) { - case BPState::BP_NORMAL: - BP_StopTimer(); - BP_SetState(BPState::BP_NORMAL); - return; - case BPState::BP_DETECTING: - { - BPDetectBeginView *view = BPDetectBeginView::GetInstance(); - if (view) + // 根据状态处理 + switch (current_state) { - 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); + case BPState::BP_IDLE: + BP_StopTimer(); + BP_SetState(BPState::BP_IDLE); + return; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp); - } -#if 1 - if (Time == 5) + case BPState::BP_DETECTING: + { + BPDetectBeginView *view = BPDetectBeginView::GetInstance(); + if (view) { - LAST_CHECK_DATA newData; - newData.timestamp = BPModel::GetCurrentTime(); - newData.last_check_sbp_value = 128; // 测试数据 - newData.last_check_dbp_value = 80; - UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); // 存储到文件 - UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据 + view->UpdateTimeText(data); } - if (Time == 20) + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time); + if (Time > 0 && Time < 30) // 一分钟后获取数据 { - LAST_CHECK_DATA newData; - newData.timestamp = BPModel::GetCurrentTime(); - newData.last_check_sbp_value = 199; // 测试数据 - newData.last_check_dbp_value = 30; - UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); // 存储到文件 - UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据 + + BP_GetData(&custom_sbp, &custom_dbp); + if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据 + { + // LAST_CHECK_DATA newData; + // newData.last_check_sbp_value = custom_sbp; // 测试数据 + // newData.last_check_dbp_value = custom_dbp; + // newData.timestamp = BPModel::GetCurrentTime(); + // save_last_check_bp_data(newData); // 保存数据 + // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp); + } } -#endif + break; } - break; - } - case BPState::BP_CALIBRATING_FIRSTTIME: - { - BPUnderCalibrationView *view = BPUnderCalibrationView::GetInstance(); - if (view) + case BPState::BP_CALIBRATING_FIRSTTIME: { - int BPv = rand() % (210 - 60) + 60; - mapDataArray(BPv); - BPv = rand() % (210 - 60) + 60; - mapDataArray(BPv); - BPv = rand() % (210 - 60) + 60; - mapDataArray(BPv); - BPv = rand() % (210 - 60) + 60; - mapDataArray(BPv); - BPv = rand() % (210 - 60) + 60; - mapDataArray(BPv); - view->UpdateTimeText(data, bp_check_value_vector); - } - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time); - if (Time > 0 && Time < 30) // 一分钟后获取数据 - { - - BP_GetData(&custom_sbp, &custom_dbp); - if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据 + BPUnderCalibrationView *view = BPUnderCalibrationView::GetInstance(); + if (view) { - LAST_CHECK_DATA newData; - newData.last_check_sbp_value = custom_sbp; // 测试数据 - newData.last_check_dbp_value = custom_dbp; - newData.timestamp = BPModel::GetCurrentTime(); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp); + view->UpdateTimeText(data); } - } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time); + if (Time > 0 && Time < 30) // 一分钟后获取数据 + { - break; - } - case BPState::BP_CALIBRATING_SECONDTIME: - { - BPSecUnderCalibrationView *view = - BPSecUnderCalibrationView::GetInstance(); - 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); + BP_GetData(&custom_sbp, &custom_dbp); + if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据 + { + LAST_CHECK_DATA newData; + newData.last_check_sbp_value = custom_sbp; // 测试数据 + newData.last_check_dbp_value = custom_dbp; + newData.timestamp = BPModel::GetCurrentTime(); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp); + } + } + + break; } - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time); - if (Time > 0 && Time < 30) // 一分钟后获取数据 + case BPState::BP_CALIBRATING_SECONDTIME: { - BP_GetData(&custom_sbp, &custom_dbp); - if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据 + BPSecUnderCalibrationView *view = + BPSecUnderCalibrationView::GetInstance(); + if (view) { - LAST_CHECK_DATA newData; - newData.last_check_sbp_value = custom_sbp; // 测试数据 - newData.last_check_dbp_value = custom_dbp; - newData.timestamp = BPModel::GetCurrentTime(); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp); + view->UpdateTimeText(data); } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Time: %d", Time); + if (Time > 0 && Time < 30) // 一分钟后获取数据 + { + BP_GetData(&custom_sbp, &custom_dbp); + if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据 + { + LAST_CHECK_DATA newData; + newData.last_check_sbp_value = custom_sbp; // 测试数据 + newData.last_check_dbp_value = custom_dbp; + newData.timestamp = BPModel::GetCurrentTime(); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp); + } + } + break; } - break; - } - case BPState::ECG_MEASURE: - { - EcgTestingView *view = EcgTestingView::GetInstance(); - if (view) + case BPState::ECG_MEASURE: { - view->UpdateTimeLabel(Time); + EcgTestingView *view = EcgTestingView::GetInstance(); + if (view) + { + view->UpdateTimeLabel(Time); + } + break; } - break; - } - - case BPState::STRESS_MEASURE: - case BPState::FATIGUE_MEASURE: - case BPState::EMO_MEASURE: - case BPState::STRESS_ANALYSIS: - case BPState::FATIGUE_ANALYSIS: - case BPState::ECG_ANALYSIS: - case BPState::EMO_ANALYSIS: - case BPState::BP_CALIBRATING_ANGLYSIS: - case BPState::ECG_REMIND: - case BPState::ECG_RESULT: - { - break; - } - default: - BP_StopTimer(); - // 显示错误界面提示 - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "current_state is error!!"); - return; - } - } - /////////////////////////////////////定时器处理 不要修改////////////////////////////////////////////////// + case BPState::STRESS_MEASURE: + case BPState::FATIGUE_MEASURE: + case BPState::EMO_MEASURE: + case BPState::STRESS_ANALYSIS: + case BPState::FATIGUE_ANALYSIS: + case BPState::ECG_ANALYSIS: + case BPState::EMO_ANALYSIS: + case BPState::BP_CALIBRATING_ANGLYSIS: + case BPState::ECG_REMIND: + case BPState::ECG_RESULT: + { + break; + } - /*定时器到期时的处理*/ - static void BP_TimerCallbackProc(int data) - { - // 倒计时 - Time--; - // 到时的处理 - if (Time < 0) - { - BPModel::GetInstance()->BP_timer_callback_out(); - return; + default: + BP_StopTimer(); + // 显示错误界面提示 + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "current_state is error!!"); + return; + } } - BPModel::GetInstance()->BP_timer_callback_proc(Time); - } - /* - * @brief 回调函数 - */ - 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) - { - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer"); - /* -------------------------- 1.检查定时器是否已经存在，如果存在则返回 - * ------------------------- */ - if (g_timer != nullptr) + /////////////////////////////////////测量时间 定时器处理 不要修改////////////////////////////////////////////////// +#if DECLARE_BP_TIMER + // 声明定时器变量 + static osTimerId_t g_timer = nullptr; + /*定时器到期时的处理*/ + static void BP_TimerCallbackProc(uint8_t data) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!"); - return; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BP_TimerCallbackProc %d", Time); + // 倒计时 + Time--; + // 到时的处理 + if (Time < 0) + { + BPModel::GetInstance()->BP_timer_callback_out(); + return; + } + BPModel::GetInstance()->BP_timer_callback_proc(Time); } - - /* --------------------------------- 2.创建定时器 - * -------------------------------- */ - g_timer = osTimerNew((osTimerFunc_t)BP_TimerCallback, osTimerPeriodic, - nullptr, nullptr); - // 检查定时器创建是否成功 - if (g_timer == nullptr) + /* + * @brief 回调函数 + */ + static void BP_TimerCallback(uint8_t data) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!"); - return; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_TimerCallback %d", data); + GraphicService::GetInstance()->PostGraphicEvent( + std::bind(BP_TimerCallbackProc, data)); } - /* ----------------------------- 3.将毫秒转换为系统时钟节拍数 - * ---------------------------- */ - /* --------------------------------- 4.启动定时器 - * -------------------------------- */ - osStatus_t ret = osTimerStart(g_timer, 1000); - /* -------------------- 5.检查定时器启动是否成功,如果启动失败，删除定时器并置为 - * nullptr -------------------- */ - if (ret != osOK) + /* + * @brief 开启定时器函数 + * @param interval 时间间隔，单位ms + */ + void BPModel::BP_StartTimer(uint32_t interval) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "osTimerDelete failed, ret = %lx!!", ret); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer"); + /* -------------------------- 1.检查定时器是否已经存在，如果存在则返回 + * ------------------------- */ if (g_timer != nullptr) { - ret = osTimerDelete(g_timer); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!"); + return; } - g_timer = nullptr; - return; - } - } - /* - * @brief 停止定时器 - */ - void BPModel::BP_StopTimer(void) - { - // 检查定时器是否存在 - if (g_timer != nullptr) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StopTimer"); - osTimerStop(g_timer); - // 删除定时器并置为 nullptr - osStatus_t ret = osTimerDelete(g_timer); + + /* --------------------------------- 2.创建定时器 + * -------------------------------- */ + g_timer = osTimerNew((osTimerFunc_t)BP_TimerCallback, osTimerPeriodic, + nullptr, nullptr); + // 检查定时器创建是否成功 + if (g_timer == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!"); + return; + } + + /* ----------------------------- 3.将毫秒转换为系统时钟节拍数 + * ---------------------------- */ + /* --------------------------------- 4.启动定时器 + * -------------------------------- */ + osStatus_t ret = osTimerStart(g_timer, interval); + /* -------------------- 5.检查定时器启动是否成功,如果启动失败，删除定时器并置为 + * nullptr -------------------- */ if (ret != osOK) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "osTimerDelete failed, ret = %lx!!", ret); + if (g_timer != nullptr) + { + ret = osTimerDelete(g_timer); + } + g_timer = nullptr; + return; + } + } + /* + * @brief 停止定时器 + */ + void BPModel::BP_StopTimer(void) + { + // 检查定时器是否存在 + if (g_timer != nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StopTimer"); + osTimerStop(g_timer); + // 删除定时器并置为 nullptr + osStatus_t ret = osTimerDelete(g_timer); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "osTimerDelete failed, ret = %lx!!", ret); + } + g_timer = nullptr; } - g_timer = nullptr; } - } - 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) - { + + /////////////////////////////////////获取数据 定时器处理 不要修改////////////////////////////////////////////////// +#if DECLARE_BP_GETDATA + // 声明定时器变量 + static osTimerId_t g_timer_get_data = nullptr; + /*定时器到期时的处理*/ + static void BP_Timer_GetData_CallbackProc(uint8_t data) + { + // 取出48个数 添加到 显示数组 + uint8_t sensorData[48] = {0}; #ifdef ENABLE_BN02 - bp_get_data(sbp, dbp); + get_bp_ui_data(sensorData, 48); // 提取前48个字节 #endif - } - - std::map> 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); - } - - /* - 1.存储到BP.bin - 2.每次测量成功存储一次data,追加ab+ - 3.开机初始化读取文件，赋值到DBP，SBP - 4.每次更新，更新数组 - 5.更新完毕，存储到文件 - */ - - bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType) - { + for (uint8_t i = 0; i < 48; i++) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Data[%d] = %d\n", i, sensorData[i]); + // 更新显示数组 + BPModel::GetInstance()->mapDataArray(sensorData[i]); + } - // 判断文件夹是否存在 - if (!CreateBPFolder()) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateBPFolder file"); - return false; - } - // 对于校准时间，只需要时间戳，创建临时数据结构 - if (StorageType == BP_STORAGE_TYPE::LAST_CALIBRATE_TIME) - { - // 校准时间不需要血压值，设为0 - calibrationData.last_check_sbp_value = 0; - calibrationData.last_check_dbp_value = 0; - return save_bin_BP(calibrationData, StorageType); - } - // 其他类逻辑处理 - else if (StorageType == BP_STORAGE_TYPE::TODAY_DATA) - { - // 对于今日数据，需要检查是否为当天 - if (!IsTimestampToday(data.timestamp)) + // 更新UI 测试更新 + BPDetectBeginView *view = BPDetectBeginView::GetInstance(); + if (view) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Data timestamp is not today"); - return false; + view->UpdateChartData(); } - return save_bin_BP(data, StorageType); } - else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA) + /* + * @brief 回调函数 + */ + static void BP_Timer_GetData_Callback(uint8_t data) { - return save_bin_BP(data, StorageType); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BP_Timer_GetData_Callback %d", data); + GraphicService::GetInstance()->PostGraphicEvent( + std::bind(BP_Timer_GetData_CallbackProc, data)); } - return false; - } - // 存储bin文件 - bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType) - { - /* 存储 bin 文件 [协议使用] */ - std::string binFilePath = GetPath(StorageType); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s", - binFilePath.c_str()); - FILE *fp; - if (StorageType == BP_STORAGE_TYPE::TODAY_DATA) + /* + * @brief 开启定时器函数 + * @param interval 时间间隔，单位ms + */ + void BPModel::BP_Start_GetData_Timer(uint32_t interval) { - fp = fopen(binFilePath.c_str(), "ab+"); // 追加模式 - } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer"); + if (g_timer_get_data != nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!"); + return; + } + g_timer_get_data = osTimerNew((osTimerFunc_t)BP_Timer_GetData_Callback, osTimerPeriodic, + nullptr, nullptr); + if (g_timer_get_data == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!"); + return; + } - else - { - fp = fopen(binFilePath.c_str(), "wb+"); // 覆盖模式 + osStatus_t ret = osTimerStart(g_timer_get_data, interval); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "osTimerDelete failed, ret = %lx!!", ret); + if (g_timer_get_data != nullptr) + { + ret = osTimerDelete(g_timer_get_data); + } + g_timer_get_data = nullptr; + return; + } } - if (fp == NULL) + /* + * @brief 停止定时器 + */ + void BPModel::BP_Stop_GetData_Timer(void) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Failed to open binary file for writing"); - return false; + // 检查定时器是否存在 + if (g_timer_get_data != nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StopTimer"); + osTimerStop(g_timer_get_data); + // 删除定时器并置为 nullptr + osStatus_t ret = osTimerDelete(g_timer_get_data); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "osTimerDelete failed, ret = %lx!!", ret); + } + g_timer_get_data = nullptr; + } } - - // 写入数据 - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sizeof(data) %d", sizeof(data)); - if ((fwrite(&data.timestamp, sizeof(data.timestamp), 1, fp) != 1) || - (fwrite(&data.last_check_sbp_value, sizeof(data.last_check_sbp_value), 1, fp) != 1) || - (fwrite(&data.last_check_dbp_value, sizeof(data.last_check_dbp_value), 1, fp) != 1)) +#endif + /////////////////////////////////////////////////数据存储//////////////////////////////////////////////////////////// + bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Failed to write data to binary file"); - fclose(fp); + + // 判断文件夹是否存在 + if (!CreateBPFolder()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateBPFolder file"); + return false; + } + if (StorageType == BP_STORAGE_TYPE::TODAY_DATA) + { + // 对于今日数据，需要检查是否为当天 + if (!IsTimestampToday(data.timestamp)) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Data timestamp is not today"); + return false; + } + return save_bin_BP(data, StorageType); + } + else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA) + { + return save_bin_BP(data, StorageType); + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "UpdateHealthData failed"); return false; } - - fclose(fp); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Saved BP data: timestamp = %d, SBP = %d, DBP = %d", data.timestamp, - data.last_check_sbp_value, - data.last_check_dbp_value); - return true; - } - /*创建文件夹*/ - bool BPModel::CreateBPFolder() - { - struct stat info; - if (stat(BP_JSON_PATH, &info) != 0) + // 存储bin文件 + bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType) { - if (mkdir(BP_JSON_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) + /* 存储 bin 文件 [协议使用] */ + + std::string binFilePath; + FILE *fp; + if (StorageType == BP_STORAGE_TYPE::TODAY_DATA) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "mkdir BP_JSON_PATH is error"); + binFilePath = GetBPDataPath(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s", + binFilePath.c_str()); + fp = fopen(binFilePath.c_str(), "ab+"); // 追加模式 + } + + else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA) + { + binFilePath = std::string(BP_LAST_DATA_PATH); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s", + binFilePath.c_str()); + fp = fopen(binFilePath.c_str(), "wb+"); // 覆盖模式 + } + if (fp == NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "Failed to open binary file for writing"); return false; } - } - return true; - } + // 写入数据 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sizeof(data) %d", sizeof(data)); + if ((fwrite(&data.timestamp, sizeof(data.timestamp), 1, fp) != 1) || + (fwrite(&data.last_check_sbp_value, sizeof(data.last_check_sbp_value), 1, fp) != 1) || + (fwrite(&data.last_check_dbp_value, sizeof(data.last_check_dbp_value), 1, fp) != 1)) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "Failed to write data to binary file"); + fclose(fp); + return false; + } - bool BPModel::IsTimestampToday(uint32_t timestamp) - { - // 获取当前时间 - struct tm currentTm; - time_t seconds; - time(&seconds); - localtime_r(&seconds, ¤tTm); - // 将给定时间戳转换为 tm 结构 - struct tm *timestampTm = - localtime(reinterpret_cast(×tamp)); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "当前年月日：%d-%d-%d", - currentTm.tm_year + 1900, currentTm.tm_mon + 1, - currentTm.tm_mday); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "给定时间戳：%d-%d-%d", - timestampTm->tm_year + 1900, timestampTm->tm_mon + 1, - timestampTm->tm_mday); - // 比较年、月和日 - if ((currentTm.tm_year == timestampTm->tm_year && - currentTm.tm_mon == timestampTm->tm_mon && - currentTm.tm_mday == timestampTm->tm_mday)) - { + fclose(fp); + // yznyzn + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "Saved BP data: timestamp = %d, SBP = %d, DBP = %d", data.timestamp, + data.last_check_sbp_value, + data.last_check_dbp_value); return true; } - else - { - return false; - } - } - /*加载文件中数据*/ - bool BPModel::LoadBP(BP_STORAGE_TYPE StorageType) - { - if (StorageType == BP_STORAGE_TYPE::TODAY_DATA) + /*创建文件夹*/ + bool BPModel::CreateBPFolder() { - bp_check_value_vector.clear(); // 清空数组 - } - - std::string binFilePath = GetPath(StorageType); // 文件路径 + struct stat info; + if (stat(BP_DATA_PATH, &info) != 0) + { + if (mkdir(BP_DATA_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "mkdir BP_JSON_PATH is error"); + return false; + } + } - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str()); // 打开失败，今天没有测量记录则没有这个文件 + return true; + } - std::ifstream ifs(binFilePath, std::ios::binary); - if (!ifs.is_open()) + bool BPModel::IsTimestampToday(uint32_t timestamp) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Failed to open binary file for reading"); - return false; + // 获取当前时间 + struct tm currentTm; + time_t seconds; + time(&seconds); + localtime_r(&seconds, ¤tTm); + // 将给定时间戳转换为 tm 结构 + struct tm *timestampTm = + localtime(reinterpret_cast(×tamp)); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "当前年月日：%d-%d-%d", + currentTm.tm_year + 1900, currentTm.tm_mon + 1, + currentTm.tm_mday); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "给定时间戳：%d-%d-%d", + timestampTm->tm_year + 1900, timestampTm->tm_mon + 1, + timestampTm->tm_mday); + // 比较年、月和日 + if ((currentTm.tm_year == timestampTm->tm_year && + currentTm.tm_mon == timestampTm->tm_mon && + currentTm.tm_mday == timestampTm->tm_mday)) + { + return true; + } + else + { + return false; + } } - - LAST_CHECK_DATA data; - // 选取数据 - while (true) + /*加载文件中数据*/ + bool BPModel::LoadBP(BP_STORAGE_TYPE StorageType) { - // 先读取时间戳 - if (!ifs.read(reinterpret_cast(&data.timestamp), sizeof(data.timestamp))) + std::string binFilePath; + if (StorageType == BP_STORAGE_TYPE::TODAY_DATA) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Failed to read heart rate value"); - break; // 如果读取失败，退出循环 + lastCheckData.clear(); // 清空数组 + binFilePath = GetBPDataPath(); // 文件路径 } - - // 再读取SBP值 - if (!ifs.read(reinterpret_cast(&data.last_check_sbp_value), sizeof(data.last_check_sbp_value))) + else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Failed to read heart rate value"); - break; // 如果读取失败，退出循环 + binFilePath = std::string(BP_LAST_DATA_PATH); } - // 再读取DBP值 - if (!ifs.read(reinterpret_cast(&data.last_check_dbp_value), sizeof(data.last_check_dbp_value))) + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str()); // 打开失败，今天没有测量记录则没有这个文件 + + std::ifstream ifs(binFilePath, std::ios::binary); + if (!ifs.is_open()) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "Failed to read heart rate value"); - break; // 如果读取失败，退出循环 + "Failed to open binary file for reading"); + return false; } - // 如果时间为当天 - if (StorageType == BP_STORAGE_TYPE::TODAY_DATA && IsTimestampToday(data.timestamp)) + + LAST_CHECK_DATA data; + // 选取数据 + while (true) { + // 先读取时间戳 + if (!ifs.read(reinterpret_cast(&data.timestamp), sizeof(data.timestamp))) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "Failed to read heart rate value"); + break; // 如果读取失败，退出循环 + } - lastCheckData.push_back(data); // 存入数组中 + // 再读取SBP值 + if (!ifs.read(reinterpret_cast(&data.last_check_sbp_value), sizeof(data.last_check_sbp_value))) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "Failed to read heart rate value"); + break; // 如果读取失败，退出循环 + } + // 再读取DBP值 + if (!ifs.read(reinterpret_cast(&data.last_check_dbp_value), sizeof(data.last_check_dbp_value))) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "Failed to read heart rate value"); + break; // 如果读取失败，退出循环 + } + // 如果时间为当天 + if (StorageType == BP_STORAGE_TYPE::TODAY_DATA && IsTimestampToday(data.timestamp)) + { + + lastCheckData.push_back(data); // 存入数组中 #if 1 - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "timestamp:%d", data.timestamp); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "last_check_sbp_value:%d", data.last_check_sbp_value); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, - "last_check_dbp_value:%d", data.last_check_dbp_value); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "timestamp:%d", data.timestamp); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "last_check_sbp_value:%d", data.last_check_sbp_value); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "last_check_dbp_value:%d", data.last_check_dbp_value); #endif + } + else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA) + { + lastData = data; // 加载上次测量时间 + } } - else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA) - { - lastData = data; // 加载上次测量时间 - } - else if (StorageType == BP_STORAGE_TYPE::LAST_CALIBRATE_TIME) - { - calibrationData.timestamp = data.timestamp; // 加载上次校准时间 - } + // 关闭文件 + ifs.close(); + return true; } - // 关闭文件 - ifs.close(); - return true; - } -} // namespace OHOS + } // namespace OHOS diff --git a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectionPresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectionPresenter.cpp index 3da896580..78f20cc0f 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectionPresenter.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/bloodpressure/src/detection/BPDetectionPresenter.cpp @@ -39,7 +39,7 @@ namespace OHOS void BPDetectionPresenter::NavigateBack() { //重置状态 - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); } void BPDetectionPresenter::OnStart() diff --git a/code/sdk/application/wearable/fd230app/nativeui/ecg/src/EcgPresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/ecg/src/EcgPresenter.cpp index 3120540d3..6ea244c7a 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/ecg/src/EcgPresenter.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/ecg/src/EcgPresenter.cpp @@ -58,7 +58,7 @@ namespace OHOS { WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "EcgPresenter::OnStop"); Presenter::OnStop(); - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); } void EcgPresenter::ChangeViewOperator(int16_t hideView, int16_t showView) diff --git a/code/sdk/application/wearable/fd230app/nativeui/emotion/src/EmoPresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/emotion/src/EmoPresenter.cpp index 8140cec7d..83174da53 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/emotion/src/EmoPresenter.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/emotion/src/EmoPresenter.cpp @@ -58,7 +58,7 @@ namespace OHOS { WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "EmoPresenter::OnStop"); Presenter::OnStop(); - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); } void EmoPresenter::ChangeViewOperator(int16_t hideView, int16_t showView) diff --git a/code/sdk/application/wearable/fd230app/nativeui/fatiguelevel/src/FatiguePresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/fatiguelevel/src/FatiguePresenter.cpp index 405b3a743..636797db8 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/fatiguelevel/src/FatiguePresenter.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/fatiguelevel/src/FatiguePresenter.cpp @@ -86,7 +86,7 @@ namespace OHOS { if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT) { - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); return true; } @@ -100,7 +100,7 @@ namespace OHOS if (keyID == static_cast(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) { - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); } return true; diff --git a/code/sdk/application/wearable/fd230app/nativeui/settings/src/SettingModel.cpp b/code/sdk/application/wearable/fd230app/nativeui/settings/src/SettingModel.cpp index 0ff95f0ae..772c37660 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/settings/src/SettingModel.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/settings/src/SettingModel.cpp @@ -35,7 +35,7 @@ namespace OHOS { int index = 0; settings[index++] = {VIEW_SETTING, nullptr, STR_SETTINGS, false};//标题：设置 - #if defined(BOARD_W9) + #if defined(BOARD_W9)||1 settings[index++] = {VIEW_BLOOD_PRESSURE_CALIBRATION, PNG_APPLIST_BP_IMAGE, STR_BP_CALIBRATE, true};//血压检测 #endif settings[index++] = {VIEW_DISPLAY_BRIGHTNESS, PNG_SETTINGS_DISPLAY_BRIGHTNESS, STR_SCREEN_AND_BRIGHTNESS, true}; diff --git a/code/sdk/application/wearable/fd230app/nativeui/stress/src/StressPresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/stress/src/StressPresenter.cpp index f95ad6fe9..512768be1 100644 --- a/code/sdk/application/wearable/fd230app/nativeui/stress/src/StressPresenter.cpp +++ b/code/sdk/application/wearable/fd230app/nativeui/stress/src/StressPresenter.cpp @@ -86,7 +86,7 @@ namespace OHOS { if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT) { - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); return true; } @@ -100,7 +100,7 @@ namespace OHOS if (keyID == static_cast(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) { - BPModel::GetInstance()->BP_Control(BPState::BP_NORMAL); + BPModel::GetInstance()->BP_Control(BPState::BP_IDLE); NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); } return true; -- 2.17.1