aws_iot.c

Go to the documentation of this file.

/*
 * Copyright 2023 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include <string.h>
#include "mmhal.h"
#include "mmosal.h"
#include "mmconfig.h"
#include "mm_app_loadconfig.h"
#include "mmipal.h"
#include "mqtt_agent_task.h"
#if defined(ENABLE_SHADOW_APP) && ENABLE_SHADOW_APP
#include "shadow_device_task.h"
#endif
#if defined(ENABLE_OTA_APP) && ENABLE_OTA_APP
#include "ota_update_task.h"
#endif
#if defined(ENABLE_PROVISIONING_APP) && ENABLE_PROVISIONING_APP
#include "fleet_provisioning_task.h"
#endif
#include "sntp_client.h"
#include "core_json.h"
#include "mm_app_common.h"
#include "aws_iot_config.h"
 
#define NTP_MIN_TIMEOUT             3000
#define NTP_MIN_BACKOFF             60000
#define NTP_MIN_BACKOFF_JITTER      3000
#define NTP_MAX_BACKOFF_JITTER      60000
 
#define SHADOW_PUBLISH_JSON               \
    "{"                                   \
        "\"state\":{"                     \
            "\"reported\":{"              \
                "\"powerOn\":%lu"         \
            "}"                           \
        "},"                              \
        "\"clientToken\":\"%06lu\""       \
    "}"
 
#if defined(ENABLE_OTA_APP) && ENABLE_OTA_APP
void ota_preupdate_callback(void)
{
    /* An OTA update has been triggered, print a message notifying the user */
    printf("An OTA update has been triggered, downloading the file in the background...\n");
 
    /* Perform any cleanup for the file system such as deleting logs, uploading data, etc.
     * If the device runs out of space in the filesystem while downloading the update then
     * the update will fail. You may block till cleanup is completed. */
}
 
void ota_postupdate_callback(const char *update_file, int status)
{
    (void)update_file;
 
    if (status == 0)
    {
        printf("OTA Update completed successfully\n");
    }
    else
    {
        printf("OTA Update failed with error code %d\n", status);
    }
}
#endif
 
#if defined(ENABLE_SHADOW_APP) && ENABLE_SHADOW_APP
 
static uint32_t ulCurrentPowerOnState = 0;
 
static uint32_t ulDesiredPowerOnState = 0;
 
struct mmosal_sem *state_change_sem = NULL;
 
void shadow_update_callback(char *json, size_t json_len,
                            enum shadow_update_status status)
{
    /* Make sure the payload is a valid json document. */
    int result = JSON_Validate(json, json_len);
 
    if (result != JSONSuccess)
    {
        printf("ERR:Invalid JSON document received\n");
        return;
    }
 
    static uint32_t ulCurrentVersion = 0; /* Remember the latest version number we've received */
    char *pcOutValue = NULL;
    uint32_t ulOutValueLength = 0UL;
    uint32_t ulVersion = 0;
    uint32_t ulCode = 0;
 
    switch (status)
    {
    case UPDATE_DELTA:
        /* The json will look similar to this:
         * @code
         * {
         *      "state": {
         *          "powerOn": 1
         *      },
         *      "metadata": {
         *          "powerOn": {
         *              "timestamp": 1595437367
         *          }
         *      },
         *      "timestamp": 1595437367,
         *      "clientToken": "388062",
         *      "version": 12
         * }
         * @endcode
         */
 
        /* Obtain the version value. */
        result = JSON_Search(json, json_len,
                             "version", strlen("version"),
                             &pcOutValue,
                             (size_t *)&ulOutValueLength);
 
        if (result != JSONSuccess)
        {
            printf("ERR:Version field not found in JSON document\n");
            return;
        }
        /* Convert the extracted value to an unsigned integer value. */
        ulVersion = (uint32_t)strtoul(pcOutValue, NULL, 10);
        /* Make sure the version is newer than the last one we received. */
        if (ulVersion <= ulCurrentVersion)
        {
            /* In this demo, we discard the incoming message
             * if the version number is not newer than the latest
             * that we've received before. Your application may use a
             * different approach. */
            printf("ERR:Received unexpected delta update with version %u, "
                   "current version is %u\n",
                   (unsigned int)ulVersion,
                   (unsigned int)ulCurrentVersion);
            return;
        }
        /* Set received version as the current version. */
        ulCurrentVersion = ulVersion;
 
        /* Get powerOn state from json documents. */
        result = JSON_Search(json, json_len,
                             "state.powerOn",
                             sizeof("state.powerOn") - 1,
                             &pcOutValue,
                             (size_t *)&ulOutValueLength);
 
        if (result != JSONSuccess)
        {
            printf("ERR:powerOn field not found in JSON document\n");
        }
        else
        {
            /* Convert the powerOn state value to an unsigned integer value. */
            ulDesiredPowerOnState = (uint32_t)strtoul(pcOutValue, NULL, 10);
 
            /* Signal user task about change of state */
            mmosal_sem_give(state_change_sem);
        }
        break;
 
    case UPDATE_ACCEPTED:
        /* Handle the reported state with state change in /update/accepted topic.
         * Thus we will retrieve the client token from the JSON document to see if
         * it's the same one we sent with reported state on the /update topic.
         * The payload will look similar to this:
         * @code
         *  {
         *      "state": {
         *          "reported": {
         *             "powerOn": 1
         *          }
         *      },
         *      "metadata": {
         *          "reported": {
         *              "powerOn": {
         *                  "timestamp": 1596573647
         *              }
         *          }
         *      },
         *      "version": 14698,
         *      "timestamp": 1596573647,
         *      "clientToken": "022485"
         *  }
         * @endcode
         */
 
        /* We do not need to do anything here unless we want to implement positive confirmation
         * that our reported state was received and acted on by the server. In which case ensure
         * you check that the @c clientToken matches the one we sent in the report. */
        break;
 
    case UPDATE_REJECTED:
        /* The payload will look similar to this:
         * {
         *    "code": error-code,
         *    "message": "error-message",
         *    "timestamp": timestamp,
         *    "clientToken": "token"
         * }
         */
 
        /*  Obtain the error code. */
        result = JSON_Search(json, json_len,
                             "code",
                             sizeof("code") - 1,
                             &pcOutValue,
                             (size_t *)&ulOutValueLength);
 
        /* Convert the code to an unsigned integer value. */
        ulCode = (uint32_t)strtoul(pcOutValue, NULL, 10);
 
        printf("ERR:Received rejected response code %lu\n",
               ulCode);
 
        /*  Obtain the message string. */
        result = JSON_Search(json, json_len,
                             "message",
                             sizeof("message") - 1,
                             &pcOutValue,
                             (size_t *)&ulOutValueLength);
        printf("    Message: %.*s\n", (int)ulOutValueLength, pcOutValue);
 
        break;
    }
}
 
void aws_shadow_loop(char *shadow_name)
{
    for (;;)
    {
        mmosal_sem_wait(state_change_sem, UINT32_MAX);
 
        if (ulDesiredPowerOnState == 1)
        {
            /* Set the new powerOn state. */
            printf("INF:Setting powerOn state to 1.\n");
            mmhal_set_led(LED_BLUE, LED_ON);
            ulCurrentPowerOnState = ulDesiredPowerOnState;
        }
        else if (ulDesiredPowerOnState == 0)
        {
            /* Set the new powerOn state. */
            printf("INF:Setting powerOn state to 0.\n");
            mmhal_set_led(LED_BLUE, LED_OFF);
            ulCurrentPowerOnState = ulDesiredPowerOnState;
        }
        else
        {
            /* Set the new powerOn state. */
            printf("ERR:Invalid power state %lu requested.\n", ulDesiredPowerOnState);
        }
 
        char UpdateDocument[MAX_JSON_LEN];
        printf("INF:Reporting change in PowerOn state to %lu.\n", ulCurrentPowerOnState);
 
        /* Create a new client token and save it for use in the callbacks */
        uint32_t ulClientToken = (mmosal_get_time_ticks() % 1000000);
 
        /* Generate update report. */
        (void)memset(UpdateDocument, 0x00, sizeof(UpdateDocument));
        snprintf(UpdateDocument, MAX_JSON_LEN, SHADOW_PUBLISH_JSON,
                 ulCurrentPowerOnState, ulClientToken);
 
        /* Send update. */
        aws_publish_shadow(shadow_name, UpdateDocument);
 
        printf("INF:Publishing to /update with following client token %lu.\n", ulClientToken);
    }
}
#endif
 
void app_init(void)
{
    printf("\n\nMorse AWS IoT Demo (Built " __DATE__ " " __TIME__ ")\n\n");
 
    /* Initialize and connect to Wi-Fi, blocks till connected */
    app_wlan_init();
    app_wlan_start();
 
    /* Wi-Fi is connected, sync to NTP - required for certificate expiry validation */
    char sntp_server[64];
    strncpy(sntp_server, "0.pool.ntp.org", sizeof(sntp_server)); /* default if key is not found */
    (void)mmconfig_read_string("sntp.server", sntp_server, sizeof(sntp_server));
    sntp_sync_with_backoff(sntp_server, NTP_MIN_TIMEOUT, NTP_MIN_BACKOFF,
                           NTP_MIN_BACKOFF_JITTER, NTP_MAX_BACKOFF_JITTER, UINT32_MAX);
 
    /* Display current time */
    time_t now;
    now = mmhal_get_time();
    printf("Current Time (UTC) is : %s\r\n", ctime(&now));
 
    /* First spool up the MQTT agent task */
    start_mqtt_agent_task();
 
    /* Look for shadow name in config store, if none found use classic shadow (NULL) */
    char *shadow_name = NULL;
    mmconfig_alloc_and_load(AWS_KEY_SHADOW_NAME, (void **)&shadow_name);
 
    /* Check if fleet provisioning is needed */
    if (mmconfig_read_string(AWS_KEY_THING_NAME, NULL, 0) < 0)
    {
#if defined(ENABLE_PROVISIONING_APP) && ENABLE_PROVISIONING_APP
        /* Ensure provisioning template is set */
        if (mmconfig_read_string(AWS_KEY_PROVISIONING_TEMPLATE, NULL, 0) > 0)
        {
            /* Device not registered, so start fleet provisioning, returns only on failure. */
            printf("Initiating fleet provisioning...\n");
            do_fleet_provisioning();
            printf("Failed to provision device, unable to continue.\n"
                   "Please see getting started guide on how to provision.\n");
            return;
        }
#else
        printf("Device is not provisioned, "
               "please see getting started guide on how to provision.\n");
#endif
    }
 
#if defined(ENABLE_OTA_APP) && ENABLE_OTA_APP
    /* Now spool up the OTA task */
    start_ota_update_task(ota_preupdate_callback, ota_postupdate_callback);
#endif
 
#if defined(ENABLE_SHADOW_APP) && ENABLE_SHADOW_APP
    state_change_sem = mmosal_sem_create(1, 1, "state_change_sem");
 
    /* Start the device shadow processing loop */
    aws_create_shadow(shadow_name, shadow_update_callback);
    aws_shadow_loop(shadow_name);
#endif
}