/*************************************************
** Command Line Interface
** This is from https://github.com/eleciawhite/reusable
** (MIT license)
**
** To use it in the simulator, press run 
**    It should print `Welcome to the Consolinator, your gateway to testing code and hardware`
** Type 'help' in the white box at the bottom and hit return.
** It lists the commands it supports.
**
** There are several files here:
** Console.c is a command parser. 
**    Call the init function during init and
**    then call the process function on every pass through a loop.
** You probably don't need to modify this file much.
**
** The interface is in consoleIo.c which currently
** uses the RPi Pico interface. You will need to modify this
** for your own hardware, connecting it to a UART in your embedded system.
**
** The command table and commands are implemented in consoleCommands.c.
** This is where you add commands, probably by copying one that is 
** already there. You need to modify mConsoleCommandTable 
** to add the command.
*************************************************/
#include <stdio.h>
#include "pico/stdlib.h"
#include "console.h"

int main() {
  stdio_init_all(); // UART setup for both input and output
  ConsoleInit();

	while(1) 
	{
		ConsoleProcess();
    sleep_ms(2); 
	}	
}

main.c

diagram.json

// Console is the generic interface to the command line. 
// These functions should not need signficant modification, only 
// to be called from the normal loop. Note that adding commands should 
// be done in console commands. 
#ifndef CONSOLE_H
#define CONSOLE_H

#include <stdint.h>

// User configuration
#define CONSOLE_PROMPT			("> ")
#define PARAMETER_SEPARATER		(' ')
#define STR_ENDLINE 			"\r\n"

// The C library itoa is sometimes a complicated function and the library costs aren't worth it
// so this is implements the parts of the function needed for console.
#define CONSOLE_USE_BUILTIN_ITOA	1


// Salled from higher up areas of the code (main)
void ConsoleInit(void);
void ConsoleProcess(void); // call this in a loop

// called from lower down areas of the code (consoleCommands)
typedef enum { 
	COMMAND_SUCCESS = 0u, 
	COMMAND_PARAMETER_ERROR = 0x10u, 
	COMMAND_PARAMETER_END   = 0x11u,
	COMMAND_ERROR =0xFFu 
} eCommandResult_T;

// The in and output of the int16 parameter use C standard library functions
// atoi and itoa. These are nice functions, usually a lot smaller than scanf and printf
// but they can be memory hogs in their flexibility. 
// The HexUint16 functions implement the parsing themselves, eschewing atoi and itoa.
eCommandResult_T ConsoleReceiveParamInt16(const char * buffer, const uint8_t parameterNumber, int16_t* parameterInt16);
eCommandResult_T ConsoleSendParamInt16(int16_t parameterInt);
eCommandResult_T ConsoleSendParamInt32(int32_t parameterInt);
eCommandResult_T ConsoleReceiveParamHexUint16(const char * buffer, const uint8_t parameterNumber, uint16_t* parameterUint16);
eCommandResult_T ConsoleSendParamHexUint16(uint16_t parameterUint16);
eCommandResult_T ConsoleSendParamHexUint8(uint8_t parameterUint8);
eCommandResult_T ConsoleSendString(const char *buffer); // must be null terminated
eCommandResult_T ConsoleSendLine(const char *buffer); // must be null terminated

#endif // CONSOLE_H

console.h

// Console is the generic interface to the command line.
// These functions should not need signficant modification, only
// to be called from the normal loop. Note that adding commands should
// be done in console commands.

#include <string.h>  // for NULL
#include <stdlib.h>  // for atoi and itoa (though this code implement a version of that)
#include <stdbool.h>
#include "console.h"
#include "consoleIo.h"
#include "consoleCommands.h"

#ifndef MIN
  #define MIN(X, Y)		(((X) < (Y)) ? (X) : (Y))
#endif

#define NOT_FOUND		-1
#define INT16_MAX_STR_LENGTH 8 // -65534: six characters plus a two NULLs
#define INT32_MAX_STR_LENGTH 16
#define NULL_CHAR            '\0'
#define CR_CHAR              '\r'
#define LF_CHAR              '\n'

// global variables
char mReceiveBuffer[CONSOLE_COMMAND_MAX_LENGTH];
uint32_t mReceivedSoFar;
bool mReceiveBufferNeedsChecking = false;

// local functions
static int32_t ConsoleCommandEndline(const char receiveBuffer[], const  uint32_t filledLength);

static uint32_t ConsoleCommandMatch(const char* name, const char *buffer);
static eCommandResult_T ConsoleParamFindN(const char * buffer, const uint8_t parameterNumber, uint32_t *startLocation);
static uint32_t ConsoleResetBuffer(char receiveBuffer[], const  uint32_t filledLength, uint32_t usedSoFar);

static eCommandResult_T ConsoleUtilHexCharToInt(char charVal, uint8_t* pInt); // this might be replaceable with *pInt = atoi(str)
static eCommandResult_T ConsoleUtilsIntToHexChar(uint8_t intVal, char* pChar); // this could be replaced with itoa (intVal, str, 16);

// ConsoleCommandMatch
// Look to see if the data in the buffer matches the command name given that
// the strings are different lengths and we have parameter separators
static uint32_t ConsoleCommandMatch(const char* name, const char *buffer)
{
	uint32_t i = 0u;
	uint32_t result = 0u; // match

	if ( buffer[i] == name [i] )
	{
		result = 1u;
		i++;
	}

	while ( ( 1u == result ) &&
		( i < CONSOLE_COMMAND_MAX_COMMAND_LENGTH )  &&
		( buffer[i] != PARAMETER_SEPARATER ) &&
		( buffer[i] != LF_CHAR ) &&( buffer[i] != CR_CHAR ) &&
		( buffer[i] != (char) NULL_CHAR )
		)
	{
		if ( buffer[i] != name[i] )
		{
			result = 0u;
		}
		i++;
	}

	return result;
}

// ConsoleResetBuffer
// In an ideal world, this would just zero out the buffer. However, thre are times when the
// buffer may have data beyond what was used in the last command.
// We don't want to lose that data so we move it to the start of the command buffer and then zero
// the rest.
static uint32_t ConsoleResetBuffer(char receiveBuffer[], const uint32_t filledLength, uint32_t usedSoFar)
{
	uint32_t remaining = (filledLength - usedSoFar);
	uint32_t i = 0;

	while (usedSoFar < filledLength)
	{
		receiveBuffer[i] = receiveBuffer[usedSoFar]; // move the end to the start
		i++;
		usedSoFar++;
	}
	for ( /* nothing */ ; i < CONSOLE_COMMAND_MAX_LENGTH ; i++)
	{
		receiveBuffer[i] =  NULL_CHAR;
	}
	return remaining;
}

// ConsoleCommandEndline
// Check to see where in the buffer stream the endline is; that is the end of the command and parameters
static int32_t ConsoleCommandEndline(const char receiveBuffer[], const  uint32_t filledLength)
{
	uint32_t i = 0;
	int32_t result = NOT_FOUND; // if no endline is found, then return -1 (NOT_FOUND)

	while ( ( CR_CHAR != receiveBuffer[i])  && (LF_CHAR != receiveBuffer[i])
			&& ( i < filledLength ) )
	{
		i++;
	}
	if ( i < filledLength )
	{
		result = i;
	}
	return result;
}

// ConsoleInit
// Initialize the console interface and all it depends on
void ConsoleInit(void)
{
	uint32_t i;

	ConsoleIoInit();
	ConsoleIoSendString("Welcome to the Consolinator, your gateway to testing code and hardware.");	
	ConsoleIoSendString(STR_ENDLINE);
	ConsoleIoSendString(CONSOLE_PROMPT);
	mReceivedSoFar = 0u;

	for ( i = 0u ; i < CONSOLE_COMMAND_MAX_LENGTH ; i++)
	{
		mReceiveBuffer[i] = NULL_CHAR;
	}

}

// ConsoleProcess
// Looks for new inputs, checks for endline, then runs the matching command.
// Call ConsoleProcess from a loop, it will handle commands as they become available
void ConsoleProcess(void)
{
	const sConsoleCommandTable_T* commandTable;
	uint32_t received;
	uint32_t cmdIndex;
	int32_t  cmdEndline;
	int32_t  found;
	eCommandResult_T result;

	ConsoleIoReceive((uint8_t*)&(mReceiveBuffer[mReceivedSoFar]), ( CONSOLE_COMMAND_MAX_LENGTH - mReceivedSoFar ), &received);
	if ( received > 0u || mReceiveBufferNeedsChecking)
	{
		mReceiveBufferNeedsChecking = false;
		mReceivedSoFar += received;
		cmdEndline = ConsoleCommandEndline(mReceiveBuffer, mReceivedSoFar);
		if ( cmdEndline >= 0 )  // have complete string, find command
		{
			commandTable = ConsoleCommandsGetTable();
			cmdIndex = 0u;
			found = NOT_FOUND;
			while ( ( NULL != commandTable[cmdIndex].name ) && ( NOT_FOUND == found ) )
			{
				if ( ConsoleCommandMatch(commandTable[cmdIndex].name, mReceiveBuffer) )
				{
					result = commandTable[cmdIndex].execute(mReceiveBuffer);
					if ( COMMAND_SUCCESS != result )
					{
						ConsoleIoSendString("Error: ");
						ConsoleIoSendString(mReceiveBuffer);

						ConsoleIoSendString("Help: ");
						ConsoleIoSendString(commandTable[cmdIndex].help);
						ConsoleIoSendString(STR_ENDLINE);

					}
					found = cmdIndex;
				}
				else
				{
					cmdIndex++;

				}
			}
			if ( ( cmdEndline != 0 ) && ( NOT_FOUND == found ) )
			{
				if (mReceivedSoFar > 2) /// shorter than that, it is probably nothing
				{
					ConsoleIoSendString("Command not found.");
					ConsoleIoSendString(STR_ENDLINE);
				}
			}
			//reset the buffer by moving over any leftovers and nulling the rest
			// clear up to and including the found end line character
			mReceivedSoFar = ConsoleResetBuffer(mReceiveBuffer, mReceivedSoFar, cmdEndline + 1);
			mReceiveBufferNeedsChecking = mReceivedSoFar > 0 ? true : false;
			ConsoleIoSendString(CONSOLE_PROMPT);
		}
	}
}

// ConsoleParamFindN
// Find the start location of the nth parametr in the buffer where the command itself is parameter 0
static eCommandResult_T ConsoleParamFindN(const char * buffer, const uint8_t parameterNumber, uint32_t *startLocation)
{
	uint32_t bufferIndex = 0;
	uint32_t parameterIndex = 0;
	eCommandResult_T result = COMMAND_SUCCESS;
	while ( ( parameterNumber != parameterIndex ) && ( bufferIndex < CONSOLE_COMMAND_MAX_LENGTH ) )
	{
		if ( PARAMETER_SEPARATER == buffer[bufferIndex] )
		{
			parameterIndex++;
		}
		bufferIndex++;
	}
	if  ( CONSOLE_COMMAND_MAX_LENGTH == bufferIndex )
	{
		result = COMMAND_PARAMETER_ERROR;
	}
	else
	{
		*startLocation = bufferIndex;
	}
	return result;
}

// ConsoleReceiveParamInt16
// Identify and obtain a parameter of type int16_t, sent in in decimal, possibly with a negative sign.
// Note that this uses atoi, a somewhat costly function. You may want to replace it, see ConsoleReceiveParamHexUint16
// for some ideas on how to do that.
eCommandResult_T ConsoleReceiveParamInt16(const char * buffer, const uint8_t parameterNumber, int16_t* parameterInt)
{
	uint32_t startIndex = 0;
	uint32_t i;
	eCommandResult_T result;
	char charVal;
	char str[INT16_MAX_STR_LENGTH];

	result = ConsoleParamFindN(buffer, parameterNumber, &startIndex);

	i = 0;
	charVal = buffer[startIndex + i];
	while ( ( LF_CHAR != charVal ) && ( CR_CHAR != charVal )
			&& ( PARAMETER_SEPARATER != charVal )
		&& ( i < INT16_MAX_STR_LENGTH ) )
	{
		str[i] = charVal;					// copy the relevant part
		i++;
		charVal = buffer[startIndex + i];
	}
	if ( i == INT16_MAX_STR_LENGTH)
	{
		result = COMMAND_PARAMETER_ERROR;
	}
	if ( COMMAND_SUCCESS == result )
	{
		str[i] = NULL_CHAR;
		*parameterInt = atoi(str);
	}
	return result;
}

// ConsoleReceiveParamHexUint16
// Identify and obtain a parameter of type uint16, sent in as hex. This parses the number and does not use
// a library function to do it.
eCommandResult_T ConsoleReceiveParamHexUint16(const char * buffer, const uint8_t parameterNumber, uint16_t* parameterUint16)
{
	uint32_t startIndex = 0;
	uint16_t value = 0;
	uint32_t i;
	eCommandResult_T result;
	uint8_t tmpUint8;

	result = ConsoleParamFindN(buffer, parameterNumber, &startIndex);
	if ( COMMAND_SUCCESS == result )
	{
		// bufferIndex points to start of integer
		// next separator or newline or NULL indicates end of parameter
		for ( i = 0u ; i < 4u ; i ++)   // U16 must be less than 4 hex digits: 0xFFFF
		{
			if ( COMMAND_SUCCESS == result )
			{
				result = ConsoleUtilHexCharToInt(buffer[startIndex + i], &tmpUint8);
			}
			if ( COMMAND_SUCCESS == result )
			{
				value = (value << 4u);
				value += tmpUint8;
			}
		}
		if  ( COMMAND_PARAMETER_END == result )
		{
			result = COMMAND_SUCCESS;
		}
		*parameterUint16 = value;
	}
	return result;
}

// ConsoleSendParamHexUint16
// Send a parameter of type uint16 as hex.
// This does not use a library function to do it (though you could
// do itoa (parameterUint16, out, 16);  instead of building it up
eCommandResult_T ConsoleSendParamHexUint16(uint16_t parameterUint16)
{
	uint32_t i;
	char out[4u + 1u];  // U16 must be less than 4 hex digits: 0xFFFF, end buffer with a NULL
	eCommandResult_T result = COMMAND_SUCCESS;
	uint8_t tmpUint8;

	for ( i = 0u ; i < 4u ; i ++)   // U16 must be less than 4 hex digits: 0xFFFF
	{
		if ( COMMAND_SUCCESS == result )
		{
			tmpUint8 = ( parameterUint16 >> (12u - (i*4u)) & 0xF);
			result = ConsoleUtilsIntToHexChar(tmpUint8, &(out[i]));
		}
	}
	out[i] = NULL_CHAR;
	ConsoleIoSendString(out);

	return COMMAND_SUCCESS;
}

eCommandResult_T ConsoleSendParamHexUint8(uint8_t parameterUint8)
{
	uint32_t i;
	char out[2u + 1u];  // U8 must be less than 4 hex digits: 0xFFFF, end buffer with a NULL
	eCommandResult_T result = COMMAND_SUCCESS;

	i = 0u;
	result = ConsoleUtilsIntToHexChar( (parameterUint8 >> 4u) & 0xF, &(out[i]));
	i++;
	if ( COMMAND_SUCCESS == result )
	{
		result = ConsoleUtilsIntToHexChar( parameterUint8 & 0xF, &(out[i]));
		i++;
	}
	out[i] = NULL_CHAR;
	ConsoleIoSendString(out);

	return COMMAND_SUCCESS;
}


#if CONSOLE_USE_BUILTIN_ITOA
#define itoa smallItoa
// The C library itoa is sometimes a complicated function and the library costs aren't worth it
// so this is implements the parts of the function needed for console.
static void smallItoa(int in, char* outBuffer, int radix)
{
	bool isNegative = false;
	int tmpIn;
	int stringLen = 1u; // it will be at least as long as the NULL character

	if (in < 0) {
		isNegative = true;
		in = -in;
		stringLen++;
	}

	tmpIn = in;
	while ((int)tmpIn/radix != 0) {
		tmpIn = (int)tmpIn/radix;
		stringLen++;
	}
    
    // Now fill it in backwards, starting with the NULL at the end
    *(outBuffer + stringLen) = NULL_CHAR;
    stringLen--;

	tmpIn = in;
	do {
		*(outBuffer+stringLen) = (tmpIn%radix)+'0';
		tmpIn = (int) tmpIn / radix;
	} while(stringLen--);

	if (isNegative) {
		*(outBuffer) = '-';
	}
}
#endif

// ConsoleSendParamInt16
// Send a parameter of type int16 using the (unsafe) C library function
// itoa to translate from integer to string.
eCommandResult_T ConsoleSendParamInt16(int16_t parameterInt)
{
	char out[INT16_MAX_STR_LENGTH];
//	memset(out, 0, INT16_MAX_STR_LENGTH);

	itoa (parameterInt, out, 10);
	ConsoleIoSendString(out);

	return COMMAND_SUCCESS;
}

// ConsoleSendParamInt32
// Send a parameter of type int16 using the (unsafe) C library function
// itoa to translate from integer to string.
eCommandResult_T ConsoleSendParamInt32(int32_t parameterInt)
{
	char out[INT32_MAX_STR_LENGTH];
	memset(out, 0, sizeof(out));

	itoa (parameterInt, out, 10);
	ConsoleIoSendString(out);

	return COMMAND_SUCCESS;
}
// ConsoleUtilHexCharToInt
// Converts a single hex character (0-9,A-F) to an integer (0-15)
static eCommandResult_T ConsoleUtilHexCharToInt(char charVal, uint8_t* pInt)
{
    eCommandResult_T result = COMMAND_SUCCESS;

    if ( ( '0' <= charVal ) && ( charVal <= '9' ) )
    {
        *pInt = charVal - '0';
    }
    else if ( ( 'A' <= charVal ) && ( charVal <= 'F' ) )
    {
        *pInt = 10u + charVal - 'A';
    }
    else if( ( 'a' <= charVal ) && ( charVal <= 'f' ) )
    {
        *pInt = 10u + charVal - 'a';
    }
	else if ( ( LF_CHAR != charVal ) || ( CR_CHAR != charVal )
			|| ( PARAMETER_SEPARATER == charVal ) )
	{
		result = COMMAND_PARAMETER_END;

	}
    else
    {
        result = COMMAND_PARAMETER_ERROR;
    }

    return result;
}
// ConsoleUtilsIntToHexChar
// Converts an integer nibble (0-15) to a hex character (0-9,A-F)
static eCommandResult_T ConsoleUtilsIntToHexChar(uint8_t intVal, char* pChar)
{
    eCommandResult_T result = COMMAND_SUCCESS;

    if ( intVal <= 9u )
    {
        *pChar = intVal + '0';
    }
    else if ( ( 10u <= intVal ) && ( intVal <= 15u ) )
    {
        *pChar = intVal - 10u + 'A';
    }
    else
    {
        result = COMMAND_PARAMETER_ERROR;
    }

    return result;
}
// ConsoleSendString
// Send a null terminated string to the console.
// This is a light wrapper around ConsoleIoSendString. It uses the same
// API convention as the rest of the top level ConsoleSendX APIs 
// while exposing this functionality at the top level so 
// that the lower level consoleIo module doesn't need to be
// a dependency.
eCommandResult_T ConsoleSendString(const char *buffer)
{
	ConsoleIoSendString(buffer);
	return COMMAND_SUCCESS;
}

// ConsoleSendLine
// Send a null terminated string to the console followed by a line ending.
eCommandResult_T ConsoleSendLine(const char *buffer)
{
	ConsoleIoSendString(buffer);
	ConsoleIoSendString(STR_ENDLINE);
	return COMMAND_SUCCESS;
}

console.c

// ConsoleCommands.c
// This is where you add commands:
//		1. Add a protoype
//			static eCommandResult_T ConsoleCommandVer(const char buffer[]);
//		2. Add the command to mConsoleCommandTable
//		    {"ver", &ConsoleCommandVer, HELP("Get the version string")},
//		3. Implement the function, using ConsoleReceiveParam<Type> to get the parameters from the buffer.

#include <string.h>
#include "consoleCommands.h"
#include "console.h"
#include "consoleIo.h"
#include "version.h"

#define IGNORE_UNUSED_VARIABLE(x)     if ( &x == &x ) {}

static eCommandResult_T ConsoleCommandComment(const char buffer[]);
static eCommandResult_T ConsoleCommandVer(const char buffer[]);
static eCommandResult_T ConsoleCommandHelp(const char buffer[]);
static eCommandResult_T ConsoleCommandParamExampleInt16(const char buffer[]);
static eCommandResult_T ConsoleCommandParamExampleHexUint16(const char buffer[]);

static const sConsoleCommandTable_T mConsoleCommandTable[] =
{
    {";", ConsoleCommandComment, HELP("Comment! You do need a space after the semicolon. ")},
    {"help", ConsoleCommandHelp, HELP("Lists the commands available")},
    {"ver", ConsoleCommandVer, HELP("Get the version string")},
    {"int", ConsoleCommandParamExampleInt16, HELP("How to get a signed int16 from params list: int -321")},
    {"u16h", ConsoleCommandParamExampleHexUint16, HELP("How to get a hex u16 from the params list: u16h aB12")},

	CONSOLE_COMMAND_TABLE_END // must be LAST
};

static eCommandResult_T ConsoleCommandComment(const char buffer[])
{
	// do nothing
	IGNORE_UNUSED_VARIABLE(buffer);
	return COMMAND_SUCCESS;
}

static eCommandResult_T ConsoleCommandHelp(const char buffer[])
{
	uint32_t i;
	uint32_t tableLength;
	eCommandResult_T result = COMMAND_SUCCESS;

    IGNORE_UNUSED_VARIABLE(buffer);

	tableLength = sizeof(mConsoleCommandTable) / sizeof(mConsoleCommandTable[0]);
	for ( i = 0u ; i < tableLength - 1u ; i++ )
	{
		ConsoleIoSendString(mConsoleCommandTable[i].name);
#if CONSOLE_COMMAND_MAX_HELP_LENGTH > 0
		ConsoleIoSendString(" : ");
		ConsoleIoSendString(mConsoleCommandTable[i].help);
#endif // CONSOLE_COMMAND_MAX_HELP_LENGTH > 0
		ConsoleIoSendString(STR_ENDLINE);
	}
	return result;
}

static eCommandResult_T ConsoleCommandParamExampleInt16(const char buffer[])
{
	int16_t parameterInt;
	eCommandResult_T result;
	result = ConsoleReceiveParamInt16(buffer, 1, &parameterInt);
	if ( COMMAND_SUCCESS == result )
	{
		ConsoleIoSendString("Parameter is ");
		ConsoleSendParamInt16(parameterInt);
		ConsoleIoSendString(" (0x");
		ConsoleSendParamHexUint16((uint16_t)parameterInt);
		ConsoleIoSendString(")");
		ConsoleIoSendString(STR_ENDLINE);
	}
	return result;
}
static eCommandResult_T ConsoleCommandParamExampleHexUint16(const char buffer[])
{
	uint16_t parameterUint16;
	eCommandResult_T result;
	result = ConsoleReceiveParamHexUint16(buffer, 1, &parameterUint16);
	if ( COMMAND_SUCCESS == result )
	{
		ConsoleIoSendString("Parameter is 0x");
		ConsoleSendParamHexUint16(parameterUint16);
		ConsoleIoSendString(STR_ENDLINE);
	}
	return result;
}

static eCommandResult_T ConsoleCommandVer(const char buffer[])
{
	eCommandResult_T result = COMMAND_SUCCESS;

    IGNORE_UNUSED_VARIABLE(buffer);

	ConsoleIoSendString(VERSION_STRING);
	ConsoleIoSendString(STR_ENDLINE);
	return result;
}


const sConsoleCommandTable_T* ConsoleCommandsGetTable(void)
{
	return (mConsoleCommandTable);
}




consoleCommands.c


// The console command interface is generally used only by console.c, 
// if you want to add a command, go to consoleCommands.c

#ifndef CONSOLE_COMMANDS_H
#define CONSOLE_COMMANDS_H

#include <stdint.h>
#include "console.h"

#define CONSOLE_COMMAND_MAX_COMMAND_LENGTH 10		// command only
#define CONSOLE_COMMAND_MAX_LENGTH 256				// whole command with argument
#define CONSOLE_COMMAND_MAX_HELP_LENGTH 64			// if this is zero, there will be no  help (XXXOPT: RAM reduction)

#if CONSOLE_COMMAND_MAX_HELP_LENGTH > 0
	#define HELP(x)  (x)
#else
	#define HELP(x)	  0
#endif // CONSOLE_COMMAND_MAX_HELP_LENGTH

typedef eCommandResult_T(*ConsoleCommand_T)(const char buffer[]);

typedef struct sConsoleCommandStruct
{
    const char* name;
    ConsoleCommand_T execute;
#if CONSOLE_COMMAND_MAX_HELP_LENGTH > 0
	char help[CONSOLE_COMMAND_MAX_HELP_LENGTH];
#else
	uint8_t junk;
#endif // CONSOLE_COMMAND_MAX_HELP_LENGTH 
} sConsoleCommandTable_T;

#define CONSOLE_COMMAND_TABLE_END {NULL, NULL, HELP("")}

const sConsoleCommandTable_T* ConsoleCommandsGetTable(void);

#endif // CONSOLE_COMMANDS_H



consoleCommands.h

// Console IO is a wrapper between the actual in and output and the console code
// In an embedded system, this might interface to a UART driver.

#include "consoleIo.h"
#include <stdio.h>

eConsoleError ConsoleIoInit(void)
{
	return CONSOLE_SUCCESS;
}

// This is modified for the Wokwi RPi Pico simulator. It works fine 
// but that's partially because the serial terminal sends all of the 
// characters at a time without losing any of them. What if this function
// wasn't called fast enough?
eConsoleError ConsoleIoReceive(uint8_t *buffer, const uint32_t bufferLength, uint32_t *readLength)
{
	uint32_t i = 0;
	char ch;

	while (uart_is_readable(uart0)) 
	{
  	ch = uart_getc(uart0);
  	uart_putc(uart0, ch); // echo
		buffer[i] = (uint8_t) ch;
		i++;
	}

	*readLength = i;
	return CONSOLE_SUCCESS;
}

eConsoleError ConsoleIoSendString(const char *buffer)
{
	printf("%s", buffer);
	return CONSOLE_SUCCESS;
}



consoleIo.c

// Console IO is a wrapper between the actual in and output and the console code

#ifndef CONSOLE_IO_H
#define CONSOLE_IO_H

#include <stdint.h>
#include "pico/stdlib.h"

typedef enum {CONSOLE_SUCCESS = 0u, CONSOLE_ERROR = 1u } eConsoleError;

eConsoleError ConsoleIoInit(void);

eConsoleError ConsoleIoReceive(uint8_t *buffer, const uint32_t bufferLength, uint32_t *readLength);
eConsoleError ConsoleIoSendString(const char *buffer); // must be null terminated

#endif // CONSOLE_IO_H


consoleIo.h

#ifndef VERSION_H
#define VERSION_H

#define VERSION_STRING "ReusableCode 0.0.0.1"

#endif // VERSION_H