#ifdef SUPPORT_MS_EXTENSIONS #pragma bss_seg(".alarm_api.data.bss") #pragma data_seg(".alarm_api.data") #pragma const_seg(".alarm_api.text.const") #pragma code_seg(".alarm_api.text") #endif #include "system/includes.h" #include "alarm.h" #include "system/timer.h" #include "app_main.h" #include "tone_player.h" #include "app_task.h" #include "app_config.h" #include "rtc.h" #define LOG_TAG_CONST APP_RTC #define LOG_TAG "[alarm]" #define LOG_ERROR_ENABLE #define LOG_DEBUG_ENABLE #define LOG_INFO_ENABLE #define LOG_DUMP_ENABLE #define LOG_CLI_ENABLE #include "debug.h" #if TCFG_PAY_ALIOS_ENABLE #include "alipay.h" #if ALIPAY_SE_FW_V2_0 #define ALIOS_SYNC_TIME_DONE() #else #define ALIOS_SYNC_TIME_DONE() alipay_vendor_sync_time_done() #endif #endif #if TCFG_APP_RTC_EN #ifdef RTC_ALM_EN /* #define ALARM_DEBUG_EN */ #ifdef ALARM_DEBUG_EN #define alarm_printf log_info #define alarm_putchar log_char #define alarm_printf_buf log_info_hexdump #else #define alarm_printf(...) #define alarm_putchar(...) #define alarm_printf_buf(...) #endif #define PRINT_FUN() alarm_printf("func : %s\n", __FUNCTION__) #define PRINT_FUN_RETURN_INFO() alarm_printf("func : %s, line : %d.\n", __FUNCTION__, __LINE__) #define MAX_YEAR 2099 #define MIN_YEAR 2000 /************************************************************* 此文件函数主要是rtc闹钟的实现代码 用户可以不主要关心实现，专心留意api调用 常用的api 有: u8 alarm_add(PT_ALARM p, u8 index); 增加闹钟 void alarm_delete(u8 index); 删除闹钟 void rtc_update_time_api(struct sys_time *time) 更新时间api(更新了时间必须调用该接口) u8 alarm_active_flag_get(void); 闹钟到达的标志 u8 alarm_get_info(PT_ALARM p, u8 index) 获取闹钟信息 u8 alarm_get_active_index(void); 获取当前激活使能的闹钟(可以理解为下一个会响的闹钟) u8 alarm_get_total(void) 获取当前已经设备的闹钟数(包括关闭的闹钟) void rtc_calculate_next_few_day(struct sys_time *data_time,u8 days) 获取今天星期几 void alarm_name_set(u8 *p, u8 index, u8 len) 设置闹钟名字 u8 alarm_name_get(u8 *p, u8 index) 获取闹钟名字 **************************************************************/ struct p11_sys_time { u32 mask; struct sys_time ram_time; /* struct _rtc_trim ram_lrc_trim; */ }; static volatile u8 g_alarm_active_flag = 0; static volatile u8 alarm_cur_active = 0;//当前在响的闹钟 static volatile u8 snooze_time = 10;//单位：分钟 static struct p11_sys_time *p11_rtc_time = 0; typedef struct __alarm_map__ { u32 mask: 16; u32 map : ((M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM + 7) / 8 * 8); //存储了闹钟数目信息（闹钟数）, 第BIT(M_MAX_ALARM_NUMS + 1)为贪睡闹钟 u32 map_sw : ((M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM + 7) / 8 * 8); //存储闹钟的使能开关(闹钟开关),第BIT(M_MAX_ALARM_NUMS + 1)为贪睡闹钟 u32 active_map : ((M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM + 7) / 8 * 8); //存储最后激活闹钟,第BIT(M_MAX_ALARM_NUMS + 1)为贪睡闹钟 u8 table[M_MAX_ALARM_NUMS];//闹钟排序 } T_ALARM_MAP, *PT_ALARM_MAP; /* volatile u8 g_alarm_ring_max_cnt = 100; */ static T_ALARM alarm_tab[M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM] = {0};//数组最后一个为贪睡闹钟 static u8 alarm_name[M_MAX_ALARM_NAME_LEN] = {0}; #define RTC_MASK (0x55aa+M_MAX_ALARM_NAME_LEN) static void *dev_handle; T_ALARM_MAP alarm_map = {0}; /*----------------------------------------------------------------------------*/ /* debug 函数代码 */ /*----------------------------------------------------------------------------*/ void alarm_vm_puts_info(PT_ALARM p) { alarm_printf("index : %d\n", p->index); alarm_printf("mode: %d\n", p->mode); alarm_printf("sw: %d\n", p->sw); /* alarm_puts_time(&(p->time)); */ } void alarm_puts_time(struct sys_time *pTime) { /* u32 rets_addr; */ /* __asm__ volatile("%0 = rets ;" : "=r"(rets_addr)); */ /* alarm_printf("%s:0x%x", __func__, rets_addr); */ u8 week = 0; ASSERT(pTime); #if 1 alarm_printf("alarm_time : %d-%d-%d,%d:%d:%d\n", pTime->year, pTime->month, pTime->day, pTime->hour, pTime->min, pTime->sec); //cppcheck-suppress unreadVariable week = rtc_calculate_week_val(pTime); #endif alarm_printf("alarm week : %d\n", week); } void alarm_print_all_info(void) { alarm_printf("<%s>:", __func__); alarm_printf("alarm_map.map:%x", alarm_map.map); alarm_printf("alarm_map.map_sw:%x", alarm_map.map_sw); alarm_printf("alarm_map.active_map:%x", alarm_map.active_map); alarm_printf_buf((u8 *)&alarm_map.table, sizeof(alarm_map.table)); for (int i = 0; i < M_MAX_ALARM_NUMS; i++) { alarm_printf_buf((u8 *)&alarm_tab[i], sizeof(T_ALARM)); } } /*----------------------------------------------------------------------------*/ /* rtc 硬化相关代码*/ /*----------------------------------------------------------------------------*/ /* void *is_sys_time_online() */ /* { */ /* return dev_handle; */ /* } */ static void get_sys_time(struct sys_time *time)//获取时间 { ASSERT(time); rtc_read_time(time); } static void set_sys_time(struct sys_time *time)//设置时间 { ASSERT(time); rtc_write_time(time); #if TCFG_PAY_ALIOS_ENABLE ALIOS_SYNC_TIME_DONE(); //更新时间 #endif /* #if TCFG_PAY_ALIOS_ENABLE */ } void alarm_hw_set_sw(u8 sw)//闹钟开关 { /* printf("alarm sw : %d\n", sw); */ rtc_alarm_switch(!!sw); } void alarm_hw_write_time(struct sys_time *time, u8 sw)//写闹钟寄存器 { ASSERT(time); log_info("write_alarm_time : %d-%d-%d,%d:%d:%d\n", time->year, time->month, time->day, time->hour, time->min, time->sec); alarm_hw_set_sw(!!sw); rtc_write_alarm(time); rtc_debug_dump(); } /*----------------------------------------------------------------------------*/ /* vm读写操作部分代码 */ /*----------------------------------------------------------------------------*/ static void alarm_vm_reset() { int i = 0; int ret = 0; T_ALARM_MAP map_temp = {0}; memset(&map_temp, 0x0, sizeof(T_ALARM_MAP)); memset(&map_temp.table, 0xff, M_MAX_ALARM_NUMS); map_temp.mask = RTC_MASK; ret = syscfg_write(VM_ALARM_MASK, (u8 *)&map_temp, sizeof(T_ALARM_MAP)); if (ret != sizeof(T_ALARM_MAP)) { PRINT_FUN_RETURN_INFO(); return; } for (i = 0; i < (M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM); i++) { T_ALARM_VM tmp = {0}; tmp.head = RTC_MASK; tmp.alarm.index = i; ret = syscfg_write(VM_ALARM_0 + i, &tmp, sizeof(T_ALARM_VM)); if (ret != sizeof(T_ALARM_VM)) { alarm_printf("The %d alarm write vm err!\n", i); return; } } } //写闹钟map表 static void alarm_vm_write_mask(PT_ALARM_MAP map) { int ret = 0; PRINT_FUN(); T_ALARM_MAP map_temp = {0}; memcpy(&map_temp, map, sizeof(T_ALARM_MAP)); if (map_temp.mask != RTC_MASK) { memset(&map_temp, 0x0, sizeof(T_ALARM_MAP)); map_temp.mask = RTC_MASK; } ret = syscfg_write(VM_ALARM_MASK, (u8 *)&map_temp, sizeof(T_ALARM_MAP)); if (ret != sizeof(T_ALARM_MAP)) { PRINT_FUN_RETURN_INFO(); return; } } //获取闹钟所有信息 static void alarm_vm_read_info(PT_ALARM_MAP map) { PRINT_FUN(); T_ALARM_VM tmp; int ret = 0; u8 i; ret = syscfg_read(VM_ALARM_MASK, (u8 *)map, sizeof(T_ALARM_MAP)); if (ret != sizeof(T_ALARM_MAP) || map->mask != RTC_MASK) { PRINT_FUN_RETURN_INFO(); memset(map, 0, sizeof(T_ALARM_MAP)); map->mask = RTC_MASK; memset(map->table, 0xff, M_MAX_ALARM_NUMS); alarm_vm_reset(); return; } //贪睡闹钟不记忆 for (i = 0; i < (M_MAX_ALARM_NUMS); i++) { if ((map->map) & BIT(i)) { ret = syscfg_read(VM_ALARM_0 + i, &tmp, sizeof(T_ALARM_VM)); if (ret != sizeof(T_ALARM_VM) || tmp.head != RTC_MASK) { alarm_printf("can't find the %d alarm from vm.\n", i); memset(&(alarm_tab[i]), 0x00, sizeof(T_ALARM)); continue; } log_info("vm info : index=%d, sw=%d, mode=%d, h=%d, m=%d, sec=%d, name_len=%d\n", tmp.alarm.index, tmp.alarm.sw, tmp.alarm.mode, \ tmp.alarm.time.hour, tmp.alarm.time.min, tmp.alarm.time.sec, tmp.alarm.name_len); memcpy(&alarm_tab[i], &(tmp.alarm), sizeof(T_ALARM)); if (alarm_tab[i].sw) { map->map_sw |= BIT(i); } else { map->map_sw &= ~(BIT(i)); } } } } //更新闹钟信息 static void alarm_vm_write_info_by_index(PT_ALARM_MAP map, u8 index) { PRINT_FUN(); s32 ret = 0; T_ALARM_VM tmp; tmp.head = RTC_MASK; memcpy(&(tmp.alarm), &alarm_tab[index], sizeof(T_ALARM)); tmp.alarm.index = index; ret = syscfg_write(VM_ALARM_0 + index, &tmp, sizeof(T_ALARM_VM)); if (ret != sizeof(T_ALARM_VM)) { alarm_printf("The %d alarm write vm err!\n", index); return; } alarm_printf("vm info : index=%d, sw=%d, mode=%d, h=%d, m=%d, name_len=%d\n", tmp.alarm.index, tmp.alarm.sw, tmp.alarm.mode, \ tmp.alarm.time.hour, tmp.alarm.time.min, tmp.alarm.name_len); alarm_vm_write_mask(map); return; } /*----------------------------------------------------------------------------*/ /*闹钟名字部分代码 */ /*----------------------------------------------------------------------------*/ static void alarm_vm_write_name(u8 *p, u8 index) { PRINT_FUN(); s32 ret = 0; ret = syscfg_write(VM_ALARM_NAME_0 + index, p, sizeof(alarm_name)); if (ret < 0) { PRINT_FUN_RETURN_INFO(); return; } return; } static void alarm_vm_read_name(u8 *p, u8 index) { PRINT_FUN(); s32 ret = 0; ret = syscfg_read(VM_ALARM_NAME_0 + index, p, sizeof(alarm_name)); if (ret < 0) { PRINT_FUN_RETURN_INFO(); return; } return; } void alarm_name_clear(void) { PRINT_FUN(); memset(alarm_name, 0x00, sizeof(alarm_name)); return; } void alarm_name_set(u8 *p, u8 index, u8 len) { PRINT_FUN(); ASSERT(p); if (index > M_MAX_ALARM_INDEX) { PRINT_FUN_RETURN_INFO(); alarm_printf("alarm is full!\n"); return; } if ((len == 0) || (len > sizeof(alarm_name))) { PRINT_FUN_RETURN_INFO(); return; } alarm_name_clear(); alarm_printf("alarm name len : %d\n", len); alarm_printf_buf(p, len); memcpy(alarm_name, p, len); alarm_vm_write_name(alarm_name, index); return; } u8 alarm_name_get(u8 *p, u8 index) { PRINT_FUN(); ASSERT(p); u8 name_len = 0; if (index > M_MAX_ALARM_INDEX) { PRINT_FUN_RETURN_INFO(); return 0; } alarm_vm_read_name(alarm_name, index); name_len = alarm_tab[index].name_len; memcpy(p, alarm_name, name_len); alarm_printf("alarm name len : %d\n", name_len); alarm_printf_buf(alarm_name, name_len); return name_len; } /*----------------------------------------------------------------------------*/ /*工具函数部分代码 */ /*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/ /**@brief 月份换算为月天数 @param month，year @return 月份天数 @note */ /*----------------------------------------------------------------------------*/ u16 month_for_day(u8 month, u16 year) { return month_to_day(year, month); } void rtc_calculate_next_few_min(struct sys_time *cur_time, struct sys_time *p_time, u8 min) { if (!min || min >= 60) { return; } ASSERT(cur_time && p_time); memcpy(p_time, cur_time, sizeof(struct sys_time)); p_time->min = cur_time->min + min; if (p_time->min >= 60) { p_time->min -= 60; if (++p_time->hour >= 24) { p_time->hour = 0; if (++p_time->day > month_for_day(p_time->month, p_time->year)) { p_time->day = 1; if (++p_time->month > 12) { p_time->month = 1; if (++p_time->year > MAX_YEAR) { p_time->year = MIN_YEAR; } } } } } /* p_time->sec = 0; */ alarm_puts_time(p_time); } /*----------------------------------------------------------------------------*/ /**@brief 计算未来几天的日期 days要小于29,防止跨两个月 @param data_time--计算日期 @return none @note */ /*----------------------------------------------------------------------------*/ void rtc_calculate_next_few_day(struct sys_time *data_time, u8 days) { if (!days || days >= 29) { return; } ASSERT(data_time); u16 tmp16 = month_for_day(data_time->month, data_time->year); data_time->day += days; if (data_time->day > tmp16) { data_time->month++; data_time->day -= tmp16; if (data_time->month > 12) { data_time->month = 1; data_time->year++; } } } /*----------------------------------------------------------------------------*/ /**@brief 日期转换为星期 @param data_time--日期 @return 星期 @note */ /*----------------------------------------------------------------------------*/ //蔡勒（Zeller）公式：w=y+[y/4]+[c/4]-2c+[26x(m+1)/10]+d-1 u8 rtc_calculate_week_val(struct sys_time *data_time) { struct sys_time t_time; u32 century, val, year; ASSERT(data_time); memcpy(&t_time, data_time, sizeof(struct sys_time)); if (t_time.month < 3) { t_time.month = t_time.month + 12; t_time.year--; } year = t_time.year % 100; century = t_time.year / 100; val = year + (year / 4) + (century / 4) + (26 * (t_time.month + 1) / 10) + t_time.day; val = val - century * 2 - 1; return (u8)(val % 7); } static int __alarm_cmp_time_num(u32 num1, u32 num2) { int ret = -2; if (num1 > num2) { ret = 1; } else if (num1 == num2) { ret = 0; } else if (num1 < num2) { ret = -1; } return ret; } /* * 函数功能 ：比较两个闹钟的时间 * 函数形参 ：time1 - 闹钟1；time2 - 闹钟2 * 返回值 ：0-两闹钟相等；1-闹钟1时间比对比闹钟2要晚；-1-闹钟1比对比闹钟2早 -2-比较出错 * 备注 ：无 * * */ static int alarm_cmp_time_member(struct sys_time *time1, struct sys_time *time2, TIME_MEMBER_ENUM type) { ASSERT(time1 && time2); switch (type) { case TIME_MEMBER_YEAR: return __alarm_cmp_time_num(time1->year, time2->year); case TIME_MEMBER_MONTH: return __alarm_cmp_time_num(time1->month, time2->month); case TIME_MEMBER_DAY: return __alarm_cmp_time_num(time1->day, time2->day); case TIME_MEMBER_HOUR: return __alarm_cmp_time_num(time1->hour, time2->hour); case TIME_MEMBER_MIN: return __alarm_cmp_time_num(time1->min, time2->min); case TIME_MEMBER_SEC: return __alarm_cmp_time_num(time1->sec, time2->sec); default: return -2; } return -2; } /* * 函数功能 ：比较两个闹钟的时间 * 函数形参 ：time1 - 闹钟1；time2 - 闹钟2 * 返回值 ：0-两闹钟相等；1-闹钟1时间比对比闹钟2要晚；-1-闹钟1比对比闹钟2早 -2-比较出错 * 备注 ：无 * * */ static int alarm_cmp_time(struct sys_time *time1, struct sys_time *time2) { u8 i; int ret = 0; ASSERT(time1 && time2); for (i = 0; i < TIME_MEMBER_MAX; i++) { ret = alarm_cmp_time_member(time1, time2, i); if (ret != 0) { break; } } return ret; } /*----------------------------------------------------------------------------*/ /*核心部分代码 */ /*----------------------------------------------------------------------------*/ /* ** 函数功能 ：根据闹钟的模式计算出实际时间 ** 函数形参 ：pTime-闹钟时间结构体；week-当下星期； mode-闹钟模式 ** 返回值 ：void ** 备注 ：无 */ static void __alarm_calc_time_by_week_mode(struct sys_time *pTime, u8 mode) { PRINT_FUN(); u8 i = 0; u8 alarm_week = 0; u8 tmp_mode = 0; alarm_week = rtc_calculate_week_val(pTime);//alarm_week 可以理解为最近可以设置的闹钟（忽略week） if (alarm_week == 0) { alarm_week = 7; //星期天写成7，方便对比计算 } //查找当前可以设置闹钟日期最近的日期 for (i = 1; i < 8; i++) { if (mode & BIT(i)) { if (i >= alarm_week) { tmp_mode = i; break; } } } if (i >= 8) {//翻越了星期的 for (i = 1; i < 8; i++) { if (mode & BIT(i)) { tmp_mode = i; break; } } } if ((tmp_mode >= 1) && (tmp_mode < 8)) { if (tmp_mode > alarm_week) { alarm_printf("***a***\n"); //没有翻越星期 rtc_calculate_next_few_day(pTime, tmp_mode - alarm_week); } else if (tmp_mode < alarm_week) { //翻越了星期 alarm_printf("***b***\n"); rtc_calculate_next_few_day(pTime, 7 - (alarm_week - tmp_mode)); } } return; } /* ** 函数功能 ：根据闹钟的时、分计算出它的贪睡时间（年、月、日、时、分、秒） ** 函数形参 ：带有时、分和闹钟模式的时间结构体 ** 返回值 ：void ** 备注 ：无 */ static void alarm_calc_snooze_time_by_index(struct sys_time *cTime, u8 index) { PT_ALARM pAlarm_tab; pAlarm_tab = &(alarm_tab[index]); if (index == (M_MAX_ALARM_INDEX + M_MAX_SNOOZE_ALARM_NUM)) {//如果是贪睡闹钟 rtc_calculate_next_few_min(cTime, &pAlarm_tab->time, snooze_time); } } /* ** 函数功能 ：根据闹钟的时、分计算出它具体的时间（年、月、日、时、分、秒） ** 函数形参 ：带有时、分和闹钟模式的时间结构体 ** 返回值 ：void ** 备注 ：无 */ static void alarm_calc_real_time_by_index(struct sys_time *cTime, u8 index) { struct sys_time tmp = {0}; PT_ALARM pAlarm_tab; if (index > M_MAX_ALARM_INDEX + M_MAX_SNOOZE_ALARM_NUM) { PRINT_FUN_RETURN_INFO(); return; } pAlarm_tab = &(alarm_tab[index]); struct sys_time *pTime = &(pAlarm_tab->time); if (pAlarm_tab->mode > M_MAX_ALARM_MODE) { PRINT_FUN_RETURN_INFO(); return; } u32 c_tmp = ((cTime->hour & 0x1f) << 12) | ((cTime->min & 0x3f) << 6) | (cTime->sec & 0x3f); u32 p_tmp = ((pTime->hour & 0x1f) << 12) | ((pTime->min & 0x3f) << 6) | (pTime->sec & 0x3f); ASSERT(cTime); if (p_tmp > c_tmp) { //时间未到 PRINT_FUN_RETURN_INFO(); pTime->year = cTime->year; pTime->month = cTime->month; pTime->day = cTime->day; /* pTime->sec = 0; */ } else { PRINT_FUN_RETURN_INFO(); memcpy(&tmp, cTime, sizeof(struct sys_time)); rtc_calculate_next_few_day(&tmp, 1); pTime->year = tmp.year; pTime->month = tmp.month; pTime->day = tmp.day; /* pTime->sec = 0; */ } if ((pAlarm_tab->mode != E_ALARM_MODE_ONCE) && (pAlarm_tab->mode != E_ALARM_MODE_EVERY_DAY)) { __alarm_calc_time_by_week_mode(pTime, pAlarm_tab->mode); } alarm_puts_time(pTime); } static void __alarm_get_the_earliest(void) { PRINT_FUN(); int ret; u8 index = 0; u8 i = 0; struct sys_time *pTmp = NULL; alarm_map.active_map = 0 ; for (i = 0; i < (M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM); i++) { if (alarm_map.map_sw & BIT(i)) { alarm_map.active_map |= BIT(i) ; pTmp = &(alarm_tab[i].time); index = i; break; } } if (i >= (M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM)) { alarm_printf("***no alarm***\n"); alarm_hw_set_sw(0); return; } for (i = index + 1; i < (M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM); i++) { if (alarm_map.map_sw & BIT(i)) { ret = alarm_cmp_time(pTmp, &(alarm_tab[i].time)); if (0 == ret) { alarm_map.active_map |= BIT(i); alarm_printf("***A***\n"); } else if (1 == ret) { alarm_printf("***B***\n"); pTmp = &(alarm_tab[i].time); index = i; alarm_map.active_map = 0; alarm_map.active_map |= BIT(i); } } } alarm_puts_time(pTmp); log_info("find the %dth alarm, the save alarm : %x\n", index, alarm_map.active_map); alarm_hw_write_time(pTmp, alarm_tab[index].sw); alarm_puts_time(pTmp); alarm_cur_active = alarm_map.active_map; return; } static void __alarm_update_all_time(struct sys_time *cTIME) { PRINT_FUN(); u8 i = 0; ASSERT(cTIME); for (i = 0; i < M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM; i++) { if (alarm_map.map_sw & BIT(i)) { alarm_calc_real_time_by_index(cTIME, i); } } return; } static void alarm_update() { PRINT_FUN(); struct sys_time current_time = {0}; get_sys_time(¤t_time); local_irq_disable(); __alarm_update_all_time(¤t_time); local_irq_enable(); __alarm_get_the_earliest(); } u8 alarm_get_active_index(void) { return alarm_cur_active; } u8 alarm_get_info(PT_ALARM p, u8 index) { u8 ret = E_SUCCESS; ASSERT(p); local_irq_disable(); if (alarm_map.map & BIT(index)) { p->index = alarm_tab[index].index; p->sw = alarm_tab[index].sw; p->mode = alarm_tab[index].mode; p->time.hour = alarm_tab[index].time.hour; p->time.min = alarm_tab[index].time.min; p->name_len = alarm_tab[index].name_len; } else { memset(p, 0x0, sizeof(T_ALARM)); ret = E_FAILURE; } local_irq_enable(); return ret; } u8 alarm_get_total(void) { PRINT_FUN(); u8 total = 0; u8 i = 0; local_irq_disable(); for (i = 0; i < M_MAX_ALARM_NUMS; i++) { if (alarm_map.map & BIT(i)) { total++; } } local_irq_enable(); alarm_printf("total %d alarm\n", total); return total; } void rtc_update_time_api(struct sys_time *time) { set_sys_time(time); local_irq_disable(); __alarm_update_all_time(time); local_irq_enable(); __alarm_get_the_earliest(); alarm_vm_write_mask(&alarm_map); } void alarm_update_info_after_isr(void) { PRINT_FUN(); struct sys_time time = {0}; get_sys_time(&time); u8 i = 0; log_info("alarm_map.active_map =%x\n", alarm_map.active_map); local_irq_disable(); alarm_cur_active = alarm_map.active_map; /* alarm_calc_snooze_time_by_index(&time, M_MAX_ALARM_NUMS); */ for (i = 0; i < (M_MAX_ALARM_NUMS + M_MAX_SNOOZE_ALARM_NUM); i++) { if (alarm_map.active_map & BIT(i)) { if (alarm_tab[i].mode != 0) { //闹钟不只响一次 //计算一次闹钟的时间 alarm_calc_real_time_by_index(&time, i); } else { //闹钟只响一次 alarm_map.map_sw &= ~BIT(i); alarm_tab[i].sw = 0; local_irq_enable(); alarm_vm_write_info_by_index(&alarm_map, i); local_irq_disable(); } } } local_irq_enable(); __alarm_get_the_earliest(); alarm_vm_write_mask(&alarm_map); } u8 alarm_add(PT_ALARM p, u8 index) { struct sys_time current_time = {0}; PRINT_FUN(); u8 ret = E_SUCCESS; if (index > M_MAX_ALARM_INDEX) { PRINT_FUN_RETURN_INFO(); alarm_printf("alarm is full!\n"); return E_FAILURE; } if (p->mode > M_MAX_ALARM_MODE) { PRINT_FUN_RETURN_INFO(); alarm_printf("alarm's mode is error"); return E_FAILURE; } local_irq_disable(); if (alarm_map.table[index] == 0xff) { int max = -1; for (int i = 0; i < M_MAX_ALARM_NUMS; i++) { if (alarm_map.table[i] != 0xff && alarm_map.table[i] > max) { max = alarm_map.table[i]; } } max++; alarm_map.table[index] = max; } alarm_map.map |= BIT(index); if (0 == p->sw) { alarm_printf("close the %dth alarm!\n", p->index); alarm_map.map_sw &= ~BIT(p->index); } else if (1 == p->sw) { alarm_printf("set the %dth alarm!\n", p->index); alarm_map.map_sw |= BIT(p->index); } alarm_tab[index].index = p->index; alarm_tab[index].sw = p->sw; alarm_tab[index].mode = p->mode; alarm_tab[index].time.hour = p->time.hour; alarm_tab[index].time.min = p->time.min; alarm_tab[index].time.sec = p->time.sec; alarm_tab[index].name_len = p->name_len; get_sys_time(¤t_time); alarm_calc_real_time_by_index(¤t_time, index);//根据当前时间和闹钟模式计算出最新闹钟时间 local_irq_enable(); __alarm_get_the_earliest(); alarm_vm_write_info_by_index(&alarm_map, index); return ret; } void alarm_delete(u8 index) { PRINT_FUN(); u8 number; if (index > M_MAX_ALARM_INDEX) { PRINT_FUN_RETURN_INFO(); alarm_printf("alarm is full!\n"); return; } alarm_printf("delete the %dth alarm!\n", index); local_irq_disable(); if (alarm_map.table[index] == 0xff) { local_irq_enable(); log_info("alarm delete manage err \n"); return; } number = alarm_map.table[index]; alarm_map.table[index] = 0xff; for (int i = 0; i < M_MAX_ALARM_NUMS; i++) { if (alarm_map.table[i] != 0xff && alarm_map.table[i] > number) { alarm_map.table[i]--; } } alarm_map.map &= ~BIT(index); alarm_map.map_sw &= ~BIT(index); alarm_tab[index].sw = 0; local_irq_enable(); __alarm_get_the_earliest(); alarm_vm_write_info_by_index(&alarm_map, index); return; } void alarm_delete_all(void) { u8 flag[M_MAX_ALARM_NUMS] = {0}; PRINT_FUN(); local_irq_disable(); for (int i = 0; i < M_MAX_ALARM_NUMS; i++) { if (alarm_map.table[i] != 0xff) { flag[i] = 1; } alarm_map.table[i] = 0xff; alarm_map.map &= ~BIT(i); alarm_map.map_sw &= ~BIT(i); alarm_tab[i].sw = 0; } local_irq_enable(); __alarm_get_the_earliest(); for (int i = 0; i < M_MAX_ALARM_NUMS; i++) { if (flag[i]) { alarm_vm_write_info_by_index(&alarm_map, i); } } return; } void alarm_snooze() { struct sys_time time = {0}; get_sys_time(&time); alarm_calc_snooze_time_by_index(&time, M_MAX_ALARM_NUMS); local_irq_disable(); alarm_map.map |= BIT(M_MAX_ALARM_NUMS); alarm_map.map_sw |= BIT(M_MAX_ALARM_NUMS); alarm_tab[M_MAX_ALARM_NUMS].sw = 1; local_irq_enable(); __alarm_get_the_earliest(); alarm_vm_write_info_by_index(&alarm_map, M_MAX_ALARM_NUMS); } u8 get_alarm_number2table(u8 num, u8 *table) { u8 idle = 0xff; local_irq_disable(); for (int i = 0; i < M_MAX_ALARM_NUMS; i++) { //printf(">>>>>%s %d\n",__FUNCTION__,alarm_map.table[i]); if (alarm_map.table[i] != 0xff && alarm_map.table[i] == num) { local_irq_enable(); *table = i; return 1; } else if (alarm_map.table[i] == 0xff && idle == 0xff) { idle = i; } } local_irq_enable(); *table = idle; return 0; } void alarm_active_flag_set(u8 flag) { g_alarm_active_flag = flag; return; } u8 alarm_active_flag_get(void) { return g_alarm_active_flag; } static void alarm_check(void *priv) { int msg[2]; msg[0] = (u32)DEVICE_EVENT_FROM_ALM; int msec = jiffies_msec2offset(app_var.start_time, jiffies_msec()); if (msec > 3000) { msg[1] = DEVICE_EVENT_IN; app_send_message_from(MSG_FROM_DEVICE, sizeof(msg), msg); } else { sys_timeout_add(NULL, alarm_check, 100); } } #if (defined(CONFIG_CPU_BR28)) int write_p11_sys_time(int param) { struct sys_time cur_time; if (p11_rtc_time) { get_lrc_rtc_trim(&p11_rtc_time->ram_lrc_trim); get_sys_time(&cur_time); memcpy(&p11_rtc_time->ram_time, &cur_time, sizeof(struct sys_time)); p11_rtc_time->mask = 0x12345678; } /* printf("write_p11_sys_time \n"); */ return 0; } static void write_p11_sys_time_by_timer(void *priv) { int argv[3]; argv[0] = (int)write_p11_sys_time; argv[1] = 1; os_taskq_post_type("app_core", Q_CALLBACK, 3, argv); } bool read_p11_sys_time(struct sys_time *t, struct _rtc_trim *lrc_trim) { if (p11_rtc_time && (p11_rtc_time->mask == 0x12345678)) { memcpy(t, &p11_rtc_time->ram_time, sizeof(struct sys_time)); memcpy(lrc_trim, &p11_rtc_time->ram_lrc_trim, sizeof(struct _rtc_trim)); return true; } return false; } void p11_sys_time_init() { ASSERT(P11_HEAP_SIZE >= sizeof(struct sys_time)); //在p11开辟一片空间暂存时间变量 p11_rtc_time = (struct p11_sys_time *)(P11_HEAP_BEGIN + P11_HEAP_SIZE - sizeof(struct p11_sys_time)); sys_s_hi_timer_add(NULL, write_p11_sys_time_by_timer, 2000); } #endif void alarm_init() { alarm_vm_read_info(&alarm_map); if (!alarm_active_flag_get()) { //判断是否闹钟在响 alarm_update();//开机重新写入闹钟寄存器信息 } else { sys_timeout_add(NULL, alarm_check, 100); } //贪睡闹钟部分参数初始化 alarm_tab[M_MAX_ALARM_NUMS].index = M_MAX_ALARM_NUMS; alarm_tab[M_MAX_ALARM_NUMS].sw = 0; alarm_tab[M_MAX_ALARM_NUMS].mode = 0; /* register_sys_event_handler(SYS_ALL_EVENT, 1, NULL, alarm_event_handler); */ } #if TCFG_BT_SUPPORT_MAP static void rtc_get_phone_time_cb(void *p) { if (bt_get_connect_status() != BT_STATUS_WAITINT_CONN) { int error = bt_cmd_prepare(USER_CTRL_MAP_READ_TIME, 0, NULL); log_error("<%s> error:%d", __func__, error); } } static int rtc_get_phone_time_periodically(void) { sys_timer_add(NULL, rtc_get_phone_time_cb, 60 * 60 * 1000); return 0; } late_initcall(rtc_get_phone_time_periodically); #endif /* if TCFG_BT_SUPPORT_MAP */ #endif //end of RTC_ALM_EN #endif