Trait AtContext 

pub trait AtContext {
    // Provided methods
    fn exec(&self) -> AtResult<'static> { ... }
    fn query(&mut self) -> AtResult<'static> { ... }
    fn test(&mut self) -> AtResult<'static> { ... }
    fn set(&mut self, _args: Args<'_>) -> AtResult<'static> { ... }
}

Trait that defines the context for AT command execution. Implementations of this trait handle the actual logic for each AT command form.

Provided Methods

fn exec(&self) -> AtResult<'static>

Execute command (AT+CMD) This is called when a command is invoked without any suffix.

Examples found in repository

examples/complete_usage.rs (line 171)

fn execute_command(cmd: &str, name: &str, module: &mut dyn AtContext) {
    println!("\n> {}", cmd);
    
    let result = if let Some(rest) = cmd.strip_prefix(name) {
        if rest.is_empty() {
            // Execute form: AT+CMD
            module.exec()
        } else if rest == "?" {
            // Query form: AT+CMD?
            module.query()
        } else if rest == "=?" {
            // Test form: AT+CMD=?
            module.test()
        } else if let Some(args_str) = rest.strip_prefix('=') {
            // Set form: AT+CMD=args
            module.set(Args { raw: args_str })
        } else {
            Err(AtError::InvalidArgs)
        }
    } else {
        Err(AtError::UnknownCommand)
    };
    
    match result {
        Ok(response) => println!("  Response: {}", response),
        Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
        Err(AtError::NotSupported) => println!("  Error: Operation not supported"),
        Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
    }
}

fn query(&mut self) -> AtResult<'static>

Query command (AT+CMD?) This is called to retrieve the current value/state of a command.

Examples found in repository

examples/complete_usage.rs (line 174)

fn execute_command(cmd: &str, name: &str, module: &mut dyn AtContext) {
    println!("\n> {}", cmd);
    
    let result = if let Some(rest) = cmd.strip_prefix(name) {
        if rest.is_empty() {
            // Execute form: AT+CMD
            module.exec()
        } else if rest == "?" {
            // Query form: AT+CMD?
            module.query()
        } else if rest == "=?" {
            // Test form: AT+CMD=?
            module.test()
        } else if let Some(args_str) = rest.strip_prefix('=') {
            // Set form: AT+CMD=args
            module.set(Args { raw: args_str })
        } else {
            Err(AtError::InvalidArgs)
        }
    } else {
        Err(AtError::UnknownCommand)
    };
    
    match result {
        Ok(response) => println!("  Response: {}", response),
        Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
        Err(AtError::NotSupported) => println!("  Error: Operation not supported"),
        Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
    }
}

fn test(&mut self) -> AtResult<'static>

Test command (AT+CMD=?) This is called to check if a command is supported or to get valid parameter ranges.

Examples found in repository

examples/complete_usage.rs (line 177)

fn execute_command(cmd: &str, name: &str, module: &mut dyn AtContext) {
    println!("\n> {}", cmd);
    
    let result = if let Some(rest) = cmd.strip_prefix(name) {
        if rest.is_empty() {
            // Execute form: AT+CMD
            module.exec()
        } else if rest == "?" {
            // Query form: AT+CMD?
            module.query()
        } else if rest == "=?" {
            // Test form: AT+CMD=?
            module.test()
        } else if let Some(args_str) = rest.strip_prefix('=') {
            // Set form: AT+CMD=args
            module.set(Args { raw: args_str })
        } else {
            Err(AtError::InvalidArgs)
        }
    } else {
        Err(AtError::UnknownCommand)
    };
    
    match result {
        Ok(response) => println!("  Response: {}", response),
        Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
        Err(AtError::NotSupported) => println!("  Error: Operation not supported"),
        Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
    }
}

fn set(&mut self, _args: Args<'_>) -> AtResult<'static>

Set command (AT+CMD=args) This is called to set parameters for a command.

Examples found in repository

examples/complete_usage.rs (line 180)

fn execute_command(cmd: &str, name: &str, module: &mut dyn AtContext) {
    println!("\n> {}", cmd);
    
    let result = if let Some(rest) = cmd.strip_prefix(name) {
        if rest.is_empty() {
            // Execute form: AT+CMD
            module.exec()
        } else if rest == "?" {
            // Query form: AT+CMD?
            module.query()
        } else if rest == "=?" {
            // Test form: AT+CMD=?
            module.test()
        } else if let Some(args_str) = rest.strip_prefix('=') {
            // Set form: AT+CMD=args
            module.set(Args { raw: args_str })
        } else {
            Err(AtError::InvalidArgs)
        }
    } else {
        Err(AtError::UnknownCommand)
    };
    
    match result {
        Ok(response) => println!("  Response: {}", response),
        Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
        Err(AtError::NotSupported) => println!("  Error: Operation not supported"),
        Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
    }
}

Implementors