1
{
2
  "clock_system_frequency_mhz": "133",
3
  "clock_usb_frequency_mhz": "48",
4
  "clock_peripheral_divider": "1",
5
  "clock_adc_frequency_mhz": "48",
6
  "clock_reference_divider": "1"
7
}

12
/// Main build script entry point
13
fn main() {
15 collapsed lines
14
    // Put `memory.x` in our output directory
15
    let out_dir = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
16
    fs::File::create(out_dir.join("memory.x"))
17
        .unwrap()
18
        .write_all(include_bytes!("memory.x"))
19
        .unwrap();
20

21
    // Ensure 'memory.x' is on the linker search path
22
    println!("cargo:rustc-link-search={}", out_dir.display());
23

24
    // Re-run for any changes to the following files
25
    println!("cargo:rerun-if-changed=build.rs");
26
    println!("cargo:rerun-if-changed=memory.x");
27
    println!("cargo:rerun-if-changed=configs.json");
28
    println!("cargo:rerun-if-changed=secrets.json");
29

30
    // Load configurations from local 'configs.json' file
31
    let configs_keys = [
32
        "clock_system_frequency_mhz",
33
        "clock_usb_frequency_mhz",
34
        "clock_peripheral_divider",
35
        "clock_adc_frequency_mhz",
36
        "clock_reference_divider",
37
    ];
38
    load_configs(out_dir.to_str().unwrap(), configs_keys).unwrap_or_else(|error| panic!("[ERROR] {error:?}"));
39

40
    // Load secrets from local 'secrets.json' file with XOR obfuscation
41
    let secrets_keys = ["super_secret_info"];
42
    load_secrets(out_dir.to_str().unwrap(), secrets_keys).unwrap_or_else(|error| panic!("[ERROR] {error:?}"));
43
}
44

6 collapsed lines
45
/// Loads configuration values from configs.json and generates a configs.rs file
46
/// with Rust constants for use in the embedded application
47
///
48
/// # Arguments
49
/// * `out_dir` - The target build directory path
50
/// * `config_keys` - Array of configuration keys to extract from configs.json
51
fn load_configs(out_dir: &str, config_keys: [&str; 5]) -> io::Result<()> {
52
    // ....
53
}
54

55
// ....

1
//! Raspberry Pi Pico 2 W RP2350 clock/PLL setup
2
//! Functions to set, verify, and log effective system clock frequencies
3

4
use embassy_rp::clocks::{self, ClockConfig, PllConfig, SysClkConfig, SysClkSrc, UsbClkConfig, UsbClkSrc, XoscConfig};
5
use embassy_rp::clocks::{AdcClkConfig, AdcClkSrc, PeriClkSrc, RefClkConfig, RefClkSrc};
6
use embassy_rp::config::Config as HalConfig;
7
use embassy_time::{Instant, Timer};
8

9
use defmt::*;
10
use defmt_rtt as _;
11
use panic_probe as _;
12

13
/// Clock configuration structure to hold all clock settings for RP2350
14
pub struct ClockSettings {
15
    pub xosc_crystal_hz: u32,
16
    pub system_frequency_mhz: u32,
17
    pub usb_frequency_mhz: u32,
18
    pub peripheral_clock_divider: u8,
19
    pub adc_frequency_mhz: u32,
20
    pub reference_clock_divider: u8,
21
}

21
// ....
22

23
/// Calculate the PLL (Phase-Locked Loop) configuration for the system clock and USB clock
24
///
25
/// * `desired_freq_mhz` - Desired frequency in MHz
26
/// * `xosc_freq_hz` - Crystal oscillator frequency in Hz
27
/// * `post_div1` - Post divider 1 value
28
/// * `post_div2` - Post divider 2 value
29
///
30
/// The formula for calculating the PLL configuration is:
31
///    `fbdiv = (desired_freq_mhz * post_div1 * post_div2) / xosc_freq_mhz`
32
pub fn calculate_pll_config(desired_freq_mhz: u32, xosc_freq_hz: u32, post_div1: u8, post_div2: u8) -> PllConfig {
33
    const HZ_PER_MHZ: u32 = 1_000_000;
34

35
    let refdiv = 1u8; // Fixed reference divider
36
    let xosc_freq_mhz = xosc_freq_hz / HZ_PER_MHZ;
37

38
    // VCO target frequency in MHz (desired output * post dividers)
39
    let vco_target_mhz = desired_freq_mhz * post_div1 as u32 * post_div2 as u32;
40

41
    // Feedback divider: how many times to multiply the reference to hit the VCO target
42
    let fbdiv = vco_target_mhz / xosc_freq_mhz;
43

44
    debug!(
45
        "PLL Config: {} MHz -> refdiv={}, fbdiv={}, post_div1={}, post_div2={}",
46
        desired_freq_mhz, refdiv, fbdiv, post_div1, post_div2
47
    );
48

49
    PllConfig {
50
        refdiv,
51
        fbdiv: fbdiv as u16,
52
        post_div1,
53
        post_div2,
54
    }
55
}

55
// ....
56

57
/// Configure all system clocks for RP2350
58
///
59
/// This function configures:
60
///   - System PLL and clock
61
///   - USB PLL and clock
62
///   - Peripheral clock source
63
///   - ADC clock
64
///   - Reference clock
65
pub fn configure_all_clocks(hal_configuration: &mut HalConfig, settings: ClockSettings) -> &mut HalConfig {
66
    // Calculate the PLL configuration for the system clock and USB clock
67
    let sys_pll_config = calculate_pll_config(settings.system_frequency_mhz, settings.xosc_crystal_hz, 6, 2);
68
    let usb_pll_config = calculate_pll_config(settings.usb_frequency_mhz, settings.xosc_crystal_hz, 6, 5);
69

70
    // Create and configure the external oscillator (XOSC) settings
71
    let mut clocks = ClockConfig::crystal(settings.xosc_crystal_hz);
72
    clocks.xosc = Some(XoscConfig {
73
        hz: settings.xosc_crystal_hz,  // Set XOSC frequency
74
        sys_pll: Some(sys_pll_config), // System PLL configuration
75
        usb_pll: Some(usb_pll_config), // USB PLL configuration
76
        delay_multiplier: 128,         // Used to calculate the startup delay (in cycles) for the crystal oscillator
77
    });
78

79
    // Configure the system clock settings
80
    clocks.sys_clk = SysClkConfig {
81
        src: SysClkSrc::PllSys, // Set system clock source to system PLL
82
        div_int: 1,             // No division
83
        div_frac: 0,            // No fractional division
84
    };
85

86
    // Configure the USB clock settings
87
    clocks.usb_clk = Some(UsbClkConfig {
88
        src: UsbClkSrc::PllUsb, // Set USB clock source to USB PLL
89
        div: 1,                 // No division
90
        phase: 0,               // No phase shift
91
    });
92

93
    // Configure the peripheral clock source
94
    // RP2350 uses peri_clk_src field
95
    clocks.peri_clk_src = Some(match settings.peripheral_clock_divider {
96
        1 => PeriClkSrc::Sys, // Use system clock directly
97
        _ => {
98
            debug!("[NOTE] Peripheral clock divider is applied at runtime, not in clock config");
99
            PeriClkSrc::Sys // Still use system clock
100
        }
101
    });
102

103
    // Configure the ADC clock
104
    // ADC clock can be sourced from USB PLL for stable 48MHz operation
105
    clocks.adc_clk = Some(AdcClkConfig {
106
        src: AdcClkSrc::PllUsb, // Source from USB PLL (48MHz)
107
        div: (settings.usb_frequency_mhz / settings.adc_frequency_mhz) as u8, // Calculate divider
108
        phase: 0,               // No phase shift
109
    });
110

111
    // Configure the reference clock
112
    // Reference clock is typically used for watchdog and timers
113
    clocks.ref_clk = RefClkConfig {
114
        src: RefClkSrc::Xosc,                  // Source from crystal oscillator
115
        div: settings.reference_clock_divider, // Apply configured divider
116
    };
117

118
    hal_configuration.clocks = clocks;
119
    hal_configuration
120
}

120
// ....
121

122
/// Verify the system clock frequency using a timer
123
///
124
/// * `milliseconds` - Duration in milliseconds to wait before measuring the system clock
125
pub async fn verify_clock_with_timer(milliseconds: u64) {
126
    let start = Instant::now(); // Start timer
127
    Timer::after_millis(milliseconds).await; // Wait for the specified duration
128
    let measured_elapsed = start.elapsed().as_micros(); // Stop timer
129
    let expected_elapsed = milliseconds * 1000;
130

131
    debug!(
132
        "[System clock frequency test] Actual: {} microseconds -> Measured: {} microseconds",
133
        expected_elapsed, measured_elapsed
134
    );
135

136
    // Calculate and print the clock accuracy percentage
137
    let measured_diff = (measured_elapsed as i64 - expected_elapsed as i64).abs();
138

139
    // Use u64 to prevent overflow in calculation
140
    let accuracy_percent_int = ((measured_diff as u64 * 100) / expected_elapsed as u64) as u32;
141
    let accuracy_percent_frac = ((measured_diff as u64 * 10000) / expected_elapsed as u64 % 100) as u32;
142

143
    debug!(
144
        "[System clock frequency test] Clock accuracy: {}.{:02}% off",
145
        accuracy_percent_int, accuracy_percent_frac
146
    );
147
}

147
// ....
148

149
/// Display device clock frequencies with enhanced detail
150
pub fn print_device_frequencies() {
151
    debug!("Log Device Clock Frequencies:");
152
    debug!("[Oscillators]");
153
    debug!("  - ROSC (Ring Oscillator): {} Hz", clocks::rosc_freq());
154
    debug!("  - XOSC (Crystal Oscillator): {} Hz", clocks::xosc_freq());
155

156
    debug!("[PLLs (Phase-Locked Loops)]");
157
    debug!("  - SYS PLL: {} Hz", clocks::pll_sys_freq());
158
    debug!("  - USB PLL: {} Hz", clocks::pll_usb_freq());
159

160
    debug!("[System Clocks]");
161
    debug!("  - SYS CLK (System Clock): {} Hz", clocks::clk_sys_freq());
162
    debug!("  - REF CLK (Reference Clock): {} Hz", clocks::clk_ref_freq());
163
    debug!("  - PERI CLK (Peripheral Clock): {} Hz", clocks::clk_peri_freq());
164

165
    debug!("[Specialized Clocks]");
166
    debug!("  - USB CLK (USB Clock): {} Hz", clocks::clk_usb_freq());
167
    debug!("  - ADC CLK (ADC Clock): {} Hz", clocks::clk_adc_freq());
168
}

4 collapsed lines
1
#![no_std]
2
#![no_main]
3
#![allow(unused_variables)] // only used for development
4
#![allow(unused_imports)] // only used for development
5

6
use defmt::*;
7
use defmt_rtt as _;
8
use panic_probe as _;
9

10
use embassy_executor::Spawner;
11
use embassy_rp::config::Config as HalConfig;
12
use embassy_rp::gpio;
13
use embassy_time::Timer;
14

15
mod clocks_config;
16
use clocks_config::ClockSettings;
17
mod utility;
18

9 collapsed lines
19
// Loading configurations
20
// Note: This comes from the 'configs.rs' file created in 'build.rs' from 'configs.json'
21
// Note: All loaded configurations will be UPPERCASE string slice (&str) constants
22
include!(concat!(env!("OUT_DIR"), "/configs.rs"));
23

24
// Loading obfuscated secrets (XOR_KEY and _OBFUSCATED constants)
25
// Note: Similar considerations as configurations
26
// Note: Load via utility.deobfuscate()
27
include!(concat!(env!("OUT_DIR"), "/secrets.rs"));
28

29
#[embassy_executor::main]
30
async fn main(spawner: Spawner) {
31
    info!("==================================");
32
    info!("    Package: {} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
33
    info!("==================================");
34

35
    // Apply default clock configuration
36
    let mut hal_configuration = HalConfig::default();
37

38
    info!("Configuring all system clocks ...");
39
    let clock_settings = ClockSettings {
40
        xosc_crystal_hz: 12_000_000, // RP2350 uses 12MHz crystal
41
        system_frequency_mhz: CLOCK_SYSTEM_FREQUENCY_MHZ.parse::<u32>().unwrap(),
42
        usb_frequency_mhz: CLOCK_USB_FREQUENCY_MHZ.parse::<u32>().unwrap(),
43
        peripheral_clock_divider: CLOCK_PERIPHERAL_DIVIDER.parse::<u8>().unwrap(),
44
        adc_frequency_mhz: CLOCK_ADC_FREQUENCY_MHZ.parse::<u32>().unwrap(),
45
        reference_clock_divider: CLOCK_REFERENCE_DIVIDER.parse::<u8>().unwrap(),
46
    };
47
    clocks_config::configure_all_clocks(&mut hal_configuration, clock_settings);
48
    let peripherals = embassy_rp::init(hal_configuration);
49

50
    // Log and verify system clock frequencies
51
    clocks_config::print_device_frequencies();
52
    clocks_config::verify_clock_with_timer(500).await;
53

54
    info!("All Set! Running async loop ...");
55

56
    // General async loop to ensure entire program runs forever while
57
    // asynchronously working on other tasks
58
    loop {
59
        Timer::after_secs(5).await;
60
    }
61
}

1
# big-button
2

4 collapsed lines
3
Just some interesting embedded Rust tutorial series I found floating around
4
the internet that I wanted to try.
5

6
Run me with `cargo run --release`
7

8
## Configurations
9

10
This project contains a `configs.json` file that contains various
11
configuration values for this program. The program will load these
12
values during the build process.
13

14
Currently the following configurations are supported:
15

16
'''json
17
{
18
  "clock_system_frequency_mhz": "133",
19
  "clock_usb_frequency_mhz": "48",
20
  "clock_peripheral_divider": "1",
21
  "clock_adc_frequency_mhz": "48",
22
  "clock_reference_divider": "1"
23
}
24
'''
25

12 collapsed lines
26
## Secrets
27

28
Create and fill in a `secrets.json` file that contains sensitive
29
secret constants used by this project to run correctly.
30

31
Currently the following secrets are needed:
32

33
'''json
34
{
35
  "super_secret_info": "Area51HasNoAliens"
36
}
37
'''