Struct AtParser 

pub struct AtParser<'a, T, const SIZE: usize>
where
    T: AtContext<SIZE> + ?Sized,
{
    pub commands: &'a mut [(&'static str, &'a mut T)],
}

The main AT command parser

Generic over T which must implement the AtContext<SIZE> trait, and over the const SIZE which determines the response buffer size.

Generic Design

The parser is generic over the command handler type T and response size SIZE to allow compile-time type checking when all handlers are of the same type. This provides:

• Type safety: Compile-time verification of handler types
• Zero overhead: No dynamic dispatch when using concrete types
• Flexibility: Can be used with trait objects (dyn AtContext<SIZE>) for mixed handler types

Usage Patterns

With trait objects (recommended for mixed types):

const SIZE: usize = 64;
let mut parser: AtParser<dyn AtContext<SIZE>, SIZE> = AtParser::new();
let commands: &mut [(&str, &mut dyn AtContext<SIZE>)] = &mut [
    ("AT+ECHO", &mut echo_handler),
    ("AT+RST", &mut reset_handler),
];
parser.set_commands(commands);

With concrete types (for homogeneous handlers):

const SIZE: usize = 64;
let mut parser: AtParser<MyHandler, SIZE> = AtParser::new();
let commands: &mut [(&str, &mut MyHandler)] = &mut [
    ("AT+CMD1", &mut handler1),
    ("AT+CMD2", &mut handler2),
];
parser.set_commands(commands);

Fields

commands: &'a mut [(&'static str, &'a mut T)]

Array of registered commands with their name and handler

Implementations

impl<'a, T, const SIZE: usize> AtParser<'a, T, SIZE>

where T: AtContext<SIZE> + ?Sized,

pub fn new() -> Self

Create a new empty parser

Examples found in repository

examples/basic_parser.rs (line 75)

pub extern "C" fn main() -> ! {
    let mut cmd1 = TestCommand { value: 0 };
    let mut cmd2 = TestCommand { value: 5 };
    let mut cmd3 = TestCommand { value: 10 };

    let mut parser: AtParser<TestCommand, SIZE> = AtParser::new();

    let commands: &mut [(&str, &mut TestCommand)] = &mut [
        ("AT+CMD1", &mut cmd1),
        ("AT+CMD2", &mut cmd2),
        ("AT+CMD3", &mut cmd3),
    ];
    parser.set_commands(commands);

    // Execute (no-op result, just exercising the API)
    let _ = parser.execute("AT+CMD1");
    let _ = parser.execute("AT+CMD1?");
    let _ = parser.execute("AT+CMD1=?");
    let _ = parser.execute("AT+CMD1=42");
    let _ = parser.execute("AT+CMD1?");
    let _ = parser.execute("AT+CMD2");
    let _ = parser.execute("AT+CMD2?");
    let _ = parser.execute("AT+CMD3=100");
    let _ = parser.execute("AT+CMD3?");
    let _ = parser.execute("AT+UNKNOWN");   // -> Err(UnknownCommand)
    let _ = parser.execute("AT+CMD1=abc");  // -> Err(InvalidArgs)

    loop {}
}

pub fn set_commands(&mut self, commands: &'a mut [(&'static str, &'a mut T)])

Register commands that this parser will handle

Examples found in repository

examples/basic_parser.rs (line 82)

pub extern "C" fn main() -> ! {
    let mut cmd1 = TestCommand { value: 0 };
    let mut cmd2 = TestCommand { value: 5 };
    let mut cmd3 = TestCommand { value: 10 };

    let mut parser: AtParser<TestCommand, SIZE> = AtParser::new();

    let commands: &mut [(&str, &mut TestCommand)] = &mut [
        ("AT+CMD1", &mut cmd1),
        ("AT+CMD2", &mut cmd2),
        ("AT+CMD3", &mut cmd3),
    ];
    parser.set_commands(commands);

    // Execute (no-op result, just exercising the API)
    let _ = parser.execute("AT+CMD1");
    let _ = parser.execute("AT+CMD1?");
    let _ = parser.execute("AT+CMD1=?");
    let _ = parser.execute("AT+CMD1=42");
    let _ = parser.execute("AT+CMD1?");
    let _ = parser.execute("AT+CMD2");
    let _ = parser.execute("AT+CMD2?");
    let _ = parser.execute("AT+CMD3=100");
    let _ = parser.execute("AT+CMD3?");
    let _ = parser.execute("AT+UNKNOWN");   // -> Err(UnknownCommand)
    let _ = parser.execute("AT+CMD1=abc");  // -> Err(InvalidArgs)

    loop {}
}

pub fn execute(&mut self, input: &str) -> AtResult<SIZE>

Parse and execute an AT command string

Arguments

• input - The raw AT command string (e.g., “AT+CMD?”)

Returns

• Ok(Bytes<SIZE>) - Success response from the command handler
• Err(AtError) - Error if parsing fails or command is not found

Examples found in repository

examples/basic_parser.rs (line 85)

pub extern "C" fn main() -> ! {
    let mut cmd1 = TestCommand { value: 0 };
    let mut cmd2 = TestCommand { value: 5 };
    let mut cmd3 = TestCommand { value: 10 };

    let mut parser: AtParser<TestCommand, SIZE> = AtParser::new();

    let commands: &mut [(&str, &mut TestCommand)] = &mut [
        ("AT+CMD1", &mut cmd1),
        ("AT+CMD2", &mut cmd2),
        ("AT+CMD3", &mut cmd3),
    ];
    parser.set_commands(commands);

    // Execute (no-op result, just exercising the API)
    let _ = parser.execute("AT+CMD1");
    let _ = parser.execute("AT+CMD1?");
    let _ = parser.execute("AT+CMD1=?");
    let _ = parser.execute("AT+CMD1=42");
    let _ = parser.execute("AT+CMD1?");
    let _ = parser.execute("AT+CMD2");
    let _ = parser.execute("AT+CMD2?");
    let _ = parser.execute("AT+CMD3=100");
    let _ = parser.execute("AT+CMD3?");
    let _ = parser.execute("AT+UNKNOWN");   // -> Err(UnknownCommand)
    let _ = parser.execute("AT+CMD1=abc");  // -> Err(InvalidArgs)

    loop {}
}