Struct Config 

pub struct Config {

    pub baudrate: u32,
    pub word_length: WordLength,
    pub parity: Parity,
    pub stop_bits: StopBits,
    pub duplex_mode: DuplexMode,
    pub sync_mode: SyncMode,
    pub clock_polarity: ClockPolarity,
    pub clock_phase: ClockPhase,
    pub clock_last_bit: bool,
    pub bit_order: BitOrder,
    pub data_inversion: bool,
    pub tx_inversion: bool,
    pub rx_inversion: bool,
    pub swap_pins: bool,
    pub loopback: bool,
    pub tx_break: bool,
    pub overwrite: bool,
    pub flow_control: FlowControl,
    pub rts_mode: RtsMode,
    pub modem: ModemConfig,
    pub dma: DmaConfig,
    pub init_timeout: u32,
}

Fields

baudrate: u32

word_length: WordLength

parity: Parity

stop_bits: StopBits

duplex_mode: DuplexMode

sync_mode: SyncMode

clock_polarity: ClockPolarity

clock_phase: ClockPhase

clock_last_bit: bool

bit_order: BitOrder

data_inversion: bool

tx_inversion: bool

rx_inversion: bool

swap_pins: bool

loopback: bool

tx_break: bool

overwrite: bool

flow_control: FlowControl

rts_mode: RtsMode

modem: ModemConfig

dma: DmaConfig

init_timeout: u32

Implementations

impl Config

pub const fn default() -> Self

Examples found in repository

examples/serial.rs (line 29)

pub extern "C" fn main() -> ! {
    let peripherals = Peripherals::take().unwrap();

    let rcc_config = RCC::default();
    RCC::init(&rcc_config);

    peripherals
        .pm
        .clk_apb_m_set()
        .modify(|_, w| w.pad_config().enable().pm().enable());

    let rx = Pin08::new().into_serial_port();
    let tx = Pin09::new().into_serial_port();

    let serial = Serial::new(peripherals.usart_1, (tx, rx), Config::default()).unwrap();
    let (mut tx, _rx) = serial.split();

    loop {
        let _ = writeln!(tx, "Hello from MIK32 USART1");
        delay(MESSAGE_DELAY_SPINS);
    }
}

pub const fn baudrate(self, baudrate: u32) -> Self

pub const fn word_length(self, word_length: WordLength) -> Self

pub const fn parity(self, parity: Parity) -> Self

pub const fn stop_bits(self, stop_bits: StopBits) -> Self

pub const fn duplex_mode(self, duplex_mode: DuplexMode) -> Self

pub const fn sync_mode(self, sync_mode: SyncMode) -> Self

pub const fn clock_polarity(self, polarity: ClockPolarity) -> Self

pub const fn clock_phase(self, phase: ClockPhase) -> Self

pub const fn clock_last_bit(self, enabled: bool) -> Self

pub const fn bit_order(self, bit_order: BitOrder) -> Self

pub const fn data_inversion(self, enabled: bool) -> Self

pub const fn tx_inversion(self, enabled: bool) -> Self

pub const fn rx_inversion(self, enabled: bool) -> Self

pub const fn swap_pins(self, enabled: bool) -> Self

pub const fn loopback(self, enabled: bool) -> Self

pub const fn tx_break(self, enabled: bool) -> Self

pub const fn overwrite(self, enabled: bool) -> Self

pub const fn flow_control(self, flow_control: FlowControl) -> Self

pub const fn rts_mode(self, mode: RtsMode) -> Self

pub const fn modem(self, modem: ModemConfig) -> Self

pub const fn dma(self, dma: DmaConfig) -> Self

pub const fn init_timeout(self, timeout: u32) -> Self

pub const fn validate(&self) -> Result<(), ConfigError>

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Config

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Config

impl PartialEq for Config

fn eq(&self, other: &Config) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Config