Struct serial_port::SerialPortBasic

pub struct SerialPortBasic { /* private fields */ }

A serial port and its various data and control registers.

TODO: use PortReadOnly and PortWriteOnly to set permissions for each register.

Implementations

impl SerialPort

pub fn new(base_port: u16) -> SerialPort

Creates and returns a new serial port structure, and initializes that port using standard configuration parameters.

The configuration parameters used in this function are:

• A baud rate of 38400.
• “8N1” mode: data word length of 8 bits, with no parity and one stop bit.
• FIFO buffer enabled with a threshold of 14 bytes.
• Interrupts enabled for receiving bytes only (not transmitting).

Arguments

• base_port: the port number (port I/O address) of the serial port. This should generally be one of the known serial ports, e.g., on x86, SerialPortAddress::COM1 through SerialPortAddress::COM4.

Note: if you are experiencing problems with serial port behavior, try enabling the loopback test part of this function to see if that passes.

pub fn enable_interrupt( &mut self, event: SerialPortInterruptEvent, enable: bool )

Enable or disable interrupts on this serial port for various events.

pub fn acknowledge_interrupt(&mut self, _event: SerialPortInterruptEvent)

Clears an interrupt in the serial port controller

pub fn out_str(&mut self, s: &str)

Write the given string to the serial port, blocking until data can be transmitted.

Special characters

Because this function writes strings, it will transmit a carriage return '\r' after transmitting a line feed (new line) '\n' to ensure a proper new line.

pub fn out_byte(&mut self, byte: u8)

Write the given byte to the serial port, blocking until data can be transmitted.

This writes the byte directly with no special cases, e.g., new lines.

pub fn out_bytes(&mut self, bytes: &[u8])

Write the given bytes to the serial port, blocking until data can be transmitted.

This writes the bytes directly with no special cases, e.g., new lines.

pub fn in_byte(&mut self) -> u8

Read one byte from the serial port, blocking until data is available.

pub fn in_bytes(&mut self, buffer: &mut [u8]) -> usize

Reads multiple bytes from the serial port into the given buffer, non-blocking.

The buffer will be filled with as many bytes as are available in the serial port. Once data is no longer available to be read, the read operation will stop.

If no data is immediately available on the serial port, this will read nothing and return 0.

Returns the number of bytes read into the given buffer.

pub fn ready_to_transmit(&self) -> bool

Returns true if the serial port is ready to transmit a byte.

pub fn data_available(&self) -> bool

Returns true if the serial port has data available to read.

pub fn base_port_address(&self) -> SerialPortAddress

Trait Implementations

impl Drop for SerialPort

fn drop(&mut self)

Executes the destructor for this type.

impl Write for SerialPort

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

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

Glue for usage of the write! macro with implementors of this trait.