aws_iot.c

Go to the documentation of this file.

/*
 * Copyright 2023 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
/* clang-format off */
/* clang-format on */
 
#include <string.h>
#include "mmhal_app.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
}