Struct sam4l::usart::USART

pub struct USART {
    registers: *mut USARTRegisters,
    clock: Clock,
    usart_mode: Cell<UsartMode>,
    usart_tx_state: Cell<USARTStateTX>,
    usart_rx_state: Cell<USARTStateRX>,
    rx_dma: Cell<Option<&'static DMAChannel>>,
    rx_dma_peripheral: DMAPeripheral,
    rx_len: Cell<usize>,
    tx_dma: Cell<Option<&'static DMAChannel>>,
    tx_dma_peripheral: DMAPeripheral,
    tx_len: Cell<usize>,
    client: Cell<Option<UsartClient<'static>>>,
    spi_chip_select: Cell<Option<&'static Pin>>,
}

Fields

registers: *mut USARTRegisters

clock: Clock

usart_mode: Cell<UsartMode>

usart_tx_state: Cell<USARTStateTX>

usart_rx_state: Cell<USARTStateRX>

rx_dma: Cell<Option<&'static DMAChannel>>

rx_dma_peripheral: DMAPeripheral

rx_len: Cell<usize>

tx_dma: Cell<Option<&'static DMAChannel>>

tx_dma_peripheral: DMAPeripheral

tx_len: Cell<usize>

client: Cell<Option<UsartClient<'static>>>

spi_chip_select: Cell<Option<&'static Pin>>

Methods

impl USART

const fn new(
    base_addr: *mut USARTRegisters,
    clock: PBAClock,
    rx_dma_peripheral: DMAPeripheral,
    tx_dma_peripheral: DMAPeripheral
) -> USART

pub fn set_dma(&self, rx_dma: &'static DMAChannel, tx_dma: &'static DMAChannel)

pub fn enable_rx(&self)

pub fn enable_tx(&self)

pub fn disable_rx(&self)

pub fn disable_tx(&self)

pub fn abort_rx(&self, error: Error)

pub fn abort_tx(&self, error: Error)

pub fn enable_tx_empty_interrupt(&self)

pub fn disable_tx_empty_interrupt(&self)

pub fn enable_rx_error_interrupts(&self)

pub fn disable_rx_interrupts(&self)

pub fn disable_tx_interrupts(&self)

pub fn disable_interrupts(&self)

pub fn reset(&self)

pub fn handle_interrupt(&self)

fn enable_clock(&self)

fn disable_clock(&self)

fn is_clock_enabled(&self) -> bool

fn set_mode(&self, mode: u32)

fn set_baud_rate(&self, baud_rate: u32)

fn rts_enable_spi_assert_cs(&self)

In non-SPI mode, this drives RTS low. In SPI mode, this asserts (drives low) the chip select line.

fn rts_disable_spi_deassert_cs(&self)

In non-SPI mode, this drives RTS high. In SPI mode, this de-asserts (drives high) the chip select line.

fn enable_rx_timeout(&self, timeout: u8)

fn disable_rx_timeout(&self)

fn enable_rx_terminator(&self, _terminator: u8)

pub fn send_byte(&self, byte: u8)

pub fn tx_ready(&self) -> bool

Trait Implementations

impl DMAClient for USART

fn xfer_done(&self, pid: DMAPeripheral)

impl UART for USART

Implementation of kernel::hil::UART

fn set_client(&self, client: &'static Client)

Set the client for this UART peripheral. The client will be called when events finish.

fn init(&self, params: UARTParams)

Initialize UART

fn transmit(&self, tx_data: &'static mut [u8], tx_len: usize)

Transmit data.

fn receive(&self, rx_buffer: &'static mut [u8], rx_len: usize)

Receive data until buffer is full.

impl UARTAdvanced for USART

fn receive_automatic(&self, rx_buffer: &'static mut [u8], interbyte_timeout: u8)

Receive data until interbyte_timeout bit periods have passed since the last byte or buffer is full. Does not timeout until at least one byte has been received.

fn receive_until_terminator(&self, rx_buffer: &'static mut [u8], terminator: u8)

Receive data until terminator data byte has been received or buffer is full

impl SpiMaster for USART

SPI

type ChipSelect = Option<&'static Pin>

fn init(&self)

fn set_client(&self, client: &'static SpiMasterClient)

fn is_busy(&self) -> bool

fn read_write_bytes(
    &self,
    write_buffer: &'static mut [u8],
    read_buffer: Option<&'static mut [u8]>,
    len: usize
) -> ReturnCode

Perform an asynchronous read/write operation, whose completion is signaled by invoking SpiMasterClient on the initialized client. write_buffer must be Some, read_buffer may be None. If read_buffer is Some, the length of the operation is the minimum of the size of the two buffers.

fn write_byte(&self, val: u8)

fn read_byte(&self) -> u8

fn read_write_byte(&self, val: u8) -> u8

fn specify_chip_select(&self, cs: Self::ChipSelect)

Pass in a None to use the HW chip select pin on the USART (RTS).

fn set_rate(&self, rate: u32) -> u32

Returns the actual rate set

fn get_rate(&self) -> u32

fn set_clock(&self, polarity: ClockPolarity)

fn get_clock(&self) -> ClockPolarity

fn set_phase(&self, phase: ClockPhase)

fn get_phase(&self) -> ClockPhase

fn hold_low(&self)

fn release_low(&self)