Merge pull request #459 from Luos-io/feat/multi_auto-update

nicolas-rabault · web-flow · commit d9b6ed57810e · 2024-01-23T09:34:02.000+01:00
Enable multi auto_update management, fix #450
diff --git a/engine/IO/src/luos_io.c b/engine/IO/src/luos_io.c
@@ -660,9 +660,7 @@ error_return_t LuosIO_ConsumeMsg(const msg_t *input)
         case UPDATE_PUB:
             // This service need to be auto updated
             TimeOD_TimeFromMsg(&time, input);
-            service->auto_refresh.target      = input->header.source;
-            service->auto_refresh.time_ms     = (uint16_t)TimeOD_TimeTo_ms(time);
-            service->auto_refresh.last_update = LuosHAL_GetSystick();
+            Service_AddAutoUpdateTarget(service, input->header.source, (uint16_t)TimeOD_TimeTo_ms(time));
             return SUCCEED;
             break;
             //**************************************** bootloader section ****************************************
diff --git a/engine/core/inc/service.h b/engine/core/inc/service.h
@@ -35,6 +35,7 @@ void Service_ResetStatistics(void);
 void Service_GenerateId(uint16_t base_id);
 void Service_ClearId(void);
 uint16_t Service_GetIndex(service_t *service);
+void Service_AddAutoUpdateTarget(service_t *service, uint16_t target, uint16_t time_ms);
 void Service_RmAutoUpdateTarget(uint16_t service_id);
 void Service_AutoUpdateManager(void);
 error_return_t Service_Deliver(phy_job_t *job);
diff --git a/engine/core/inc/struct_luos.h b/engine/core/inc/struct_luos.h
@@ -133,17 +133,6 @@ typedef struct __attribute__((__packed__))
     };
 } msg_t;
 
-/******************************************************************************
- * This structure is used to manage services timed auto update
- * please refer to the documentation
- ******************************************************************************/
-typedef struct timed_update_t
-{
-    uint32_t last_update;
-    uint16_t time_ms;
-    uint16_t target;
-} timed_update_t;
-
 /******************************************************************************
  * This structure is used to manage dead target message
  * Service_id or node_id can be set to 0 to ignore it.
@@ -217,11 +206,22 @@ typedef struct service_t
     // Private Variables
     uint16_t last_topic_position;                /*!< Position pointer of the last topic added. */
     uint16_t topic_list[MAX_LOCAL_TOPIC_NUMBER]; /*!< multicast target bank. */
-    timed_update_t auto_refresh;                 /*!< service auto refresh context. */
     void *profile_context;                       /*!< Pointer to the profile context. */
 
 } service_t;
 
+/******************************************************************************
+ * This structure is used to manage services timed auto update
+ * please refer to the documentation
+ ******************************************************************************/
+typedef struct timed_update_t
+{
+    service_t *service;
+    uint32_t last_update;
+    uint16_t time_ms;
+    uint16_t target;
+} timed_update_t;
+
 typedef void (*SERVICE_CB)(service_t *service, const msg_t *msg);
 
 #endif /*__LUOS_STRUCT_H */
diff --git a/engine/core/src/service.c b/engine/core/src/service.c
@@ -20,6 +20,7 @@ typedef struct
 {
     service_t list[MAX_LOCAL_SERVICE_NUMBER];
     uint16_t number;
+    timed_update_t auto_refresh[MAX_AUTO_REFRESH_NUMBER]; /*!< service auto refresh context. */
 } service_ctx_t;
 
 /*******************************************************************************
@@ -107,11 +108,9 @@ void Service_ClearId(void)
 {
     for (uint16_t i = 0; i < service_ctx.number; i++)
     {
-        service_ctx.list[i].id                       = DEFAULTID;
-        service_ctx.list[i].auto_refresh.target      = 0;
-        service_ctx.list[i].auto_refresh.time_ms     = 0;
-        service_ctx.list[i].auto_refresh.last_update = 0;
+        service_ctx.list[i].id = DEFAULTID;
     }
+    memset((void *)service_ctx.auto_refresh, 0, sizeof(timed_update_t) * MAX_AUTO_REFRESH_NUMBER);
 }
 
 /******************************************************************************
@@ -125,20 +124,41 @@ uint16_t Service_GetIndex(service_t *service)
     return ((uintptr_t)service - (uintptr_t)service_ctx.list) / sizeof(service_t);
 }
 
+/******************************************************************************
+ * @brief Remove all services auto update targetting this service_id
+ * @param service_id
+ * @return None
+ ******************************************************************************/
+void Service_AddAutoUpdateTarget(service_t *service, uint16_t target, uint16_t time_ms)
+{
+    LUOS_ASSERT(service && (time_ms > 0) && (target != 0));
+    for (uint16_t i = 0; i < MAX_AUTO_REFRESH_NUMBER; i++)
+    {
+        if (service_ctx.auto_refresh[i].time_ms == 0)
+        {
+            service_ctx.auto_refresh[i].service     = service;
+            service_ctx.auto_refresh[i].target      = target;
+            service_ctx.auto_refresh[i].time_ms     = time_ms;
+            service_ctx.auto_refresh[i].last_update = LuosHAL_GetSystick();
+            return;
+        }
+    }
+    // No more space for auto update
+    LUOS_ASSERT(0);
+}
+
 /******************************************************************************
  * @brief Remove all services auto update targetting this service_id
  * @param service_id
  * @return None
  ******************************************************************************/
 void Service_RmAutoUpdateTarget(uint16_t service_id)
 {
-    for (uint16_t i = 0; i < service_ctx.number; i++)
+    for (uint16_t i = 0; i < MAX_AUTO_REFRESH_NUMBER; i++)
     {
-        if (service_ctx.list[i].auto_refresh.target == service_id)
+        if (service_ctx.auto_refresh[i].target == service_id)
         {
-            service_ctx.list[i].auto_refresh.target      = 0;
-            service_ctx.list[i].auto_refresh.time_ms     = 0;
-            service_ctx.list[i].auto_refresh.last_update = 0;
+            memset((void *)&service_ctx.auto_refresh[i], 0, sizeof(timed_update_t));
         }
     }
 }
@@ -150,45 +170,44 @@ void Service_RmAutoUpdateTarget(uint16_t service_id)
  ******************************************************************************/
 void Service_AutoUpdateManager(void)
 {
-    // Check all services timed_update_t contexts
-    for (uint16_t i = 0; i < service_ctx.number; i++)
+    // Check if detection is OK
+    if (Node_GetState() != DETECTION_OK)
     {
-        // check if services have an actual ID. If not, we are in detection mode and should reset the auto refresh
-        if (service_ctx.list[i].id == DEFAULTID)
-        {
-            // this service have not been detected or is in detection mode. remove auto_refresh parameters
-            service_ctx.list[i].auto_refresh.target      = 0;
-            service_ctx.list[i].auto_refresh.time_ms     = 0;
-            service_ctx.list[i].auto_refresh.last_update = 0;
-        }
-        else
+        // We have not been detected or we are in detection mode. remove auto_refresh parameters
+        memset((void *)&service_ctx.auto_refresh, 0, sizeof(timed_update_t) * MAX_AUTO_REFRESH_NUMBER);
+    }
+    else
+    {
+        // Check all timed_update_t
+        for (uint16_t i = 0; i < MAX_AUTO_REFRESH_NUMBER; i++)
         {
             // check if there is a timed update setted and if it's time to update it.
-            if (service_ctx.list[i].auto_refresh.time_ms)
+            if (service_ctx.auto_refresh[i].time_ms)
             {
-                if ((LuosHAL_GetSystick() - service_ctx.list[i].auto_refresh.last_update) >= service_ctx.list[i].auto_refresh.time_ms)
+                if ((LuosHAL_GetSystick() - service_ctx.auto_refresh[i].last_update) >= service_ctx.auto_refresh[i].time_ms)
                 {
                     // This service need to send an update
                     // Create a fake message for it from the service asking for update
                     msg_t updt_msg;
+                    LUOS_ASSERT(service_ctx.auto_refresh[i].service);
                     updt_msg.header.config      = BASE_PROTOCOL;
-                    updt_msg.header.target      = service_ctx.list[i].id;
-                    updt_msg.header.source      = service_ctx.list[i].auto_refresh.target;
+                    updt_msg.header.target      = service_ctx.auto_refresh[i].service->id;
+                    updt_msg.header.source      = service_ctx.auto_refresh[i].target;
                     updt_msg.header.target_mode = SERVICEIDACK;
                     updt_msg.header.cmd         = GET_CMD;
                     updt_msg.header.size        = 0;
-                    if ((service_ctx.list[i].service_cb != 0))
+                    if ((service_ctx.auto_refresh[i].service->service_cb != 0))
                     {
-                        service_ctx.list[i].service_cb(&service_ctx.list[i], &updt_msg);
+                        service_ctx.auto_refresh[i].service->service_cb(service_ctx.auto_refresh[i].service, &updt_msg);
                     }
                     else
                     {
                         if (Node_GetState() == DETECTION_OK)
                         {
-                            Luos_SendMsg(&service_ctx.list[i], &updt_msg);
+                            Luos_SendMsg(service_ctx.auto_refresh[i].service, &updt_msg);
                         }
                     }
-                    service_ctx.list[i].auto_refresh.last_update = LuosHAL_GetSystick();
+                    service_ctx.auto_refresh[i].last_update = LuosHAL_GetSystick();
                 }
             }
         }
diff --git a/engine/engine_config.h b/engine/engine_config.h
@@ -22,6 +22,10 @@
     #define MAX_LOCAL_SERVICE_NUMBER 5 // The maximum number of local services
 #endif
 
+#ifndef MAX_AUTO_REFRESH_NUMBER
+    #define MAX_AUTO_REFRESH_NUMBER MAX_LOCAL_SERVICE_NUMBER // The maximum number of auto refresh in the node
+#endif
+
 #ifndef MAX_SERVICE_NUMBER
     #define MAX_SERVICE_NUMBER 20 // The maximum number of services in the complete architecture
 #endif
diff --git a/network/ws_network/HAL/ARDUINO/ws_hal_config.h b/network/ws_network/HAL/ARDUINO/ws_hal_config.h
@@ -12,7 +12,7 @@
 #ifndef SECRET_SSID
     #warning "You must define SECRET_SSID and SECRET_PASS in your node_config.h"
 #endif
-#ifndef SECRESECRET_PASST_SSID
+#ifndef SECRET_PASS
     #warning "You must define SECRET_SSID and SECRET_PASS in your node_config.h"
 #endif
 #endif /* _WS_CONFIG_H_ */
diff --git a/test/tests_core/test_service/main.c b/test/tests_core/test_service/main.c
@@ -211,20 +211,80 @@ void unittest_Service_GetIndex(void)
     }
 }
 
+void unittest_Service_AddAutoUpdateTarget(void)
+{
+    NEW_TEST_CASE("Test Service_AddAutoUpdateTarget assert conditions");
+    {
+        TRY
+        {
+            Service_AddAutoUpdateTarget(NULL, 1, 10);
+        }
+        TEST_ASSERT_TRUE(IS_ASSERT());
+        END_TRY;
+
+        TRY
+        {
+            Service_AddAutoUpdateTarget(&service_ctx.list[0], 0, 10);
+        }
+        TEST_ASSERT_TRUE(IS_ASSERT());
+        END_TRY;
+
+        TRY
+        {
+            Service_AddAutoUpdateTarget(&service_ctx.list[0], 1, 0);
+        }
+        TEST_ASSERT_TRUE(IS_ASSERT());
+        END_TRY;
+    }
+    NEW_TEST_CASE("Test Service_AddAutoUpdateTarget");
+    {
+        TRY
+        {
+            Service_AddAutoUpdateTarget(&service_ctx.list[0], 2, 20);
+            TEST_ASSERT_EQUAL(2, service_ctx.auto_refresh[0].target);
+            TEST_ASSERT_EQUAL(20, service_ctx.auto_refresh[0].time_ms);
+            TEST_ASSERT_EQUAL(&service_ctx.list[0], service_ctx.auto_refresh[0].service);
+            Service_AddAutoUpdateTarget(&service_ctx.list[0], 3, 10);
+            TEST_ASSERT_EQUAL(2, service_ctx.auto_refresh[0].target);
+            TEST_ASSERT_EQUAL(20, service_ctx.auto_refresh[0].time_ms);
+            TEST_ASSERT_EQUAL(&service_ctx.list[0], service_ctx.auto_refresh[0].service);
+            TEST_ASSERT_EQUAL(3, service_ctx.auto_refresh[1].target);
+            TEST_ASSERT_EQUAL(10, service_ctx.auto_refresh[1].time_ms);
+            TEST_ASSERT_EQUAL(&service_ctx.list[0], service_ctx.auto_refresh[1].service);
+            Service_AddAutoUpdateTarget(&service_ctx.list[1], 1, 5);
+            TEST_ASSERT_EQUAL(2, service_ctx.auto_refresh[0].target);
+            TEST_ASSERT_EQUAL(20, service_ctx.auto_refresh[0].time_ms);
+            TEST_ASSERT_EQUAL(&service_ctx.list[0], service_ctx.auto_refresh[0].service);
+            TEST_ASSERT_EQUAL(3, service_ctx.auto_refresh[1].target);
+            TEST_ASSERT_EQUAL(10, service_ctx.auto_refresh[1].time_ms);
+            TEST_ASSERT_EQUAL(&service_ctx.list[0], service_ctx.auto_refresh[1].service);
+            TEST_ASSERT_EQUAL(1, service_ctx.auto_refresh[2].target);
+            TEST_ASSERT_EQUAL(5, service_ctx.auto_refresh[2].time_ms);
+            TEST_ASSERT_EQUAL(&service_ctx.list[1], service_ctx.auto_refresh[2].service);
+        }
+        CATCH
+        {
+            TEST_ASSERT_TRUE(false);
+        }
+        END_TRY;
+    }
+}
+
 void unittest_Service_RmAutoUpdateTarget(void)
 {
     NEW_TEST_CASE("Test Service_RmAutoUpdateTarget");
     {
         TRY
         {
-            service_ctx.number                           = 10;
-            service_ctx.list[2].auto_refresh.target      = 2;
-            service_ctx.list[2].auto_refresh.time_ms     = 20;
-            service_ctx.list[2].auto_refresh.last_update = 30;
+            service_ctx.number                      = 10;
+            service_ctx.auto_refresh[0].service     = &service_ctx.list[0];
+            service_ctx.auto_refresh[0].target      = 2;
+            service_ctx.auto_refresh[0].time_ms     = 20;
+            service_ctx.auto_refresh[0].last_update = 30;
             Service_RmAutoUpdateTarget(2);
-            TEST_ASSERT_EQUAL(0, service_ctx.list[2].auto_refresh.target);
-            TEST_ASSERT_EQUAL(0, service_ctx.list[2].auto_refresh.time_ms);
-            TEST_ASSERT_EQUAL(0, service_ctx.list[2].auto_refresh.last_update);
+            TEST_ASSERT_EQUAL(0, service_ctx.auto_refresh[0].target);
+            TEST_ASSERT_EQUAL(0, service_ctx.auto_refresh[0].time_ms);
+            TEST_ASSERT_EQUAL(0, service_ctx.auto_refresh[0].last_update);
         }
         CATCH
         {
@@ -243,11 +303,12 @@ void unittest_Service_AutoUpdateManager(void)
             //  Init default scenario context
             Init_Context();
             Luos_Loop();
-            service_ctx.list[2].auto_refresh.target      = 1;
-            service_ctx.list[2].auto_refresh.time_ms     = 10;
-            service_ctx.list[2].auto_refresh.last_update = 30;
+            service_ctx.auto_refresh[0].service     = default_sc.App_3.app;
+            service_ctx.auto_refresh[0].target      = 1;
+            service_ctx.auto_refresh[0].time_ms     = 10;
+            service_ctx.auto_refresh[0].last_update = 30;
             Service_AutoUpdateManager();
-            TEST_ASSERT_NOT_EQUAL(30, service_ctx.list[2].auto_refresh.last_update);
+            TEST_ASSERT_NOT_EQUAL(30, service_ctx.auto_refresh[0].last_update);
             TEST_ASSERT_EQUAL(GET_CMD, default_sc.App_3.last_rx_msg.header.cmd);
             TEST_ASSERT_EQUAL(1, default_sc.App_3.last_rx_msg.header.source);
             TEST_ASSERT_EQUAL(3, default_sc.App_3.last_rx_msg.header.target);
@@ -534,6 +595,7 @@ int main(int argc, char **argv)
     UNIT_TEST_RUN(unittest_Service_GenerateId);
     UNIT_TEST_RUN(unittest_Service_ClearId);
     UNIT_TEST_RUN(unittest_Service_GetIndex);
+    UNIT_TEST_RUN(unittest_Service_AddAutoUpdateTarget);
     UNIT_TEST_RUN(unittest_Service_RmAutoUpdateTarget);
     UNIT_TEST_RUN(unittest_Service_AutoUpdateManager);
     UNIT_TEST_RUN(unittest_Service_GetConcerned);
diff --git a/test/tests_io/test_luos_io/main.c b/test/tests_io/test_luos_io/main.c
@@ -723,12 +723,13 @@ void unittest_luosIO_ConsumeMsg()
             Luos_handled_job  = NULL;
             Robus_handled_job = NULL;
 
-            Node_Get()->node_id                          = 1;
-            service_ctx.number                           = 2;
-            service_ctx.list[0].id                       = 1;
-            service_ctx.list[0].auto_refresh.target      = 0;
-            service_ctx.list[0].auto_refresh.time_ms     = 0;
-            service_ctx.list[0].auto_refresh.last_update = 0;
+            Node_Get()->node_id                     = 1;
+            service_ctx.number                      = 2;
+            service_ctx.list[0].id                  = 1;
+            service_ctx.auto_refresh[0].service     = &service_ctx.list[0];
+            service_ctx.auto_refresh[0].target      = 0;
+            service_ctx.auto_refresh[0].time_ms     = 0;
+            service_ctx.auto_refresh[0].last_update = 0;
             // Generate the filters
             Service_GenerateId(1);
 
@@ -742,8 +743,8 @@ void unittest_luosIO_ConsumeMsg()
 
             // Check received message content
             TEST_ASSERT_EQUAL(SUCCEED, ret_val);
-            TEST_ASSERT_EQUAL(1, service_ctx.list[0].auto_refresh.target);
-            TEST_ASSERT_EQUAL((uint16_t)TimeOD_TimeTo_ms(time), service_ctx.list[0].auto_refresh.time_ms);
+            TEST_ASSERT_EQUAL(1, service_ctx.auto_refresh[0].target);
+            TEST_ASSERT_EQUAL((uint16_t)TimeOD_TimeTo_ms(time), service_ctx.auto_refresh[0].time_ms);
         }
         CATCH
         {

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ typedef struct`
`20`	`20`	`{`
`21`	`21`	`service_t list[MAX_LOCAL_SERVICE_NUMBER];`
`22`	`22`	`uint16_t number;`
	`23`	`+ timed_update_t auto_refresh[MAX_AUTO_REFRESH_NUMBER]; /!< service auto refresh context. /`
`23`	`24`	`} service_ctx_t;`
`24`	`25`
`25`	`26`	`/*******************************************************************************`
`@@ -107,11 +108,9 @@ void Service_ClearId(void)`
`107`	`108`	`{`
`108`	`109`	`for (uint16_t i = 0; i < service_ctx.number; i++)`
`109`	`110`	`{`
`110`		`- service_ctx.list[i].id = DEFAULTID;`
`111`		`- service_ctx.list[i].auto_refresh.target = 0;`
`112`		`- service_ctx.list[i].auto_refresh.time_ms = 0;`
`113`		`- service_ctx.list[i].auto_refresh.last_update = 0;`
	`111`	`+ service_ctx.list[i].id = DEFAULTID;`
`114`	`112`	`}`
	`113`	`+ memset((void )service_ctx.auto_refresh, 0, sizeof(timed_update_t) MAX_AUTO_REFRESH_NUMBER);`
`115`	`114`	`}`
`116`	`115`
`117`	`116`	`/******************************************************************************`
`@@ -125,20 +124,41 @@ uint16_t Service_GetIndex(service_t *service)`
`125`	`124`	`return ((uintptr_t)service - (uintptr_t)service_ctx.list) / sizeof(service_t);`
`126`	`125`	`}`
`127`	`126`
	`127`	`+/******************************************************************************`
	`128`	`+ * @brief Remove all services auto update targetting this service_id`
	`129`	`+ * @param service_id`
	`130`	`+ * @return None`
	`131`	`+ ******************************************************************************/`
	`132`	`+void Service_AddAutoUpdateTarget(service_t *service, uint16_t target, uint16_t time_ms)`
	`133`	`+{`
	`134`	`+ LUOS_ASSERT(service && (time_ms > 0) && (target != 0));`
	`135`	`+ for (uint16_t i = 0; i < MAX_AUTO_REFRESH_NUMBER; i++)`
	`136`	`+ {`
	`137`	`+ if (service_ctx.auto_refresh[i].time_ms == 0)`
	`138`	`+ {`
	`139`	`+ service_ctx.auto_refresh[i].service = service;`
	`140`	`+ service_ctx.auto_refresh[i].target = target;`
	`141`	`+ service_ctx.auto_refresh[i].time_ms = time_ms;`
	`142`	`+ service_ctx.auto_refresh[i].last_update = LuosHAL_GetSystick();`
	`143`	`+ return;`
	`144`	`+ }`
	`145`	`+ }`
	`146`	`+ // No more space for auto update`
	`147`	`+ LUOS_ASSERT(0);`
	`148`	`+}`
	`149`	`+`
`128`	`150`	`/******************************************************************************`
`129`	`151`	`* @brief Remove all services auto update targetting this service_id`
`130`	`152`	`* @param service_id`
`131`	`153`	`* @return None`
`132`	`154`	`******************************************************************************/`
`133`	`155`	`void Service_RmAutoUpdateTarget(uint16_t service_id)`
`134`	`156`	`{`
`135`		`- for (uint16_t i = 0; i < service_ctx.number; i++)`
	`157`	`+ for (uint16_t i = 0; i < MAX_AUTO_REFRESH_NUMBER; i++)`
`136`	`158`	`{`
`137`		`- if (service_ctx.list[i].auto_refresh.target == service_id)`
	`159`	`+ if (service_ctx.auto_refresh[i].target == service_id)`
`138`	`160`	`{`
`139`		`- service_ctx.list[i].auto_refresh.target = 0;`
`140`		`- service_ctx.list[i].auto_refresh.time_ms = 0;`
`141`		`- service_ctx.list[i].auto_refresh.last_update = 0;`
	`161`	`+ memset((void *)&service_ctx.auto_refresh[i], 0, sizeof(timed_update_t));`
`142`	`162`	`}`
`143`	`163`	`}`
`144`	`164`	`}`
`@@ -150,45 +170,44 @@ void Service_RmAutoUpdateTarget(uint16_t service_id)`
`150`	`170`	`******************************************************************************/`
`151`	`171`	`void Service_AutoUpdateManager(void)`
`152`	`172`	`{`
`153`		`- // Check all services timed_update_t contexts`
`154`		`- for (uint16_t i = 0; i < service_ctx.number; i++)`
	`173`	`+ // Check if detection is OK`
	`174`	`+ if (Node_GetState() != DETECTION_OK)`
`155`	`175`	`{`
`156`		`- // check if services have an actual ID. If not, we are in detection mode and should reset the auto refresh`
`157`		`- if (service_ctx.list[i].id == DEFAULTID)`
`158`		`- {`
`159`		`- // this service have not been detected or is in detection mode. remove auto_refresh parameters`
`160`		`- service_ctx.list[i].auto_refresh.target = 0;`
`161`		`- service_ctx.list[i].auto_refresh.time_ms = 0;`
`162`		`- service_ctx.list[i].auto_refresh.last_update = 0;`
`163`		`- }`
`164`		`- else`
	`176`	`+ // We have not been detected or we are in detection mode. remove auto_refresh parameters`
	`177`	`+ memset((void )&service_ctx.auto_refresh, 0, sizeof(timed_update_t) MAX_AUTO_REFRESH_NUMBER);`
	`178`	`+ }`
	`179`	`+ else`
	`180`	`+ {`
	`181`	`+ // Check all timed_update_t`
	`182`	`+ for (uint16_t i = 0; i < MAX_AUTO_REFRESH_NUMBER; i++)`
`165`	`183`	`{`
`166`	`184`	`// check if there is a timed update setted and if it's time to update it.`
`167`		`- if (service_ctx.list[i].auto_refresh.time_ms)`
	`185`	`+ if (service_ctx.auto_refresh[i].time_ms)`
`168`	`186`	`{`
`169`		`- if ((LuosHAL_GetSystick() - service_ctx.list[i].auto_refresh.last_update) >= service_ctx.list[i].auto_refresh.time_ms)`
	`187`	`+ if ((LuosHAL_GetSystick() - service_ctx.auto_refresh[i].last_update) >= service_ctx.auto_refresh[i].time_ms)`
`170`	`188`	`{`
`171`	`189`	`// This service need to send an update`
`172`	`190`	`// Create a fake message for it from the service asking for update`
`173`	`191`	`msg_t updt_msg;`
	`192`	`+ LUOS_ASSERT(service_ctx.auto_refresh[i].service);`
`174`	`193`	`updt_msg.header.config = BASE_PROTOCOL;`
`175`		`- updt_msg.header.target = service_ctx.list[i].id;`
`176`		`- updt_msg.header.source = service_ctx.list[i].auto_refresh.target;`
	`194`	`+ updt_msg.header.target = service_ctx.auto_refresh[i].service->id;`
	`195`	`+ updt_msg.header.source = service_ctx.auto_refresh[i].target;`
`177`	`196`	`updt_msg.header.target_mode = SERVICEIDACK;`
`178`	`197`	`updt_msg.header.cmd = GET_CMD;`
`179`	`198`	`updt_msg.header.size = 0;`
`180`		`- if ((service_ctx.list[i].service_cb != 0))`
	`199`	`+ if ((service_ctx.auto_refresh[i].service->service_cb != 0))`
`181`	`200`	`{`
`182`		`- service_ctx.list[i].service_cb(&service_ctx.list[i], &updt_msg);`
	`201`	`+ service_ctx.auto_refresh[i].service->service_cb(service_ctx.auto_refresh[i].service, &updt_msg);`
`183`	`202`	`}`
`184`	`203`	`else`
`185`	`204`	`{`
`186`	`205`	`if (Node_GetState() == DETECTION_OK)`
`187`	`206`	`{`
`188`		`- Luos_SendMsg(&service_ctx.list[i], &updt_msg);`
	`207`	`+ Luos_SendMsg(service_ctx.auto_refresh[i].service, &updt_msg);`
`189`	`208`	`}`
`190`	`209`	`}`
`191`		`- service_ctx.list[i].auto_refresh.last_update = LuosHAL_GetSystick();`
	`210`	`+ service_ctx.auto_refresh[i].last_update = LuosHAL_GetSystick();`
`192`	`211`	`}`
`193`	`212`	`}`
`194`	`213`	`}`