socket.c

Go to the documentation of this file.

/*
 * Copyright 2025 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include "mmconfig.h"
#include "mmosal.h"
#include "mmhal_app.h"
#include "mmipal.h"
 
#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/mbedtls_config.h"
#else
#include MBEDTLS_CONFIG_FILE
#endif
#include "mbedtls/net.h"
 
#include "mm_app_common.h"
#include "mmwlan.h"
 
#define DEFAULT_TARGET_ADDR "192.168.1.1"
#define DEFAULT_PORT "1337"
#define DEFAULT_IP_PROTOCOL MBEDTLS_NET_PROTO_TCP
#define DEFAULT_IP_PROTOCOL_STR "tcp"
 
#define DEFAULT_PACKET_COUNT 5
#define DEFAULT_PACKET_INTERVAL_MS 10000
#define MAX_DATA_SIZE_BYTES (uint32_t)1500
#define DEFAULT_DATA_SIZE_BYTES 500
#define PACKET_DATA_FORMAT "Packet index %ld, len=%ld: "
#define PACKET_SEND_DURATION_MS 200
#define CONNECT_MAX_ATTEMPTS 5
 
#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
#include "mmutils.h"
#define PWR_MEAS_DELAY_MS(delay_ms) MM_UNUSED(delay_ms)
#define SET_DEBUG_STATE(state)      MM_UNUSED(state)
#endif
 
uint8_t buf[MAX_DATA_SIZE_BYTES] = {};
 
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_MBEDTLS_INIT = 0x02,
    DEBUG_STATE_MBEDTLS_CONNECTING = 0x03,
    DEBUG_STATE_MBEDTLS_SEND = 0x01,
    DEBUG_STATE_MBEDTLS_SEND_DONE = 0x00,
    DEBUG_STATE_TERMINATING = 0x03,
};
 
int parse_protocol_str(const char *protocol, uint8_t len)
{
    if (strncmp("tcp", protocol, len) == 0)
    {
        return MBEDTLS_NET_PROTO_TCP;
    }
    else if (strncmp("udp", protocol, len) == 0)
    {
#if defined(ipconfigUSE_IPv4) || defined(ipconfigUSE_IPv6)
        printf("WARNING: The FreeRTOS+TCP socket implementation for Mbed TLS dos not currently "
               "support UDP\n");
        return -1;
#endif
        return MBEDTLS_NET_PROTO_UDP;
    }
    return -1;
}
 
void generate_packet_data(uint32_t packet_idx, uint32_t len, unsigned char *buf)
{
    snprintf(((char *)buf), sizeof(PACKET_DATA_FORMAT), PACKET_DATA_FORMAT, packet_idx, len);
    for (uint32_t i = sizeof(PACKET_DATA_FORMAT); i < len; i++)
    {
        buf[i] = '0' + (i % 10);
    }
}
 
void app_init(void)
{
    SET_DEBUG_STATE(DEBUG_STATE_BOOTING_CHIP);
 
    printf("\n\nSockets Example (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_MBEDTLS_INIT);
 
    mbedtls_net_context server_fd;
    mbedtls_net_init(&server_fd);
 
    PWR_MEAS_DELAY_MS(100);
 
    uint32_t data_size_bytes = DEFAULT_DATA_SIZE_BYTES;
    (void)mmconfig_read_uint32("socket.data_size_bytes", &data_size_bytes);
    if (data_size_bytes > MAX_DATA_SIZE_BYTES)
    {
        data_size_bytes = MAX_DATA_SIZE_BYTES;
        printf("Selected data size (socket.data_size_bytes) too large. Using the maximum of %ld "
               "instead",
               MAX_DATA_SIZE_BYTES);
    }
 
    struct mmipal_ip_config ip_config = MMIPAL_IP_CONFIG_DEFAULT;
    enum mmipal_status status = mmipal_get_ip_config(&ip_config);
    char target_ip[48] = DEFAULT_TARGET_ADDR;
    if (status == MMIPAL_SUCCESS && ip_config.mode != MMIPAL_DISABLED)
    {
        memcpy(target_ip, ip_config.gateway_addr, sizeof(ip_config.gateway_addr));
    }
    else
    {
        printf("Failed to retrieve IP config\n");
    }
    /* If socket.target is set, we use it as an override */
    (void)mmconfig_read_string("socket.target", target_ip, sizeof(target_ip));
 
    char target_port[6] = DEFAULT_PORT;
    (void)mmconfig_read_string("socket.port", target_port, sizeof(target_port));
 
    int ip_protocol;
    char protocol_str[4];
    (void)mmconfig_read_string("socket.protocol", protocol_str, sizeof(protocol_str));
    if ((ip_protocol = parse_protocol_str(protocol_str, sizeof(protocol_str))) < 0)
    {
        ip_protocol = DEFAULT_IP_PROTOCOL;
        snprintf(protocol_str, sizeof(protocol_str), DEFAULT_IP_PROTOCOL_STR);
        printf("Failed to parse socket.protocol config. Defaulting to %s\n", protocol_str);
    }
 
    SET_DEBUG_STATE(DEBUG_STATE_MBEDTLS_CONNECTING);
 
    printf("Connecting to %s server at %s:%s...\n", protocol_str, target_ip, target_port);
 
    int ret;
    uint32_t retries = CONNECT_MAX_ATTEMPTS;
    while ((ret = mbedtls_net_connect(&server_fd, target_ip, target_port, ip_protocol)) &&
           retries--)
    {
        printf("Failed to connect to server. Status: %d\n", ret);
    }
    if (ret == 0)
    {
        printf("Successfully connected to server.\n");
    }
 
    /* Send an empty packet to ensure all ARP activity completes. This prevents the first
     * packet from taking longer and consuming more power. Wait 2 seconds for network
     * activity to finish. */
    mbedtls_net_send(&server_fd, NULL, 0);
    PWR_MEAS_DELAY_MS(2000);
 
    uint32_t packet_interval_ms = DEFAULT_PACKET_INTERVAL_MS;
    uint32_t packet_count = DEFAULT_PACKET_COUNT;
    mmconfig_read_uint32("socket.packet_interval_ms", &packet_interval_ms);
    mmconfig_read_uint32("socket.count", &packet_count);
    MMOSAL_ASSERT(packet_interval_ms >= PACKET_SEND_DURATION_MS);
    for (uint32_t packet_idx = 0; packet_idx < packet_count; packet_idx++)
    {
        SET_DEBUG_STATE(DEBUG_STATE_MBEDTLS_SEND);
        generate_packet_data(packet_idx, data_size_bytes, buf);
        printf("Sending packet number %ld... ", packet_idx);
        if ((ret = mbedtls_net_send(&server_fd, buf, data_size_bytes)) < 0)
        {
            printf("Packet failed to send. Return code: %d\n", ret);
        }
        else if ((uint32_t)ret < data_size_bytes)
        {
            printf("Packet not fully sent: %d of %ld\n", ret, data_size_bytes);
        }
        else
        {
            printf("Packet successfully sent\n");
        }
#if defined(ENABLE_PWR_MEAS) && ENABLE_PWR_MEAS
        PWR_MEAS_DELAY_MS(PACKET_SEND_DURATION_MS);
 
        SET_DEBUG_STATE(DEBUG_STATE_MBEDTLS_SEND_DONE);
 
        PWR_MEAS_DELAY_MS(packet_interval_ms - PACKET_SEND_DURATION_MS);
#else
        mmosal_task_sleep(packet_interval_ms);
#endif
    }
 
    SET_DEBUG_STATE(DEBUG_STATE_TERMINATING);
 
    /* Disconnect from Wi-Fi */
    app_wlan_stop();
}