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

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").unwrap_infallible();

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

Implementations§

source§

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,

source

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.

source§

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

source

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

Deinitialize/disable this peripheral and release the pins.

source

pub fn flush(&mut self)

Block until all remaining data has been transmitted.

source

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.

source

pub fn read_byte(&mut self) -> u8

Receive a byte.

This method will block until a byte could be received.

source

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

Enable the interrupt for Event.

source

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

Disable the interrupt for Event.

source

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§

source§

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

§

type Error = Infallible

Read error
source§

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

Reads a single word from the serial interface
source§

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

§

type Error = Infallible

Write error
source§

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

Writes a single word to the serial interface
source§

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

Ensures that none of the previously written words are still buffered
source§

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

§

type Error = Infallible

The error associated to this writer
source§

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

Writes a string slice into this writer, returning whether the write succeeded. Read more
source§

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

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

Auto Trait Implementations§

§

impl<H, USART, RX, TX, CLOCK> RefUnwindSafe for Usart<H, USART, RX, TX, CLOCK>

§

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,

§

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,

§

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,

§

impl<H, USART, RX, TX, CLOCK> UnwindSafe for Usart<H, USART, RX, TX, CLOCK>
where CLOCK: UnwindSafe, H: UnwindSafe, RX: UnwindSafe, TX: UnwindSafe, USART: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.