udp_broadcast.c

Go to the documentation of this file.

/*
 * Copyright 2021-2023 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include <string.h>
#include <endian.h>
#include "mmosal.h"
#include "mmwlan.h"
#include "mmconfig.h"
 
#include "mmipal.h"
#include "lwip/icmp.h"
#include "lwip/tcpip.h"
#include "lwip/udp.h"
 
#include "mm_app_common.h"
 
/* Application default configurations. */
 
#define DEFAULT_BROADCAST_PACKET_COUNT 10
#define DEFAULT_UDP_PORT 1337
#define DEFAULT_PACKET_INTERVAL_MS 10000
#define BROADCAST_PACKET_MAX_TX_PAYLOAD_LEN 35
#define BROADCAST_PACKET_TX_PAYLOAD_FMT "G'day World, packet no. %lu."
#define DEFAULT_UDP_BROADCAST_MODE TX_MODE
#define DEFAULT_UDP_BROADCAST_ID 0
 
#define MMBC_KEY 0x43424d4d
 
enum udp_broadcast_mode
{
    TX_MODE,
    RX_MODE
};
 
PACK_STRUCT_STRUCT struct udp_broadcast_rx_payload
{
    uint32_t key;
 
    struct
    {
        uint8_t red;
        uint8_t green;
        uint8_t blue;
    } data[];
};
 
struct udp_broadcast_rx_metadata
{
    uint32_t last_rx_time_ms;
    uint32_t id;
};
 
static struct udp_broadcast_rx_metadata rx_metadata = { 0 };
 
static void udp_raw_recv(void *arg,
                         struct udp_pcb *pcb,
                         struct pbuf *p,
                         const ip_addr_t *addr,
                         u16_t port)
{
    LWIP_UNUSED_ARG(pcb);
    LWIP_UNUSED_ARG(addr);
    LWIP_UNUSED_ARG(port);
 
    if (p == NULL)
    {
        return;
    }
 
    struct udp_broadcast_rx_metadata *metadata = (struct udp_broadcast_rx_metadata *)arg;
    struct udp_broadcast_rx_payload *payload = (struct udp_broadcast_rx_payload *)p->payload;
    uint32_t current_time_ms = mmosal_get_time_ms();
 
    /* This is the minimum length we need to prevent reading off the end of the payload. */
    uint32_t min_payload_len =
        sizeof(payload->key) + (sizeof(payload->data[0]) * (metadata->id + 1));
 
    if (p->len < min_payload_len)
    {
        printf("Payload length to short. Len: %u. Min len: %lu\n", p->len, min_payload_len);
        goto exit;
    }
 
    if (le32toh(payload->key) != MMBC_KEY)
    {
        printf("Invalid payload received.\n");
        goto exit;
    }
 
    printf("Valid payload received. \n"
           "    Time since last: %lums\n"
           "    Data recieved: 0x%02x%02x%02x\n\n",
           (current_time_ms - metadata->last_rx_time_ms),
           payload->data[metadata->id].red,
           payload->data[metadata->id].green,
           payload->data[metadata->id].blue);
 
    metadata->last_rx_time_ms = current_time_ms;
 
    mmhal_set_led(LED_RED, payload->data[metadata->id].red);
    mmhal_set_led(LED_GREEN, payload->data[metadata->id].green);
    mmhal_set_led(LED_BLUE, payload->data[metadata->id].blue);
 
exit:
    pbuf_free(p);
}
 
static void udp_broadcast_rx_start(struct udp_pcb *pcb)
{
    mmconfig_read_uint32("udp_broadcast.id", &(rx_metadata.id));
 
    LOCK_TCPIP_CORE();
    udp_recv(pcb, udp_raw_recv, &rx_metadata);
    UNLOCK_TCPIP_CORE();
}
 
static void udp_broadcast_tx_start(struct udp_pcb *pcb)
{
    err_t err;
    uint32_t count;
    uint32_t packet_count = DEFAULT_BROADCAST_PACKET_COUNT;
    uint32_t packet_interval_ms = DEFAULT_PACKET_INTERVAL_MS;
 
    /* Read out any params from configstore if they exist. If they don't the variables will retain
     * their current values. */
    mmconfig_read_uint32("udp_broadcast.packet_count", &packet_count);
    mmconfig_read_uint32("udp_broadcast.packet_interval_ms", &packet_interval_ms);
 
    for (count = 0; (count < packet_count) || (packet_count == 0); count++)
    {
        printf("Sending Broadcast UDP packet no. %lu.\n", count);
 
        struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, BROADCAST_PACKET_MAX_TX_PAYLOAD_LEN, PBUF_RAM);
        if (p == NULL)
        {
            printf("Failed to allocate pbuf for transmit\n");
            break;
        }
        snprintf((char *)p->payload, p->len, BROADCAST_PACKET_TX_PAYLOAD_FMT, count);
 
        LOCK_TCPIP_CORE();
        err = udp_send(pcb, p);
        if (err)
        {
            printf("Failed to send, err:%d.\n", err);
            break;
        }
        UNLOCK_TCPIP_CORE();
 
        pbuf_free(p);
 
        mmosal_task_sleep(packet_interval_ms);
    }
}
 
static struct udp_pcb *init_udp_pcb(void)
{
    struct udp_pcb *pcb = NULL;
    err_t err;
    uint32_t port_num = DEFAULT_UDP_PORT;
 
    mmconfig_read_uint32("udp_broadcast.port", &port_num);
    if (port_num > UINT16_MAX)
    {
        port_num = DEFAULT_UDP_PORT;
        printf("Specified port number is too large. Falling back to %lu\n", port_num);
    }
 
    LOCK_TCPIP_CORE();
    pcb = udp_new();
 
    if (pcb == NULL)
    {
        printf("Error creating PCB.\n");
        goto exit;
    }
 
    err = udp_bind(pcb, IP_ADDR_ANY, (uint16_t)port_num);
    if (err)
    {
        printf("Failed to bind, err:%d.\n", err);
        udp_remove(pcb);
        pcb = NULL;
        goto exit;
    }
 
exit:
    UNLOCK_TCPIP_CORE();
    return pcb;
}
 
static enum udp_broadcast_mode get_mode(void)
{
    enum udp_broadcast_mode mode = DEFAULT_UDP_BROADCAST_MODE;
    char mode_str[32];
    if (mmconfig_read_string("udp_broadcast.mode", mode_str, sizeof(mode_str)) > 0)
    {
        if (strcasecmp(mode_str, "tx") == 0)
        {
            mode = TX_MODE;
        }
        else if (strcasecmp(mode_str, "rx") == 0)
        {
            mode = RX_MODE;
        }
        else
        {
            printf("Unknown mode: %s. Reverting to default.\n", mode_str);
        }
    }
 
    return mode;
}
 
void app_init(void)
{
    struct udp_pcb *pcb;
    enum udp_broadcast_mode mode;
 
    printf("\n\nMorse UDP broadcast Demo (Built " __DATE__ " " __TIME__ ")\n\n");
 
    /* Initialize and connect to Wi-Fi, blocks till connected */
    app_wlan_init();
    app_wlan_start();
 
    pcb = init_udp_pcb();
    if (pcb == NULL)
    {
        return;
    }
 
    mode = get_mode();
    if (mode == TX_MODE)
    {
        udp_broadcast_tx_start(pcb);
 
        /* Since we have broadcast all the packets we're going to send lets clean up. */
        LOCK_TCPIP_CORE();
        udp_remove(pcb);
        UNLOCK_TCPIP_CORE();
        app_wlan_stop();
    }
    else
    {
        /* Since this registers a callback we leave the WLAN interface up and just allow this
         * app_init thread to be cleaned up. */
        udp_broadcast_rx_start(pcb);
    }
}