cli_commands.c

Go to the documentation of this file.

/*
 * ether2ser — Ethernet <-> synchronous V.24 (RS-232/V.28) bridge
 *
 * File:    src/system/cli_commands.c
 * Purpose: CLI command handlers and dispatch.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Copyright (c) 2026 Florian <f.leuze@outlook.de>
 */
 
// Related headers
#include "cli_commands.h"
 
// Standard library headers
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
// Library Headers
#include "hardware/gpio.h"
#include "hardware/structs/io_bank0.h"
#include "hardware/watchdog.h"
#include "wizchip_conf.h"
#include "wizchip_qspi_pio.h"
 
// Project Headers
#include "drivers/v24_config.h"
#include "platform/watchdog.h"
#include "system/cli_parser.h"
#include "system/common.h"
#include "system/error.h"
#include "system/event_queue.h"
// Generated headers
 
#define MAX_CMD_BUFFER_LEN 16
#define MAX_PIN_NAME_LEN 16
#define MAX_ARG_BUFFER_LEN 64
 
// Command handler type
typedef void (*cmd_handler_t)(const char* args);
 
typedef struct
{
    const char*   name;
    cmd_handler_t handler;
    const char*   help;
} command_t;
 
typedef void (*category_set_handler_t)(const char* args);
typedef void (*category_get_handler_t)(const char* args);
 
typedef struct
{
    const char*            name;
    category_set_handler_t set_handler;
    category_get_handler_t get_handler;
    const char*            help;
} category_t;
 
typedef void (*subcmd_set_handler_t)(const char* args);
typedef void (*subcmd_get_handler_t)(const char* args);
 
typedef struct
{
    const char*          name;
    subcmd_set_handler_t set_handler;
    subcmd_get_handler_t get_handler;
    const char*          help;
} subcmd_t;
 
// Forward declarations for lookup tables
static void cmd_help(const char* args);
static void cmd_status(const char* args);
static void cmd_mem(const char* args);
static void cmd_net(const char* args);
static void cmd_set(const char* args);
static void cmd_get(const char* args);
static void cmd_pininfo(const char* args);
static void cmd_save(const char* args);
static void cmd_wipe(const char* args);
static void cmd_reboot(const char* args);
static void cat_gpio_set(const char* args);
static void cat_gpio_get(const char* args);
static void cat_net_set(const char* args);
static void cat_net_get(const char* args);
static void cat_v24_set(const char* args);
static void cat_v24_get(const char* args);
static void cat_loglevel_set(const char* args);
static void cat_loglevel_get(const char* args);
static void subcmd_set_ip_local(const char* args);
static void subcmd_get_ip_local(const char* args);
static void subcmd_set_ip_remote(const char* args);
static void subcmd_get_ip_remote(const char* args);
static void subcmd_set_ip_gateway(const char* args);
static void subcmd_get_ip_gateway(const char* args);
static void subcmd_set_udp_port_local(const char* args);
static void subcmd_get_udp_port_local(const char* args);
static void subcmd_set_udp_port_remote(const char* args);
static void subcmd_get_udp_port_remote(const char* args);
static void subcmd_set_v24_baudrate(const char* args);
static void subcmd_get_v24_baudrate(const char* args);
static void subcmd_set_v24_inverted(const char* args);
static void subcmd_get_v24_inverted(const char* args);
static void subcmd_set_v24_clockmode(const char* args);
static void subcmd_get_v24_clockmode(const char* args);
 
// Lookup tables
static const command_t commands[] = {
    {"help", cmd_help, "Show available commands"},
    {"status", cmd_status, "Show system status and RXC estimate"},
    {"mem", cmd_mem, "Show RAM/flash memory usage"},
    {"save", cmd_save, "Persist current configuration to flash"},
    {"wipe", cmd_wipe, "Erase persistent configuration from flash"},
    {"net", cmd_net, "Show current network status (W5500)"},
    {"set", cmd_set, "Set values (e.g. set gpio <pin> <0|1>, set net ip.local <addr>/<cidr>)"},
    {"get", cmd_get, "Get values (e.g. get gpio <pin>, get net ip.local)"},
    {"pininfo", cmd_pininfo, "Show pin details: pininfo <pin>"},
    {"reboot", cmd_reboot, "Reboot the device"},
};
 
static const category_t categories[] = {
    {"gpio", cat_gpio_set, cat_gpio_get, "GPIO controls and queries"},
    {"net", cat_net_set, cat_net_get, "Network configuration and queries"},
    {"v24", cat_v24_set, cat_v24_get, "V.24 config (inverted pins, baudrate)"},
    {"loglevel", cat_loglevel_set, cat_loglevel_get, "Runtime logging level"}};
 
static const subcmd_t net_subcmds[] = {
    {"ip.local", subcmd_set_ip_local, subcmd_get_ip_local, "Local IP address (CIDR)"},
    {"ip.remote", subcmd_set_ip_remote, subcmd_get_ip_remote, "Remote IP address"},
    {"ip.gateway", subcmd_set_ip_gateway, subcmd_get_ip_gateway, "Gateway IP address"},
    {"udp.port.local", subcmd_set_udp_port_local, subcmd_get_udp_port_local, "Local UDP port"},
    {"udp.port.remote", subcmd_set_udp_port_remote, subcmd_get_udp_port_remote, "Remote UDP port"},
};
#define INVERT_HELP "Invert pins (comma-separated, e.g. set v24 invert txd,rxd)"
static const subcmd_t v24_subcmds[] = {
    {"invert", subcmd_set_v24_inverted, subcmd_get_v24_inverted, INVERT_HELP},
    {"baudrate", subcmd_set_v24_baudrate, subcmd_get_v24_baudrate, "Baudrate"},
    {"txclock", subcmd_set_v24_clockmode, subcmd_get_v24_clockmode,
     "<0|1> Internal or external tx clock"}};
 
#define NUM_COMMANDS (sizeof(commands) / sizeof(commands[0]))
#define NUM_CATEGORIES ARRAY_LEN(categories)
#define NUM_NET_SUBCMDS ARRAY_LEN(net_subcmds)
#define NUM_V24_SUBCMDS ARRAY_LEN(v24_subcmds)
#define NUM_PINS get_num_pins()
 
static const V24_BAUDRATE_T v24_baudrates[] = {
    V24_BAUD_1200,  V24_BAUD_2400,  V24_BAUD_4800,  V24_BAUD_9600,   V24_BAUD_16000,
    V24_BAUD_19200, V24_BAUD_38400, V24_BAUD_57600, V24_BAUD_115200,
};
#define NUM_V24_BAUDRATES ARRAY_LEN(v24_baudrates)
 
typedef struct
{
    const char* name;
    log_level_t value;
} loglevel_entry_t;
 
static const loglevel_entry_t loglevels[] = {
    {"error", LOG_LEVEL_ERROR}, {"info", LOG_LEVEL_INFO},    {"debug", LOG_LEVEL_DEBUG},
    {"trace", LOG_LEVEL_TRACE}, {"tracea", LOG_LEVEL_TRACE},
};
#define NUM_LOGLEVELS ARRAY_LEN(loglevels)
 
static void dispatch_v24_polarities(const V24_POLARITIES_T* polarities)
{
    event_queue_data_t event_data = {.id = V24_POLARITIES};
    memcpy(&event_data.value.polarities, polarities, sizeof(V24_POLARITIES_T));
 
    event_t event = {
        .type      = EV_SET_V24_SETTINGS,
        .data_len  = sizeof(event_data),
        .is_inline = true,
    };
    memcpy(event.data.bytes, &event_data, sizeof(event_data));
    event_queue_push(&event);
}
 
static void dispatch_get_request(event_queue_data_types_t type, event_type_t event_type)
{
    event_queue_data_t get_request = {.id = type};
 
    event_t event = {
        .type      = event_type,
        .data_len  = sizeof(get_request),
        .is_inline = true,
    };
    memcpy(event.data.bytes, &get_request, sizeof(get_request));
    event_queue_push(&event);
}
static void subcmd_set_v24_inverted(const char* args)
{
    V24_POLARITIES_T polarities;
    if (parse_set_v24_polarities(args, &polarities) != E2S_OK)
    {
        LOG_PLAIN("usage: set v24 polarities txd,rxd,rts\r\n");
        return;
    }
    dispatch_v24_polarities(&polarities);
}
 
static void subcmd_get_v24_inverted(const char* args)
{
    (void)args;
    dispatch_get_request(V24_POLARITIES, EV_GET_V24_SETTINGS);
}
 
static void dispatch_v24_baudrate(const V24_BAUDRATE_T* baudrate)
{
    event_queue_data_t event_data = {.id = V24_BAUDRATE};
    memcpy(&event_data.value.baudrate, baudrate, sizeof(V24_BAUDRATE_T));
 
    event_t event = {
        .type      = EV_SET_V24_SETTINGS,
        .data_len  = sizeof(event_data),
        .is_inline = true,
    };
    memcpy(event.data.bytes, &event_data, sizeof(event_data));
    event_queue_push(&event);
}
static void subcmd_set_v24_clockmode(const char* args)
{
    bool clockmode;
    if (parse_set_v24_clockmode(args, &clockmode) != E2S_OK)
    {
        LOG_PLAIN("usage: set v24 txclock <0|1> \r\n");
        return;
    }
    event_queue_data_t event_data = {.id = V24_CLOCK_MODE};
    memcpy(&event_data.value.v24_clock_mode, &clockmode, sizeof(bool));
 
    event_t event = {
        .type      = EV_SET_V24_SETTINGS,
        .data_len  = sizeof(event_data),
        .is_inline = true,
    };
    memcpy(event.data.bytes, &event_data, sizeof(event_data));
    event_queue_push(&event);
}
 
static void subcmd_set_v24_baudrate(const char* args)
{
    V24_BAUDRATE_T baudrate;
    if (parse_set_v24_baudrate(args, &baudrate) != E2S_OK)
    {
        LOG_PLAIN("usage: set v24 baudrate 9600\r\n");
        return;
    }
    dispatch_v24_baudrate(&baudrate);
}
static void subcmd_get_v24_clockmode(const char* args)
{
    (void)args;
    dispatch_get_request(V24_CLOCK_MODE, EV_GET_V24_SETTINGS);
}
 
static void subcmd_get_v24_baudrate(const char* args)
{
    (void)args;
    dispatch_get_request(V24_BAUDRATE, EV_GET_V24_SETTINGS);
}
 
static void cat_v24_set(const char* args)
{
    LOG_DEBUG("set v24: args='%s'\r\n", args);
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: set v24 <subcmd> <args>\r\n");
        LOG_PLAIN("available v24 subcmds:\r\n");
        for (size_t i = 0; i < NUM_V24_SUBCMDS; i++)
        {
            LOG_PLAIN("  %s  - %s\r\n", v24_subcmds[i].name, v24_subcmds[i].help);
        }
        return;
    }
    for (size_t i = 0; i < NUM_V24_SUBCMDS; i++)
    {
        size_t len = strlen(v24_subcmds[i].name);
        if (strncmp(args, v24_subcmds[i].name, len) == 0 && (args[len] == ' ' || args[len] == '\0'))
        {
            const char* sub_args = args[len] == ' ' ? args + len + 1 : "";
            v24_subcmds[i].set_handler(sub_args);
            return;
        }
    }
    LOG_PLAIN("unknown v24 subcmd: '%s'\r\n", args);
}
 
static void cat_v24_get(const char* args)
{
    LOG_DEBUG("get v24: args='%s'\r\n", args);
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: get v24 <subcmd>\r\n");
        LOG_PLAIN("available v24 subcmds:\r\n");
        for (size_t i = 0; i < NUM_V24_SUBCMDS; i++)
        {
            LOG_PLAIN("  %s  - %s\r\n", v24_subcmds[i].name, v24_subcmds[i].help);
        }
        return;
    }
    for (size_t i = 0; i < NUM_V24_SUBCMDS; i++)
    {
        size_t len = strlen(v24_subcmds[i].name);
        if (strncmp(args, v24_subcmds[i].name, len) == 0 && (args[len] == ' ' || args[len] == '\0'))
        {
            const char* sub_args = args[len] == ' ' ? args + len + 1 : "";
            v24_subcmds[i].get_handler(sub_args);
            return;
        }
    }
    LOG_PLAIN("unknown v24 subcmd: '%s'\r\n", args);
}
 
static void cat_loglevel_set(const char* args)
{
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: set loglevel <error|info|debug|trace>\r\n");
        return;
    }
 
    char level_name[16];
    if (sscanf(args, "%15s", level_name) != 1)
    {
        LOG_PLAIN("usage: set loglevel <error|info|debug|trace>\r\n");
        return;
    }
 
    for (size_t i = 0; i < NUM_LOGLEVELS; i++)
    {
        if (strcmp(level_name, loglevels[i].name) == 0)
        {
            set_loglevel(loglevels[i].value);
            LOG_PLAIN("LOG_LEVEL: %s\r\n", log_level_tag(get_loglevel()));
            return;
        }
    }
 
    LOG_PLAIN("unknown loglevel: '%s'\r\n", level_name);
    LOG_PLAIN("available loglevels: error, info, debug, trace\r\n");
}
 
static void cat_loglevel_get(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: get loglevel\r\n");
        return;
    }
    LOG_PLAIN("LOG_LEVEL: %s\r\n", log_level_tag(get_loglevel()));
}
 
static void cmd_reboot(const char* args)
{
    (void)args;
 
    (void)args;
    event_t status_event = {.type = EV_REBOOT, .data.ptr = NULL, .data_len = 0, .is_inline = false};
    event_queue_push(&status_event);
}
 
static void dispatch_ip(const uint8_t* ip_addr, const event_queue_data_types_t type)
{
    event_queue_data_t ip_event_data = {.id = type};
    memcpy(ip_event_data.value.ip, ip_addr, 4); //
 
    event_t ip_event = {
        .type      = EV_SET_NET_SETTINGS,
        .data_len  = sizeof(ip_event_data),
        .is_inline = true,
    };
    memcpy(ip_event.data.bytes, &ip_event_data, sizeof(ip_event_data));
    event_queue_push(&ip_event);
}
 
static void subcmd_get_ip_local(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: get net ip.local\r\n");
        return;
    }
    dispatch_get_request(NET_IP_LOCAL, EV_GET_NET_SETTINGS);
}
 
static void subcmd_set_ip_local(const char* args)
{
    uint8_t ip_addr[4];
    uint8_t mask[4];
    if (parse_set_ip_args(args, ip_addr, mask) != E2S_OK)
    {
        LOG_PLAIN("usage: set net ip 192.168.29.2/24\r\n");
        return;
    }
    dispatch_ip(ip_addr, NET_IP_LOCAL);
    dispatch_ip(mask, NET_IP_MASK);
}
 
static void subcmd_get_ip_remote(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: get net ip.remote\r\n");
        return;
    }
    dispatch_get_request(NET_IP_REMOTE, EV_GET_NET_SETTINGS);
}
 
static void subcmd_set_ip_remote(const char* args)
{
    uint8_t ip_addr[4];
    if (parse_set_ip_remote_args(args, ip_addr) != E2S_OK)
    {
        LOG_PLAIN("usage: set net ip.remote 192.168.29.2\r\n");
        return;
    }
    dispatch_ip(ip_addr, NET_IP_REMOTE);
}
 
static void subcmd_get_ip_gateway(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: get net ip.gateway\r\n");
        return;
    }
    dispatch_get_request(NET_IP_GATEWAY, EV_GET_NET_SETTINGS);
}
 
static void subcmd_set_ip_gateway(const char* args)
{
    uint8_t ip_addr[4];
    if (parse_set_ip_remote_args(args, ip_addr) != E2S_OK)
    {
        LOG_PLAIN("usage: set net ip.gateway 192.168.29.1\r\n");
        return;
    }
    dispatch_ip(ip_addr, NET_IP_GATEWAY);
}
 
static void dispatch_get_udp_port(const event_queue_data_types_t type)
{
    event_queue_data_t get_request = {.id = type};
 
    event_t event = {
        .type      = EV_GET_NET_SETTINGS,
        .data_len  = sizeof(get_request),
        .is_inline = true,
    };
    memcpy(event.data.bytes, &get_request, sizeof(get_request));
    event_queue_push(&event);
}
 
static void dispatch_set_udp_port(const event_queue_data_types_t type, uint16_t port)
{
    event_queue_data_t set_request = {.id = type, .value.port = port};
 
    event_t event = {
        .type      = EV_SET_NET_SETTINGS,
        .data_len  = sizeof(set_request),
        .is_inline = true,
    };
    memcpy(event.data.bytes, &set_request, sizeof(set_request));
    event_queue_push(&event);
}
 
static void subcmd_get_udp_port_local(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: get net udp.port.local\r\n");
        return;
    }
    dispatch_get_udp_port(NET_PORT_LOCAL);
}
 
static void subcmd_set_udp_port_local(const char* args)
{
    uint16_t port = 0;
    if (parse_set_udp_port_local_args(args, &port) != E2S_OK)
    {
        LOG_PLAIN("usage: set net udp.port.local 6969\r\n");
        return;
    }
    dispatch_set_udp_port(NET_PORT_LOCAL, port);
}
 
static void subcmd_get_udp_port_remote(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: get net udp.port.remote\r\n");
        return;
    }
 
    dispatch_get_udp_port(NET_PORT_REMOTE);
}
 
static void subcmd_set_udp_port_remote(const char* args)
{
    uint16_t port = 0;
    if (parse_set_udp_port_remote_args(args, &port) != E2S_OK)
    {
        LOG_PLAIN("usage: set net udp.port.remote 6969\r\n");
        return;
    }
    dispatch_set_udp_port(NET_PORT_REMOTE, port);
}
 
static void cat_net_get(const char* args)
{
    LOG_DEBUG("get net: args='%s'\r\n", args);
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: get net <subcmd>\r\n");
        LOG_PLAIN("available net subcmds:\r\n");
        for (size_t i = 0; i < NUM_NET_SUBCMDS; i++)
        {
            LOG_PLAIN("  %s  - %s\r\n", net_subcmds[i].name, net_subcmds[i].help);
        }
        return;
    }
    for (size_t i = 0; i < NUM_NET_SUBCMDS; i++)
    {
        size_t len = strlen(net_subcmds[i].name);
        if (strncmp(args, net_subcmds[i].name, len) == 0 && (args[len] == ' ' || args[len] == '\0'))
        {
            const char* sub_args = args[len] == ' ' ? args + len + 1 : "";
            net_subcmds[i].get_handler(sub_args);
            return;
        }
    }
    LOG_PLAIN("unknown net subcmd: '%s'\r\n", args);
}
 
static void cat_gpio_set(const char* args)
{
    char              pin_name[MAX_PIN_NAME_LEN];
    int               value;
    const pin_info_t* pin           = NULL;
    e2s_error_t       parser_result = parse_set_gpio_args(args, pin_name, &value, &pin);
 
    switch (parser_result)
    {
    case E2S_ERR_CLI_USAGE_SET:
        LOG_PLAIN("usage:\r\n");
        LOG_PLAIN("  set gpio <pin> <0|1>\r\n");
        return;
    case E2S_ERR_CLI_UNKNOWN_PIN:
        LOG_PLAIN("unknown pin: '%s'\r\n", pin_name);
        return;
    case E2S_ERR_CLI_PIN_INPUT_ONLY:
        LOG_PLAIN("pin '%s' is input-only\r\n", pin_name);
        return;
    case E2S_OK:
        break;
    default:
        // Unreachable
        return;
    }
 
    if (pin == NULL)
    {
        return;
    }
 
    gpio_init(pin->gpio_num);
    gpio_set_dir(pin->gpio_num, GPIO_OUT);
    gpio_put(pin->gpio_num, value);
 
    LOG_PLAIN("set %s (pin %u) = %d\r\n", pin_name, pin->gpio_num, value);
}
 
static void cat_net_set(const char* args)
{
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: set net <subcmd> <args>\r\n");
        LOG_PLAIN("available net subcmds:\r\n");
        for (size_t i = 0; i < NUM_NET_SUBCMDS; i++)
        {
            LOG_PLAIN("  %s  - %s\r\n", net_subcmds[i].name, net_subcmds[i].help);
        }
        return;
    }
    for (size_t i = 0; i < NUM_NET_SUBCMDS; i++)
    {
        size_t len = strlen(net_subcmds[i].name);
        if (strncmp(args, net_subcmds[i].name, len) == 0 && (args[len] == ' ' || args[len] == '\0'))
        {
            const char* sub_args = args[len] == ' ' ? args + len + 1 : "";
            net_subcmds[i].set_handler(sub_args);
            return;
        }
    }
    LOG_PLAIN("unknown net subcmd: '%s'\r\n", args);
}
 
static void cat_gpio_get(const char* args)
{
    char              pin_name[MAX_PIN_NAME_LEN];
    const pin_info_t* pin = NULL;
 
    e2s_error_t parser_result = parse_get_args(args, pin_name, &pin);
 
    switch (parser_result)
    {
    case E2S_ERR_CLI_USAGE_GET:
        LOG_PLAIN("usage: get <pin>\r\n");
        return;
    case E2S_ERR_CLI_UNKNOWN_PIN:
        LOG_PLAIN("unknown pin: '%s'\r\n", pin_name);
        return;
    case E2S_OK:
        break;
    default:
        // Unreachable
        return;
    }
 
    if (pin == NULL)
    {
        return;
    }
 
    // Only initialize if not already a GPIO function
    if (gpio_get_function(pin->gpio_num) != GPIO_FUNC_SIO)
    {
        gpio_init(pin->gpio_num);
        gpio_set_dir(pin->gpio_num, GPIO_IN);
    }
    // If already GPIO but not configured as input/output, set as input
    else if (!gpio_is_dir_out(pin->gpio_num))
    {
        // Already initialized as GPIO input, no change needed
    }
 
    int  value     = gpio_get(pin->gpio_num);
    bool is_output = gpio_is_dir_out(pin->gpio_num);
 
    LOG_PLAIN("get %s (pin %u) = %d [%s]\r\n", pin_name, pin->gpio_num, value,
              is_output ? "OUT" : "IN");
}
 
static void cmd_set(const char* args)
{
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: set <category> <args>\r\n");
        LOG_PLAIN("available categories:\r\n");
        for (size_t i = 0; i < NUM_CATEGORIES; i++)
        {
            LOG_PLAIN("  %s  - %s\r\n", categories[i].name, categories[i].help);
        }
        return;
    }
    for (size_t i = 0; i < NUM_CATEGORIES; i++)
    {
        size_t len = strlen(categories[i].name);
        if (strncmp(args, categories[i].name, len) == 0 && args[len] == ' ')
        {
            categories[i].set_handler(args + len + 1);
            return;
        }
    }
    LOG_PLAIN("unknown set category: '%s'\r\n", args);
}
 
static void cmd_get(const char* args)
{
    if (args == NULL || args[0] == '\0')
    {
        LOG_PLAIN("usage: get <category> <args>\r\n");
        LOG_PLAIN("available categories:\r\n");
        for (size_t i = 0; i < NUM_CATEGORIES; i++)
        {
            LOG_PLAIN("  %s  - %s\r\n", categories[i].name, categories[i].help);
        }
        return;
    }
    for (size_t i = 0; i < NUM_CATEGORIES; i++)
    {
        size_t len = strlen(categories[i].name);
        if (strncmp(args, categories[i].name, len) == 0 && (args[len] == ' ' || args[len] == '\0'))
        {
            const char* cat_args = args[len] == ' ' ? args + len + 1 : "";
            categories[i].get_handler(cat_args);
            return;
        }
    }
    LOG_PLAIN("unknown get category: '%s'\r\n", args);
}
 
static void cmd_wipe(const char* args)
{
    (void)args;
    event_t wipe_event = {
        .type = EV_WIPE_CONFIG, .data.ptr = NULL, .data_len = 0, .is_inline = false};
    event_queue_push(&wipe_event);
}
 
static void cmd_save(const char* args)
{
    (void)args;
    event_t save_event = {
        .type = EV_SAVE_CONFIG, .data.ptr = NULL, .data_len = 0, .is_inline = false};
    event_queue_push(&save_event);
}
 
// Command handlers
static void cmd_help(const char* args)
{
    (void)args;
 
    size_t max_cmd = 0;
    for (size_t i = 0; i < NUM_COMMANDS; i++)
    {
        size_t len = strlen(commands[i].name);
        if (len > max_cmd)
        {
            max_cmd = len;
        }
    }
 
    LOG_PLAIN("\r\nCommands:\r\n");
    for (size_t i = 0; i < NUM_COMMANDS; i++)
    {
        LOG_PLAIN("  %-*s  %s\r\n", (int)max_cmd, commands[i].name, commands[i].help);
    }
 
    LOG_PLAIN("\r\nSet/Get Categories:\r\n");
    for (size_t i = 0; i < NUM_CATEGORIES; i++)
    {
        LOG_PLAIN("  %s  - %s\r\n", categories[i].name, categories[i].help);
    }
 
    LOG_PLAIN("\r\nNet Subcommands:\r\n");
    for (size_t i = 0; i < NUM_NET_SUBCMDS; i++)
    {
        LOG_PLAIN("  %s  - %s\r\n", net_subcmds[i].name, net_subcmds[i].help);
    }
 
    LOG_PLAIN("\r\nV24 Subcommands:\r\n");
    for (size_t i = 0; i < NUM_V24_SUBCMDS; i++)
    {
        LOG_PLAIN("  %s  - %s\r\n", v24_subcmds[i].name, v24_subcmds[i].help);
    }
 
    LOG_PLAIN("\r\nPins:\r\n");
    const pin_info_t* pin_table = get_pin_table();
    for (size_t i = 0; i < NUM_PINS; i++)
    {
        LOG_PLAIN("  %-10s  %s\r\n", pin_table[i].name, pin_table[i].is_output ? "OUT" : "IN");
    }
 
    LOG_PLAIN("\r\nBaudrates:\r\n");
    LOG_PLAIN("  ");
    for (size_t i = 0; i < NUM_V24_BAUDRATES; i++)
    {
        LOG_PLAIN("%u", (unsigned)v24_baudrates[i]);
        if (i < NUM_V24_BAUDRATES - 1)
        {
            LOG_PLAIN(", ");
        }
    }
    LOG_PLAIN("\r\n");
 
    LOG_PLAIN("\r\nLoglevels:\r\n");
    LOG_PLAIN("  error, info, debug, trace\r\n");
}
 
static void cmd_status(const char* args)
{
    (void)args;
    event_t status_event = {.type = EV_STATUS, .data.ptr = NULL, .data_len = 0, .is_inline = false};
    event_queue_push(&status_event);
}
 
static void cmd_mem(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: mem\r\n");
        return;
    }
    event_t mem_event = {.type = EV_MEM, .data.ptr = NULL, .data_len = 0, .is_inline = false};
    event_queue_push(&mem_event);
}
 
static void cmd_net(const char* args)
{
    if (args != NULL && args[0] != '\0')
    {
        LOG_PLAIN("usage: net\r\n");
        return;
    }
    wiz_NetInfo net_info;
    wizchip_getnetinfo(&net_info);
    LOG_PLAIN("ip=%u.%u.%u.%u gw=%u.%u.%u.%u\r\n", net_info.ip[0], net_info.ip[1], net_info.ip[2],
              net_info.ip[3], net_info.gw[0], net_info.gw[1], net_info.gw[2], net_info.gw[3]);
}
 
static void cmd_pininfo(const char* args)
{
    char pin_name[MAX_PIN_NAME_LEN];
 
    if (sscanf(args, "%15s", pin_name) != 1)
    {
        LOG_PLAIN("usage: pininfo <pin>\r\n");
        return;
    }
 
    const pin_info_t* pin = find_pin(pin_name);
    if (!pin)
    {
        LOG_PLAIN("unknown pin: '%s'\r\n", pin_name);
        return;
    }
 
    uint8_t gpio_num  = pin->gpio_num;
    bool    is_output = gpio_is_dir_out(gpio_num);
    int     value     = gpio_get(gpio_num);
 
    LOG_PLAIN("Pin %s (GPIO %u):\r\n", pin_name, gpio_num);
    LOG_PLAIN("  Direction: %s\r\n", is_output ? "OUTPUT" : "INPUT");
    LOG_PLAIN("  Value: %d\r\n", value);
    LOG_PLAIN("  Function: %d\r\n", gpio_get_function(gpio_num));
}
 
const char* get_command_name(int index)
{
    return commands[index].name;
}
 
void handle_cli_line(const char* line)
{
    char cmd[MAX_CMD_BUFFER_LEN]  = {0};
    char args[MAX_ARG_BUFFER_LEN] = {0};
 
    e2s_error_t parse_result = cli_parse(line, cmd, sizeof(cmd), args, sizeof(args));
    if (parse_result == E2S_ERR_CLI_EMPTY_LINE)
    {
        return;
    }
    if (parse_result == E2S_ERR_CLI_LINE_TRUNCATED)
    {
        LOG_PLAIN("error: command too long\r\n");
        return;
    }
    if (parse_result != E2S_OK)
    {
        LOG_PLAIN("error: invalid command line\r\n");
        return;
    }
 
    for (size_t i = 0; i < NUM_COMMANDS; i++)
    {
        if (strcmp(cmd, commands[i].name) == 0)
        {
            commands[i].handler(args);
            return;
        }
    }
 
    LOG_PLAIN("unknown: '%s' (try 'help')\r\n", cmd);
}