#define __MMI_HEALTH_MEASURE_TEMPERATURE_SUPPORT__
//#define __MMI_APP_QRCODE_MENU_SUPPORT__
+#define __MMI_APP_QRCODE_AND_DEVICE_QRCODE_IN_ONE_SUPPORT__
#define __MMI_ZHSX_SUPPORT_NO_SIM_POWER_OFF__
#if 0 != USE_LV_WATCH_WEATHER
#define __MMI_WEATHER_MENU_SUPPORT__
+//#define __MMI_WEATHER_MENU_NOT_DISPLAY_TEMPERATURE_RANGE__
#endif
+#define __MMI_PEDOMETER_STEP_AND_GOAL_STYLE__
static void * s_timing_control_timer = NULL;
static int8_t s_timing_control_last_min = -1;
-
-#define TIMING_FIRST_TIMER_INTERVAL (3 * 1000) // ms
-#define TIMING_TIMER_INTERVAL (20 * 1000) // ms
-
-#define MMI_GUI_TIMING_TASK_PRIORITY 219
-#define MMI_GUI_TIMING_TASK_STACK_SIZE (1 * 1024)
-#define MMI_GUI_TIMING_MSG_QUEUE_SIZE (16)
+static uint32_t s_timing_control_timer_counter = 0;
TASK_HANDLE * s_gui_timing_task_id = NULL;
-static void mmi_gui_timing_task_20_second_mission(void * time_param);
+static void mmi_gui_timing_task_3_second_mission(void * time_param);
+static void mmi_gui_timing_task_15_second_mission(void * time_param);
static void mmi_gui_timing_task_1_minute_mission(void * time_param);
{
if(NULL == s_gui_timing_task_id)
{
- TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task not exist\n",__FUNCTION__,__LINE__);
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task not exist\n", __FUNCTION__, __LINE__);
if(NULL != msg_param)
Hal_Mem_Free(msg_param);
if((MMI_GUI_TIMING_MSG_QUEUE_SIZE - 1) < Hal_Get_Message_Count(s_gui_timing_task_id))
{
- TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg queue full\n",__FUNCTION__,__LINE__);
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg queue full\n", __FUNCTION__, __LINE__);
if(NULL != msg_param)
Hal_Mem_Free(msg_param);
return;
}
- TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg_id=%d\n",__FUNCTION__,__LINE__, msg_id);
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg_id=%d\n", __FUNCTION__, __LINE__, msg_id);
mmi_gui_timing_task_msg_t * msg = Hal_Mem_Alloc(sizeof(mmi_gui_timing_task_msg_t));
if(NULL == msg)
{
- TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n",__FUNCTION__,__LINE__);
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__);
if(NULL != msg_param)
Hal_Mem_Free(msg_param);
MMI_GUI_TIMING_MSG_ID_E msg_id = msg->msg_id;
void * msg_param = msg->msg_param;
- TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg_id=%d\n",__FUNCTION__,__LINE__, msg_id);
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg_id=%d\n", __FUNCTION__, __LINE__, msg_id);
switch(msg_id)
{
- case MMI_GUI_TIMING_MSG_20_SECOND:
- mmi_gui_timing_task_20_second_mission(msg_param);
+ case MMI_GUI_TIMING_MSG_3_SECOND:
+ mmi_gui_timing_task_3_second_mission(msg_param);
+ break;
+
+ case MMI_GUI_TIMING_MSG_15_SECOND:
+ mmi_gui_timing_task_15_second_mission(msg_param);
break;
case MMI_GUI_TIMING_MSG_1_MINUTE:
MMI_GUI_TIMING_TASK_PRIORITY,
"mmi_gui_timing_task");
- TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task_id=0x%x\n",__FUNCTION__,__LINE__, s_gui_timing_task_id);
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task_id=0x%x\n", __FUNCTION__, __LINE__, s_gui_timing_task_id);
+}
+
+static void mmi_gui_timing_task_3_second_mission(void * time_param)
+{
+ hal_rtc_t cur_time = {0};
+
+ if(NULL != time_param)
+ {
+ Hal_Mem_Copy(&cur_time, time_param, sizeof(hal_rtc_t));
+ }
+ else
+ {
+ Hal_Rtc_Gettime(&cur_time);
+ }
+
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+
+ // wear
+ static bool s_init_wear_flag = true;
+ bool t_wear_flag = true;
+
+#ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
+ t_wear_flag = mmi_health_measure_wear_state_get();
+#endif
+ TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: wear_state=%d,now_state=%d\n", __FUNCTION__, __LINE__, s_init_wear_flag, t_wear_flag);
+ if(s_init_wear_flag != t_wear_flag)
+ {
+ s_init_wear_flag = t_wear_flag;
+ if(false == s_init_wear_flag)
+ {
+ mmi_protocol_action_take_off();
+ }
+ else
+ {
+ mmi_protocol_action_take_on();
+ }
+ }
+
+
}
-static void mmi_gui_timing_task_20_second_mission(void * time_param)
+static void mmi_gui_timing_task_15_second_mission(void * time_param)
{
hal_rtc_t cur_time = {0};
- Hal_Mem_Copy(&cur_time, time_param, sizeof(hal_rtc_t));
+ if(NULL != time_param)
+ {
+ Hal_Mem_Copy(&cur_time, time_param, sizeof(hal_rtc_t));
+ }
+ else
+ {
+ Hal_Rtc_Gettime(&cur_time);
+ }
TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
{
hal_rtc_t cur_time = {0};
- Hal_Mem_Copy(&cur_time, time_param, sizeof(hal_rtc_t));
+ if(NULL != time_param)
+ {
+ Hal_Mem_Copy(&cur_time, time_param, sizeof(hal_rtc_t));
+ }
+ else
+ {
+ Hal_Rtc_Gettime(&cur_time);
+ }
TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %02d:%02d:%02d\n", __FUNCTION__, __LINE__, cur_time.tm_hour, cur_time.tm_min, cur_time.tm_sec);
uos_timer_stop(s_timing_control_timer);
- uos_timer_start(s_timing_control_timer, MS_TO_TICKS(TIMING_TIMER_INTERVAL), 0, timing_timer_callback, NULL);
+ uos_timer_start(s_timing_control_timer, MS_TO_TICKS(MMI_GUI_TIMING_TIMER_INTERVAL), 0, timing_timer_callback, NULL);
+
+ s_timing_control_timer_counter++;
- hal_rtc_t * p_cur_time_20 = Hal_Mem_Alloc(sizeof(hal_rtc_t));
- Hal_Mem_Copy(p_cur_time_20, &cur_time, sizeof(hal_rtc_t));
- mmi_gui_timing_task_msg_send(MMI_GUI_TIMING_MSG_20_SECOND, p_cur_time_20);
+ mmi_gui_timing_task_msg_send(MMI_GUI_TIMING_MSG_3_SECOND, NULL); // 3 seconds
+
+ if(0 == s_timing_control_timer_counter % 5) // 15 seconds
+ {
+ hal_rtc_t * p_cur_time_15 = Hal_Mem_Alloc(sizeof(hal_rtc_t));
+ Hal_Mem_Copy(p_cur_time_15, &cur_time, sizeof(hal_rtc_t));
+ mmi_gui_timing_task_msg_send(MMI_GUI_TIMING_MSG_15_SECOND, p_cur_time_15);
+ }
- if(cur_time.tm_min != s_timing_control_last_min)
+ if(cur_time.tm_min != s_timing_control_last_min) // minute changed
{
TIMING_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, s_timing_control_last_min);
mmi_gui_timing_task_create();
uos_timer_create(&s_timing_control_timer);
- uos_timer_start(s_timing_control_timer, MS_TO_TICKS(TIMING_FIRST_TIMER_INTERVAL), 0, timing_timer_callback, NULL);
+ uos_timer_start(s_timing_control_timer, MS_TO_TICKS(MMI_GUI_TIMING_TIMER_INTERVAL), 0, timing_timer_callback, NULL);
}
#else
#endif
+#define MMI_GUI_TIMING_TIMER_INTERVAL (3 * 1000) // ms
+
+#define MMI_GUI_TIMING_TASK_PRIORITY 219
+#define MMI_GUI_TIMING_TASK_STACK_SIZE (1 * 1024)
+#define MMI_GUI_TIMING_MSG_QUEUE_SIZE (16)
+
+
typedef enum
{
MMI_GUI_TIMING_MSG_ID_START,
- MMI_GUI_TIMING_MSG_5_SECOND,
- MMI_GUI_TIMING_MSG_20_SECOND,
+ MMI_GUI_TIMING_MSG_3_SECOND,
+ MMI_GUI_TIMING_MSG_15_SECOND,
MMI_GUI_TIMING_MSG_1_MINUTE,
MMI_GUI_TIMING_MSG_2_MINUTE,
if(true == direct_trigger
|| s_health_measure_timed_data.heart_timed_interval <= (cur_time_stamp - s_health_measure_heart_timed_time_stamp))
{
- HEALTH_MEASURE_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+ HEALTH_MEASURE_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: cur_stamp=%d,timed_stamp=%d\n", __FUNCTION__, __LINE__, cur_time_stamp, s_health_measure_heart_timed_time_stamp);
mmi_health_measure_timed_list_node_add(MMI_HEALTH_MEASURE_HEART);
if(true == mmi_health_measure_timed_list_trigger(MMI_HEALTH_MEASURE_HEART))
if(true == direct_trigger
|| s_health_measure_timed_data.temperature_timed_interval <= (cur_time_stamp - s_health_measure_temperature_timed_time_stamp))
{
- HEALTH_MEASURE_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+ HEALTH_MEASURE_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: cur_stamp=%d,timed_stamp=%d\n", __FUNCTION__, __LINE__, cur_time_stamp, s_health_measure_temperature_timed_time_stamp);
mmi_health_measure_timed_list_node_add(MMI_HEALTH_MEASURE_TEMPERATURE);
if(true == mmi_health_measure_timed_list_trigger(MMI_HEALTH_MEASURE_TEMPERATURE))
return false;
}
+bool mmi_health_measure_timed_mission_action(uint32_t cur_time_stamp)
+{
+ mmi_health_measure_heart_timed_action(false, cur_time_stamp);
+ mmi_health_measure_temperature_timed_action(false, cur_time_stamp);
+ mmi_health_measure_blood_timed_action(false, cur_time_stamp);
+ mmi_health_measure_spo2_timed_action(false, cur_time_stamp);
+
+ return true;
+}
+
+bool mmi_health_measure_first_mission_action(uint32_t cur_time_stamp)
+{
+ mmi_health_measure_heart_timed_action(true, cur_time_stamp);
+ mmi_health_measure_temperature_timed_action(true, cur_time_stamp);
+ mmi_health_measure_blood_timed_action(true, cur_time_stamp);
+ mmi_health_measure_spo2_timed_action(true, cur_time_stamp);
+
+ return true;
+}
+
void mmi_health_measure_server_set_save(MMI_HEALTH_MEASURE_TYPE_E measure_type, int value_interval)
{
uint8_t flag = (0 == value_interval) ? 0 : 1;
void mmi_health_measure_task_init(void)
{
+ if(NULL != s_health_measure_task_id)
+ {
+ HEALTH_MEASURE_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task_id=0x%x\n",__FUNCTION__,__LINE__, s_health_measure_task_id);
+ return;
+ }
+
s_health_measure_task_id = uos_create_task(mmi_health_measure_task_entry,
NULL,
MMI_HEALTH_MEASURE_MSG_QUEUE_SIZE,
void mmi_health_measure_timed_info_nv_read(void);
void mmi_health_measure_timed_info_nv_default(nv_watch_health_measure_timed_t * data);
-bool mmi_health_measure_heart_timed_action(bool direct_trigger, uint32_t cur_time_stamp);
-bool mmi_health_measure_temperature_timed_action(bool direct_trigger, uint32_t cur_time_stamp);
-bool mmi_health_measure_blood_timed_action(bool direct_trigger, uint32_t cur_time_stamp);
-bool mmi_health_measure_spo2_timed_action(bool direct_trigger, uint32_t cur_time_stamp);
+bool mmi_health_measure_timed_mission_action(uint32_t cur_time_stamp);
+bool mmi_health_measure_first_mission_action(uint32_t cur_time_stamp);
static void cancel_btn_event_cb(lv_obj_t * obj, lv_event_t e);
static lv_obj_t * setting_opt_create(lv_obj_t * par);
static lv_obj_t * roller_create(lv_obj_t * par, uint8_t type, uint16_t sel_value);
-static void bodyinfo_set(nv_watch_pedometer_setting_t * pedo_set);
+//static void bodyinfo_set(nv_watch_pedometer_setting_t * pedo_set);
static lv_obj_t * bodyinfo_setting_create(lv_obj_t * activity_obj);
static void bodyinfo_prepare_destory(lv_obj_t * activity_obj);
static void get_optstr_from_num(uint16_t num, char * stropt, uint8_t type);
* STATIC FUNCTIONS
**********************/
-static void bodyinfo_set(nv_watch_pedometer_setting_t * pedo_set)
+//static void bodyinfo_set(nv_watch_pedometer_setting_t * pedo_set)
+void bodyinfo_set(nv_watch_pedometer_setting_t * pedo_set)
{
//write to nv
UI_NV_Write_Req(NV_SECTION_UI_PEDOMETER, NV_PEDOMETER_SETTING_OFFSET, NV_PEDOMETER_SETTING_LEN, (uint8_t *)pedo_set);
}
else if(4 == index)
{
+ #if USE_LV_WATCH_BODYINFO != 0
+ nv_watch_pedometer_setting_t pedo;
+ memset(&pedo, 0, sizeof(nv_watch_pedometer_setting_t));
+ bodyinfo_init(&pedo);
+ pedo.goal = s_step_goal_temp_value;
+ bodyinfo_set(&pedo);
+ #endif
pedometer_set_goalsteps(s_step_goal_temp_value);
pedometer_update_screen();
lv_obj_t * record_create(lv_obj_t * tileview, uint16_t id);
#endif
void bodyinfo_init(nv_watch_pedometer_setting_t* pedo_set);
+void bodyinfo_set(nv_watch_pedometer_setting_t * pedo_set);
uint16_t pedometer_get_goalsteps(void);
uint16_t pedometer_get_steps(void);
void pedometer_update_goal(uint16_t goal);
#ifdef __MMI_USER_PROFILE_SUPPORT__
mmi_watch_user_profile_nv_read();
#endif
+ mmi_watch_location_mission_list_init();
+#ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
+ mmi_health_measure_task_init();
+ mmi_health_measure_timed_info_nv_read();
+#endif
static nv_watch_protocol_data_t s_watch_protocol_data = {0};
static bool s_watch_bind_state = false;
-static void * s_watch_timed_mission_timer_id = NULL;
-static uint32_t s_watch_timed_location_time_stamp = 0, s_watch_timed_weather_time_stamp = 0;
-static void * s_watch_heartbeat_action_timer_id = NULL;
-static uint32_t s_watch_heartbeat_action_time_stamp = 0;
-static uint32_t s_watch_timed_location_last_steps = 0;
-
-static void mmi_protocol_watch_timed_mission_timer_cb(uint32_t para);
-static void mmi_protocol_watch_heartbeat_timer_cb(uint32_t para);
bool mmi_protocol_action_location(void);
mmi_watch_protocol_data_nv_write();
}
-static void mmi_protocol_watch_timed_mission_timer_cb(uint32_t para)
-{
- uint32_t cur_time_stamp = 0;
- Hal_Rtc_Gettime_Count_Utc(&cur_time_stamp); // Hal_Rtc_Gettime_Count(&cur_time_stamp);
+
+static void * s_protocol_timing_timer = NULL;
+TASK_HANDLE * s_protocol_timing_task_id = NULL;
+static uint32_t s_protocol_heartbeat_time_stamp = 0, s_protocol_timed_location_time_stamp = 0, s_protocol_timed_weather_time_stamp = 0;
+
+static void mmi_protocol_timing_timer_callback(uint32_t param);
+
+static void mmi_protocol_timing_task_msg_send(MMI_PROTOCOL_TIMING_MSG_ID_E msg_id, void * msg_param)
+{
+ if(NULL == s_protocol_timing_task_id)
+ {
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task not exist\n",__FUNCTION__,__LINE__);
+ if(NULL != msg_param)
+ Hal_Mem_Free(msg_param);
+
+ return;
+ }
- //location
- if(mmi_protocol_watch_location_upload_interval_get() <= (cur_time_stamp - s_watch_timed_location_time_stamp))
+ if((PROTOCOL_TIMING_MSG_QUEUE_SIZE - 1) < Hal_Get_Message_Count(s_protocol_timing_task_id))
{
- uint32_t current_steps = asl_pedometer_steps_get();
- //if(current_steps != s_watch_timed_location_last_steps)
- {
- mmi_protocol_action_location();
- }
- s_watch_timed_location_time_stamp = cur_time_stamp;
- s_watch_timed_location_last_steps = current_steps;
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg queue full\n",__FUNCTION__,__LINE__);
+ if(NULL != msg_param)
+ Hal_Mem_Free(msg_param);
+
+ return;
}
- //weather
- if(mmi_protocol_watch_weather_update_interval_get() <= (cur_time_stamp - s_watch_timed_weather_time_stamp))
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg_id=%d\n",__FUNCTION__,__LINE__, msg_id);
+ mmi_protocol_timing_task_msg_t * msg = Hal_Mem_Alloc(sizeof(mmi_protocol_timing_task_msg_t));
+ if(NULL == msg)
{
- mmi_protocol_action_get_weather();
- s_watch_timed_weather_time_stamp = cur_time_stamp;
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n",__FUNCTION__,__LINE__);
+ if(NULL != msg_param)
+ Hal_Mem_Free(msg_param);
+
+ return;
}
+ msg->msg_id = msg_id;
+ msg->msg_param = msg_param;
-#ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
- //health measure
- mmi_health_measure_heart_timed_action(false, cur_time_stamp);
- mmi_health_measure_temperature_timed_action(false, cur_time_stamp);
- mmi_health_measure_blood_timed_action(false, cur_time_stamp);
- mmi_health_measure_spo2_timed_action(false, cur_time_stamp);
-#endif
-
- uos_timer_stop(s_watch_timed_mission_timer_id);
- uos_timer_start(s_watch_timed_mission_timer_id, MS_TO_TICKS(1000 * 20), 0, mmi_protocol_watch_timed_mission_timer_cb, NULL);
+ Hal_Send_Message((TASK_ID)s_protocol_timing_task_id, (void *)msg);
}
-void mmi_protocol_watch_timed_mission_action(void)
+static void mmi_protocol_timing_task_handle(void * param)
{
- if(NULL == s_watch_timed_mission_timer_id)
+ mmi_protocol_timing_task_msg_t * msg = (mmi_protocol_timing_task_msg_t *)param;
+ MMI_PROTOCOL_TIMING_MSG_ID_E msg_id = msg->msg_id;
+ void * msg_param = msg->msg_param;
+
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: msg_id=%d\n",__FUNCTION__,__LINE__, msg_id);
+ switch(msg_id)
{
- uint32_t cur_time_stamp = 0;
-
- Hal_Rtc_Gettime_Count_Utc(&cur_time_stamp); // Hal_Rtc_Gettime_Count(&cur_time_stamp);
-
- mmi_watch_location_mission_list_init();
- mmi_protocol_action_location();
- s_watch_timed_location_time_stamp = cur_time_stamp;
- s_watch_timed_location_last_steps = asl_pedometer_steps_get();
-
- mmi_protocol_action_get_weather();
- s_watch_timed_weather_time_stamp = cur_time_stamp;
-
- #ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
- mmi_health_measure_task_init();
- mmi_health_measure_timed_info_nv_read();
- mmi_health_measure_heart_timed_action(true, cur_time_stamp);
- mmi_health_measure_temperature_timed_action(true, cur_time_stamp);
- mmi_health_measure_blood_timed_action(true, cur_time_stamp);
- mmi_health_measure_spo2_timed_action(true, cur_time_stamp);
- #endif
-
- uos_timer_create(&s_watch_timed_mission_timer_id);
- uos_timer_start(s_watch_timed_mission_timer_id, MS_TO_TICKS(1000 * 20), 0, mmi_protocol_watch_timed_mission_timer_cb, NULL);
- }
+ case MMI_PROTOCOL_TIMING_MSG_HEARTBEAT:
+ mmi_protocol_fzd_action_HEARTBEAT();
+ break;
+
+ case MMI_PROTOCOL_TIMING_MSG_LOCATION_UPDATE:
+ mmi_protocol_action_location();
+ break;
+
+ case MMI_PROTOCOL_TIMING_MSG_WEATHER_UPDATE:
+ mmi_protocol_action_get_weather();
+ break;
+
+ case MMI_PROTOCOL_TIMING_MSG_HEALTH_MEASURE:
+ #ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
+ uint32_t cur_time_stamp = *((uint32_t *) msg_param);
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: cur_stamp=%d\n", __FUNCTION__, __LINE__, cur_time_stamp);
+ mmi_health_measure_timed_mission_action(cur_time_stamp);
+ #endif
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void mmi_protocol_timing_task_entry(void * para)
+{
+ while(NULL == s_protocol_timing_task_id)
+ {
+ uos_sleep(10);
+ }
+
+ while(1)
+ {
+ mmi_protocol_timing_task_msg_t * msg = (mmi_protocol_timing_task_msg_t *)Hal_Receive_Message((TASK_ID)s_protocol_timing_task_id, TRUE);
+
+ mmi_protocol_timing_task_handle(msg);
+
+ Hal_Mem_Free(msg->msg_param);
+ Hal_Mem_Free(msg);
+ }
}
-void mmi_protocol_watch_heartbeat_stop(void)
+static void mmi_protocol_timing_task_create(void)
{
- if(NULL != s_watch_heartbeat_action_timer_id)
+ if(NULL != s_protocol_timing_task_id)
{
- uos_timer_stop(s_watch_heartbeat_action_timer_id);
- uos_timer_delete(s_watch_heartbeat_action_timer_id);
- s_watch_heartbeat_action_timer_id = NULL;
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task_id=0x%x\n",__FUNCTION__,__LINE__, s_protocol_timing_task_id);
+ return;
}
+
+ s_protocol_timing_task_id = uos_create_task(mmi_protocol_timing_task_entry,
+ NULL,
+ PROTOCOL_TIMING_MSG_QUEUE_SIZE,
+ PROTOCOL_TIMING_TASK_STACK_SIZE,
+ PROTOCOL_TIMING_TASK_PRIORITY,
+ "mmi_protocol_timing_task");
+
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: task_id=0x%x\n",__FUNCTION__,__LINE__, s_protocol_timing_task_id);
}
-static void mmi_protocol_watch_heartbeat_timer_cb(uint32_t para)
+static void mmi_protocol_timing_timer_callback(uint32_t param)
{
uint32_t cur_time_stamp = 0;
- Hal_Rtc_Gettime_Count_Utc(&cur_time_stamp); // Hal_Rtc_Gettime_Count(&cur_time_stamp);
- if(mmi_protocol_watch_heartbeat_action_interval_get() <= (cur_time_stamp - s_watch_heartbeat_action_time_stamp))
+ Hal_Rtc_Gettime_Count_Utc(&cur_time_stamp);
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: cur_time_stamp=%d\n", __FUNCTION__, __LINE__, cur_time_stamp);
+
+ uos_timer_stop(s_protocol_timing_timer);
+ uos_timer_start(s_protocol_timing_timer, MS_TO_TICKS(PROTOCOL_TIMING_TIMER_INTERVAL), 0, mmi_protocol_timing_timer_callback, NULL);
+
+ // heartbeat
+ if(mmi_protocol_watch_heartbeat_action_interval_get() <= (cur_time_stamp - s_protocol_heartbeat_time_stamp))
{
- PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: cur=%d, stamp=%d\n", __FUNCTION__, __LINE__, cur_time_stamp, s_watch_heartbeat_action_time_stamp);
-
- mmi_protocol_fzd_action_HEARTBEAT();
- s_watch_heartbeat_action_time_stamp = cur_time_stamp;
+ mmi_protocol_timing_task_msg_send(MMI_PROTOCOL_TIMING_MSG_HEARTBEAT, NULL);
+ s_protocol_heartbeat_time_stamp = cur_time_stamp;
+ }
+
+ //location
+ if(mmi_protocol_watch_location_upload_interval_get() <= (cur_time_stamp - s_protocol_timed_location_time_stamp))
+ {
+ //if(current_steps != s_watch_timed_location_last_steps)
+ {
+ mmi_protocol_timing_task_msg_send(MMI_PROTOCOL_TIMING_MSG_LOCATION_UPDATE, NULL);
+ }
+ s_protocol_timed_location_time_stamp = cur_time_stamp;
}
- uos_timer_stop(s_watch_heartbeat_action_timer_id);
- uos_timer_start(s_watch_heartbeat_action_timer_id, MS_TO_TICKS(1000 * 20), 0, mmi_protocol_watch_heartbeat_timer_cb, NULL);
+ //weather
+ if(mmi_protocol_watch_weather_update_interval_get() <= (cur_time_stamp - s_protocol_timed_weather_time_stamp))
+ {
+ mmi_protocol_timing_task_msg_send(MMI_PROTOCOL_TIMING_MSG_WEATHER_UPDATE, NULL);
+ s_protocol_timed_weather_time_stamp = cur_time_stamp;
+ }
+
+ //health measure
+#ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
+ uint32_t * time_stamp_p = Hal_Mem_Alloc(sizeof(uint32_t));
+ //Hal_Mem_Copy(time_stamp_p, &cur_time_stamp, sizeof(uint32_t));
+ * time_stamp_p = cur_time_stamp;
+ mmi_protocol_timing_task_msg_send(MMI_PROTOCOL_TIMING_MSG_HEALTH_MEASURE, time_stamp_p);
+#endif
+
}
-void mmi_protocol_watch_heartbeat_action(void)
+void mmi_protocol_timing_mission_action(void)
{
- if(NULL == s_watch_heartbeat_action_timer_id)
- {
- PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
-
- mmi_protocol_fzd_action_HEARTBEAT();
-
- Hal_Rtc_Gettime_Count_Utc(&s_watch_heartbeat_action_time_stamp); // Hal_Rtc_Gettime_Count(&s_watch_heartbeat_action_time_stamp);
+ mmi_protocol_timing_task_create();
+
+ uint32_t cur_time_stamp = 0;
+
+ Hal_Rtc_Gettime_Count_Utc(&cur_time_stamp);
+ PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: cur_time_stamp=%d\n", __FUNCTION__, __LINE__, cur_time_stamp);
+
+ mmi_protocol_fzd_action_HEARTBEAT();
+ s_protocol_heartbeat_time_stamp = cur_time_stamp;
+
+ mmi_protocol_action_location();
+ s_protocol_timed_location_time_stamp = cur_time_stamp;
+
+ mmi_protocol_action_get_weather();
+ s_protocol_timed_weather_time_stamp = cur_time_stamp;
+
+#ifdef __MMI_ZHSX_SUPPORT_HEALTH_SENSOR__
+ //mmi_health_measure_task_init();
+ //mmi_health_measure_timed_info_nv_read();
+ mmi_health_measure_first_mission_action(cur_time_stamp);
+#endif
+
+ if(NULL == s_protocol_timing_timer)
+ uos_timer_create(&s_protocol_timing_timer);
+ else
+ uos_timer_stop(s_protocol_timing_timer);
+
+ uos_timer_start(s_protocol_timing_timer, MS_TO_TICKS(PROTOCOL_TIMING_TIMER_INTERVAL), 0, mmi_protocol_timing_timer_callback, NULL);
+}
- uos_timer_create(&s_watch_heartbeat_action_timer_id);
- uos_timer_start(s_watch_heartbeat_action_timer_id, MS_TO_TICKS(1000 * 20), 0, mmi_protocol_watch_heartbeat_timer_cb, NULL);
+void mmi_protocol_timing_mission_stop(void)
+{
+ if(NULL != s_protocol_timing_timer)
+ {
+ uos_timer_stop(s_protocol_timing_timer);
+ uos_timer_delete(s_protocol_timing_timer);
+ s_protocol_timing_timer = NULL;
}
}
+
+
extern void dm_send_msg_active(void);
bool mmi_protocol_watch_link_action(void)
{
#endif
+#define PROTOCOL_TIMING_TIMER_INTERVAL (20 * 1000) // ms
+
+#define PROTOCOL_TIMING_TASK_PRIORITY 220
+#define PROTOCOL_TIMING_TASK_STACK_SIZE (1 * 1024)
+#define PROTOCOL_TIMING_MSG_QUEUE_SIZE (16)
+
+
+typedef enum
+{
+ MMI_PROTOCOL_TIMING_MSG_ID_START,
+
+ MMI_PROTOCOL_TIMING_MSG_HEARTBEAT,
+ MMI_PROTOCOL_TIMING_MSG_LOCATION_UPDATE,
+ MMI_PROTOCOL_TIMING_MSG_WEATHER_UPDATE,
+ MMI_PROTOCOL_TIMING_MSG_HEALTH_MEASURE,
+
+ MMI_PROTOCOL_TIMING_MSG_ID_END
+}MMI_PROTOCOL_TIMING_MSG_ID_E;
+
+
+typedef struct
+{
+ uint16_t msg_id;
+ void * msg_param;
+}mmi_protocol_timing_task_msg_t;
+
+
+
bool mmi_watch_tcp_connect_state_get(void);
bool mmi_protocol_watch_bind_state_get(void);
-
void mmi_protocol_watch_bind_state_set(bool state);
void mmi_protocol_receive_data_process(char * recv_str, int recv_len);
-
void * mmi_protocol_send_space_ptr_get(int cmd);
-
int mmi_protocol_send_space_size_get(int cmd);
-
void mmi_protocol_send_space_free(int cmd);
-
bool mmi_protocol_send_cmd_check(int cmd);
void mmi_watch_protocol_data_nv_read(void);
char * mmi_protocol_device_name_get(void);
void mmi_protocol_device_name_set(char * device_name);
-void mmi_protocol_watch_timed_mission_action(void);
-
-void mmi_protocol_watch_heartbeat_stop(void);
-void mmi_protocol_watch_heartbeat_action(void);
+void mmi_protocol_timing_mission_action(void);
+void mmi_protocol_timing_mission_stop(void);
bool mmi_protocol_watch_link_action(void);
{
mmi_protocol_fzd_action_bind();
}
- //mmi_protocol_watch_heartbeat_action();
return true;
}
mmi_watch_sim_unbind_check();
#endif
- // socket heartbeat
- mmi_protocol_watch_heartbeat_action();
-
// timing mission
- mmi_protocol_watch_timed_mission_action();
+ mmi_protocol_timing_mission_action();
//video call
#ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL__
#ifdef __MMI_ZHSX_SUPPORT__
printf("[@CHENG_DEBUG][%s][%d]: \n",__FUNCTION__,__LINE__);
- //#ifdef __MMI_ZHSX_SUPPORT_WULIAN_SERVER__
mmi_protocol_watch_link_action();
- //#else
- //mmi_protocol_watch_heartbeat_action();
- //#endif
#else
mmi_protocol_watch_bind_state_set(false);
- mmi_protocol_watch_heartbeat_stop();
+ mmi_protocol_timing_mission_stop();
#else
projects / mirrors / ASR3603_Z5.git / commitdiff