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