Struct RCC 

pub struct RCC {

    pub hsi32m: bool,
    pub osc32m: bool,
    pub lsi32k: bool,
    pub osc32k: bool,
    pub freq_monitor: FreqMonitor,
    pub ahb_div: u8,
    pub apb_m_div: u8,
    pub apb_p_div: u8,
    pub hsi32m_calibration_value: u8,
    pub lsi32k_calibration_value: u8,
    pub rtcclk: RtcClkMux,
    pub rtccpuclk: CpuRtcClkMux,
    pub clocks: Clocks,
}

Fields

hsi32m: bool

osc32m: bool

lsi32k: bool

osc32k: bool

freq_monitor: FreqMonitor

ahb_div: u8

apb_m_div: u8

apb_p_div: u8

hsi32m_calibration_value: u8

lsi32k_calibration_value: u8

rtcclk: RtcClkMux

rtccpuclk: CpuRtcClkMux

clocks: Clocks

Implementations

impl RCC

pub fn init(config: &RCC)

Examples found in repository

examples/serial.rs (line 19)

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);
    }
}

examples/gpio.rs (line 18)

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

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

    p.pm.clk_apb_p_set().modify(|_, w| w.gpio_0().enable());
    p.pm.clk_apb_m_set()
        .modify(|_, w| w.pad_config().enable().pm().enable());

    let mut led_pin = Pin09::new().into_output();
    let mut button_pin = Pin10::new().into_pull_down_input();

    loop {
        if button_pin.is_high().unwrap() {
            let _ = led_pin.set_high();
        } else {
            let _ = led_pin.set_low();
        }

        for _ in 0..1000 {
            core::hint::spin_loop();
        }
    }
}

examples/tsense.rs (line 19)

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

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

    let sensor_config = Config::default()
        .clock_from_source(ClockSource::HSI32M)
        .with_frequency(SENSOR_CLOCK_HZ);

    let mut sensor = TSENS::new(peripherals.tsens, &rcc_config.clocks, sensor_config).unwrap();

    let mut current_temperature_c = sensor.single_measurement(Some(STARTUP_TIMEOUT)).unwrap();
    let mut min_temperature_c = current_temperature_c;
    let mut max_temperature_c = current_temperature_c;

    sensor.start_continuous();

    loop {
        current_temperature_c = sensor.get_temperature();

        if current_temperature_c < min_temperature_c {
            min_temperature_c = current_temperature_c;
        }

        if current_temperature_c > max_temperature_c {
            max_temperature_c = current_temperature_c;
        }

        let _temperature_snapshot = (current_temperature_c, min_temperature_c, max_temperature_c);

        delay(SAMPLE_DELAY_SPINS);
    }
}

Trait Implementations

impl Default for RCC

fn default() -> Self

Returns the “default value” for a type.