m2m_controller.c

Go to the documentation of this file.

/*
 * Copyright 2024 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include "mmhal_app.h"
#include "mmhal_core.h"
#include "mmosal.h"
#include "mmutils.h"
#include "mmagic_controller.h"
 
/* Default SSID  */
#ifndef SSID
#define SSID                            MorseMicro
#endif
 
/* Default passphrase  */
#ifndef SAE_PASSPHRASE
#define SAE_PASSPHRASE                  12345678
#endif
 
#define _STRINGIFY(x) #x
#define STRINGIFY(x) _STRINGIFY(x)
 
#define LINK_STATE_TIMEOUT_MS 20000
 
#define TCP_ECHCO_SERVER_PORT 5000
 
void agent_start_handler(struct mmagic_controller *controller, void *arg)
{
    MM_UNUSED(controller);
    struct mmosal_semb *started = (struct mmosal_semb *)arg;
    printf("Agent start notification received\n");
    mmosal_semb_give(started);
}
 
static struct mmosal_semb *agent_started_semb = NULL;
 
static bool wlan_connect(struct mmagic_controller *controller)
{
    printf("\n\n#### Example WLAN Connect using MMAGIC Controller ####\n\n");
    enum mmagic_status status;
 
    printf("Attempting to connect to %s with passphrase %s\n", STRINGIFY(SSID),
           STRINGIFY(SAE_PASSPHRASE));
    printf("This may take some time (~10 seconds)\n");
    status = mmagic_controller_set_wlan_ssid(controller, STRINGIFY(SSID));
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d setting the wlan ssid\n", status);
        return false;
    }
 
    status = mmagic_controller_set_wlan_password(controller, STRINGIFY(SAE_PASSPHRASE));
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d setting the wlan password\n", status);
        return false;
    }
 
    struct mmagic_core_wlan_connect_cmd_args connect_args = {
        .timeout = 120000,
    };
    status = mmagic_controller_wlan_connect(controller, &connect_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d after sending the connect command\n", status);
        return false;
    }
 
    struct mmagic_core_ip_status_rsp_args ip_status_rsp_args = {};
    uint32_t timeout = mmosal_get_time_ms() + LINK_STATE_TIMEOUT_MS;
    while (mmosal_time_lt(mmosal_get_time_ms(), timeout))
    {
        status = mmagic_controller_ip_status(controller, &ip_status_rsp_args);
        if ((status == MMAGIC_STATUS_OK) &&
            (ip_status_rsp_args.status.link_state == MMAGIC_IP_LINK_STATE_UP))
        {
            printf("Link Up\n");
            printf("Link is up %s. Time: %lu ms, ",
                   ip_status_rsp_args.status.dhcp_enabled ? "(DHCP)" : "(Static)",
                   mmosal_get_time_ms());
            printf("IP: %s, ", ip_status_rsp_args.status.ip_addr.addr);
            printf("Netmask: %s, ", ip_status_rsp_args.status.netmask.addr);
            printf("Gateway: %s", ip_status_rsp_args.status.gateway.addr);
            printf("\n");
            return true;
        }
        mmosal_task_sleep(500);
    }
 
    return false;
}
 
static bool is_wlan_connected(struct mmagic_controller *controller)
{
    mmosal_task_sleep(100);
    printf("\n\n#### Example check WLAN connection using MMAGIC Controller ####\n\n");
    enum mmagic_status status;
 
    printf("Checking SSID and password match expected values\n");
    struct string32 agent_ssid = {};
    const size_t ssid_len = sizeof(STRINGIFY(SSID)) - 1;
    status = mmagic_controller_get_wlan_ssid(controller, &agent_ssid);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d getting the wlan ssid\n", status);
        return false;
    }
    if ((ssid_len != agent_ssid.len) || memcmp(agent_ssid.data, STRINGIFY(SSID), ssid_len + 1))
    {
        printf("SSID mismatch\n");
        return false;
    }
 
    struct string100 agent_pwd = {};
    const size_t pwd_len = sizeof(STRINGIFY(SAE_PASSPHRASE)) - 1;
    status = mmagic_controller_get_wlan_password(controller, &agent_pwd);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d getting the wlan password\n", status);
        return false;
    }
    if ((pwd_len != agent_pwd.len) || memcmp(agent_pwd.data, STRINGIFY(SAE_PASSPHRASE),
                                             pwd_len + 1))
    {
        printf("Password mismatch\n");
        return false;
    }
 
    printf("Checking STA connection status\n");
    struct mmagic_core_wlan_get_sta_status_rsp_args rsp_args = {};
    status = mmagic_controller_wlan_get_sta_status(controller, &rsp_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d getting wlan sta status\n", status);
        return false;
    }
    if (rsp_args.sta_status != MMAGIC_STA_STATE_CONNECTED)
    {
        printf("STA not connected\n");
        return false;
    }
 
    printf("Checking link status\n");
    struct mmagic_core_ip_status_rsp_args ip_status_rsp_args = {};
    for (int attempts = 2; attempts > 0; --attempts)
    {
        status = mmagic_controller_ip_status(controller, &ip_status_rsp_args);
        if ((status == MMAGIC_STATUS_OK) &&
            (ip_status_rsp_args.status.link_state == MMAGIC_IP_LINK_STATE_UP))
        {
            printf("Link is up %s. Time: %lu ms, ",
                   ip_status_rsp_args.status.dhcp_enabled ? "(DHCP)" : "(Static)",
                   mmosal_get_time_ms());
            printf("IP: %s, ", ip_status_rsp_args.status.ip_addr.addr);
            printf("Netmask: %s, ", ip_status_rsp_args.status.netmask.addr);
            printf("Gateway: %s", ip_status_rsp_args.status.gateway.addr);
            printf("\n");
            return true;
        }
        mmosal_task_sleep(500);
    }
 
    printf("Link Down\n");
    return false;
}
 
struct beacon_monitor_thread_args
{
    struct mmagic_controller *controller;
    uint8_t stream_id;
};
 
void beacon_monitor_rx_handler(
    const struct mmagic_wlan_beacon_rx_event_args *args, void *arg)
{
    uint32_t offset = 0;
 
    MM_UNUSED(arg);
 
    while (offset < args->vendor_ies.len)
    {
        uint8_t ie_type;
        uint8_t ie_len;
        uint32_t ii;
 
        if (offset + 2 > args->vendor_ies.len)
        {
            printf("Beacon IEs malformed!\n");
            break;
        }
 
        ie_type = args->vendor_ies.data[offset];
        ie_len = args->vendor_ies.data[offset + 1];
 
        offset += 2;
 
        if (offset + ie_len > args->vendor_ies.len)
        {
            printf("Beacon IEs malformed!\n");
            break;
        }
 
        printf("    IE type 0x%02x, IE len 0x%02x, Contents: ", ie_type, ie_len);
        for (ii = 0; ii < ie_len; ii++)
        {
            printf("%02x", args->vendor_ies.data[offset++]);
        }
        printf("\n");
    }
}
 
static void beacon_monitor_example_start(struct mmagic_controller *controller)
{
    enum mmagic_status status;
 
    printf("\n\n#### Example Beacon Monitor using MMAGIC Controller ####\n\n");
 
    struct mmagic_core_wlan_beacon_monitor_enable_cmd_args beacon_monitor_args = {
        /* OUI for default Microsoft WMN/WME IE */
        .oui_filter = {.count = 1, .ouis = { { { 0x00, 0x50, 0xF2 } } }}
    };
 
    mmagic_controller_register_wlan_beacon_rx_handler(controller, beacon_monitor_rx_handler, NULL);
 
    status = mmagic_controller_wlan_beacon_monitor_enable(controller, &beacon_monitor_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d enabling beacon monitor\n", status);
        return;
    }
    printf("Enabled beacon monitor for OUI %02x:%02x:%02x\n",
           beacon_monitor_args.oui_filter.ouis[0].oui[0],
           beacon_monitor_args.oui_filter.ouis[0].oui[1],
           beacon_monitor_args.oui_filter.ouis[0].oui[2]);
}
 
static void tcp_client_example(struct mmagic_controller *controller,
                               struct mmosal_semb *rx_ready_semb)
{
    printf("\n\n#### Example TCP Client using MMAGIC Controller ####\n\n");
    enum mmagic_status status;
 
    struct mmagic_core_tcp_connect_cmd_args tcp_connect_args = {
        .url = {.data = "google.com", .len = strlen("google.com")},
        .port = 80
    };
    struct mmagic_core_tcp_connect_rsp_args tcp_rsp_args = {};
    status = mmagic_controller_tcp_connect(controller, &tcp_connect_args, &tcp_rsp_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d establishing TCP connection\n", status);
        MMOSAL_ASSERT(false);
    }
    uint8_t tcp_stream_id = tcp_rsp_args.stream_id;
    printf("Opened TCP socket on stream_id %u\n", tcp_stream_id);
 
    struct mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args args = {
        .stream_id = tcp_stream_id,
        .enabled = true,
    };
    status = mmagic_controller_tcp_set_rx_ready_evt_enabled(controller, &args);
    bool rx_ready_event_enabled = false;
    if (status == MMAGIC_STATUS_OK)
    {
        rx_ready_event_enabled = true;
    }
    else if (status == MMAGIC_STATUS_NOT_SUPPORTED)
    {
        printf("RX ready event not supported.\n");
    }
    else
    {
        printf("Error %d enabling rx ready event\n", status);
    }
 
    struct mmagic_core_tcp_send_cmd_args tcp_send_cmd_args = {
        .stream_id = tcp_stream_id,
        .buffer = {.data = "GET /\n\n", .len = strlen("GET /\n\n")}
    };
    status = mmagic_controller_tcp_send(controller, &tcp_send_cmd_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d whilst sending data\n", status);
        MMOSAL_ASSERT(false);
    }
    printf("Successfully sent GET request\n");
 
    if (rx_ready_event_enabled)
    {
        printf("Waiting for RX ready event...\n");
        mmosal_semb_wait(rx_ready_semb, UINT32_MAX);
    }
 
    struct mmagic_core_tcp_recv_cmd_args tcp_recv_cmd_args = {
        .stream_id = tcp_stream_id,
        .len = 1536,
        .timeout = 5000,
    };
    struct mmagic_core_tcp_recv_rsp_args tcp_recv_rsp_args = {};
    status = mmagic_controller_tcp_recv(controller, &tcp_recv_cmd_args, &tcp_recv_rsp_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d whilst receiving data\n", status);
    }
    else
    {
        printf("Received: %.12s, Length %u\n", tcp_recv_rsp_args.buffer.data,
               tcp_recv_rsp_args.buffer.len);
    }
 
    struct mmagic_core_tcp_close_cmd_args tcp_close_cmd_args = {.stream_id = tcp_stream_id};
    status = mmagic_controller_tcp_close(controller, &tcp_close_cmd_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %d whilst closing tcp socket\n", status);
        MMOSAL_ASSERT(false);
    }
    printf("Closed TCP Socket\n");
}
 
struct tcp_echo_server_thread_args
{
    struct mmagic_controller *controller;
    uint8_t stream_id;
};
 
static void tcp_echo_server_task(void *args)
{
    enum mmagic_status status;
    struct tcp_echo_server_thread_args *thread_args =
        (struct tcp_echo_server_thread_args *)args;
    struct mmagic_controller *controller = thread_args->controller;
    uint8_t stream_id = thread_args->stream_id;
 
    printf("Accepted a TCP connection on stream_id %u\n", stream_id);
 
    struct mmagic_core_tcp_recv_cmd_args tcp_recv_cmd_args = {
        .stream_id = stream_id,
        .len = 1536,
        .timeout = 1000,
    };
    struct mmagic_core_tcp_recv_rsp_args tcp_recv_rsp_args = {};
    struct mmagic_core_tcp_send_cmd_args tcp_send_cmd_args =
    {
        .stream_id = stream_id
    };
 
    while (true)
    {
        status = mmagic_controller_tcp_recv(controller, &tcp_recv_cmd_args, &tcp_recv_rsp_args);
        if (status == MMAGIC_STATUS_TIMEOUT)
        {
            continue;
        }
        else if (status == MMAGIC_STATUS_CLOSED)
        {
            printf("Connection closed by the other side!\n");
            break;
        }
        else if (status != MMAGIC_STATUS_OK)
        {
            printf("Error %d whilst receiving data\n", status);
            break;
        }
        printf("Received: %d bytes, echoing.\n", tcp_recv_rsp_args.buffer.len);
 
        memcpy(tcp_send_cmd_args.buffer.data, tcp_recv_rsp_args.buffer.data,
               tcp_recv_rsp_args.buffer.len);
        tcp_send_cmd_args.buffer.len = tcp_recv_rsp_args.buffer.len;
        status = mmagic_controller_tcp_send(controller, &tcp_send_cmd_args);
        if (status != MMAGIC_STATUS_OK)
        {
            printf("Error %d whilst sending data\n", status);
            break;
        }
    }
 
    struct mmagic_core_tcp_close_cmd_args tcp_close_cmd_args =
    {
        .stream_id = stream_id
    };
    status = mmagic_controller_tcp_close(controller, &tcp_close_cmd_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %u whilst trying to close the TCP socket on stream_id %u\n",
               status, stream_id);
    }
    printf("Closed TCP socket\n");
}
 
static enum mmagic_status tcp_echo_server_start(struct mmagic_controller *controller, uint16_t port)
{
    printf("\n\n#### Example TCP Echo Server using MMAGIC Controller ####\n\n");
    enum mmagic_status status;
    static struct tcp_echo_server_thread_args thread_args;
 
    struct mmagic_core_tcp_bind_cmd_args tcp_bind_cmd_args = {.port = port};
    struct mmagic_core_tcp_bind_rsp_args tcp_bind_rsp_args = {};
    status = mmagic_controller_tcp_bind(controller, &tcp_bind_cmd_args, &tcp_bind_rsp_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %u whilst opening the tcp socket\n", status);
        return status;
    }
    uint8_t tcp_socket_stream_id = tcp_bind_rsp_args.stream_id;
    printf("Opened listening socket (Port %u) on stream_id %u\n",
           tcp_bind_cmd_args.port, tcp_socket_stream_id);
 
    struct mmagic_core_tcp_accept_cmd_args tcp_accept_cmd_args = {
        .stream_id = tcp_socket_stream_id
    };
    struct mmagic_core_tcp_accept_rsp_args tcp_accept_rsp_args = {};
    while (true)
    {
        status = mmagic_controller_tcp_accept(controller,
                                              &tcp_accept_cmd_args,
                                              &tcp_accept_rsp_args);
        if (status != MMAGIC_STATUS_OK)
        {
            printf("Error %u whilst trying to accept a TCP connection\n", status);
            break;
        }
 
        thread_args.stream_id = tcp_accept_rsp_args.stream_id;
        thread_args.controller = controller;
 
        mmosal_task_create(tcp_echo_server_task, &thread_args,
                           MMOSAL_TASK_PRI_LOW, 2048, "tcp_echo_server_task");
    }
 
    struct mmagic_core_tcp_close_cmd_args tcp_close_cmd_args =
    {
        .stream_id = tcp_socket_stream_id
    };
    status = mmagic_controller_tcp_close(controller, &tcp_close_cmd_args);
    if (status != MMAGIC_STATUS_OK)
    {
        printf("Error %u whilst trying to close the listening socket on stream_id %u\n",
               status, tcp_socket_stream_id);
    }
    else
    {
        printf("Closed listening socket\n");
    }
    return status;
}
 
static void tcp_rx_ready_event_handler(
    const struct mmagic_tcp_rx_ready_event_args *event_args,
    void *arg)
{
    MM_UNUSED(event_args);
    printf("TCP RX ready event\n");
    struct mmosal_semb *rx_ready_semb = (struct mmosal_semb *)arg;
    mmosal_semb_give(rx_ready_semb);
}
 
static void run_examples_task(void *args)
{
    MM_UNUSED(args);
 
    agent_started_semb = mmosal_semb_create("agent_started");
    struct mmagic_controller_init_args init_args = MMAGIC_CONTROLLER_ARGS_INIT;
    init_args.agent_start_cb = agent_start_handler;
    init_args.agent_start_arg = (void *)agent_started_semb;
 
    struct mmagic_controller *controller = mmagic_controller_init(&init_args);
 
    enum {
        AGENT_ACTION_TIMEOUT_MS = 1000,
    };
 
    bool agent_already_running = false;
    enum mmagic_status status;
    printf("M2M Controller enabled. Awaiting Agent start\n");
    if (mmosal_semb_wait(agent_started_semb, AGENT_ACTION_TIMEOUT_MS))
    {
        goto agent_started;
    }
 
    printf("No agent start notification, agent may already be running.\n");
    printf("Attempting sync to recover connection.\n");
    status = mmagic_controller_agent_sync(controller, AGENT_ACTION_TIMEOUT_MS);
    if (status == MMAGIC_STATUS_OK)
    {
        agent_already_running = true;
        /* Check for existing connection */
        if (is_wlan_connected(controller))
        {
            printf("WLAN connection reattached\n");
            goto agent_connected;
        }
        goto agent_started;
    }
 
    printf("Sync failed with status %d, attempting LLC agent reset.\n", status);
    status = mmagic_controller_request_agent_reset(controller);
    if (mmosal_semb_wait(agent_started_semb, AGENT_ACTION_TIMEOUT_MS))
    {
        goto agent_started;
    }
 
    printf("LLC reset failed with status %d. Please hard reset the agent.\n", status);
    mmosal_semb_wait(agent_started_semb, UINT32_MAX);
 
agent_started:
    if (!wlan_connect(controller))
    {
        printf("Failed to connect\n");
        return;
    }
    printf("WLAN connection established\n");
 
agent_connected:
    beacon_monitor_example_start(controller);
 
    struct mmosal_semb *rx_ready_semb = mmosal_semb_create("rxready");
    MMOSAL_ASSERT(rx_ready_semb != NULL);
    mmagic_controller_register_tcp_rx_ready_handler(controller, tcp_rx_ready_event_handler, rx_ready_semb);
 
    tcp_client_example(controller, rx_ready_semb);
 
    status = tcp_echo_server_start(controller, TCP_ECHCO_SERVER_PORT);
    if ((status == MMAGIC_STATUS_SOCKET_LISTEN_FAILED) && agent_already_running)
    {
        /* Socket may already be open from previous run, try another port */
        status = tcp_echo_server_start(controller, TCP_ECHCO_SERVER_PORT + mmhal_random_u32(1, 10));
        printf("TCP echo server ended with status %d\n", status);
    }
}
 
void app_init(void)
{
    printf("\n\nM2M Controller Example (Built " __DATE__ " " __TIME__ ")\n\n");
 
    /* Keep controller awake for now */
    mmhal_set_deep_sleep_veto(MMHAL_VETO_ID_APP_MIN);
 
    /* Run the examples in a different task to cater for the higher stack size requirements */
    mmosal_task_create(run_examples_task, NULL,
                       MMOSAL_TASK_PRI_LOW, 2048, "run_examples_task");
}