return std::string(buffer);
}
- // 获取当前时间+路经字符串 // 格式: 文件路径+YYYY_MM_DD+文件名
- std::string BPModel::GetCurrentTimePath()
++ // 获取今天血压数据路径 // 格式: 文件路径+YYYY_MM_DD+文件名
++ std::string BPModel::GetBPDataPath()
+ {
+ uint32_t timeStamp = 0;
+
+ if (uapi_get_timestampe_ss(&timeStamp) != ERRCODE_SUCC)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to get timestamp");
+ return "----/--/--";
+ }
+
+ // 将时间戳转换为 time_t 类型
+ time_t rawtime = static_cast<time_t>(timeStamp);
+ struct tm *timeinfo = localtime(&rawtime);
+
+ if (timeinfo == NULL)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to convert time");
+ return "----/--/--";
+ }
+
+ // 格式化时间为字符串
+ char buffer[20]; // 格式: YYYY-MM-DD HH:MM
+ std::strftime(buffer, sizeof(buffer), "%Y_%m_%d", timeinfo);
+
- return std::string(BP_JSON_PATH) + std::string(buffer) + "BP.bin";
++ std::string binFilePath;
++ // 统一处理文件路径获取
++
++ binFilePath = std::string(BP_JSON_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)
{
{
bpDetectionView->ChangeView(CALIBRATION_BPVIEW, RESULT_BPVIEW);
}
- BP_STOP(); // 停止检测
- if(bp_resullt == BPRESULT::NOT_TESTED)//未测量到数据
++ BP_STOP(); // 停止检测
++ if (bp_resullt == BPRESULT::NOT_TESTED) // 未测量到数据
+ {
- BP_SetResultState(BPRESULT::TIMEOUT);//测量超时
++ BP_SetResultState(BPRESULT::TIMEOUT); // 测量超时
+ }
BP_SetState(BPState::BP_NORMAL);
return;
}
BPDetectBeginView *view = BPDetectBeginView::GetInstance();
if (view)
{
- view->UpdateTimeText(data);
+ 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 (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 (newData.last_check_sbp_value >= 140 || newData.last_check_dbp_value >= 90) // 高血压：收缩压≥140 mmHg 或 舒张压≥90 mmHg。
- {
- BP_SetResultState(BPRESULT::HIGH_RESULT);
- UpdateHealthData(newData); // 存储到文件
- }
- else if (newData.last_check_sbp_value < 90 || newData.last_check_dbp_value < 60) // 低血压：收缩压＜90 mmHg 且 舒张压＜60 mmHg。
- {
- BP_SetResultState(BPRESULT::LOW_RESULT);
- UpdateHealthData(newData);
- }
- else if (newData.last_check_sbp_value < 90 || newData.last_check_dbp_value < 60) // 正常血压：收缩压（高压）＜120 mmHg 且 舒张压（低压）＜80 mmHg。
- {
- BP_SetResultState(BPRESULT::SUCCESS);
- UpdateHealthData(newData);
- }
- else // 数据异常
- {
- BP_SetResultState(BPRESULT::INVALID_DATA); // 无效数据，不存储
- }
- BP_GetData(&custom_sbp, &custom_dbp);
- if (custom_sbp > 0 && custom_dbp > 0) // 检测到数据
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SBP: %d, DBP: %d", custom_sbp, custom_dbp);
+ }
+#if 1
+ if (Time == 5)
{
- // 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);
+ LAST_CHECK_DATA newData;
+ newData.timestamp = BPModel::GetCurrentTime();
+ newData.last_check_sbp_value = 128; // 测试数据
+ newData.last_check_dbp_value = 80;
- UpdateHealthData(newData);
++ UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); // 存储到文件
++ UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据
+ }
+ if (Time == 20)
+ {
+ LAST_CHECK_DATA newData;
+ newData.timestamp = BPModel::GetCurrentTime();
+ newData.last_check_sbp_value = 199; // 测试数据
+ newData.last_check_dbp_value = 30;
- UpdateHealthData(newData);
++ UpdateHealthData(newData, BP_STORAGE_TYPE::TODAY_DATA); // 存储到文件
++ UpdateHealthData(newData, BP_STORAGE_TYPE::LAST_MEASURE_DATA); // 存储上次测量数据
}
+#endif
}
break;
}
}
/*
- * @brief 开启定时器函数
- * @param interval 时间间隔，单位ms
- */
- void BPModel::BP_Start_GetData_Timer(uint32_t interval)
+ 1.存储到BP.bin
+ 2.每次测量成功存储一次data,追加ab+
+ 3.开机初始化读取文件，赋值到DBP，SBP
+ 4.每次更新，更新数组
+ 5.更新完毕，存储到文件
+ */
+
- bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data)
++ bool BPModel::UpdateHealthData(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BPModel::BP_StartTimer");
- if (g_timer_get_data != nullptr)
+
+ // 判断文件夹是否存在
+ if (!CreateBPFolder())
{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
- return;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateBPFolder file");
+ return false;
}
- if (!save_bin_BP(data) || (!IsTimestampToday(data.timestamp)))
- { // 存储bin文件[协议使用]
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SaveBP failed");
- return false;
- g_timer_get_data = osTimerNew((osTimerFunc_t)BP_Timer_GetData_Callback, osTimerPeriodic,
- nullptr, nullptr);
- if (g_timer_get_data == nullptr)
++ // 对于校准时间，只需要时间戳，创建临时数据结构
++ if (StorageType == BP_STORAGE_TYPE::LAST_CALIBRATE_TIME)
+ {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
- return;
++ // 校准时间不需要血压值，设为0
++ calibrationData.last_check_sbp_value = 0;
++ calibrationData.last_check_dbp_value = 0;
++ return save_bin_BP(calibrationData, StorageType);
+ }
- return true;
++ // 其他类逻辑处理
++ else 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);
++ }
++ return false;
+ }
+ // 存储bin文件
- bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data)
++ bool BPModel::save_bin_BP(const LAST_CHECK_DATA &data, BP_STORAGE_TYPE StorageType)
+ {
+ /* 存储 bin 文件 [协议使用] */
- std::string binFilePath = GetCurrentTimePath();
++ std::string binFilePath = GetPath(StorageType);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
+ binFilePath.c_str());
- FILE *fp = fopen(binFilePath.c_str(), "ab+");
+
- osStatus_t ret = osTimerStart(g_timer_get_data, interval);
- if (ret != osOK)
++ FILE *fp;
++ if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
++ {
++ fp = fopen(binFilePath.c_str(), "ab+"); // 追加模式
++ }
++
++ else
++ {
++ fp = fopen(binFilePath.c_str(), "wb+"); // 覆盖模式
++ }
+ if (fp == NULL)
{
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
- "osTimerDelete failed, ret = %lx!!", ret);
- if (g_timer_get_data != nullptr)
+ "Failed to open binary file for writing");
+ return false;
+ }
+
+ // 写入数据
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sizeof(HeartRateData) %d", sizeof(HeartRateData));
++ 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;
+ }
+
+ 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)
+ {
+ if (mkdir(BP_JSON_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0)
{
- ret = osTimerDelete(g_timer_get_data);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "mkdir BP_JSON_PATH is error");
+ return false;
}
- g_timer_get_data = nullptr;
- return;
}
+
+ return true;
}
- /*
- * @brief 停止定时器
- */
- void BPModel::BP_Stop_GetData_Timer(void)
+
+ bool BPModel::IsTimestampToday(uint32_t timestamp)
{
- // 检查定时器是否存在
- if (g_timer_get_data != nullptr)
+ // 获取当前时间
+ 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))
{
- 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)
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ /*加载文件中数据*/
- bool BPModel::LoadBP()
++ bool BPModel::LoadBP(BP_STORAGE_TYPE StorageType)
+ {
- bp_check_value_vector.clear(); // 清空数组
- std::string binFilePath = GetCurrentTimePath(); // 文件夹+时间+文件名
++ if (StorageType == BP_STORAGE_TYPE::TODAY_DATA)
++ {
++ bp_check_value_vector.clear(); // 清空数组
++ }
++
++ std::string binFilePath = GetPath(StorageType); // 文件路径
+
+ WEARABLE_LOGE(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 open binary file for reading");
+ return false;
+ }
+
+ LAST_CHECK_DATA data;
+ // 选取数据
+ while (true)
+ {
+ // 先读取时间戳
+ if (!ifs.read(reinterpret_cast<char *>(&data.timestamp), sizeof(data.timestamp)))
{
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
- "osTimerDelete failed, ret = %lx!!", ret);
+ "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 (IsTimestampToday(data.timestamp))
++ 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);
+#endif
+ }
++ else if (StorageType == BP_STORAGE_TYPE::LAST_MEASURE_DATA)
++ {
++ lastData = data; // 加载上次测量时间
++ }
++ else if (StorageType == BP_STORAGE_TYPE::LAST_CALIBRATE_TIME)
++ {
++ calibrationData.timestamp = data.timestamp; // 加载上次校准时间
+ }
- g_timer_get_data = nullptr;
}
-
++ // 关闭文件
++ ifs.close();
+ return true;
}
-#endif
+
} // namespace OHOS
projects / mirrors / FD230.git / commitdiff