Struct tm4c123x_hal::serial::Serial

pub struct Serial<UART, TX, RX, RTS, CTS> { /* private fields */ }

Serial abstraction

Implementations

impl<TX, RX, RTS, CTS> Serial<UART0, TX, RX, RTS, CTS>

pub fn uart0(
    uart: UART0,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART0>,
    RX: RxPin<UART0>,
    CTS: CtsPin<UART0>,
    RTS: RtsPin<UART0>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART0, TX, RTS>, Rx<UART0, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART0, TX, RTS>,
    rx: Rx<UART0, RX, CTS>
) -> Serial<UART0, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART0, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART1, TX, RX, RTS, CTS>

pub fn uart1(
    uart: UART1,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART1>,
    RX: RxPin<UART1>,
    CTS: CtsPin<UART1>,
    RTS: RtsPin<UART1>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART1, TX, RTS>, Rx<UART1, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART1, TX, RTS>,
    rx: Rx<UART1, RX, CTS>
) -> Serial<UART1, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART1, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART2, TX, RX, RTS, CTS>

pub fn uart2(
    uart: UART2,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART2>,
    RX: RxPin<UART2>,
    CTS: CtsPin<UART2>,
    RTS: RtsPin<UART2>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART2, TX, RTS>, Rx<UART2, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART2, TX, RTS>,
    rx: Rx<UART2, RX, CTS>
) -> Serial<UART2, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART2, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART3, TX, RX, RTS, CTS>

pub fn uart3(
    uart: UART3,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART3>,
    RX: RxPin<UART3>,
    CTS: CtsPin<UART3>,
    RTS: RtsPin<UART3>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART3, TX, RTS>, Rx<UART3, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART3, TX, RTS>,
    rx: Rx<UART3, RX, CTS>
) -> Serial<UART3, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART3, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART4, TX, RX, RTS, CTS>

pub fn uart4(
    uart: UART4,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART4>,
    RX: RxPin<UART4>,
    CTS: CtsPin<UART4>,
    RTS: RtsPin<UART4>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART4, TX, RTS>, Rx<UART4, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART4, TX, RTS>,
    rx: Rx<UART4, RX, CTS>
) -> Serial<UART4, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART4, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART5, TX, RX, RTS, CTS>

pub fn uart5(
    uart: UART5,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART5>,
    RX: RxPin<UART5>,
    CTS: CtsPin<UART5>,
    RTS: RtsPin<UART5>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART5, TX, RTS>, Rx<UART5, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART5, TX, RTS>,
    rx: Rx<UART5, RX, CTS>
) -> Serial<UART5, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART5, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART6, TX, RX, RTS, CTS>

pub fn uart6(
    uart: UART6,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART6>,
    RX: RxPin<UART6>,
    CTS: CtsPin<UART6>,
    RTS: RtsPin<UART6>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART6, TX, RTS>, Rx<UART6, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART6, TX, RTS>,
    rx: Rx<UART6, RX, CTS>
) -> Serial<UART6, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART6, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

impl<TX, RX, RTS, CTS> Serial<UART7, TX, RX, RTS, CTS>

pub fn uart7(
    uart: UART7,
    tx_pin: TX,
    rx_pin: RX,
    rts_pin: RTS,
    cts_pin: CTS,
    baud_rate: Bps,
    nl_mode: NewlineMode,
    clocks: &Clocks,
    pc: &PowerControl
) -> Selfwhere
    TX: TxPin<UART7>,
    RX: RxPin<UART7>,
    CTS: CtsPin<UART7>,
    RTS: RtsPin<UART7>,

Configures a UART peripheral to provide serial communication

pub fn split(self) -> (Tx<UART7, TX, RTS>, Rx<UART7, RX, CTS>)

Splits the Serial abstraction into a transmitter and a receiver half. If you do this you can transmit and receive in different threads.

pub fn write_all<I: ?Sized>(&mut self, data: &I)where
    I: AsRef<[u8]>,

Write a complete string to the UART. If this returns Ok(()), all the data was sent. Otherwise you get number of octets sent and the error.

pub fn combine(
    tx: Tx<UART7, TX, RTS>,
    rx: Rx<UART7, RX, CTS>
) -> Serial<UART7, TX, RX, RTS, CTS>

Re-combine a split UART

pub fn free(self) -> (UART7, TX, RX, RTS, CTS)

Releases the UART peripheral and associated pins

Trait Implementations

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART0, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART1, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART2, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART3, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART4, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART5, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART6, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Read<u8> for Serial<UART7, TX, RX, RTS, CTS>

type Error = Void

Read error

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

Reads a single word from the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART0, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART1, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART2, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART3, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART4, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART5, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART6, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write<u8> for Serial<UART7, TX, RX, RTS, CTS>

type Error = Void

Write error

fn flush(&mut self) -> Result<(), Void>

Ensures that none of the previously written words are still buffered

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

Writes a single word to the serial interface

impl<TX, RX, RTS, CTS> Write for Serial<UART0, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART1, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART2, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART3, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART4, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART5, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART6, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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<TX, RX, RTS, CTS> Write for Serial<UART7, TX, RX, RTS, CTS>

Allows the Uart to be passed to ‘write!()’ and friends.

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.