something

Author: simensrostad

app/prj.conf

@@ -210,3 +210,6 @@ CONFIG_TASK_WDT_MIN_TIMEOUT=10000
 # Device power management
 CONFIG_PM_DEVICE=y
 CONFIG_PM_DEVICE_SHELL=y
+
+# JSON library
+CONFIG_JSON_LIBRARY=y

app/src/main.c

@@ -32,6 +32,8 @@
 #define POWER_MSG_SIZE	0
 #endif /* CONFIG_APP_POWER */
 
+#define UPDATE_INTERVAL_STRING_FORMAT "{\"config\": {\"update_interval\": %d}}"
+
 /* Register log module */
 LOG_MODULE_REGISTER(main, CONFIG_APP_LOG_LEVEL);
 
@@ -232,6 +234,54 @@ static const struct smf_state states[] = {
 };
 
 /* Static helper function */
+static int get_update_interval_from_json(const uint8_t *json, size_t json_len, uint64_t *interval_sec)
+{
+	int err;
+
+// #include <zephyr/kernel.h>
+// #include <zephyr/data/json.h>
+// #include <stdio.h>
+
+// struct config {
+//     int update_interval;
+// };
+
+// // Define the expected JSON structure
+// static const struct json_obj_descr config_descr[] = {
+//     JSON_OBJ_DESCR_PRIM(struct config, update_interval, JSON_TOK_NUMBER),
+// };
+
+// struct root {
+//     struct config config;
+// };
+
+// // Define the full JSON structure
+// static const struct json_obj_descr root_descr[] = {
+//     JSON_OBJ_DESCR_OBJECT(struct root, config, config_descr),
+// };
+
+// int main(void) {
+//     const char *json_string = "{\"config\": {\"update_interval\": 30}}";
+
+//     struct root parsed_data = {0};  // Initialize struct
+
+//     // Parse JSON string
+//     int ret = json_obj_parse(json_string, strlen(json_string), root_descr,
+//                              ARRAY_SIZE(root_descr), &parsed_data);
+
+//     if (ret >= 0) {
+//         printf("Update Interval: %d\n", parsed_data.config.update_interval);
+//     } else {
+//         printf("Failed to parse JSON, error code: %d\n", ret);
+//     }
+
+//     return 0;
+// }
+
+
+	return 0;
+}
+
 static void task_wdt_callback(int channel_id, void *user_data)
 {
 	LOG_ERR("Watchdog expired, Channel: %d, Thread: %s",
@@ -441,6 +491,7 @@ static void triggering_entry(void *o)
 
 static void triggering_run(void *o)
 {
+	int err;
 	struct main_state *state_object = o;
 
 	if (state_object->chan == &CLOUD_CHAN) {
@@ -454,13 +505,18 @@ static void triggering_run(void *o)
 		}
 
 		if (msg.type == CLOUD_SHADOW_RESPONSE) {
-			/* Missing: Parse the interval received in the shadow response,
-			 * write to state object and schedule new interval
-			 */
 
-			int err = k_work_reschedule(&trigger_work,
-						    K_SECONDS(state_object->interval_sec));
+			err = get_update_interval_from_json(msg.response.buffer,
+							    msg.response.buffer_len,
+							    &state_object->interval_sec);
+			if (err) {
+				LOG_ERR("json_parse, error: %d", err);
+				SEND_FATAL_ERROR();
+				return;
+			}
 
+			err = k_work_reschedule(&trigger_work,
+						K_SECONDS(state_object->interval_sec));
 			if (err < 0) {
 				LOG_ERR("k_work_reschedule, error: %d", err);
 				SEND_FATAL_ERROR();

app/src/modules/cloud/cloud_module.c

@@ -491,7 +491,37 @@ static void shadow_get(bool delta_only)
 		return;
 	}
 
-	/* No further processing of shadow is implemented */
+	/* Distribute the received shadow configuration and report back the adopted
+	 * configurations thereby clearing the shadow delta
+	 */
+	struct cloud_msg msg = {
+		.type = CLOUD_SHADOW_RESPONSE,
+	};
+
+	__BUILD_ASSERT(sizeof(msg.response.buffer) >= sizeof(recv_buf),
+		       "Buffer size must be large enough to hold the received data");
+
+	memcpy(msg.response.buffer, recv_buf, recv_buf_len);
+	msg.response.buffer_len = recv_buf_len;
+
+	err = zbus_chan_pub(&CLOUD_CHAN, &msg, K_SECONDS(1));
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+	}
+
+	err = nrf_cloud_coap_patch("state/reported", NULL,
+				   msg.response.buffer,
+				   msg.response.buffer_len,
+				   COAP_CONTENT_FORMAT_APP_JSON,
+				   true,
+				   NULL,
+				   NULL);
+	if (err < 0) {
+		LOG_ERR("Failed to send PATCH request: %d", err);
+	} else if (err > 0) {
+		LOG_ERR("Error from the server: %d", err);
+	}
 }
 
 static void state_connected_ready_entry(void *o)

app/src/modules/cloud/cloud_module.h

@@ -43,6 +43,7 @@ enum cloud_msg_type {
 struct cloud_msg {
 	enum cloud_msg_type type;
 	struct cloud_payload payload;
+	struct cloud_shadow_response response;
 };
 
 #define MSG_TO_CLOUD_MSG(_msg)	(*(const struct cloud_msg *)_msg)

tests/module/main/src/main.c

@@ -141,19 +141,17 @@ static void send_location_search_done(void)
 	TEST_ASSERT_EQUAL(0, err);
 }
 
-/*
 static void send_config(uint64_t interval)
 {
-	const struct configuration config = {
-		.update_interval_present = true,
-		.update_interval = interval,
+	const struct cloud_msg msg = {
+		.type = CLOUD_SHADOW_RESPONSE,
+		.response.buffer_len = "sometinhg"
 	};
 
-	int err = zbus_chan_pub(&CONFIG_CHAN, &config, K_SECONDS(1));
+	int err = zbus_chan_pub(&CLOUD_CHAN, &shadow_response, K_SECONDS(1));
 
 	TEST_ASSERT_EQUAL(0, err);
 }
-*/
 
 static void send_cloud_disconnected(void)
 {
@@ -214,7 +212,6 @@ void test_button_press_on_disconnected(void)
 	check_no_events(7200);
 }
 
-/*
 void test_trigger_interval_change_in_connected(void)
 {
 	send_cloud_connected_ready_to_send();
@@ -230,9 +227,8 @@ void test_trigger_interval_change_in_connected(void)
 	send_cloud_disconnected();
 	check_no_events(WEEK_IN_SECONDS);
 }
-*/
 
-/*
+
 void test_trigger_disconnect_and_connect_when_triggering(void)
 {
 	send_cloud_connected_ready_to_send();
@@ -255,7 +251,6 @@ void test_trigger_disconnect_and_connect_when_triggering(void)
 	send_cloud_disconnected();
 	check_no_events(WEEK_IN_SECONDS);
 }
-*/
 
 /* This is required to be added to each test. That is because unity's
  * main may return nonzero, while zephyr's main currently must