* @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() {}
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)
}
return time;
}
-
+ // 获取上次校准时间
std::string BPModel::GetLastCalibrationTime()
{
if (LastCalibrationTime.empty())
}
/////////////////////////状态管理//////////////////////////////////////////
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; }
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,
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<uint8_t>(temp_sbp);
- } else {
- *sbp = 0; // 默认值
- }
-
- if (temp_dbp >= 0 && temp_dbp <= UINT8_MAX) {
- *dbp = static_cast<uint8_t>(temp_dbp);
- } else {
- *dbp = 0;
- }
- }
- #endif
- }
-
- std::map<uint8_t, std::pair<uint8_t, uint8_t>> BPModel::GetBPValueMap()
- {
- 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<uint8_t>(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<uint8_t>(temp_dbp);
+ }
+ else
+ {
+ *dbp = 0;
+ }
+ }
+#endif
+ }
- // 使用固定大小的vector，通过索引循环覆盖旧数据
- static size_t index = 0;
- if (bp_check_value_vector.size() < MAX_SHOW_CHECK_NUM)
+ std::map<uint8_t, std::pair<uint8_t, uint8_t>> 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<uint8_t> 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<uint8_t> 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<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);
- }
-
- /*
- 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<const time_t *>(×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<const time_t *>(×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<char *>(&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<char *>(&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<char *>(&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<char *>(&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<char *>(&data.last_check_sbp_value), sizeof(data.last_check_sbp_value)))
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "Failed to read heart rate value");
+ break; // 如果读取失败，退出循环
+ }
+ // 再读取DBP值
+ if (!ifs.read(reinterpret_cast<char *>(&data.last_check_dbp_value), sizeof(data.last_check_dbp_value)))
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "Failed to read heart rate value");
+ break; // 如果读取失败，退出循环
+ }
+ // 如果时间为当天
+ if (StorageType == BP_STORAGE_TYPE::TODAY_DATA && IsTimestampToday(data.timestamp))
+ {
+
+ lastCheckData.push_back(data); // 存入数组中
#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
projects / mirrors / FD230.git / commitdiff