meshx_shell.c File Reference

Core implementation of the MeshX standalone shell. More...

#include "interface/utils/meshx_shell.h"
#include "interface/meshx_platform.h"
#include "interface/rtos/meshx_task.h"
#include "interface/logging/meshx_log.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
#include "interface/utils/meshx_tiny_printf.h"

Macros
#define	SHELL_MAX_LINE_LEN   256
#define	SHELL_MAX_ARGS   16
#define	SHELL_PROMPT   ""

Functions
void	meshx_shell_printf (const char *fmt,...)
	Prints a message to the shell console.
static void	shell_help_cmd (void)
static void	shell_process_line (char *line)
static void	shell_task (void *pvParameters)
meshx_err_t	meshx_shell_init (void)
	Initializes the MeshX shell core and the underlying platform console.
meshx_err_t	meshx_shell_register_command (const meshx_shell_cmd_t *cmd)
	Registers a command with the MeshX shell.
meshx_err_t	meshx_shell_start (void)
	Starts the MeshX shell task.

Variables
struct {
meshx_shell_cmd_t   commands [32]
uint8_t   cmd_count
char   line_buffer [256]
uint8_t   line_ptr
bool   initialized
}	shell_ctx

Detailed Description

Core implementation of the MeshX standalone shell.

Copyright © 2024 - 2025 MeshX

Macro Definition Documentation

SHELL_MAX_ARGS

#define SHELL_MAX_ARGS   16

SHELL_MAX_LINE_LEN

#define SHELL_MAX_LINE_LEN   256

SHELL_PROMPT

#define SHELL_PROMPT   ""

Function Documentation

meshx_shell_init()

meshx_err_t meshx_shell_init

(

void

)

Initializes the MeshX shell core and the underlying platform console.

Returns

meshx_err_t MESHX_SUCCESS on success, error code otherwise.

                                   {
    if (shell_ctx.initialized) return MESHX_SUCCESS;
 
    memset(&shell_ctx, 0, sizeof(shell_ctx));
    MESHX_LOGD(MODULE_ID_COMMON, "Initializing MeshX Shell...");
 
    meshx_err_t err = meshx_platform_console_init();
    if (err != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_COMMON, "Platform console init failed: %d", err);
        return err;
    }
 
    shell_ctx.initialized = true;
    MESHX_LOGD(MODULE_ID_COMMON, "MeshX Shell Initialized");
    return MESHX_SUCCESS;
}

meshx_shell_printf()

void meshx_shell_printf	(	const char *	fmt,
			... )

Prints a message to the shell console.

Parameters

[in]	fmt	Format string.
[in]	...	Arguments.

                                              {
    va_list args;
    va_start(args, fmt);
    meshx_tiny_vprintf(fmt, args);
    va_end(args);
}

meshx_shell_register_command()

meshx_err_t meshx_shell_register_command

(

const meshx_shell_cmd_t *

cmd

)

Registers a command with the MeshX shell.

Parameters

[in]

cmd

Pointer to the command structure.

Returns

meshx_err_t MESHX_SUCCESS on success, error code otherwise.

                                                                       {
    if (!shell_ctx.initialized) {
        MESHX_LOGE(MODULE_ID_COMMON, "Shell not initialized, cannot register command '%s'", cmd->command);
        return MESHX_ERR_NOT_INIT;
    }
    if (shell_ctx.cmd_count >= MESHX_SHELL_MAX_COMMANDS) return MESHX_FAIL;
 
    shell_ctx.commands[shell_ctx.cmd_count++] = *cmd;
    return MESHX_SUCCESS;
}

meshx_shell_start()

meshx_err_t meshx_shell_start

(

void

)

Starts the MeshX shell task.

Returns

meshx_err_t MESHX_SUCCESS on success, error code otherwise.

                                    {
    meshx_task_t task_cfg = {
        .task_cb = shell_task,
        .task_name = "meshx_shell",
        .stack_size = 4096,
        .priority = 4,
        .arg = NULL
    };
 
    return meshx_task_create(&task_cfg);
}

shell_help_cmd()

void shell_help_cmd ( void )

static

                                 {
    meshx_shell_printf("\nAvailable Commands:\n");
    for (int i = 0; i < shell_ctx.cmd_count; i++) {
        meshx_shell_printf("  %-12s : %s\n", shell_ctx.commands[i].command, shell_ctx.commands[i].help);
    }
}

shell_process_line()

void shell_process_line ( char * line )

static

                                           {
    char *argv[SHELL_MAX_ARGS];
    int argc = 0;
 
    // Simple tokenizer
    char *token = strtok(line, " \t\n\r");
    while (token != NULL && argc < SHELL_MAX_ARGS) {
        argv[argc++] = token;
        token = strtok(NULL, " \t\n\r");
    }
 
    if (argc == 0) return;
 
    if (strcmp(argv[0], "help") == 0 || strcmp(argv[0], "?") == 0) {
        shell_help_cmd();
        return;
    }
 
    for (int i = 0; i < shell_ctx.cmd_count; i++) {
        if (strcmp(argv[0], shell_ctx.commands[i].command) == 0) {
            int ret = shell_ctx.commands[i].func(argc, argv);
            if (ret != 0) {
                MESHX_LOGE(MODULE_ID_COMMON, "Command %s returned error: %d\n", argv[0], ret);
            }
            return;
        }
    }
 
    meshx_shell_printf("Unknown command: %s. Type 'help' for available commands.\n", argv[0]);
}

shell_task()

void shell_task ( void * pvParameters )

static

                                           {
    uint8_t c;
    meshx_shell_printf("\n%s", SHELL_PROMPT);
 
    while (1) {
        if (meshx_platform_console_read(&c, 1) > 0) {
            if (c == '\r' || c == '\n') {
                shell_ctx.line_buffer[shell_ctx.line_ptr] = '\0';
                if (shell_ctx.line_ptr > 0) {
                    shell_process_line(shell_ctx.line_buffer);
                }
                shell_ctx.line_ptr = 0;
                meshx_shell_printf(SHELL_PROMPT);
            } else if (c == '\b' || c == 0x7F) { // Backspace
                if (shell_ctx.line_ptr > 0) {
                    shell_ctx.line_ptr--;
                }
            } else if (shell_ctx.line_ptr < SHELL_MAX_LINE_LEN - 1) {
                if (isprint(c)) {
                    shell_ctx.line_buffer[shell_ctx.line_ptr++] = c;
                }
            }
        }
        meshx_task_delay(10); // Small delay to prevent tight loop
    }
}

Variable Documentation

cmd_count

uint8_t cmd_count

commands

meshx_shell_cmd_t commands[32]

initialized

bool initialized

line_buffer

char line_buffer[256]

line_ptr

uint8_t line_ptr

[struct]

struct { ... } shell_ctx