[][src]Struct avr_hal_generic::usart::Usart

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

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
[src]

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

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>[src]

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

Deinitialize/disable this peripheral and release the pins.

pub fn flush(&mut self)[src]

Block until all remaining data has been transmitted.

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

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[src]

Receive a byte.

This method will block until a byte could be received.

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

Enable the interrupt for Event.

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

Disable the interrupt for Event.

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

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>[src]

type Error = Void

Read error

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

type Error = Void

Write error

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

type Error = Void

The error associated to this writer

Auto Trait Implementations

impl<H, USART, RX, TX, CLOCK> Send for Usart<H, USART, RX, TX, CLOCK> where
    CLOCK: Send,
    H: Send,
    RX: Send,
    TX: Send,
    USART: Send
[src]

impl<H, USART, RX, TX, CLOCK> Sync for Usart<H, USART, RX, TX, CLOCK> where
    CLOCK: Sync,
    H: Sync,
    RX: Sync,
    TX: Sync,
    USART: Sync
[src]

impl<H, USART, RX, TX, CLOCK> Unpin for Usart<H, USART, RX, TX, CLOCK> where
    CLOCK: Unpin,
    H: Unpin,
    RX: Unpin,
    TX: Unpin,
    USART: Unpin
[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.