UART Command Shell — Kareem Ahmed

C++17
std::string_view
Function pointers
Zero allocation
Exception-free
Unit-tested

What it is

A command interpreter for embedded devices you can talk to over a UART. It reads a line of input, parses and validates it, and dispatches to the right handler — the kind of debug/diagnostic console real firmware needs on the bench. The whole thing is built to embedded constraints: it never touches the heap, avoids std::function, and reports outcomes with explicit Status codes instead of exceptions.

How it works

Zero-copy tokenizing. The input line is split into std::string_view tokens that point back into the original buffer — no string copies, no allocation.
Function-pointer dispatch. Commands register a plain function pointer (not std::function), stored in a fixed-size array registry — deterministic, heap-free, ISR-friendly.
Typed, range-checked settings. The set/get commands own a table of settings with min/max bounds and write straight to the target variable, rejecting out-of-range input with a clear status.
Built-in commands: help, echo, set, get, and history — with unit tests that run on the host.

Why it's built this way

Every design choice maps to an embedded reality. string_view avoids allocation; function pointers keep the dispatch table small and predictable; explicit Status return codes replace exceptions (which are often banned in safety-critical firmware). It's a compact demonstration of writing modern, clean C++ that still respects the tight budget of a microcontroller.

enum class Status { Ok, Empty, UnknownCommand, BadArguments }; // register a handler — no heap, no std::function shell.register_command("echo", &handle_echo); // dispatch a received line, get an explicit status back Status s = shell.execute("set speed 50");