补交优化运动模式切换函数，添加静态模式切换函数

diff --git a/code/sdk/application/wearable/fd230app/nativeui/traing/include/TraingModel.h b/code/sdk/application/wearable/fd230app/nativeui/traing/include/TraingModel.h
index aa9fa12..1e224bc 100644 (file)
--- a/code/sdk/application/wearable/fd230app/nativeui/traing/include/TraingModel.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/traing/include/TraingModel.h
@@ -180,7 +180,7 @@ namespace OHOS
         /*获取运动类型*/
         ExerciseClass GetSportType();
         /*解析传输过来的数据*/
-        void AnalysisData(cywee_result_t *cyweeInfo);
+        void AnalysisData(cywee_activity_result_t *cyweeInfo);
         /*获取训练数据*/
         SportData *GetSportdata();
 

diff --git a/code/sdk/application/wearable/fd230app/nativeui/traing/src/TraingModel.cpp b/code/sdk/application/wearable/fd230app/nativeui/traing/src/TraingModel.cpp
index 4f9d0eb..7ea0f99 100644 (file)
--- a/code/sdk/application/wearable/fd230app/nativeui/traing/src/TraingModel.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/traing/src/TraingModel.cpp
@@ -299,7 +299,7 @@ namespace OHOS
     {
         return sportstate_;
     }
-    void TraingModel::AnalysisData(cywee_result_t *cyweeInfo)
+    void TraingModel::AnalysisData(cywee_activity_result_t *cyweeInfo)
     {
         // 不同的运动类型解析不同的数据
         ExerciseClass type = GetSportType();
@@ -331,54 +331,54 @@ namespace OHOS
         {
             return;
         }
-        cywee_result_t *cyweeInfo = nullptr; // 在switch语句外部定义变量
+        cywee_activity_result_t *cyweeInfo = nullptr; // 在switch语句外部定义变量
         int rets;
         switch (request->msgId)
         {
         case TOPIC_EVENT_TREADMILL_UPDATE:
-            cyweeInfo = new cywee_result_t(); // 在case块内分配内存
-            rets = memcpy_s(cyweeInfo, sizeof(cywee_result_t), (cywee_result_t *)request->data, request->len);
+            cyweeInfo = new cywee_activity_result_t(); // 在case块内分配内存
+            rets = memcpy_s(cyweeInfo, sizeof(cywee_activity_result_t), (cywee_activity_result_t *)request->data, request->len);
             if (rets != EOK)
             {
                 delete cyweeInfo; // 处理内存分配失败的情况
                 cyweeInfo = NULL;
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_result_t fail！ ret = %d", rets);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_activity_result_t fail！ ret = %d", rets);
                 return;
             }
             TraingModel::GetInstance()->AnalysisData(cyweeInfo);
             break;
         case TOPIC_EVENT_OUTDOOR_RUNNING_UPDATE:
-            cyweeInfo = new cywee_result_t(); // 在case块内分配内存
-            rets = memcpy_s(cyweeInfo, sizeof(cywee_result_t), (cywee_result_t *)request->data, request->len);
+            cyweeInfo = new cywee_activity_result_t(); // 在case块内分配内存
+            rets = memcpy_s(cyweeInfo, sizeof(cywee_activity_result_t), (cywee_activity_result_t *)request->data, request->len);
             if (rets != EOK)
             {
                 delete cyweeInfo; // 处理内存分配失败的情况
                 cyweeInfo = NULL;
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_result_t fail！ ret = %d", rets);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_activity_result_t fail！ ret = %d", rets);
                 return;
             }
             TraingModel::GetInstance()->AnalysisData(cyweeInfo);
             break;
         case TOPIC_EVENT_INDOOR_RUNNING_UPDATE:
-            cyweeInfo = new cywee_result_t(); // 在case块内分配内存
-            rets = memcpy_s(cyweeInfo, sizeof(cywee_result_t), (cywee_result_t *)request->data, request->len);
+            cyweeInfo = new cywee_activity_result_t(); // 在case块内分配内存
+            rets = memcpy_s(cyweeInfo, sizeof(cywee_activity_result_t), (cywee_activity_result_t *)request->data, request->len);
             if (rets != EOK)
             {
                 delete cyweeInfo; // 处理内存分配失败的情况
                 cyweeInfo = NULL;
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_result_t fail！ ret = %d", rets);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_activity_result_t fail！ ret = %d", rets);
                 return;
             }
             TraingModel::GetInstance()->AnalysisData(cyweeInfo);
             break;
         case TOPIC_EVENT_FITNESS_PEDOMETERR_UPDATE:
-            cyweeInfo = new cywee_result_t(); // 在case块内分配内存
-            rets = memcpy_s(cyweeInfo, sizeof(cywee_result_t), (cywee_result_t *)request->data, request->len);
+            cyweeInfo = new cywee_activity_result_t(); // 在case块内分配内存
+            rets = memcpy_s(cyweeInfo, sizeof(cywee_activity_result_t), (cywee_activity_result_t *)request->data, request->len);
             if (rets != EOK)
             {
                 delete cyweeInfo; // 处理内存分配失败的情况
                 cyweeInfo = NULL;
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_result_t fail！ ret = %d", rets);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s cywee_activity_result_t fail！ ret = %d", rets);
                 return;
             }
             TraingModel::GetInstance()->AnalysisData(cyweeInfo);

diff --git a/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h b/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h
index 9100c06..aac08c6 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h
+++ b/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h
@@ -454,7 +454,29 @@ typedef struct
     int max_pace;
     int ar_alert_type;
     int MHR_zone;
-}cywee_result_t;
+}cywee_activity_result_t;
+
+typedef struct 
+{
+    int inactivity_mode;
+    int sedentary_status;
+    int sleep_status;
+    int nap_status;
+    int stand_freq;
+    int month;
+    int day;
+    int hour;
+    int minute;
+    int total_sleep_time;
+    int total_nap_time;
+    int total_mild_sleep_time;
+    int total_deep_sleep_time;
+    int total_wake_time;
+    int total_rem_sleep_time;
+}cywee_inactivity_result_t;
+
+
+
 #pragma pack()
 typedef enum{
     CYWEE_MSG_TYPE_NORMAL_UPDATE,
@@ -465,6 +487,11 @@ typedef enum{
     CYWEE_MSG_TYPE_FREE_TRAINING_UPDATE,
     CYWEE_MSG_TYPE_AR_ALERT_UPDATE,
     CYWEE_MSG_TYPE_EXTRA_INFO_UPDATE,
+    CYWEE_MSG_TYPE_SEDENTARY_UPDATE,
+    CYWEE_MSG_TYPE_SLEEPING_UPDATE,
+    CYWEE_MSG_TYPE_SLEEPING_ACCUMULATE_TIME_UPDATE,
+    CYWEE_MSG_TYPE_NAP_UPDATE,
+    CYWEE_MSG_TYPE_NAP_ACCUMULATE_TIME_UPDATE
 } cywee_msg_type_t;
 
 

diff --git a/code/sdk/drivers/peripheral/cywee/service/cywee_service.c b/code/sdk/drivers/peripheral/cywee/service/cywee_service.c
index 4873144..8e30013 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/service/cywee_service.c
+++ b/code/sdk/drivers/peripheral/cywee/service/cywee_service.c
@@ -60,79 +60,143 @@ static void cywee_service_check_timer_callback(void* data);
 void cywee_msg_callback(uint8_t msg_type, uint8_t *msg_data, int32_t msg_datalen)
 {
     PRINT("cywee_msg_callback\r\n");
-    cywee_result_t c_result_t;
-    memcpy(&c_result_t, msg_data, sizeof(cywee_result_t));
+    cywee_activity_result_t c_activity_result_t;
+    cywee_inactivity_result_t c_inactivity_result_t;
     switch(msg_type)
     {
         //一般模式
         case CYWEE_MSG_TYPE_NORMAL_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_NORMAL_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_NORMAL_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], steps[%d], distance[%d], calories[%d], step frequency[%d], step length[%d], pace[%d], BMR calories[%d], is_pause[%d],len[%d]\n",
-            c_result_t.activity_mode,c_result_t.steps,c_result_t.distance,c_result_t.calories,c_result_t.step_frequency,
-            c_result_t.step_length,c_result_t.pace,c_result_t.BMR_calories,c_result_t.is_pause,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_NORMAL_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.steps,c_activity_result_t.distance,c_activity_result_t.calories,c_activity_result_t.step_frequency,
+            c_activity_result_t.step_length,c_activity_result_t.pace,c_activity_result_t.BMR_calories,c_activity_result_t.is_pause,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_NORMAL_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //跑步机模式
         case CYWEE_MSG_TYPE_TREADMILL_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_TREADMILL_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_TREADMILL_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], steps[%d], distance[%d], calories[%d], step frequency[%d], step length[%d], pace[%d], BMR calories[%d], is_pause[%d],len[%d]\n",
-            c_result_t.activity_mode,c_result_t.steps,c_result_t.distance,c_result_t.calories,c_result_t.step_frequency,
-            c_result_t.step_length,c_result_t.pace,c_result_t.BMR_calories,c_result_t.is_pause,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_TREADMILL_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.steps,c_activity_result_t.distance,c_activity_result_t.calories,c_activity_result_t.step_frequency,
+            c_activity_result_t.step_length,c_activity_result_t.pace,c_activity_result_t.BMR_calories,c_activity_result_t.is_pause,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_TREADMILL_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //户外跑步模式
         case CYWEE_MSG_TYPE_OUTDOOR_RUNNING_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_OUTDOOR_RUNNING_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_OUTDOOR_RUNNING_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], steps[%d], distance[%d], calories[%d], step frequency[%d], step length[%d], pace[%d], BMR calories[%d], is_pause[%d],len[%d]\n",
-            c_result_t.activity_mode,c_result_t.steps,c_result_t.distance,c_result_t.calories,c_result_t.step_frequency,
-            c_result_t.step_length,c_result_t.pace,c_result_t.BMR_calories,c_result_t.is_pause,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_OUTDOOR_RUNNING_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.steps,c_activity_result_t.distance,c_activity_result_t.calories,c_activity_result_t.step_frequency,
+            c_activity_result_t.step_length,c_activity_result_t.pace,c_activity_result_t.BMR_calories,c_activity_result_t.is_pause,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_OUTDOOR_RUNNING_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //室内跑步模式
         case CYWEE_MSG_TYPE_INDOOR_RUNNING_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_INDOOR_RUNNING_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_INDOOR_RUNNING_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], steps[%d], distance[%d], calories[%d], step frequency[%d], step length[%d], pace[%d], BMR calories[%d], is_pause[%d],len[%d]\n",
-            c_result_t.activity_mode,c_result_t.steps,c_result_t.distance,c_result_t.calories,c_result_t.step_frequency,
-            c_result_t.step_length,c_result_t.pace,c_result_t.BMR_calories,c_result_t.is_pause,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_INDOOR_RUNNING_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.steps,c_activity_result_t.distance,c_activity_result_t.calories,c_activity_result_t.step_frequency,
+            c_activity_result_t.step_length,c_activity_result_t.pace,c_activity_result_t.BMR_calories,c_activity_result_t.is_pause,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_INDOOR_RUNNING_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //防误触计步模式
         case CYWEE_MSG_TYPE_FITNESS_PEDOMETERR_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_FITNESS_PEDOMETERR_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_FITNESS_PEDOMETERR_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], steps[%d], distance[%d], calories[%d], step frequency[%d], step length[%d], pace[%d], BMR calories[%d], is_pause[%d],len[%d]\n",
-            c_result_t.activity_mode,c_result_t.steps,c_result_t.distance,c_result_t.calories,c_result_t.step_frequency,
-            c_result_t.step_length,c_result_t.pace,c_result_t.BMR_calories,c_result_t.is_pause,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_FITNESS_PEDOMETERR_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.steps,c_activity_result_t.distance,c_activity_result_t.calories,c_activity_result_t.step_frequency,
+            c_activity_result_t.step_length,c_activity_result_t.pace,c_activity_result_t.BMR_calories,c_activity_result_t.is_pause,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_FITNESS_PEDOMETERR_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //自由运动模式
         case CYWEE_MSG_TYPE_FREE_TRAINING_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_FREE_TRAINING_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_FREE_TRAINING_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], calories[%d], duration[%d], MHR_zone[%d],len[%d]\n",
-            c_result_t.activity_mode,c_result_t.calories,c_result_t.duration,c_result_t.MHR_zone,sizeof(c_result_t));
-            CustomEventPublish(TOPIC_EVENT_FREE_TRAINING_UPDATE,&c_result_t,sizeof(c_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.calories,c_activity_result_t.duration,c_activity_result_t.MHR_zone,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_FREE_TRAINING_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //长时间动作侦测模式
         case CYWEE_MSG_TYPE_AR_ALERT_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_AR_ALERT_UPDATE");
+            PRINT("CYWEE_MSG_TYPE_AR_ALERT_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
             PRINT("activit_mode[%d], ar alert type[%d], len[%d]\n",
-            c_result_t.activity_mode,c_result_t.ar_alert_type,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_AR_ALERT_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            c_activity_result_t.activity_mode,c_activity_result_t.ar_alert_type,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_AR_ALERT_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
 
         //额外信息
         case CYWEE_MSG_TYPE_EXTRA_INFO_UPDATE:
-            PRINT("CYWEE_MSG_TYPE_EXTRA_INFO_UPDATE");
-            PRINT("average step frequency[%d], average step length[%d], average pace[%d], max step frequency[%d], max pace[%d]\n",
-            c_result_t.avg_step_freq,c_result_t.avg_step_len,c_result_t.avg_pace,c_result_t.max_step_freq,c_result_t.max_pace,sizeof(cywee_result_t));
-            CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_result_t,sizeof(cywee_result_t));
+            PRINT("CYWEE_MSG_TYPE_EXTRA_INFO_UPDATE\r\n");
+            memcpy(&c_activity_result_t, msg_data, sizeof(cywee_activity_result_t));
+            PRINT("average step frequency[%d], average step length[%d], average pace[%d], max step frequency[%d], max pace[%d], len[%d]\n",
+            c_activity_result_t.avg_step_freq,c_activity_result_t.avg_step_len,c_activity_result_t.avg_pace,c_activity_result_t.max_step_freq,c_activity_result_t.max_pace,sizeof(cywee_activity_result_t));
+            CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
             break;
+
+        //久坐
+        case CYWEE_MSG_TYPE_SEDENTARY_UPDATE:
+            PRINT("CYWEE_MSG_TYPE_SEDENTARY_UPDATE\r\n");
+            memcpy(&c_inactivity_result_t, msg_data, sizeof(cywee_inactivity_result_t));
+            PRINT("inactivity_mode_number[%d], sedentary status[%d], stand freq[%d], len[%d]\n",
+            c_inactivity_result_t.inactivity_mode,c_inactivity_result_t.sedentary_status,
+            c_inactivity_result_t.stand_freq,sizeof(cywee_inactivity_result_t));
+            //CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
+            break;
+
+        //睡眠
+        case CYWEE_MSG_TYPE_SLEEPING_UPDATE:
+            PRINT("CYWEE_MSG_TYPE_SLEEPING_UPDATE\r\n");
+            memcpy(&c_inactivity_result_t, msg_data, sizeof(cywee_inactivity_result_t));
+            PRINT("inactivity_mode_number[%d], sleep status[%d], month[%d], day[%d], hour[%d], min[%d], len[%d]\n",
+            c_inactivity_result_t.inactivity_mode,c_inactivity_result_t.sleep_status,
+            c_inactivity_result_t.month,c_inactivity_result_t.day,
+            c_inactivity_result_t.hour,c_inactivity_result_t.minute,
+            sizeof(cywee_inactivity_result_t));
+            //CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
+            break;
+
+        //睡眠累计
+        case CYWEE_MSG_TYPE_SLEEPING_ACCUMULATE_TIME_UPDATE:
+            PRINT("CYWEE_MSG_TYPE_SLEEPING_ACCUMULATE_TIME_UPDATE\r\n");
+            memcpy(&c_inactivity_result_t, msg_data, sizeof(cywee_inactivity_result_t));
+            PRINT("inactivity_mode_number[%d], total sleep time[%d], total nap time[%d], total deep sleep time[%d], total wake time[%d], total rem sleep time[%d], len[%d]\n",
+            c_inactivity_result_t.inactivity_mode,c_inactivity_result_t.total_sleep_time,c_inactivity_result_t.total_mild_sleep_time,
+            c_inactivity_result_t.total_deep_sleep_time,c_inactivity_result_t.total_wake_time,c_inactivity_result_t.total_rem_sleep_time,
+            c_inactivity_result_t.stand_freq,sizeof(cywee_inactivity_result_t));
+            //CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
+            break;
+
+        //小睡
+        case CYWEE_MSG_TYPE_NAP_UPDATE:
+            PRINT("CYWEE_MSG_TYPE_NAP_UPDATE\r\n");
+            memcpy(&c_inactivity_result_t, msg_data, sizeof(cywee_inactivity_result_t));
+            PRINT("inactivity_mode_number[%d], nap status[%d], month[%d], day[%d], hour[%d], min[%d], len[%d]\n",
+            c_inactivity_result_t.inactivity_mode,c_inactivity_result_t.nap_status,c_inactivity_result_t.month,
+            c_inactivity_result_t.day,c_inactivity_result_t.hour,c_inactivity_result_t.minute,sizeof(cywee_inactivity_result_t));
+            //CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
+            break;
+        
+        //小睡累计
+        case CYWEE_MSG_TYPE_NAP_ACCUMULATE_TIME_UPDATE:
+            PRINT("CYWEE_MSG_TYPE_NAP_ACCUMULATE_TIME_UPDATE\r\n");
+            memcpy(&c_inactivity_result_t, msg_data, sizeof(cywee_inactivity_result_t));
+            PRINT("inactivity_mode_number[%d], total nap time[%d], total mild time[%d], total deep sleep time[%d], total wake time[%d], total rem sleep time[%d], len[%d]\n",
+            c_inactivity_result_t.inactivity_mode,c_inactivity_result_t.total_nap_time,c_inactivity_result_t.total_mild_sleep_time,
+            c_inactivity_result_t.total_deep_sleep_time,c_inactivity_result_t.total_wake_time,c_inactivity_result_t.total_rem_sleep_time,
+            c_inactivity_result_t.stand_freq,sizeof(cywee_inactivity_result_t));
+            //CustomEventPublish(TOPIC_EVENT_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
+            break;
+
         default:
+
             PRINT("Unknown sensor message type");
             break;
     }

diff --git a/code/sdk/drivers/peripheral/cywee/src/main_dml.c b/code/sdk/drivers/peripheral/cywee/src/main_dml.c
index 3ea540d..57723e5 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/src/main_dml.c
+++ b/code/sdk/drivers/peripheral/cywee/src/main_dml.c
@@ -12,6 +12,8 @@
 #include "osal_mutex.h" 
 #include "ppg_service.h"
 #include "custom_utils.h"
+#include "sys/time.h"
+#include "time.h"
 
 #define AP_ENABLE_DML_SDO_LISTEN
 
@@ -30,8 +32,8 @@ static int16 right_falg=-1;
 
 SettingControl_t scl;
 
-cywee_result_t c_result_t;
-
+cywee_activity_result_t c_activity_result_t;
+cywee_inactivity_result_t c_inactivity_result_t;
 static int cywee_installized = 0 ;
 static int free_training_installized = 0 ;
 
@@ -43,23 +45,26 @@ static osTimerId_t g_cywee_oncharging_timer;
 
 CustomSensorData csd;
 
-// void time_sync(void)
-// {
-//     char databuf[64] = {0};
-//     int year,month,day,hour,min,sec;
-//     uapi_get_yyyymmddhhmmss_Date(databuf);
-//     PRINT("databuf : %s \r\n",databuf);
-//     sscanf(databuf, "%4d%2d%2d%2d%2d%2d", &year, &month, &day, &hour, &min, &sec);
-//     memset(&scl, 0, sizeof(scl));
-//     scl.iData[0] = 1;
-//     scl.iData[1] = year;
-//     scl.iData[2] = month;
-//     scl.iData[3] = day;
-//     scl.iData[4] = hour;
-//     scl.iData[5] = min;
-//     scl.iData[6] = sec;
-//     CWM_SettingControl(SCL_DATE_TIME, &scl);
-// }
+void time_sync(void)
+{
+    time_t rawtime;
+    struct tm* timeinfo;
+    time(&rawtime);
+    timeinfo = localtime(&rawtime);
+    PRINT("year[%d], mon[%d], day[%d], hour[%d], min[%d], msc[%d] \r\n",
+    timeinfo->tm_year,timeinfo->tm_mon,timeinfo->tm_mday,
+    timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);
+
+    memset(&scl, 0, sizeof(scl));
+    scl.iData[0] = 1;
+    scl.iData[1] = timeinfo->tm_year;
+    scl.iData[2] = timeinfo->tm_mon;
+    scl.iData[3] = timeinfo->tm_mday;
+    scl.iData[4] = timeinfo->tm_hour;
+    scl.iData[5] = timeinfo->tm_min;
+    scl.iData[6] = timeinfo->tm_sec;
+    CWM_SettingControl(SCL_DATE_TIME, &scl);
+}
 
 
 void cywee_hrs_check_timer_callback(void)
@@ -170,6 +175,7 @@ void cyw_inactivity_mode_change(int mode)
 {
     switch (mode)
     {
+        //無作用
         case INACTIVITY_MODE_NOTHING:
             memset(&scl, 0, sizeof(scl));
             scl.iData[0] = 1;
@@ -177,6 +183,7 @@ void cyw_inactivity_mode_change(int mode)
             CWM_SettingControl(SCL_SET_INACTIVITY_MODE, &scl);
             break;
 
+        //久坐和有效站立
         case INACTIVITY_MODE_SEDENTARY:
             memset(&scl, 0, sizeof(scl));
             scl.iData[0] = 1;
@@ -184,6 +191,7 @@ void cyw_inactivity_mode_change(int mode)
             CWM_SettingControl(SCL_SET_INACTIVITY_MODE, &scl);
             break;
 
+        //睡眠
         case INACTIVITY_MODE_SLEEPING:
             memset(&scl, 0, sizeof(scl));
             scl.iData[0] = 1;
@@ -191,6 +199,7 @@ void cyw_inactivity_mode_change(int mode)
             CWM_SettingControl(SCL_SET_INACTIVITY_MODE, &scl);
             break;
 
+        //久坐、有效站立和小睡
         case INACTIVITY_MODE_SEDENTARY_AND_NAP:
             memset(&scl, 0, sizeof(scl));
             scl.iData[0] = 1;
@@ -198,6 +207,7 @@ void cyw_inactivity_mode_change(int mode)
             CWM_SettingControl(SCL_SET_INACTIVITY_MODE, &scl);
             break;
 
+        //小睡
         case INACTIVITY_MODE_NAP:
             memset(&scl, 0, sizeof(scl));
             scl.iData[0] = 1;
@@ -416,22 +426,91 @@ void CWM_AP_SensorListen(pSensorEVT_t sensorEVT) {
             CWM_OS_dbgPrintf("IDX_ALGO_SHAKE\n");
              break;
         case IDX_ALGO_INACTIVITY_OUTPUT:
+            cywee_func = cywee_get_send_msg_callback_func();
             CWM_OS_dbgPrintf("IDX_ALGO_INACTIVITY_OUTPUT\n");
-            if((int)sensorEVT->fData[0] == 21)
+            if((int)sensorEVT->fData[0] == 20)
             {
-                CWM_OS_dbgPrintf("sleep status[%d], month[%d], day[%d], hour[%d], min[%d], mintue[%d], inactivity_mode_number[%d]\n",
+                CWM_OS_dbgPrintf("inactivity_mode_number[%d], sedentary status[%d], stand freq[%d]\n",
+                                (int)sensorEVT->fData[15],
+                                (int)sensorEVT->fData[2],
+                                (int)sensorEVT->fData[3]);
+                memset(&c_inactivity_result_t,0,sizeof(cywee_inactivity_result_t));
+                c_inactivity_result_t.inactivity_mode = (int)sensorEVT->fData[15];
+                c_inactivity_result_t.sedentary_status = (int)sensorEVT->fData[2];
+                c_inactivity_result_t.stand_freq = (int)sensorEVT->fData[3];
+                cywee_func(CYWEE_MSG_TYPE_SEDENTARY_UPDATE,&c_inactivity_result_t,sizeof(cywee_inactivity_result_t));
+
+            }else if((int)sensorEVT->fData[0] == 21){
+                CWM_OS_dbgPrintf("inactivity_mode_number[%d], sleep status[%d], month[%d], day[%d], hour[%d], min[%d]\n",
+                                (int)sensorEVT->fData[15],
                                 (int)sensorEVT->fData[2],
                                 (int)sensorEVT->fData[3],
                                 (int)sensorEVT->fData[4],
                                 (int)sensorEVT->fData[5],
-                                (int)sensorEVT->fData[6],
-                                (int)sensorEVT->fData[8],
-                                (int)sensorEVT->fData[9],
-                                (int)sensorEVT->fData[10],
-                                (int)sensorEVT->fData[15]);
-            }   
+                                (int)sensorEVT->fData[6]);
+                memset(&c_inactivity_result_t,0,sizeof(cywee_inactivity_result_t));
+                c_inactivity_result_t.inactivity_mode = (int)sensorEVT->fData[15];
+                c_inactivity_result_t.sleep_status = (int)sensorEVT->fData[2];
+                c_inactivity_result_t.month = (int)sensorEVT->fData[3];
+                c_inactivity_result_t.day = (int)sensorEVT->fData[4];
+                c_inactivity_result_t.hour = (int)sensorEVT->fData[5];
+                c_inactivity_result_t.minute = (int)sensorEVT->fData[6];
+                cywee_func(CYWEE_MSG_TYPE_SLEEPING_UPDATE,&c_inactivity_result_t,sizeof(cywee_inactivity_result_t));
+
+            }else if((int)sensorEVT->fData[0] == 31){
+                CWM_OS_dbgPrintf("inactivity_mode_number[%d], total sleep time[%d], total mild time[%d], total deep sleep time[%d], total wake time[%d], total rem sleep time[%d]\n",
+                                (int)sensorEVT->fData[15],
+                                (int)sensorEVT->fData[1],
+                                (int)sensorEVT->fData[2],
+                                (int)sensorEVT->fData[3],
+                                (int)sensorEVT->fData[4],
+                                (int)sensorEVT->fData[5]);
+                memset(&c_inactivity_result_t,0,sizeof(cywee_inactivity_result_t));
+                c_inactivity_result_t.inactivity_mode = (int)sensorEVT->fData[15];
+                c_inactivity_result_t.total_sleep_time = (int)sensorEVT->fData[1];
+                c_inactivity_result_t.total_mild_sleep_time = (int)sensorEVT->fData[2];
+                c_inactivity_result_t.total_deep_sleep_time = (int)sensorEVT->fData[3];
+                c_inactivity_result_t.total_wake_time = (int)sensorEVT->fData[4];
+                c_inactivity_result_t.total_rem_sleep_time = (int)sensorEVT->fData[5];
+                cywee_func(CYWEE_MSG_TYPE_SLEEPING_ACCUMULATE_TIME_UPDATE,&c_inactivity_result_t,sizeof(cywee_inactivity_result_t));
+
+            }else if((int)sensorEVT->fData[0] == 22){
+                CWM_OS_dbgPrintf("inactivity_mode_number[%d], nap status[%d], month[%d], day[%d], hour[%d], min[%d]\n",
+                                (int)sensorEVT->fData[15],
+                                (int)sensorEVT->fData[2],
+                                (int)sensorEVT->fData[3],
+                                (int)sensorEVT->fData[4],
+                                (int)sensorEVT->fData[5],
+                                (int)sensorEVT->fData[6]);
+                memset(&c_inactivity_result_t,0,sizeof(cywee_inactivity_result_t));
+                c_inactivity_result_t.inactivity_mode = (int)sensorEVT->fData[15];
+                c_inactivity_result_t.nap_status = (int)sensorEVT->fData[2];
+                c_inactivity_result_t.month = (int)sensorEVT->fData[3];
+                c_inactivity_result_t.day = (int)sensorEVT->fData[4];
+                c_inactivity_result_t.hour = (int)sensorEVT->fData[5];
+                c_inactivity_result_t.minute = (int)sensorEVT->fData[6];
+                cywee_func(CYWEE_MSG_TYPE_NAP_UPDATE,&c_inactivity_result_t,sizeof(cywee_inactivity_result_t));
+
+            }else if((int)sensorEVT->fData[0] == 32){
+                CWM_OS_dbgPrintf("inactivity_mode_number[%d], total nap time[%d], total mild time[%d], total deep sleep time[%d], total wake time[%d], total rem sleep time[%d]\n",
+                                (int)sensorEVT->fData[15],
+                                (int)sensorEVT->fData[1],
+                                (int)sensorEVT->fData[2],
+                                (int)sensorEVT->fData[3],
+                                (int)sensorEVT->fData[4],
+                                (int)sensorEVT->fData[5]);
+                memset(&c_inactivity_result_t,0,sizeof(cywee_inactivity_result_t));
+                c_inactivity_result_t.inactivity_mode = (int)sensorEVT->fData[15];
+                c_inactivity_result_t.total_nap_time = (int)sensorEVT->fData[1];
+                c_inactivity_result_t.total_mild_sleep_time = (int)sensorEVT->fData[2];
+                c_inactivity_result_t.total_deep_sleep_time = (int)sensorEVT->fData[3];
+                c_inactivity_result_t.total_wake_time = (int)sensorEVT->fData[4];
+                c_inactivity_result_t.total_rem_sleep_time = (int)sensorEVT->fData[5];
+                cywee_func(CYWEE_MSG_TYPE_NAP_ACCUMULATE_TIME_UPDATE,&c_inactivity_result_t,sizeof(cywee_inactivity_result_t));
+            }  
             break;
         case IDX_ALGO_ACTIVITY_OUTPUT:
+            cywee_func = cywee_get_send_msg_callback_func();
             if((int)sensorEVT->fData[0] == 100)
             {
                 CWM_OS_dbgPrintf("average step frequency[%d], average step length[%d], average pace[%d], max step frequency[%d], max pace[%d]\n",
@@ -441,14 +520,13 @@ void CWM_AP_SensorListen(pSensorEVT_t sensorEVT) {
                                 (int)sensorEVT->fData[4],
                                 (int)sensorEVT->fData[5]);
 
-                memset(&c_result_t,0,sizeof(cywee_result_t));
-                c_result_t.avg_step_freq = (int)sensorEVT->fData[1];
-                c_result_t.avg_step_len = (int)sensorEVT->fData[2];
-                c_result_t.avg_pace = (int)sensorEVT->fData[3];
-                c_result_t.max_step_freq = (int)sensorEVT->fData[4];
-                c_result_t.max_pace = (int)sensorEVT->fData[5];
-                cywee_func = cywee_get_send_msg_callback_func();
-                cywee_func(CYWEE_MSG_TYPE_EXTRA_INFO_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                memset(&c_activity_result_t,0,sizeof(cywee_activity_result_t));
+                c_activity_result_t.avg_step_freq = (int)sensorEVT->fData[1];
+                c_activity_result_t.avg_step_len = (int)sensorEVT->fData[2];
+                c_activity_result_t.avg_pace = (int)sensorEVT->fData[3];
+                c_activity_result_t.max_step_freq = (int)sensorEVT->fData[4];
+                c_activity_result_t.max_pace = (int)sensorEVT->fData[5];
+                cywee_func(CYWEE_MSG_TYPE_EXTRA_INFO_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
 
             }else if((int)sensorEVT->fData[0] == 5001)
             {
@@ -457,23 +535,21 @@ void CWM_AP_SensorListen(pSensorEVT_t sensorEVT) {
                                 (int)sensorEVT->fData[5],
                                 (int)sensorEVT->fData[6]);
 
-                memset(&c_result_t,0,sizeof(cywee_result_t));
-                c_result_t.activity_mode = (int)sensorEVT->fData[0];
-                c_result_t.calories = (int)sensorEVT->fData[1];
-                c_result_t.duration = (int)sensorEVT->fData[5];
-                c_result_t.MHR_zone = (int)sensorEVT->fData[6];
-                cywee_func = cywee_get_send_msg_callback_func();
-                cywee_func(CYWEE_MSG_TYPE_FREE_TRAINING_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                memset(&c_activity_result_t,0,sizeof(cywee_activity_result_t));
+                c_activity_result_t.activity_mode = (int)sensorEVT->fData[0];
+                c_activity_result_t.calories = (int)sensorEVT->fData[1];
+                c_activity_result_t.duration = (int)sensorEVT->fData[5];
+                c_activity_result_t.MHR_zone = (int)sensorEVT->fData[6];
+                cywee_func(CYWEE_MSG_TYPE_FREE_TRAINING_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                 
             }else if((int)sensorEVT->fData[0] == 102)
             {
                 CWM_OS_dbgPrintf("ar alert type : %d\n",(int)sensorEVT->fData[1]);
 
-                memset(&c_result_t,0,sizeof(cywee_result_t));
-                c_result_t.activity_mode = (int)sensorEVT->fData[0];
-                c_result_t.ar_alert_type = (int)sensorEVT->fData[1];
-                cywee_func = cywee_get_send_msg_callback_func();
-                cywee_func(CYWEE_MSG_TYPE_AR_ALERT_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                memset(&c_activity_result_t,0,sizeof(cywee_activity_result_t));
+                c_activity_result_t.activity_mode = (int)sensorEVT->fData[0];
+                c_activity_result_t.ar_alert_type = (int)sensorEVT->fData[1];
+                cywee_func(CYWEE_MSG_TYPE_AR_ALERT_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                 
             }else{
                  CWM_OS_dbgPrintf("activity_mode[%d], steps[%d], distance[%d], calories[%d], step frequency[%d], step length[%d], pace[%d], BMR calories[%d], is_pause[%d]\n",
@@ -487,38 +563,37 @@ void CWM_AP_SensorListen(pSensorEVT_t sensorEVT) {
                                 (int)sensorEVT->fData[8],
                                 (int)sensorEVT->fData[14]);
                 int stepcount = (int)sensorEVT->fData[1];
-                memset(&c_result_t,0,sizeof(cywee_result_t));
-                c_result_t.activity_mode = (int)sensorEVT->fData[0];
-                c_result_t.steps = (int)sensorEVT->fData[1];
-                c_result_t.distance = (int)sensorEVT->fData[2];
-                c_result_t.calories = (int)sensorEVT->fData[3];
-                c_result_t.step_frequency = (int)sensorEVT->fData[5];
-                c_result_t.step_length = (int)sensorEVT->fData[6];
-                c_result_t.pace = (int)sensorEVT->fData[7];
-                c_result_t.BMR_calories = (int)sensorEVT->fData[8];
-                c_result_t.is_pause = (int)sensorEVT->fData[14];
-                cywee_func = cywee_get_send_msg_callback_func();
+                memset(&c_activity_result_t,0,sizeof(cywee_activity_result_t));
+                c_activity_result_t.activity_mode = (int)sensorEVT->fData[0];
+                c_activity_result_t.steps = (int)sensorEVT->fData[1];
+                c_activity_result_t.distance = (int)sensorEVT->fData[2];
+                c_activity_result_t.calories = (int)sensorEVT->fData[3];
+                c_activity_result_t.step_frequency = (int)sensorEVT->fData[5];
+                c_activity_result_t.step_length = (int)sensorEVT->fData[6];
+                c_activity_result_t.pace = (int)sensorEVT->fData[7];
+                c_activity_result_t.BMR_calories = (int)sensorEVT->fData[8];
+                c_activity_result_t.is_pause = (int)sensorEVT->fData[14];
 
                 switch ((int)sensorEVT->fData[0])
                 {
                     case SPORT_ACTIVE_MODE_NORMAL:
-                        cywee_func(CYWEE_MSG_TYPE_NORMAL_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                        cywee_func(CYWEE_MSG_TYPE_NORMAL_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                         break;
 
                     case SPORT_ACTIVE_MODE_TREADMILL:
-                        cywee_func(CYWEE_MSG_TYPE_TREADMILL_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                        cywee_func(CYWEE_MSG_TYPE_TREADMILL_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                         break;
 
                     case SPORT_ACTIVE_MODE_OUTDOOR_RUNNING:
-                        cywee_func(CYWEE_MSG_TYPE_OUTDOOR_RUNNING_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                        cywee_func(CYWEE_MSG_TYPE_OUTDOOR_RUNNING_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                         break;
 
                     case SPORT_ACTIVE_MODE_INDOOR_RUNNING:
-                        cywee_func(CYWEE_MSG_TYPE_INDOOR_RUNNING_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                        cywee_func(CYWEE_MSG_TYPE_INDOOR_RUNNING_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                         break;
 
                     case SPORT_ACTIVE_MODE_FITNESS_PEDOMETERR:
-                        cywee_func(CYWEE_MSG_TYPE_FITNESS_PEDOMETERR_UPDATE,&c_result_t,sizeof(cywee_result_t));
+                        cywee_func(CYWEE_MSG_TYPE_FITNESS_PEDOMETERR_UPDATE,&c_activity_result_t,sizeof(cywee_activity_result_t));
                         break;
                     
                     default:
@@ -585,7 +660,7 @@ void CWM_AP_dmlSensorDataOutput_listen(const dml_sensorData_t * pSdo) {
 int cywee_main_dml(void) 
 {
 
-    if (cywee_installized==0)
+    if (cywee_installized == 1)
     {
         CWM_OS_dbgPrintf("cywee_installized skip install\n");
         return 0;