#include "app_config.h" #include "app_task.h" #include "system/timer.h" #include "app_main.h" #include "system/includes.h" #include "key_event_deal.h" #include "timestamp/timestamp.h" #include "health_manager/health_manager.h" #define LOG_TAG_CONST SPORT_HEALTH_MANAGE #define LOG_TAG "[SHM_SLEEP]" #define LOG_ERROR_ENABLE #define LOG_DEBUG_ENABLE #define LOG_INFO_ENABLE #define LOG_CLI_ENABLE #include "debug.h" #ifdef SUPPORT_MS_EXTENSIONS #pragma bss_seg(".health_manager.data.bss") #pragma data_seg(".health_manager.data") #pragma const_seg(".health_manager.text.const") #pragma code_seg(".health_manager.text") #endif #if (TCFG_SPORT_HEALTH_ENABLE&&TCFG_SPORT_HEALTH_SLEEP) //睡眠记录配置 #define HEALTH_FILE_TYPE F_TYPE_SLEEP #define HEALTH_FILE_VERSION (0) //协议约定 #define HEALTH_FILE_INTERVAL (0Xff) //协议约定 #define TCFG_SPORT_HEALTH_AWAKE_MAX_LEN 30 //30min的清醒数据将被过滤 //测试数据配置 #define TCFG_SPORT_HEALTH_SLEEP_TEST 0 #define TCFG_SPORT_HEALTH_SLEEP_TEST_YEAR 2024 #define TCFG_SPORT_HEALTH_SLEEP_TEST_MONTH 9 #define TCFG_SPORT_HEALTH_SLEEP_TEST_DAY 7 #define TCFG_SPORT_HEALTH_SLEEP_TARGET_MIN (8*60*60)//7h #pragma pack(1)// struct sleep_storage_data { u8 stage; u8 sleep_min;//min }; #pragma pack()// static void motion_sleep_data_test_get(sleep_data *out); /* ------------------------------------------------------------------------------------*/ /** * @brief motion_sleep_data_get_switch 睡眠数据选择接口 * * @param out 数据 * * @return */ /* ------------------------------------------------------------------------------------*/ static int motion_sleep_data_get_switch(sleep_data *out) { //使用模拟测试数据 #if TCFG_SPORT_HEALTH_SLEEP_TEST motion_sleep_data_test_get(out); #else //使用JL算法数据 //若当前处于睡眠，则拒绝数据获取 if (!algo_motion_sleep_is_terminated()) { return false; } //获取数据 algo_motion_sleep_get(out); #endif return true; } /* ------------------------------------------------------------------------------------*/ /** * @brief sport_health_sleep_data_stroage 睡眠数据存储 * * @return */ /* ------------------------------------------------------------------------------------*/ static int sport_health_sleep_data_stroage() { sleep_data out = {0}; //获取睡眠数据 if (!motion_sleep_data_get_switch(&out)) { //需要忽略本次数据 return SHM_ERR_OK; } //没有数据，或者只有清醒数据，忽略 if ((out.blocks == 0) || ((out.blocks == 1) && (out.chart[0].stage == SLEEP_STAGE_AWAKE))) { return SHM_ERR_OK; } //获取系统时间 struct sys_time time; rtc_read_time(&time); #if TCFG_SPORT_HEALTH_SLEEP_TEST //测试使用 struct sys_time _time = { .year = TCFG_SPORT_HEALTH_SLEEP_TEST_YEAR, .month = TCFG_SPORT_HEALTH_SLEEP_TEST_MONTH, .day = TCFG_SPORT_HEALTH_SLEEP_TEST_DAY + 1, .hour = 22, .min = 30, }; memcpy(&time, &_time, sizeof(struct sys_time)); #endif //获取文件句柄 int file_len = 0; int swap_days = 0; void *fp = sport_health_file_open_by_time(HEALTH_FILE_TYPE, time.year, time.month, time.day); #if TCFG_SPORT_HEALTH_SLEEP_TEST//测试使用 if (fp) { sport_health_file_delete(fp); sport_health_file_close(fp); fp = NULL; } #endif if (!fp) { //若句柄不存在，则新建文件 struct health_file_total_head file_head = { .type = HEALTH_FILE_TYPE, .year = time.year, .month = time.month, .day = time.day, .crc = 0, .interval = HEALTH_FILE_INTERVAL, .version = HEALTH_FILE_VERSION, .reserve = 0, }; sport_health_common_swapX((u8 *)&file_head.year, (u8 *)&file_head.year, 2); fp = sport_health_file_open(HEALTH_FILE_TYPE, 0); file_len = sport_health_file_write(fp, (u8 *)&file_head, file_len, sizeof(struct health_file_total_head)); } else { //否则续写 file_len = sport_health_file_get_len(fp); } u8 valid_point_num = 0; u8 data_head_flag = 0; struct health_file_data_head data_head = {0}; for (int i = 0; i < out.blocks - 1; i++) { //数据开头的清醒数据不需要记录 if ((i == 0) && (out.chart[i].stage == SLEEP_STAGE_AWAKE)) { continue; } //写入数据包头 if (!data_head_flag) { struct sys_time start_time; timestamp_utc_sec_2_mytime(out.chart[i].timestamp, &start_time); data_head .hour = start_time.hour; data_head .min = start_time.min; data_head .len = 0xffff; file_len = sport_health_file_write(fp, (u8 *)&data_head, file_len, sizeof(struct health_file_data_head)); data_head_flag = 1; } //按格式写入数据到文件 int block_len = out.chart[i + 1].timestamp - out.chart[i].timestamp; struct sys_time block_time_begin; timestamp_utc_sec_2_mytime(out.chart[i].timestamp, &block_time_begin); struct sys_time block_time_end; timestamp_utc_sec_2_mytime(out.chart[i + 1].timestamp, &block_time_end); struct sleep_storage_data sleep_block = { .stage = (out.chart[i].stage == SLEEP_STAGE_AWAKE) ? 0xff : out.chart[i].stage, }; log_debug("[%d:%d]~[%d %d]", block_time_begin.hour, block_time_begin.min, block_time_end.hour, block_time_end.min); if (block_time_end.hour * 60 + block_time_end.min < block_time_begin.hour * 60 + block_time_begin.min) { //存在跨天数据，则在0点分段写入，方便绘图 swap_days = 1; int sleep_min = 24 * 60 - (block_time_begin.hour * 60 + block_time_begin.min); do { //睡眠时间超过255分钟时，需要分段写入 if (sleep_min > 255) { sleep_block.sleep_min = 255; log_debug("[1]index:%d stage:%d len:%d", valid_point_num, sleep_block.stage, sleep_block.sleep_min); file_len = sport_health_file_write(fp, (u8 *)&sleep_block, file_len, sizeof(struct sleep_storage_data)); valid_point_num++; sleep_min -= 255; } else { sleep_block.sleep_min = sleep_min; log_debug("[2]index:%d stage:%d len:%d", valid_point_num, sleep_block.stage, sleep_block.sleep_min); file_len = sport_health_file_write(fp, (u8 *)&sleep_block, file_len, sizeof(struct sleep_storage_data)); valid_point_num++; } } while (sleep_min > 255); sleep_min = block_time_end.hour * 60 + block_time_end.min; do { //睡眠时间超过255分钟时，需要分段写入 if (sleep_min > 255) { sleep_block.sleep_min = 255; log_debug("[3]index:%d stage:%d len:%d", valid_point_num, sleep_block.stage, sleep_block.sleep_min); file_len = sport_health_file_write(fp, (u8 *)&sleep_block, file_len, sizeof(struct sleep_storage_data)); valid_point_num++; sleep_min -= 255; } else { sleep_block.sleep_min = sleep_min; log_debug("[4]index:%d stage:%d len:%d", valid_point_num, sleep_block.stage, sleep_block.sleep_min); file_len = sport_health_file_write(fp, (u8 *)&sleep_block, file_len, sizeof(struct sleep_storage_data)); valid_point_num++; } } while (sleep_min > 255); } else { //正常写入 int sleep_min = (out.chart[i + 1].timestamp - out.chart[i].timestamp + 30) / 60; do { //睡眠时间超过255分钟时，需要分段写入 if (sleep_min > 255) { sleep_block.sleep_min = 255; log_debug("[5]index:%d stage:%d len:%d", valid_point_num, sleep_block.stage, sleep_block.sleep_min); file_len = sport_health_file_write(fp, (u8 *)&sleep_block, file_len, sizeof(struct sleep_storage_data)); valid_point_num++; sleep_min -= 255; } else { sleep_block.sleep_min = sleep_min; log_debug("[6]index:%d stage:%d len:%d", valid_point_num, sleep_block.stage, sleep_block.sleep_min); file_len = sport_health_file_write(fp, (u8 *)&sleep_block, file_len, sizeof(struct sleep_storage_data)); valid_point_num++; } } while (sleep_min > 255); } } //记录数据长度 data_head.len = valid_point_num * 2; sport_health_common_swapX((u8 *) & (data_head.len), (u8 *) & (data_head.len), 2); sport_health_file_update(fp, (u8 *)&data_head, sizeof(struct health_file_total_head), sizeof(struct health_file_data_head)); //更新文件头的crc和跨天信息 struct health_file_total_head re_file_head; sport_health_file_read(fp, (u8 *)& re_file_head, 0, sizeof(struct health_file_total_head)); for (int i = 0; i < 16; i++) { //用reserve区记录分段信息 re_file_head.reserve |= (swap_days << re_file_head.crc); //CRC做强制校验，有差异即可 re_file_head.crc++; } sport_health_file_update(fp, (u8 *)&re_file_head, 0, sizeof(struct health_file_total_head)); //关闭文件，结束记录 sport_health_file_close(fp); return SHM_ERR_OK; } /* ------------------------------------------------------------------------------------*/ /** * @brief sport_health_sleep_rec_data_get 获取记录数据 * * @param value 句柄 * * @return */ /* ------------------------------------------------------------------------------------*/ static int sport_health_sleep_rec_data_get(struct sleep_data_analysis *value) { sleep_data *out = (sleep_data *)value->data; //获取日期 struct sys_time time; #if 0//只读当天 rtc_read_time(&time); #else//由句柄指定日期 memcpy(&time, &value->file_time, sizeof(struct sys_time)); #endif //打开文件 void *fp = sport_health_file_open_by_time(HEALTH_FILE_TYPE, time.year, time.month, time.day); if (!fp) { out->blocks = 0; //文件不存在 return -SHM_ERR_FILE_NOT_FIND; } /* int block_idx = 0; */ int file_total = sport_health_file_get_len(fp); int file_offset = 0; //读取文件头 struct health_file_total_head total_head; sport_health_file_read(fp, (u8 *)&total_head, 0, sizeof(struct health_file_total_head)); sport_health_common_swapX((u8 *)&total_head.year, (u8 *)&total_head.year, 2); file_offset += sizeof(struct health_file_total_head); struct sys_time start_time; u32 timestamp_start; u32 timestamp_block; //分段读睡眠数据 int sleep_data_cnt = 0; do { //数据包头 struct health_file_data_head data_head; sport_health_file_read(fp, (u8 *)&data_head, file_offset, sizeof(struct health_file_data_head)); file_offset += sizeof(struct health_file_data_head); start_time.year = total_head.year; start_time.month = total_head.month; start_time.day = total_head.day; start_time.hour = data_head.hour; start_time.min = data_head.min; start_time.sec = 0; timestamp_start = timestamp_mytime_2_utc_sec(&start_time); //数据跨天 if (total_head.reserve & BIT(sleep_data_cnt)) { timestamp_start -= 24 * 60 * 60; } timestamp_block = timestamp_start; u16 blocks = data_head.len; //异常数据退出 if (blocks == 0xffff) { break; } sport_health_common_swapX((u8 *)&blocks, (u8 *)&blocks, 2); u8 *rbuf = zalloc(blocks); sport_health_file_read(fp, rbuf, file_offset, blocks); file_offset += blocks; struct sleep_storage_data *p = (struct sleep_storage_data *)rbuf; //读取该段数据 for (int i = 0; i < blocks / 2; i++) { //记录睡眠的状态和起始时间戳 p->stage = (p->stage == 0xff) ? SLEEP_STAGE_AWAKE : p->stage; out->chart[out->blocks].stage = p->stage; out->chart[out->blocks].timestamp = timestamp_block; #if 0 //debug使用 struct sys_time block_t; timestamp_utc_sec_2_mytime(out->chart[out->blocks].timestamp, &block_t); printf("[SLEEP_TEST_READ]%d STA:%d [%4d-%2d-%2d-%2d:%2d:%2d]", out->blocks, out->chart[out->blocks].stage, block_t.year, block_t.month, block_t.day, block_t.hour, block_t.min, block_t.sec); #endif//TCFG_SPORT_HEALTH_SLEEP_TEST //sw下一段睡眠 timestamp_block += p->sleep_min * 60; out->blocks++; p++; } //清醒作为包尾,用特殊值标记，跟清醒数据区分 out->chart[out->blocks].stage = SLEEP_STAGE_BLOCK_END; out->chart[out->blocks].timestamp = timestamp_block; out->blocks++; free(rbuf); } while (file_offset < file_total); sport_health_file_close(fp); return SHM_ERR_OK; } /* ------------------------------------------------------------------------------------*/ /** * @brief sport_health_sleep_data_analysis 解析睡眠数据 * * @param value 句柄 * * @return */ /* ------------------------------------------------------------------------------------*/ static int sport_health_sleep_data_analysis(struct sleep_data_analysis *value) { sleep_data *data = (sleep_data *)value->data; for (int i = 0; i < data->blocks - 1; i++) { int time_len = data->chart[i + 1].timestamp - data->chart[i].timestamp; //统计各类型睡眠的时长 if (data->chart[i].stage == SLEEP_STAGE_DEEP) { value->deep_min += time_len; } else if (data->chart[i].stage == SLEEP_STAGE_LIGHT) { value->light_min += time_len; } else if (data->chart[i].stage == SLEEP_STAGE_REM) { value->rem_min += time_len; } else if (data->chart[i].stage == SLEEP_STAGE_AWAKE) { //可能包含有较长的清醒数据,根据项目需求进行过滤 #if TCFG_SPORT_HEALTH_AWAKE_MAX_LEN time_len = time_len > TCFG_SPORT_HEALTH_AWAKE_MAX_LEN ? 0 : time_len; #endif value->awake_min += time_len; } else { time_len = 0; } value->total_min += time_len; } return SHM_ERR_OK; } static int shm_sleep_io_crtl(int cmd, void *priv) { int ret = SHM_ERR_OK; switch (cmd) { case SHM_CMD_SAVE_SINGLE: ret = sport_health_sleep_data_stroage(); break; default: /* ret = -SHE_ERR_MOD_NO_THIS_CMD; */ break; } return ret; } static int shm_sleep_get_value(int type, void *priv) { int ret = SHM_ERR_OK; switch (type) { case SHM_GET_TYPE_INFO: break; case SHM_GET_TYPE_INFO_STORAGE: //get date from file ret = sport_health_sleep_rec_data_get((struct sleep_data_analysis *)priv); break; case SHM_GET_TYPE_DATA_ANALYSIS: ret = sport_health_sleep_data_analysis((struct sleep_data_analysis *)priv); break; default: ret = -SHM_ERR_MOD_NO_THIS_TYPE; break; } return ret; } REGISTER_SPORT_HEALTH_MODULE(sleep) { .module = SHM_MOD_SLEEP, .io_ctrl = shm_sleep_io_crtl, .get_value = shm_sleep_get_value, }; /*****************************************************************************************************/ #if TCFG_SPORT_HEALTH_SLEEP_TEST /* ------------------------------------------------------------------------------------*/ /** * @brief motion_sleep_data_test_get 模拟数据 * * @param out */ /* ------------------------------------------------------------------------------------*/ static void motion_sleep_data_test_get(sleep_data *out) { struct sys_time time = { .year = TCFG_SPORT_HEALTH_SLEEP_TEST_YEAR, .month = TCFG_SPORT_HEALTH_SLEEP_TEST_MONTH, .day = TCFG_SPORT_HEALTH_SLEEP_TEST_DAY, .hour = 22, .min = 30, }; struct sys_time block_t; int timestamp_tmp = timestamp_mytime_2_utc_sec(&time); int sleep_time = 0; out->blocks = 0; do { out->chart[out->blocks].stage = rand32() % 3; out->chart[out->blocks].timestamp = timestamp_tmp; timestamp_utc_sec_2_mytime(out->chart[out->blocks].timestamp, &block_t); int len = rand32() % 3000 + 10 * 60; printf("[SLEEP_TEST_GET]%d STA:%d [%4d-%2d-%2d-%2d:%2d:%2d]len:%d \n", out->blocks, out->chart[out->blocks].stage, block_t.year, block_t.month, block_t.day, block_t.hour, block_t.min, block_t.sec, len); timestamp_tmp += len; sleep_time += len; out->blocks++; } while (sleep_time < TCFG_SPORT_HEALTH_SLEEP_TARGET_MIN); } static sleep_data_analysis value = { .file_time.year = TCFG_SPORT_HEALTH_SLEEP_TEST_YEAR, .file_time.month = TCFG_SPORT_HEALTH_SLEEP_TEST_MONTH, .file_time.day = TCFG_SPORT_HEALTH_SLEEP_TEST_DAY + 1, .file_time.hour = 22, .file_time.min = 30, .file_time.blocks = 0, }; int sleep_data_test() { sport_health_sleep_data_stroage(); sport_health_sleep_rec_data_get(&value); return 0; } #endif//TCFG_SPORT_HEALTH_SLEEP_TEST #endif// SPORT_HEALTH_MANAGE_SLEEP_ENABLE