Struct UbootShell 

pub struct UbootShell {
    pub tx: Option<Box<dyn Write + Send>>,
    pub rx: Option<Box<dyn Read + Send>>,
    /* private fields */
}

U-Boot shell communication interface.

UbootShell provides methods to interact with U-Boot bootloader over a serial connection. It handles shell synchronization, command execution, and file transfers.

Example

use uboot_shell::UbootShell;

// Assuming tx and rx are Read/Write implementations
let mut shell = UbootShell::new(tx, rx).unwrap();
let result = shell.cmd("printenv").unwrap();

Fields

tx: Option<Box<dyn Write + Send>>

Transmit channel for sending data to U-Boot.

rx: Option<Box<dyn Read + Send>>

Receive channel for reading data from U-Boot.

Implementations

impl UbootShell

pub fn new( tx: impl Write + Send + 'static, rx: impl Read + Send + 'static, ) -> Result<Self>

Creates a new UbootShell instance and waits for U-Boot shell to be ready.

This function will block until it successfully detects the U-Boot shell prompt. It sends interrupt signals (Ctrl+C) to ensure the shell is in a clean state.

Arguments

• tx - A writable stream for sending data to U-Boot
• rx - A readable stream for receiving data from U-Boot

Returns

Returns Ok(UbootShell) if the shell is successfully initialized, or an Err if communication fails.

Errors

Returns an error if the serial I/O fails or the prompt cannot be detected within the internal retry loop.

Example

use uboot_shell::UbootShell;

let port = serialport::new("/dev/ttyUSB0", 115200).open().unwrap();
let rx = port.try_clone().unwrap();
let mut uboot = UbootShell::new(port, rx).unwrap();

pub fn wait_for_reply(&mut self, val: &str) -> Result<String>

Waits for a specific string to appear in the U-Boot output.

Reads from the serial connection until the specified string is found.

Arguments

• val - The string to wait for

Returns

Returns the accumulated output up to and including the matched string.

Errors

Returns an error when the underlying read operation times out or fails.

pub fn cmd_without_reply(&mut self, cmd: &str) -> Result<()>

Sends a command to U-Boot without waiting for the response.

This is useful for commands that don’t produce output or when you want to handle the response separately.

Arguments

• cmd - The command string to send

Errors

Returns any I/O error that occurs while writing to the serial stream.

pub fn cmd(&mut self, cmd: &str) -> Result<String>

Executes a command in U-Boot shell and returns the output.

This method sends the command, waits for completion, and verifies that the command executed successfully. It includes automatic retry logic (up to 3 attempts) for improved reliability.

Arguments

• cmd - The command string to execute

Returns

Returns Ok(String) with the command output on success, or an Err if the command fails after all retries.

Errors

Returns an error if the command fails after retries or if serial I/O fails.

Example

let output = uboot.cmd("printenv bootargs").unwrap();
println!("bootargs: {}", output);

pub fn set_env( &mut self, name: impl Into<String>, value: impl Into<String>, ) -> Result<()>

Sets a U-Boot environment variable.

Arguments

• name - The name of the environment variable
• value - The value to set

Example

uboot.set_env("bootargs", "console=ttyS0,115200").unwrap();

Errors

Returns any error from the underlying command execution.

pub fn env(&mut self, name: impl Into<String>) -> Result<String>

Gets the value of a U-Boot environment variable.

Arguments

• name - The name of the environment variable

Returns

Returns Ok(String) with the variable value, or an Err if not found.

Errors

Returns ErrorKind::NotFound if the variable is not set or cannot be read.

Example

let bootargs = uboot.env("bootargs").unwrap();

Errors

Returns ErrorKind::NotFound if the variable is not set or cannot be read.

pub fn env_int(&mut self, name: impl Into<String>) -> Result<usize>

Gets a U-Boot environment variable as an integer.

Supports both decimal and hexadecimal (0x prefix) formats.

Arguments

• name - The name of the environment variable

Returns

Returns Ok(usize) with the parsed integer value, or an Err if not found or not a valid number.

Errors

Returns ErrorKind::InvalidData if the value is not a valid integer.

pub fn loady( &mut self, addr: usize, file: impl Into<PathBuf>, on_progress: impl Fn(usize, usize), ) -> Result<String>

Transfers a file to U-Boot memory using YMODEM protocol.

Uses the U-Boot loady command to receive files via YMODEM protocol. The file will be loaded to the specified memory address.

Arguments

• addr - The memory address where the file will be loaded
• file - Path to the file to transfer
• on_progress - Callback function called with (bytes_sent, total_bytes)

Returns

Returns Ok(String) with the U-Boot response on success.

Errors

Returns an error if the file cannot be opened, the path has a non-UTF-8 file name, or if the serial transfer fails.

Example

uboot.loady(0x80000000, "kernel.bin", |sent, total| {
    println!("Progress: {}/{} bytes", sent, total);
}).unwrap();

Trait Implementations

impl Read for UbootShell

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.

impl Write for UbootShell

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.