move cumulative reset to RPC and wake main thread after reset

RPC is better suited than LightDB State for instructing the device to reset
its cumulative ontime count.

Wake the main thread after resetting cumulative ontime so that the sensor
read will immediately update the cloud with new (reset) cumulative values.
Before this change, we waited until the next scheduled sensor reading to
update the cloud copy of cumulative values.

Signed-off-by: Mike Szczys <mike@golioth.io>

Author: szczys

README.rst

@@ -152,6 +152,10 @@ The following RPCs can be initiated in the Remote Procedure Call menu of the
 ``reboot``
    Reboot the system.
 
+``reset_cumulative``
+   Reset the cumulative "on time" values stored on the device. After executing, the device will
+   update the cloud's ``state/cumulative`` values using the LightDB State service.
+
 ``set_log_level``
    Set the log level.
 
@@ -188,15 +192,11 @@ endpoint.
 Stateful Data (LightDB State)
 -----------------------------
 
-The concept of Digital Twin is demonstrated with the LightDB State via the ``desired`` and
-``actual`` endpoints.
+The concept of Digital Twin is demonstrated with the LightDB State via the ``state`` path.
 
 .. code-block:: json
 
    {
-     "desired": {
-       "reset_cumulative": false
-     },
      "state": {
        "cumulative": {
          "ch0": 138141,
@@ -209,12 +209,8 @@ The concept of Digital Twin is demonstrated with the LightDB State via the ``des
      }
    }
 
-* ``desired.reset_cumulative`` values may be changed from the cloud side. The device will recognize
-  when this endpoint is set to ``true``, clearing the stored ``cumulative`` values and writing the
-  ``reset_cumulative`` value to ``false`` to indicate the operation was completed.
-
-* ``actual`` values will be updated by the device. The cloud may read the ``actual`` endpoints to
-  determine device status, but only the device should ever write to the ``actual`` endpoints.
+* ``state`` values will be updated by the device. The cloud may read the ``state`` path to
+  determine device status, but only the device should ever write to that path.
 
 Hardware Variations
 *******************

src/app_rpc.c

@@ -14,6 +14,8 @@ LOG_MODULE_REGISTER(app_rpc, LOG_LEVEL_DBG);
 #include <zephyr/sys/reboot.h>
 
 #include <network_info.h>
+#include "main.h"
+#include "app_sensors.h"
 #include "app_rpc.h"
 
 static void reboot_work_handler(struct k_work *work)
@@ -96,6 +98,17 @@ static enum golioth_rpc_status on_reboot(zcbor_state_t *request_params_array,
 	return GOLIOTH_RPC_OK;
 }
 
+static enum golioth_rpc_status on_reset_cumulative(zcbor_state_t *request_params_array,
+						   zcbor_state_t *response_detail_map,
+						   void *callback_arg)
+{
+	LOG_INF("Request to reset cumulative values received. Processing now.");
+	reset_cumulative_totals();
+	wake_system_thread();
+
+	return GOLIOTH_RPC_OK;
+}
+
 static void rpc_log_if_register_failure(int err)
 {
 	if (err) {
@@ -115,6 +128,9 @@ void app_rpc_register(struct golioth_client *client)
 	err = golioth_rpc_register(rpc, "reboot", on_reboot, NULL);
 	rpc_log_if_register_failure(err);
 
+	err = golioth_rpc_register(rpc, "reset_cumulative", on_reset_cumulative, NULL);
+	rpc_log_if_register_failure(err);
+
 	err = golioth_rpc_register(rpc, "set_log_level", on_set_log_level, NULL);
 	rpc_log_if_register_failure(err);
 }

src/app_state.c

@@ -12,14 +12,14 @@ LOG_MODULE_REGISTER(app_state, LOG_LEVEL_DBG);
 #include <zcbor_decode.h>
 #include <zcbor_encode.h>
 
+#include "main.h"
 #include "app_sensors.h"
 #include "app_state.h"
 
 #define LIVE_RUNTIME_FMT "{\"live_runtime\":{\"ch0\":%lld,\"ch1\":%lld}"
 #define CUMULATIVE_RUNTIME_FMT ",\"cumulative\":{\"ch0\":%lld,\"ch1\":%lld}}"
 #define DEVICE_STATE_FMT LIVE_RUNTIME_FMT "}"
 #define DEVICE_STATE_FMT_CUMULATIVE LIVE_RUNTIME_FMT CUMULATIVE_RUNTIME_FMT
-#define DESIRED_RESET_KEY "reset_cumulative"
 
 static struct golioth_client *client;
 static struct ontime ot;
@@ -39,41 +39,6 @@ static void async_handler(struct golioth_client *client,
 	LOG_DBG("State successfully set");
 }
 
-static int app_state_reset_desired(void)
-{
-	int err;
-	uint8_t cbor_payload[32];
-	bool ok;
-
-	LOG_INF("Resetting \"%s\" LightDB State endpoint to defaults.", APP_STATE_DESIRED_ENDP);
-
-	ZCBOR_STATE_E(encoding_state, 16, cbor_payload, sizeof(cbor_payload), 0);
-	ok = zcbor_map_start_encode(encoding_state, 2) &&
-	     zcbor_tstr_put_lit(encoding_state, DESIRED_RESET_KEY) &&
-	     zcbor_bool_put(encoding_state, false) &&
-	     zcbor_map_end_encode(encoding_state, 2);
-
-	if (!ok) {
-		LOG_ERR("Error encoding CBOR to reset desired endpoint");
-		return -ENODATA;
-	}
-
-	size_t cbor_len = encoding_state->payload - cbor_payload;
-	LOG_HEXDUMP_DBG(cbor_payload, cbor_len, "cbor_payload");
-
-	err = golioth_lightdb_set_async(client,
-					APP_STATE_DESIRED_ENDP,
-					GOLIOTH_CONTENT_TYPE_CBOR,
-					cbor_payload,
-					cbor_len,
-					async_handler,
-					NULL);
-	if (err) {
-		LOG_ERR("Unable to write to LightDB State: %d", err);
-	}
-	return err;
-}
-
 static int app_state_update_actual(void)
 {
 	int err;
@@ -148,76 +113,12 @@ int app_state_report_ontime(adc_node_t *ch0, adc_node_t *ch1)
 	return 0;
 }
 
-static void app_state_desired_handler(struct golioth_client *client,
-				      const struct golioth_response *response,
-				      const char *path,
-				      const uint8_t *payload,
-				      size_t payload_size,
-				      void *arg)
-{
-	if (response->status != GOLIOTH_OK) {
-		LOG_ERR("Failed to receive '%s' endpoint: %d",
-			APP_STATE_DESIRED_ENDP,
-			response->status);
-		return;
-	}
-
-	LOG_HEXDUMP_DBG(payload, payload_size, APP_STATE_DESIRED_ENDP);
-
-	if ((payload_size == 1) && (payload[0] == 0xf6)) {
-		/* This is `null` in CBOR */
-		LOG_ERR("Endpoint is null, resetting desired to defaults");
-		app_state_reset_desired();
-		return;
-	}
-
-	struct zcbor_string key;
-	bool reset_cumulative;
-	bool ok;
-
-	ZCBOR_STATE_D(decoding_state, 1, payload, payload_size, 1, NULL);
-	ok = zcbor_map_start_decode(decoding_state) &&
-	     zcbor_tstr_decode(decoding_state, &key) &&
-	     zcbor_bool_decode(decoding_state, &reset_cumulative) &&
-	     zcbor_map_end_decode(decoding_state);
-
-	if (!ok) {
-		LOG_ERR("ZCBOR Decoding Error");
-		LOG_HEXDUMP_ERR(payload, payload_size, "cbor_payload");
-		app_state_reset_desired();
-		return;
-	}
-
-	if (strncmp(key.value, DESIRED_RESET_KEY, strlen(DESIRED_RESET_KEY)) != 0) {
-		LOG_ERR("Unexpected key received: %.*s", key.len, key.value);
-		app_state_reset_desired();
-		return;
-	}
-
-	LOG_DBG("Decoded: %.*s == %s", key.len, key.value, reset_cumulative ? "true" : "false");
-	if (reset_cumulative) {
-		LOG_INF("Request to reset cumulative values received. Processing now.");
-		reset_cumulative_totals();
-		app_state_reset_desired();
-	}
-}
-
 int app_state_observe(struct golioth_client *state_client)
 {
 	int err;
 
 	client = state_client;
 
-	err = golioth_lightdb_observe_async(client,
-					    APP_STATE_DESIRED_ENDP,
-					    GOLIOTH_CONTENT_TYPE_CBOR,
-					    app_state_desired_handler,
-					    NULL);
-	if (err) {
-		LOG_WRN("failed to observe lightdb path: %d", err);
-		return err;
-	}
-
 	/* This will only run once. It updates the actual state of the device
 	 * with the Golioth servers. Future updates will be sent whenever
 	 * changes occur.