Struct PL011

pub struct PL011<UART> {
    pub regs: UART,
    /* private fields */
}

Struct representing the actual driver.

Notice that there are no silly ideas like setting the baud rate, or assigning GPIO pins to the driver: the qemu implementation doesnt need any of that, we can just write to the registers directly.

Implements embedded_hal::serial as well as core::fmt::Write

Examples

use pl011_qemu;
// build a driver for UART1
let mut uart = pl011_qemu::PL011::new(pl011_qemu::UART1::take().unwrap());

Fields

regs: UART

owned copy of the underlying uart registers.

Since they are moved into this struct, no one else can access them after the driver is initialized

Implementations

impl<T> PL011<T>

where T: ConstRegBlockPtr<PL011_Regs>,

pub fn new(uart: T) -> Self

Initialize a UART driver. Needs a UART struct to be passed in

pub fn split(self) -> (Tx<T>, Rx<T>)

splits a single PL011 uart object into separate Rx and Tx streams.

Useful when you want to separate the two different halves of the UART and use them in different parts of the application

Note that the Rx and Tx structs do not contain a reference to the underlying UART, this is because once you split the UART in half, it is no longer possible to interact with the uart hardware directly, since the other half (rx or tx) might be using it at the same time.

pub fn write_byte(&self, data: u8)

writes a single byte out the uart

spins until space is available in the fifo

pub fn read_byte(&self) -> u8

reads a single byte out the uart

spins until a byte is available in the fifo

Trait Implementations

impl<T> Write for PL011<T>

where Tx<T>: Write,

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

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.

impl<T> Read<u8> for PL011<T>

where Rx<T>: Read<u8, Error = Error>,

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Self::Error>

Reads a single word from the serial interface

impl<T> Write<u8> for PL011<T>

where Tx<T>: Write<u8, Error = Error>,

type Error = Error

Write error

fn write(&mut self, word: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

fn flush(&mut self) -> Result<(), Self::Error>

Ensures that none of the previously written words are still buffered