wnm_sleep.c

Go to the documentation of this file.

/*
 * Copyright 2023 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include <string.h>
#include "mmhal_app.h"
#include "mmosal.h"
#include "mmwlan.h"
#include "mmping.h"
#include "mmconfig.h"
#include "mmutils.h"
 
#include "mmipal.h"
 
#include "mm_app_common.h"
 
/* Default Application configurations. These are used if the required parameters cannot be found in
 * the configstore*/
#ifndef DEFAULT_PING_COUNT
#define DEFAULT_PING_COUNT 10
#endif
#ifndef DEFAULT_PING_DATA_SIZE
#define DEFAULT_PING_DATA_SIZE 56
#endif
#ifndef DEFAULT_PING_INTERVAL_MS
#define DEFAULT_PING_INTERVAL_MS 1000
#endif
#ifndef DEFAULT_WNM_SLEEP_DURATION_MS
#define DEFAULT_WNM_SLEEP_DURATION_MS 20000
#endif
#ifndef POST_PING_DELAY_MS
#define POST_PING_DELAY_MS 10000
#endif
#ifndef UPDATE_INTERVAL_MS
#define UPDATE_INTERVAL_MS (5000)
#endif
 
#define MIN_WNM_SLEEP_EXIT_STATE_DURATION_MS 20
 
#if defined(ENABLE_PWR_MEAS) && ENABLE_PWR_MEAS
#define PWR_MEAS_DELAY_MS(delay_ms) mmosal_task_sleep(delay_ms)
#define SET_DEBUG_STATE(state) mmhal_set_debug_pins(MMHAL_ALL_DEBUG_PINS, state);
#else
#define PWR_MEAS_DELAY_MS(delay_ms) MM_UNUSED(delay_ms)
#define SET_DEBUG_STATE(state)      MM_UNUSED(state)
#endif
 
enum debug_state
{
    DEBUG_STATE_INIT = 0x00,
    DEBUG_STATE_CONNECTING = 0x01,
    DEBUG_STATE_CONNECTED = 0x03,
    DEBUG_STATE_PINGING_0 = 0x02,
    DEBUG_STATE_PING_0_DONE = 0x00,
    DEBUG_STATE_WNM_SLEEP = 0x01,
    DEBUG_STATE_EXITING_WNM_SLEEP = 0x03,
    DEBUG_STATE_WNM_SLEEP_DONE = 0x02,
    DEBUG_STATE_PINGING_1 = 0x00,
    DEBUG_STATE_PING_1_DONE = 0x01,
    DEBUG_STATE_WNM_SLEEP_POWER_DOWN = 0x03,
    DEBUG_STATE_EXITING_WNM_SLEEP_POWER_DOWN = 0x02,
    DEBUG_STATE_WNM_SLEEP_POWER_DOWN_DONE = 0x00,
    DEBUG_STATE_TERMINATING = 0x01,
};
 
static void execute_ping_request(int iteration)
{
    struct mmping_args args = MMPING_ARGS_DEFAULT;
 
    SET_DEBUG_STATE(iteration == 0 ? DEBUG_STATE_PINGING_0 : DEBUG_STATE_PINGING_1);
 
    /* Get the target IP */
    struct mmipal_ip_config ip_config = MMIPAL_IP_CONFIG_DEFAULT;
    enum mmipal_status status = mmipal_get_ip_config(&ip_config);
    if (status == MMIPAL_SUCCESS)
    {
        memcpy(args.ping_target, ip_config.gateway_addr, sizeof(ip_config.gateway_addr));
    }
    else
    {
        printf("Failed to retrieve IP config\n");
    }
    /* If ping.target is set, we use it as an override */
    (void)mmconfig_read_string("ping.target", args.ping_target, sizeof(args.ping_target));
 
    status = mmipal_get_local_addr(args.ping_src, args.ping_target);
    if (status != MMIPAL_SUCCESS)
    {
        printf("failed to get local address for PING\n");
    }
 
    args.ping_count = DEFAULT_PING_COUNT;
    mmconfig_read_uint32("ping.count", &args.ping_count);
 
    args.ping_size = DEFAULT_PING_DATA_SIZE;
    mmconfig_read_uint32("ping.target", &args.ping_size);
 
    args.ping_interval_ms = DEFAULT_PING_INTERVAL_MS;
    mmconfig_read_uint32("ping.interval", &args.ping_interval_ms);
 
    mmping_start(&args);
    printf("\nPing %s %lu(%lu) bytes of data.\n",
           args.ping_target,
           args.ping_size,
           MMPING_ICMP_ECHO_HDR_LEN + args.ping_size);
 
    struct mmping_stats stats;
    uint32_t next_update_time_ms = mmosal_get_time_ms() + UPDATE_INTERVAL_MS;
    unsigned last_ping_recv_count = 0;
    mmping_stats(&stats);
    while (stats.ping_is_running)
    {
        mmosal_task_sleep(args.ping_interval_ms / 2);
        mmping_stats(&stats);
        if (stats.ping_recv_count != last_ping_recv_count ||
            mmosal_time_has_passed(next_update_time_ms))
        {
            printf("(%s) packets transmitted/received = %lu/%lu, "
                   "round-trip min/avg/max = %lu/%lu/%lu ms\n",
                   stats.ping_receiver,
                   stats.ping_total_count,
                   stats.ping_recv_count,
                   stats.ping_min_time_ms,
                   stats.ping_avg_time_ms,
                   stats.ping_max_time_ms);
            last_ping_recv_count = stats.ping_recv_count;
            next_update_time_ms = mmosal_get_time_ms() + UPDATE_INTERVAL_MS;
        }
    }
    uint32_t loss = 0;
    if (stats.ping_total_count == 0)
    {
        loss = 0;
    }
    else
    {
        loss = (1000 *
                (stats.ping_total_count - stats.ping_recv_count) *
                100 /
                stats.ping_total_count);
    }
 
    SET_DEBUG_STATE(iteration == 0 ? DEBUG_STATE_PING_0_DONE : DEBUG_STATE_PING_1_DONE);
 
    printf("\n--- %s ping statistics ---\n%lu packets transmitted, %lu packets received, ",
           stats.ping_receiver,
           stats.ping_total_count,
           stats.ping_recv_count);
    printf("%lu.%03lu%% packet loss\nround-trip min/avg/max = %lu/%lu/%lu ms\n",
           loss / 1000,
           loss % 1000,
           stats.ping_min_time_ms,
           stats.ping_avg_time_ms,
           stats.ping_max_time_ms);
}
 
static void execute_wnm_sleep(uint32_t wnm_sleep_duration_ms)
{
    enum mmwlan_status status = MMWLAN_ERROR;
 
    printf("\nEntering WNM sleep with chip power down disabled\n");
    printf("Expected sleep time %lums.\n", wnm_sleep_duration_ms);
    /* Delay to allow printf's to settle so we measure only idle current */
    PWR_MEAS_DELAY_MS(100);
 
    SET_DEBUG_STATE(DEBUG_STATE_WNM_SLEEP);
 
    uint32_t timestamp = mmosal_get_time_ms();
    status = mmwlan_set_wnm_sleep_enabled(true);
    uint32_t wnm_sleep_enable_duration_ms = mmosal_get_time_ms() - timestamp;
    if (status != MMWLAN_SUCCESS)
    {
        printf("Failed to enable WNM sleep\n");
        return;
    }
 
    mmosal_task_sleep(wnm_sleep_duration_ms);
 
    timestamp = mmosal_get_time_ms();
 
    SET_DEBUG_STATE(DEBUG_STATE_EXITING_WNM_SLEEP);
    status = mmwlan_set_wnm_sleep_enabled(false);
 
    uint32_t sleep_exit_duration = mmosal_get_time_ms() - timestamp;
    int32_t exit_duration_delta = MIN_WNM_SLEEP_EXIT_STATE_DURATION_MS - sleep_exit_duration;
    if (exit_duration_delta > 0)
    {
        PWR_MEAS_DELAY_MS(exit_duration_delta);
    }
    SET_DEBUG_STATE(DEBUG_STATE_WNM_SLEEP_DONE);
 
    if (status == MMWLAN_SUCCESS)
    {
        printf("\nEnter WNM sleep took %lu ms.\n", wnm_sleep_enable_duration_ms);
        printf("\nExit WNM sleep took %lu ms.\n", sleep_exit_duration);
    }
    else
    {
        printf("Failed to disable WNM sleep\n");
    }
}
 
static void execute_wnm_sleep_ext(uint32_t wnm_sleep_duration_ms)
{
    enum mmwlan_status status = MMWLAN_ERROR;
    struct mmwlan_set_wnm_sleep_enabled_args wnm_sleep_args =
        MMWLAN_SET_WNM_SLEEP_ENABLED_ARGS_INIT;
 
    printf("\nEntering WNM sleep with chip power down enabled.\n");
    printf("Expected sleep time %lums.\n", wnm_sleep_duration_ms);
    /* Delay to allow printf's to settle so we measure only idle current */
    PWR_MEAS_DELAY_MS(100);
    SET_DEBUG_STATE(DEBUG_STATE_WNM_SLEEP_POWER_DOWN);
 
    uint32_t timestamp = mmosal_get_time_ms();
    wnm_sleep_args.wnm_sleep_enabled = true;
    wnm_sleep_args.chip_powerdown_enabled = true;
    status = mmwlan_set_wnm_sleep_enabled_ext(&wnm_sleep_args);
    uint32_t wnm_sleep_enable_duration_ms = mmosal_get_time_ms() - timestamp;
    if (status != MMWLAN_SUCCESS)
    {
        printf("Failed to enable WNM sleep\n");
        return;
    }
 
    mmosal_task_sleep(wnm_sleep_duration_ms);
 
    timestamp = mmosal_get_time_ms();
    wnm_sleep_args.wnm_sleep_enabled = false;
 
    SET_DEBUG_STATE(DEBUG_STATE_EXITING_WNM_SLEEP_POWER_DOWN);
    status = mmwlan_set_wnm_sleep_enabled_ext(&wnm_sleep_args);
 
    uint32_t sleep_exit_duration = mmosal_get_time_ms() - timestamp;
    int32_t exit_duration_delta = MIN_WNM_SLEEP_EXIT_STATE_DURATION_MS - sleep_exit_duration;
    if (exit_duration_delta > 0)
    {
        PWR_MEAS_DELAY_MS(exit_duration_delta);
    }
 
    SET_DEBUG_STATE(DEBUG_STATE_WNM_SLEEP_POWER_DOWN_DONE);
 
    if (status == MMWLAN_SUCCESS)
    {
        printf("\nEnter WNM sleep took %lu ms.\n", wnm_sleep_enable_duration_ms);
        printf("\nExit WNM sleep took %lu ms.\n", sleep_exit_duration);
    }
    else
    {
        printf("Failed to disable WNM sleep\n");
    }
}
 
void app_init(void)
{
    printf("\n\nMorse WNM Sleep Demo (Built " __DATE__ " " __TIME__ ")\n\n");
 
    /* Initialize and connect to Wi-Fi, blocks till connected */
    app_wlan_init();
 
    SET_DEBUG_STATE(DEBUG_STATE_CONNECTING);
 
    app_wlan_start();
 
    PWR_MEAS_DELAY_MS(150);
 
    SET_DEBUG_STATE(DEBUG_STATE_CONNECTED);
 
    /* Delay to allow communications to settle so we measure only idle current */
    PWR_MEAS_DELAY_MS(600);
 
    uint32_t wnm_sleep_duration_ms = DEFAULT_WNM_SLEEP_DURATION_MS;
    mmconfig_read_uint32("wlan.wnm_sleep_duration_ms", &wnm_sleep_duration_ms);
 
    execute_ping_request(0);
 
    /* The following demonstrates basic WNM Sleep functionality. The MM chip remains powered,
     * but does not wake up to receive beacons. */
    execute_wnm_sleep(wnm_sleep_duration_ms);
 
    execute_ping_request(1);
 
    /* The following demonstrates extended WNM Sleep API that allows the chip to be shutdown
     * while in WNM Sleep. */
    execute_wnm_sleep_ext(wnm_sleep_duration_ms);
 
    /* Delay to allow communications to settle so we measure only idle current */
    PWR_MEAS_DELAY_MS(150);
 
    SET_DEBUG_STATE(DEBUG_STATE_TERMINATING);
 
    /* Disconnect from Wi-Fi */
    app_wlan_stop();
}