Module clocks 

Clocks (CLOCKS)

Usage simple

use rp235x_hal::{self as hal, clocks::init_clocks_and_plls, watchdog::Watchdog};

let mut peripherals = hal::pac::Peripherals::take().unwrap();
let mut watchdog = Watchdog::new(peripherals.WATCHDOG);
const XOSC_CRYSTAL_FREQ: u32 = 12_000_000; // Typically found in BSP crates
let mut clocks = init_clocks_and_plls(
    XOSC_CRYSTAL_FREQ,
    peripherals.XOSC,
    peripherals.CLOCKS,
    peripherals.PLL_SYS,
    peripherals.PLL_USB,
    &mut peripherals.RESETS,
    &mut watchdog,
)
.ok()
.unwrap();

Usage extended

use fugit::RateExtU32;
use rp235x_hal::{clocks::{Clock, ClocksManager, ClockSource, InitError}, gpio::Pins, self as hal, pll::{common_configs::{PLL_SYS_150MHZ, PLL_USB_48MHZ}, setup_pll_blocking}, Sio, watchdog::Watchdog, xosc::setup_xosc_blocking};

let mut peripherals = hal::pac::Peripherals::take().unwrap();
let mut watchdog = Watchdog::new(peripherals.WATCHDOG);
const XOSC_CRYSTAL_FREQ: u32 = 12_000_000; // Typically found in BSP crates

// Enable the xosc
let xosc = setup_xosc_blocking(peripherals.XOSC, XOSC_CRYSTAL_FREQ.Hz()).map_err(InitError::XoscErr)?;

// Start tick in watchdog
watchdog.enable_tick_generation((XOSC_CRYSTAL_FREQ / 1_000_000) as u16);

let mut clocks = ClocksManager::new(peripherals.CLOCKS);

// Configure PLLs
//                   REF     FBDIV VCO            POSTDIV
// PLL SYS: 12 / 1 = 12MHz * 125 = 1500MHZ / 5 / 2 = 150MHz
// PLL USB: 12 / 1 = 12MHz * 40  = 480 MHz / 5 / 2 =  48MHz
let pll_sys = setup_pll_blocking(peripherals.PLL_SYS, xosc.operating_frequency().into(), PLL_SYS_150MHZ, &mut clocks, &mut peripherals.RESETS).map_err(InitError::PllError)?;
let pll_usb = setup_pll_blocking(peripherals.PLL_USB, xosc.operating_frequency().into(), PLL_USB_48MHZ, &mut clocks, &mut peripherals.RESETS).map_err(InitError::PllError)?;

// Configure clocks
// CLK_REF = XOSC (12MHz) / 1 = 12MHz
clocks.reference_clock.configure_clock(&xosc, xosc.get_freq()).map_err(InitError::ClockError)?;

// CLK SYS = PLL SYS (150MHz) / 1 = 150MHz
clocks.system_clock.configure_clock(&pll_sys, pll_sys.get_freq()).map_err(InitError::ClockError)?;

// CLK USB = PLL USB (48MHz) / 1 = 48MHz
clocks.usb_clock.configure_clock(&pll_usb, pll_usb.get_freq()).map_err(InitError::ClockError)?;

// CLK ADC = PLL USB (48MHZ) / 1 = 48MHz
clocks.adc_clock.configure_clock(&pll_usb, pll_usb.get_freq()).map_err(InitError::ClockError)?;

// CLK HSTX = PLL SYS (150MHz) / 1 = 150MHz
clocks.hstx_clock.configure_clock(&pll_sys, pll_sys.get_freq()).map_err(InitError::ClockError)?;

// CLK PERI = clk_sys. Used as reference clock for Peripherals. No dividers so just select and enable
// Normally choose clk_sys or clk_usb
clocks.peripheral_clock.configure_clock(&clocks.system_clock, clocks.system_clock.freq()).map_err(InitError::ClockError)?;

See Chapter 8 for more details.

Structs

AdcClock

ADC reference clock.

ChangingClockToken

Token which can be used to await the glitchless switch

ClockGate

Bit field mapping clock enable bits.

ClocksManager

Abstraction layer providing Clock Management.

GpioOutput0Clock

GPIO Output 0 Clock Generator

GpioOutput1Clock

GPIO Output 1 Clock Generator

GpioOutput2Clock

GPIO Output 2 Clock Generator

GpioOutput3Clock

GPIO Output 3 Clock Generator

HstxClock

HSTX (High-Speed Transmitter) Clock

PeripheralClock

Peripheral clock.

ReferenceClock

Reference clock that is always running 6 - 12MHz unless in DORMANT mode.

SystemClock

System clock that is always running unless in DORMANT mode.

UsbClock

USB reference clock.

Enums

ClkAdcSrcType

Holds register value for ClockSource for AdcClock

ClkGpout0SrcType

Holds register value for ClockSource for GpioOutput0Clock

ClkGpout1SrcType

Holds register value for ClockSource for GpioOutput1Clock

ClkGpout2SrcType

Holds register value for ClockSource for GpioOutput2Clock

ClkGpout3SrcType

Holds register value for ClockSource for GpioOutput3Clock

ClkHstxSrcType

Holds register value for ClockSource for HstxClock

ClkPeriSrcType

Holds register value for ClockSource for PeripheralClock

ClkRefSrcType

Holds register value for ClockSource for ReferenceClock

ClkSysSrcType

Holds register value for ClockSource for SystemClock

ClkUsbSrcType

Holds register value for ClockSource for UsbClock

ClockError

Something when wrong setting up the clock

InitError

Possible init errors

Traits

Clock

For clocks

ClockSource

Trait for things that can be used as clock source

StoppableClock

For clocks that can be disabled

ValidSrc

Trait to contrain which ClockSource is valid for which Clock

Functions

init_clocks_and_plls

Initialize the clocks and plls according to the reference implementation