ping.c

Go to the documentation of this file.

/*
 * Copyright 2021-2023 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include <string.h>
#include "mmhal_app.h"
#include "mmosal.h"
#include "mmwlan.h"
#include "mmconfig.h"
#include "mmping.h"
#include "mmutils.h"
 
#include "mmipal.h"
 
#include "mm_app_common.h"
 
/* Ping configurations. */
#ifndef PING_COUNT
#define PING_COUNT 10
#endif
#ifndef PING_DATA_SIZE
#define PING_DATA_SIZE 56
#endif
#ifndef PING_INTERVAL_MS
#define PING_INTERVAL_MS 1000
#endif
#ifndef POST_PING_DELAY_MS
#define POST_PING_DELAY_MS 10000
#endif
#ifndef UPDATE_INTERVAL_MS
#define UPDATE_INTERVAL_MS (5000)
#endif
 
#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_BOOTING_CHIP = 0x01,
    DEBUG_STATE_CONNECTING = 0x03,
    DEBUG_STATE_CONNECTED = 0x02,
    DEBUG_STATE_CONNECTED_IDLE = 0x00,
    DEBUG_STATE_PINGING = 0x02,
    DEBUG_STATE_PING_DONE = 0x03,
    DEBUG_STATE_IDLE = 0x01,
    DEBUG_STATE_TERMINATING = 0x00,
};
 
void app_init(void)
{
    struct mmping_args args = MMPING_ARGS_DEFAULT;
 
    SET_DEBUG_STATE(DEBUG_STATE_BOOTING_CHIP);
 
    printf("\n\nMorse Ping 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);
 
    SET_DEBUG_STATE(DEBUG_STATE_CONNECTED_IDLE);
 
    PWR_MEAS_DELAY_MS(1000);
 
    SET_DEBUG_STATE(DEBUG_STATE_PINGING);
 
    /* 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 = PING_COUNT;
    mmconfig_read_uint32("ping.count", &args.ping_count);
 
    args.ping_size = PING_DATA_SIZE;
    mmconfig_read_uint32("ping.size", &args.ping_size);
 
    args.ping_interval_ms = 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;
        }
    }
 
    SET_DEBUG_STATE(DEBUG_STATE_PING_DONE);
 
    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);
    }
    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);
 
    /* Delay to allow communications to settle so we measure only idle current */
    PWR_MEAS_DELAY_MS(150);
 
    SET_DEBUG_STATE(DEBUG_STATE_IDLE);
 
    uint32_t post_ping_delay_ms = POST_PING_DELAY_MS;
    mmconfig_read_uint32("ping.post_ping_delay_ms", &post_ping_delay_ms);
    mmosal_task_sleep(post_ping_delay_ms);
 
    SET_DEBUG_STATE(DEBUG_STATE_TERMINATING);
 
    /* Disconnect from Wi-Fi */
    app_wlan_stop();
}