Struct tm4c129x_hal::serial::Serial

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

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
) -> Self where
    TX: TxPin<UART0>,
    RX: RxPin<UART0>,
    CTS: CtsPin<UART0>,
    RTS: RtsPin<UART0>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART1>,
    RX: RxPin<UART1>,
    CTS: CtsPin<UART1>,
    RTS: RtsPin<UART1>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART2>,
    RX: RxPin<UART2>,
    CTS: CtsPin<UART2>,
    RTS: RtsPin<UART2>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART3>,
    RX: RxPin<UART3>,
    CTS: CtsPin<UART3>,
    RTS: RtsPin<UART3>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART4>,
    RX: RxPin<UART4>,
    CTS: CtsPin<UART4>,
    RTS: RtsPin<UART4>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART5>,
    RX: RxPin<UART5>,
    CTS: CtsPin<UART5>,
    RTS: RtsPin<UART5>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART6>,
    RX: RxPin<UART6>,
    CTS: CtsPin<UART6>,
    RTS: RtsPin<UART6>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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
) -> Self where
    TX: TxPin<UART7>,
    RX: RxPin<UART7>,
    CTS: CtsPin<UART7>,
    RTS: RtsPin<UART7>, 

Configures a UART peripheral to provide serial communication

pub fn change_baud_rate(&mut self, baud_rate: Bps, clocks: &Clocks)

Change the current baud rate for the UART. We need the clocks object in order to calculate the magic baud rate register values.

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.

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.