at-parser-rs 0.5.0

A flexible AT command parser for embedded systems and communication devices with no_std support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

/***************************************************************************
 *
 * AT Command Parser
 * Copyright (C) 2026 Antonio Salsi <passy.linux@zresa.it>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <https://www.gnu.org/licenses/>.
 *
 ***************************************************************************/
 
//! Advanced example: error handling patterns with the at_response! macro
//!
//! Demonstrates how to propagate and inspect `AtResult` values whose Ok and
//! Err variants both carry the AT response prefix alongside the payload.

#![allow(dead_code)]
#![no_std]
#![no_main]

extern crate at_parser_rs;

use at_parser_rs::context::AtContext;
use at_parser_rs::parser::AtParser;
use at_parser_rs::{Args, AtError, AtResult, at_response};

const SIZE: usize = 64;

/// A command that may fail in different ways
struct DiagModule {
    armed: bool,
}

impl AtContext<SIZE> for DiagModule {
    fn exec(&mut self, at_response: &'static str) -> AtResult<'_, SIZE> {
        if self.armed {
            Ok(at_response!(SIZE, at_response; "TRIGGERED"))
        } else {
            Err((at_response, AtError::Unhandled("not armed")))
        }
    }

    fn query(&mut self, at_response: &'static str) -> AtResult<'_, SIZE> {
        Ok(at_response!(SIZE, at_response; if self.armed { 1u8 } else { 0u8 }))
    }

    fn test(&mut self, at_response: &'static str) -> AtResult<'_, SIZE> {
        Ok(at_response!(SIZE, at_response; "(0,1)"))
    }

    fn set(&mut self, at_response: &'static str, args: Args) -> AtResult<'_, SIZE> {
        let val = args.get(0).ok_or((at_response, AtError::InvalidArgs))?;
        match val.as_ref() {
            "0" => { self.armed = false; Ok(at_response!(SIZE, at_response; "OK")) }
            "1" => { self.armed = true;  Ok(at_response!(SIZE, at_response; "OK")) }
            _ => Err((at_response, AtError::InvalidArgs)),
        }
    }
}

/// Inspect the result of an execute call and return a status byte
fn check_result(result: AtResult<SIZE>) -> u8 {
    match result {
        Ok((_, _))                           => 0,  // success
        Err((_, AtError::InvalidArgs))       => 1,
        Err((_, AtError::NotSupported))      => 2,
        Err((_, AtError::UnknownCommand))    => 3,
        Err((_, AtError::Unhandled(_)))      => 4,
        Err((_, AtError::UnhandledOwned(_))) => 5,
    }
}

#[unsafe(no_mangle)]
pub extern "C" fn main() -> ! {
    let mut diag = DiagModule { armed: false };

    let mut parser: AtParser<DiagModule, SIZE> = AtParser::new();
    let commands: &mut [(&str, &str, &mut DiagModule)] = &mut [
        ("AT+DIAG", "+DIAG: ", &mut diag),
    ];
    parser.set_commands(commands);

    // Not armed yet: exec returns Unhandled
    let _s = check_result(parser.execute("AT+DIAG"));    // -> 4

    // Arm it
    let _s = check_result(parser.execute("AT+DIAG=1"));  // -> 0

    // Now exec succeeds
    let _s = check_result(parser.execute("AT+DIAG"));    // -> 0

    // Query state
    let _s = check_result(parser.execute("AT+DIAG?"));   // -> 0

    // Invalid argument
    let _s = check_result(parser.execute("AT+DIAG=2"));  // -> 1

    // Unknown command
    let _s = check_result(parser.execute("AT+UNKNOWN")); // -> 3

    loop {}
}