Struct avr_hal_generic::usart::Usart

pub struct Usart<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> { /* private fields */ }

USART/Serial driver

Example

(This example is taken from Arduino Uno)

let dp = arduino_uno::Peripherals::take().unwrap();
let mut pins = arduino_uno::Pins::new(dp.PORTB, dp.PORTC, dp.PORTD);
let mut serial = arduino_uno::Serial::new(
    dp.USART0,
    pins.d0,
    pins.d1.into_output(&mut pins.ddr),
    57600.into_baudrate(),
);

ufmt::uwriteln!(&mut serial, "Hello from Arduino!\r").void_unwrap();

loop {
    let b = nb::block!(serial.read()).void_unwrap();
    ufmt::uwriteln!(&mut serial, "Got {}!\r", b).void_unwrap();
}

Implementations

impl<H, USART, RXPIN, TXPIN, CLOCK> Usart<H, USART, Pin<Input, RXPIN>, Pin<Output, TXPIN>, CLOCK> where
    USART: UsartOps<H, Pin<Input, RXPIN>, Pin<Output, TXPIN>>,
    RXPIN: PinOps,
    TXPIN: PinOps, 

pub fn new<IMODE: InputMode>(
    p: USART,
    rx: Pin<Input<IMODE>, RXPIN>,
    tx: Pin<Output, TXPIN>,
    baudrate: Baudrate<CLOCK>
) -> Self

Initialize a USART peripheral on the given pins.

Note that the RX and TX pins are hardwired for each USART peripheral and you must pass the correct ones. This is enforced at compile time.

impl<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> Usart<H, USART, RX, TX, CLOCK>

pub fn release(self) -> (USART, RX, TX)

Deinitialize/disable this peripheral and release the pins.

pub fn flush(&mut self)

Block until all remaining data has been transmitted.

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

Transmit a byte.

This method will block until the byte has been enqueued for transmission but not until it was entirely sent.

pub fn read_byte(&mut self) -> u8

Receive a byte.

This method will block until a byte could be received.

pub fn listen(&mut self, event: Event)

Enable the interrupt for Event.

pub fn unlisten(&mut self, event: Event)

Disable the interrupt for Event.

pub fn split(
    self
) -> (UsartReader<H, USART, RX, TX, CLOCK>, UsartWriter<H, USART, RX, TX, CLOCK>)

Split this USART into a UsartReader and a UsartWriter.

This allows concurrently receiving and transmitting data from different contexts.

Trait Implementations

impl<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> Read<u8> for Usart<H, USART, RX, TX, CLOCK>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> Write<u8> for Usart<H, USART, RX, TX, CLOCK>

type Error = Void

Write error

fn write(&mut self, byte: 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

impl<H, USART: UsartOps<H, RX, TX>, RX, TX, CLOCK> uWrite for Usart<H, USART, RX, TX, CLOCK>

type Error = Void

The error associated to this writer

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

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

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

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