//进行心率列表保存
void save_heart_list() { HealthService::GetInstance()->SaveDailyHeartRate(); }
}
+
+//判断时间戳是否为今日
+bool 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;
+ }
+}
+
static HealthService *g_pHealthService = nullptr;
/*获取日期*/
std::string GetCurrentDate() {
}
// 读取心率数据
-HeartRateData *HealthService::ReadHeartRateData() {
- // 判断文件夹是否存在
- if (!CreateHealthFolder()) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to create health folder");
- return nullptr;
- }
-
- // 读取文件
- std::ifstream inFile(HEART_JSON_PATH);
- if (!inFile.is_open()) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
- "Failed to open JSON file, creating default data");
-
- // 创建默认值为 0 的数据并存储到 JSON 文件
- HeartRateData defaultData;
- defaultData.Heart = 0; // 默认心率值
- defaultData.timestamp = static_cast<double>(time(nullptr)); // 当前时间戳
-
- // 创建 JSON 对象并写入文件
- cJSON *defaultRoot = cJSON_CreateObject();
- cJSON_AddNumberToObject(defaultRoot, "value", defaultData.Heart);
- cJSON_AddNumberToObject(defaultRoot, "timestamp", defaultData.timestamp);
-
- // 写入 JSON 文件
- FILE *file = fopen(HEART_JSON_PATH, "w");
- if (file) {
- char *jsonString = cJSON_Print(defaultRoot);
- fprintf(file, "%s", jsonString);
- fclose(file);
- free(jsonString);
- }
- cJSON_Delete(defaultRoot);
-
- // 返回默认数据
- HeartRateData *data = new HeartRateData(defaultData);
- return data;
- }
-
- // 读取文件内容到字符串
- std::stringstream buffer;
- buffer << inFile.rdbuf();
- std::string jsonDataString = buffer.str();
- const char *jsonData = jsonDataString.c_str();
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "jsonData: %s", jsonData);
-
- // 关闭文件
- inFile.close();
-
- if (jsonDataString.empty()) {
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "jsonDataString is empty");
- return nullptr;
- }
-
- cJSON *heart_root = cJSON_Parse(jsonData);
- if (heart_root == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to parse JSON data");
- return nullptr;
- }
-
- HeartRateData *data = new HeartRateData();
-
- cJSON *value_item = cJSON_GetObjectItem(heart_root, "value");
- cJSON *timestamp_item = cJSON_GetObjectItem(heart_root, "timestamp");
-
- // 检查是否存在必要字段，并验证数据类型
- if (value_item && cJSON_IsNumber(value_item) && timestamp_item &&
- cJSON_IsNumber(timestamp_item)) {
- data->Heart = value_item->valueint;
- data->timestamp = timestamp_item->valuedouble;
- } else {
- // 读取的数据异常
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Missing or invalid data fields");
- cJSON_Delete(heart_root);
- delete data;
- return nullptr;
- }
-
- cJSON_Delete(heart_root);
- return data;
+void HealthService::ReadHeartRateData(HeartRateData &data) {
+ data.timestamp = heart_time;
+ data.Heart = heart_rate;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "heart_time: %d, heart_rate: %d",
+ data.timestamp, data.Heart);
}
-// 保存血氧数据
+// 保存血氧数据X
bool HealthService::UpdateHealthData(const BloodOxygenData &data) {
// 配置血氧存储状态
uapi_dev_runtime_set_bloodoxygen_storage_status(1);
return true;
}
-//存储心率
-bool HealthService::UpdateHealthData(const HeartRateData &data) {
- // 配置心率存储状态
- uapi_dev_runtime_set_heartrate_storage_status(1);
-
- // 判断文件夹是否存在
- if (!CreateHealthFolder()) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateHealthFolder file");
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return false;
- }
-
- // 判断文件是否存在，不存在即创建并打开以输出模式
- std::ofstream outFile(HEART_JSON_PATH, std::ios::trunc);
- if (!outFile.is_open()) {
- // 文件创建失败
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
- "Failed to create or open JSON file for writing");
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return false;
- }
-
- // 创建一个 JSON 对象
- cJSON *heart_root = cJSON_CreateObject();
- if (heart_root == NULL) {
- outFile.close();
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return false;
- }
-
- cJSON_AddItemToObject(heart_root, "value", cJSON_CreateNumber(data.Heart));
- cJSON_AddItemToObject(heart_root, "timestamp",
- cJSON_CreateNumber(data.timestamp));
-
- char *jsonData = cJSON_Print(heart_root);
- if (jsonData == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to generate JSON data");
- cJSON_Delete(heart_root); // 使用 cJSON_Delete 释放内存
- outFile.close();
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return false;
- }
-
- // 写入 JSON 数据到文件
- outFile << jsonData;
-
- // 释放资源
- cJSON_Delete(heart_root);
- free(jsonData);
- outFile.close();
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "UpdateHealthData Heart JSON is ok");
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "UpdateHourlyHeartRate is ok");
-
- if (!SaveDailyHeartRate()) // 进行心率历史数据文件存储
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SaveDailyHeartRate failed");
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return false;
- }
-
- if (!save_bin_heart(data)) { // 存储bin文件[协议使用]
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SaveDailyHeartRate failed");
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return false;
- }
-
- uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
- return true;
-}
// 清空健康数据
bool HealthService::CleanHealthData() {
//清空心率数组
}
}
-// 加载心率列表
-bool HealthService::LoadDailyHeartRate() {
- ClearHourlyHeartRates(); // 清空数组
-
- // 使用 RAII 管理文件流
- std::ifstream file(HEART_DATA_PATH, std::ios::binary);
- if (!file.is_open()) {
- std::cerr << "Error: Unable to open heart rate data file for reading"
- << std::endl;
- return false;
- }
-
- // 读取时间戳
- file.read(reinterpret_cast<char *>(&lastLoadTime), sizeof(lastLoadTime));
- if (lastLoadTime == 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "LoadDailyHeartRate is not today");
- return false; // 无有效数据
- }
-
- // 判断时间戳是否为今天
- tm *lastTm = localtime(&lastLoadTime);
- time_t now = time(nullptr);
- tm *currentTm = localtime(&now);
- if (currentTm->tm_year == lastTm->tm_year &&
- currentTm->tm_yday == lastTm->tm_yday) {
- // 今天：进行数据读取
- for (int i = 0; i < MAX_HOURS; ++i) {
- HeartRateData rate; // 假设您有一个 HeartRateData 结构体
- if (!file.read(reinterpret_cast<char *>(&rate), sizeof(rate))) {
- std::cerr << "Error: Failed to read heart rate data." << std::endl;
- return false; // 读取失败
- }
- dailyHeartRates[i] = rate; // 保存心率和时间戳
- std::cout << "Hour " << i << ": Heart Rate " << rate.Heart << std::endl;
- }
- return true; // 成功读取
- }
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "LoadDailyHeartRate is not today");
- return false; // 不是今日
-}
-
-// 保存今日心率列表
-bool HealthService::SaveDailyHeartRate() {
- std::ofstream outFile(HEART_DATA_PATH, std::ios::binary | std::ios::trunc);
- if (!outFile.is_open()) {
- std::cerr << "Error: Unable to open heart rate data file for writing"
- << std::endl;
- return false; // 文件打开失败
- }
-
- // 存储时间戳
- time_t currentTime = time(nullptr);
- outFile.write(reinterpret_cast<const char *>(¤tTime),
- sizeof(currentTime));
-
- // 存储心率数据
- for (const auto &rate : dailyHeartRates) {
- if (!outFile.write(reinterpret_cast<const char *>(&rate), sizeof(rate))) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
- "Failed to write heart rate data to file");
- return false; // 写入失败
- }
- }
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "SaveDailyHeartRate is ok");
- return true; // 成功保存
-}
-
// 更新心率列表项
void HealthService::UpdateHourlyHeartRate(time_t timestamp,
uint16_t heartRate) {
}
// 加载最大最小值
void HealthService::LoadHeartMaxMin(uint16_t &max, uint16_t &min) {
- std::ifstream inFile(HEART_MAX_MIN_PATH, std::ios::binary);
- if (!inFile.is_open()) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to open file %s",
- HEART_MAX_MIN_PATH);
- return;
- }
-
- inFile.read(reinterpret_cast<char *>(&max), sizeof(max));
- if (!inFile) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to read max value");
- return;
- }
-
- inFile.read(reinterpret_cast<char *>(&min), sizeof(min));
- if (!inFile) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Failed to read min value");
- return;
- }
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "LoadHeartMaxMin is ok max %d, min %d",
- max, min);
+ max = heart_max;
+ if (heart_min == 255)
+ min = 0;
+ else
+ min = heart_min;
}
//进行消息发送
CUSTOM_FILEOPERATE_MSG_TYPE_BLOODXYGEN_SAVE, nullptr, 0);
}
-uint32_t HealthService::GetListTime() {
- return lastLoadTime;
-}
+//获取list文件
+uint32_t HealthService::GetListTime() { return lastLoadTime; }
std::string HealthService::formatTime(uint32_t time) {
char labelTime[20];
return labelTime; // 成功获取时间
}
+/********************************************************************************************/
+/*******************************************************************************************
+ */
+//存储心率
+bool HealthService::UpdateHealthData(const HeartRateData &data) {
+ // 配置心率存储状态
+ uapi_dev_runtime_set_heartrate_storage_status(1);
+
+ // 判断文件夹是否存在
+ if (!CreateHealthFolder()) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CreateHealthFolder file");
+ uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
+ return false;
+ }
+
+ if (data.timestamp < 0 || (!IsTimestampToday(data.timestamp))) {
+ uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Invalid timestamp %d",
+ data.timestamp);
+ return false;
+ }
+ if (!save_bin_heart(data)) { // 存储bin文件[协议使用]
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SaveDailyHeartRate failed");
+ uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
+ return false;
+ }
+
+ uapi_dev_runtime_set_heartrate_storage_status(0); // 恢复状态
+ return true;
+}
+//存储bin文件
bool HealthService::save_bin_heart(const HeartRateData &data) {
/* 存储 bin 文件 [协议使用] */
std::string binFilePath = GetBinFilePath(HEALTH_TYPE_HEART);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "save_bin_heart binFilePath %s",
+ binFilePath.c_str());
FILE *fp = fopen(binFilePath.c_str(), "ab+");
if (fp == NULL) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
return false;
}
- // 检查时间戳是否有效
- if (data.timestamp < 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Invalid timestamp: %d",
- data.timestamp);
- fclose(fp);
- return false; // 返回错误
- }
-
// 写入数据
- if (fwrite(&data, sizeof(HeartRateData), 1, fp) != 1) {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "sizeof(HeartRateData) %d", sizeof(HeartRateData));
+ if ((fwrite(&data.timestamp, sizeof(data.timestamp), 1, fp) != 1) || (fwrite(&data.Heart, sizeof(data.Heart), 1, fp) != 1)) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
"Failed to write data to binary file");
fclose(fp);
data.Heart);
return true;
}
-
+// 加载心率数据 24小时数据
+bool HealthService::LoadDailyHeartRate() {
+ ClearHourlyHeartRates(); // 清空数组 赋0操作
+ std::string binFilePath = GetBinFilePath(HEALTH_TYPE_HEART);
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "LoadDailyHeartRate");
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str());
+
+ // 配置心率存储状态
+ uapi_dev_runtime_set_heartrate_storage_status(1);
+
+ std::ifstream ifs(binFilePath, std::ios::binary);
+ if (!ifs.is_open()) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "Failed to open binary file for reading");
+ uapi_dev_runtime_set_heartrate_storage_status(0);
+ return false;
+ }
+
+ HeartRateData data;
+
+ // 选取每个小时的最新数据
+ while (true) {
+ // 先读取时间戳
+ if (!ifs.read(reinterpret_cast<char *>(&data.timestamp), sizeof(data.timestamp))) {
+ break; // 如果读取失败，退出循环
+ }
+
+ // 再读取心率值
+ if (!ifs.read(reinterpret_cast<char *>(&data.Heart), sizeof(data.Heart))) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "Failed to read heart rate value");
+ break; // 如果读取失败，退出循环
+ }
+
+ // 检查时间戳是否为当天
+ if (IsTimestampToday(data.timestamp)) {
+ // 计算当前小时
+ time_t rawTime = static_cast<time_t>(data.timestamp);
+ struct tm *timeInfo = localtime(&rawTime);
+ int hour = timeInfo->tm_hour; // 获取小时数
+
+ // 更新每小时最新心率数据
+ if (dailyHeartRates[hour].timestamp < data.timestamp) {
+ dailyHeartRates[hour].Heart = data.Heart; // 更新最新数据
+ dailyHeartRates[hour].timestamp = data.timestamp;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "hour %d %d %d", hour,
+ data.timestamp, data.Heart);
+ }
+
+ // 更新最高、最低心率
+ if (data.Heart > heart_max) {
+ heart_max = data.Heart;
+ }
+ if (data.Heart < heart_min) {
+ heart_min = data.Heart;
+ }
+ // 更新最新心率数据
+ heart_time = data.timestamp;
+ heart_rate = data.Heart;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,
+ "Loaded heart data: timestamp = %d, Heart = %d",
+ data.timestamp, data.Heart);
+ } else {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,
+ "error data: timestamp = %d, Heart = %d", data.timestamp,
+ data.Heart);
+ }
+ }
+
+ // 打印list内容
+ // for (int i = 0; i < MAX_HOURS; i++) {
+ // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "dailyHeartRates[%d] %d %d", i,
+ // dailyHeartRates[i].timestamp, dailyHeartRates[i].Heart);
+ // }
+
+ uapi_dev_runtime_set_heartrate_storage_status(0);
+ return true;
+}
std::string HealthService::get_heart_data() {
std::string binFilePath = GetBinFilePath(HEALTH_TYPE_HEART);
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "binFilePath %s", binFilePath.c_str());
}
// 将数据格式化为字符串，拼接到结果中
- result << formatTime(data.timestamp) << "," << std::to_string(data.Heart) << "\n";
+ result << formatTime(data.timestamp) << "," << std::to_string(data.Heart)
+ << "\n";
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "get_heart_data %d %d",
data.timestamp, data.Heart);
}
\r
HeartModel::HeartModel() {\r
/*初始化读取文件*/\r
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartModel()");\r
- HeartRateData *data = HealthService::GetInstance()->ReadHeartRateData();\r
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartModel()");\r
/*初始化历史文件*/\r
HealthService::GetInstance()->LoadDailyHeartRate();\r
- if (data != nullptr) {\r
- currentheart = data->Heart;\r
- timestamp_ms = data->timestamp;\r
- // 更新表盘心率数据\r
- DialModelHeartRate::GetInstance()->UpdateHeartRate(currentheart);\r
- delete data;\r
- } else {\r
- currentheart = 0;\r
- timestamp_ms = 0;\r
- }\r
+ /*读取上一次心率数据*/\r
+ HeartRateData data;\r
+ HealthService::GetInstance()->ReadHeartRateData(data);\r
+ currentheart = data.Heart;\r
+ timestamp_ms = data.timestamp;\r
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "currentheart %d timestamp_ms %d",\r
+ currentheart, timestamp_ms);\r
+ // 更新表盘心率数据\r
+ DialModelHeartRate::GetInstance()->UpdateHeartRate(currentheart);\r
+\r
//读取最大最小值\r
HealthService::GetInstance()->LoadHeartMaxMin(displayheart_max,\r
displayheart_min);\r
\r
uint32_t timestamp = HeartResultPresenter::GetInstance()->GetCurrentTime();\r
SetCheckTime(timestamp);\r
-#if MSG_SAVE_TEST\r
- HeartRateData data;\r
- data.Heart = currentheart;\r
- data.timestamp = timestamp_ms;\r
- HealthService::GetInstance()->UpdateHealthData(data);\r
-#else\r
+\r
HealthService::GetInstance()->send_heart_save();\r
+ \r
+ // 更新最大和最小心率\r
+ displayheart_max =\r
+ (displayheart_max < currentheart ? currentheart : displayheart_max);\r
+\r
+ // 确保最小心率的第一次赋值大于50\r
+ if (displayheart_min == 0 && currentheart > MIN_DISPLAY_HEART) {\r
+ displayheart_min = currentheart; // 初始化最小心率\r
+ } else {\r
+ displayheart_min =\r
+ (displayheart_min > currentheart && currentheart > MIN_DISPLAY_HEART)\r
+ ? currentheart\r
+ : displayheart_min;\r
+ }\r
+\r
// 将更新曲线写到这里提前更新\r
HealthService::GetInstance()->UpdateHourlyHeartRate(timestamp_ms,\r
currentheart);\r
-#endif\r
// WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "保存的心率数据：%d%ld",\r
// currentheart,data.timestamp);\r
}\r
: (result == HeartResult::TIMEOUT) ? "超时" : "无效数据";\r
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果:%s情况", resultMsg);\r
uapi_set_screen_on_api(); // 亮屏\r
- NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_ABNORMAL);\r
+ //需要先判断界面 心率卡片界面\r
+ if (MainViewSample::GetInstance()) {\r
+ if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE)\r
+ NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_ABNORMAL);\r
+ } else\r
+ NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_ABNORMAL);\r
}\r
// 处理低心率情况\r
void HeartModel::handleLowHeartRate() {\r
HealthState lowHealthState = {HEART_CHECK, LOW, thresholdValue};\r
HealthService::GetInstance()->SetHealthCurrent(lowHealthState);\r
uapi_set_screen_on_api(); // 亮屏\r
- NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID);\r
+ if (MainViewSample::GetInstance()) {\r
+ if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE)\r
+ NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID);\r
+ } else\r
+ NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID);\r
}\r
// 处理高心率情况\r
void HeartModel::handleHighHeartRate() {\r
HealthState highHealthState = {HEART_CHECK, HIGH, thresholdValue};\r
HealthService::GetInstance()->SetHealthCurrent(highHealthState);\r
uapi_set_screen_on_api(); // 亮屏\r
- NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID);\r
+ if (MainViewSample::GetInstance()) {\r
+ if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE)\r
+ NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID);\r
+ } else\r
+ NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID);\r
}\r
// 设置佩戴状态\r
void HeartModel::SetWearStatus() {\r
valid_counter_++; // 增加有效计数器\r
disvalid_counter_ = 0; // 清空无效计数器\r
\r
- // 更新最大和最小心率\r
- displayheart_max =\r
- (displayheart_max < displayheart ? displayheart : displayheart_max);\r
-\r
- // 确保最小心率的第一次赋值大于50\r
- if (displayheart_min == 0 && displayheart > MIN_DISPLAY_HEART) {\r
- displayheart_min = displayheart; // 初始化最小心率\r
- } else {\r
- displayheart_min =\r
- (displayheart_min > displayheart && displayheart > MIN_DISPLAY_HEART)\r
- ? displayheart\r
- : displayheart_min;\r
- }\r
} else {\r
disvalid_counter_++; // 增加无效计数器\r
valid_counter_ = 0; // 清零有效计数器\r
projects / mirrors / FD230.git / commitdiff