STM32L4xx HAL

https://github.com/stm32-rs/stm32l4xx-hal
Admin
A Hardware Abstraction Layer (HAL) for the STM32L4xx family of microcontrollers, providing Rust...
Tokens:6,397
Snippets:25
Trust Score:9.1
Update:8 months ago
Show doc for...
Tokens:
Raw
### I2C Communication Example

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Demonstrates I2C communication, supporting various modes up to 1 MHz. The example configures pins for I2C1, sets the clock speed, and shows basic read/write operations to a MAX17048 fuel gauge.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::i2c::{Config, I2c};
use stm32l4xx_hal::stm32;
use stm32l4xx_hal::prelude::*

#[entry]
fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();

    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
    let clocks = rcc.cfgr.freeze(&mut flash.acr, &mut pwr);

    let mut gpioa = dp.GPIOA.split(&mut rcc.ahb2);

    // Configure I2C pins with internal pull-ups (open drain required)
    let mut scl = gpioa
        .pa9
        .into_alternate_open_drain(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrh);
    scl.internal_pull_up(&mut gpioa.pupdr, true);

    let mut sda = gpioa
        .pa10
        .into_alternate_open_drain(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrh);
    sda.internal_pull_up(&mut gpioa.pupdr, true);

    // Create I2C1 at 100 kHz
    let mut i2c = I2c::i2c1(
        dp.I2C1,
        (scl, sda),
        Config::new(100.kHz(), clocks),
        &mut rcc.apb1r1,
    );

    // Example: Read from MAX17048 fuel gauge
    const MAX17048_ADDR: u8 = 0x36;
    let mut buffer = [0u8; 2];

    // Write register address, then read 2 bytes
    i2c.write_read(MAX17048_ADDR, &[0x08], &mut buffer).unwrap();
    let version: u16 = (buffer[0] as u16) << 8 | buffer[1] as u16;

    // Write only
    i2c.write(MAX17048_ADDR, &[0x00, 0x54, 0x00]).unwrap();

    // Read only
    i2c.read(MAX17048_ADDR, &mut buffer).unwrap();

    loop {}
}

```

--------------------------------

### Advanced Serial Configuration Options

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Shows how to configure advanced serial parameters like parity, stop bits, oversampling, character match, and receiver timeout. This example uses USART1.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::serial::{Config, Parity, StopBits, Oversampling, Serial};
use stm32l4xx_hal::stm32;
use stm32l4xx_hal::prelude::*

#[entry]
fn main() -> ! {
    let p = stm32::Peripherals::take().unwrap();

    let mut flash = p.FLASH.constrain();
    let mut rcc = p.RCC.constrain();
    let mut pwr = p.PWR.constrain(&mut rcc.apb1r1);
    let mut gpioa = p.GPIOA.split(&mut rcc.ahb2);

    let clocks = rcc.cfgr.sysclk(80.MHz()).freeze(&mut flash.acr, &mut pwr);

    let tx = gpioa.pa9.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrh);
    let rx = gpioa.pa10.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrh);

    // Advanced serial configuration
    let config = Config::default()
        .baudrate(115_200.bps())
        .parity_even()
        .stopbits(StopBits::STOP1)
        .oversampling(Oversampling::Over16)
        .character_match(b'\n')      // Interrupt on newline
        .receiver_timeout(1000)       // Timeout after 1000 bit durations
        .with_overrun_disabled();

    let serial = Serial::usart1(p.USART1, (tx, rx), config, clocks, &mut rcc.apb2);
    let (mut tx, mut rx) = serial.split();

    loop {}
}

```

--------------------------------

### Basic GPIO Pin Configuration with stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Demonstrates basic GPIO pin configuration, supporting input (floating, pull-up, pull-down), output (push-pull, open-drain), analog, and alternate function modes. This example configures PB3 as a push-pull output for an LED and uses SysTick for delay.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::{delay::Delay, prelude::*, stm32};

#[entry]
fn main() -> ! {
    let cp = cortex_m::Peripherals::take().unwrap();
    let dp = stm32::Peripherals::take().unwrap();

    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
    let clocks = rcc.cfgr.hclk(8.MHz()).freeze(&mut flash.acr, &mut pwr);

    // Split GPIO port B into individual pins
    let mut gpiob = dp.GPIOB.split(&mut rcc.ahb2);

    // Configure PB3 as push-pull output for LED
    let mut led = gpiob
        .pb3
        .into_push_pull_output(&mut gpiob.moder, &mut gpiob.otyper);

    // Create delay timer using SysTick
    let mut timer = Delay::new(cp.SYST, clocks);

    loop {
        led.set_high();
        timer.delay_ms(1000_u32);
        led.set_low();
        timer.delay_ms(1000_u32);
    }
}

```

--------------------------------

### UART/USART Serial Communication Example

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Demonstrates basic serial communication using USART2. It configures pins, sets a baud rate, and performs a send/receive operation. Requires the `nb` crate for blocking operations.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use nb::block;
use stm32l4xx_hal::{serial::Serial, stm32};
use stm32l4xx_hal::prelude::*

#[entry]
fn main() -> ! {
    let p = stm32::Peripherals::take().unwrap();

    let mut flash = p.FLASH.constrain();
    let mut rcc = p.RCC.constrain();
    let mut pwr = p.PWR.constrain(&mut rcc.apb1r1);
    let mut gpioa = p.GPIOA.split(&mut rcc.ahb2);

    let clocks = rcc
        .cfgr
        .sysclk(80.MHz())
        .pclk1(80.MHz())
        .pclk2(80.MHz())
        .freeze(&mut flash.acr, &mut pwr);

    // Configure PA2 (TX) and PA3 (RX) for USART2
    let tx = gpioa
        .pa2
        .into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);
    let rx = gpioa
        .pa3
        .into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);

    // Create serial interface at 9600 baud
    let serial = Serial::usart2(p.USART2, (tx, rx), 9_600.bps(), clocks, &mut rcc.apb1r1);
    let (mut tx, mut rx) = serial.split();

    // Send and receive data
    let sent = b'X';
    block!(tx.write(sent)).ok();
    let received = block!(rx.read()).unwrap();
    assert_eq!(received, sent);

    loop {}
}

```

--------------------------------

### Generate PWM Signals in Rust

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Demonstrates generating Pulse Width Modulation (PWM) signals using hardware timers. Allows configuration of multiple channels on different pins with independent duty cycles. The example shows how to enable PWM and dynamically adjust the duty cycle.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::{delay::Delay, prelude::*, stm32};

#[entry]
fn main() -> ! {
    let c = cortex_m::Peripherals::take().unwrap();
    let p = stm32::Peripherals::take().unwrap();

    let mut flash = p.FLASH.constrain();
    let mut rcc = p.RCC.constrain();
    let mut pwr = p.PWR.constrain(&mut rcc.apb1r1);
    let clocks = rcc.cfgr.freeze(&mut flash.acr, &mut pwr);

    let mut gpioa = p.GPIOA.split(&mut rcc.ahb2);

    // Configure TIM2 channels on PA0-PA3
    let c1 = gpioa.pa0.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);
    let c2 = gpioa.pa1.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);
    let c3 = gpioa.pa2.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);
    let c4 = gpioa.pa3.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);

    // Create PWM at 1 kHz, get channel 4
    let mut pwm = p
        .TIM2
        .pwm((c1, c2, c3, c4), 1.kHz(), clocks, &mut rcc.apb1r1)
        .3;  // Get channel 4

    let max = pwm.get_max_duty();
    pwm.enable();

    let mut timer = Delay::new(c.SYST, clocks);

    loop {
        pwm.set_duty(max);           // 100% duty
        timer.delay_ms(100_u32);
        pwm.set_duty(max / 2);       // 50% duty
        timer.delay_ms(100_u32);
        pwm.set_duty(max / 4);       // 25% duty
        timer.delay_ms(100_u32);
    }
}

```

--------------------------------

### GPIO External Interrupts (EXTI) with stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Configures GPIO pins to trigger interrupts on rising, falling, or both edges using the EXTI peripheral. This example sets up PC13 as an input with a pull-up resistor and configures it to trigger on a falling edge, with an interrupt handler for EXTI15_10.

```rust
#![no_std]
#![no_main]

use core::cell::RefCell;
use core::ops::DerefMut;
use cortex_m::{interrupt::{free, Mutex}, peripheral::NVIC};
use cortex_m_rt::entry;
use stm32l4xx_hal::{
    gpio::{gpioc::PC13, Edge, ExtiPin, Input, PullUp},
    interrupt,
    prelude::*,
    stm32,
};

static BUTTON: Mutex<RefCell<Option<PC13<Input<PullUp>>>>> = Mutex::new(RefCell::new(None));

#[entry]
fn main() -> ! {
    let mut dp = stm32::Peripherals::take().unwrap();
    dp.RCC.apb2enr.write(|w| w.syscfgen().set_bit());

    let mut rcc = dp.RCC.constrain();
    let mut flash = dp.FLASH.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
    rcc.cfgr.sysclk(80.MHz()).freeze(&mut flash.acr, &mut pwr);

    let mut gpioc = dp.GPIOC.split(&mut rcc.ahb2);

    // Configure PC13 as input with pull-up and interrupt
    let mut board_btn = gpioc
        .pc13
        .into_pull_up_input(&mut gpioc.moder, &mut gpioc.pupdr);
    board_btn.make_interrupt_source(&mut dp.SYSCFG, &mut rcc.apb2);
    board_btn.enable_interrupt(&mut dp.EXTI);
    board_btn.trigger_on_edge(&mut dp.EXTI, Edge::Falling);

    unsafe { NVIC::unmask(stm32::Interrupt::EXTI15_10); }

    free(|cs| { BUTTON.borrow(cs).replace(Some(board_btn)); });

    loop {}
}

#[interrupt]
fn EXTI15_10() {
    free(|cs| {
        let mut btn_ref = BUTTON.borrow(cs).borrow_mut();
        if let Some(ref mut btn) = btn_ref.deref_mut() {
            if btn.check_interrupt() {
                btn.clear_interrupt_pending_bit();
                // Handle button press here
            }
        }
    });
}

```

--------------------------------

### Generate Random Numbers using RNG with stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

This example shows how to use the hardware Random Number Generator (RNG) peripheral. It requires the 48 MHz HSI48 clock source to be enabled. The code initializes the RNG, reads random bytes into a buffer, and demonstrates its usage within a loop.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::{
    delay::Delay,
    prelude::*,
    stm32,
    hal::blocking::rng::Read,
};

#[entry]
fn main() -> ! {
    let core = cortex_m::Peripherals::take().unwrap();
    let device = stm32::Peripherals::take().unwrap();

    let mut flash = device.FLASH.constrain();
    let mut rcc = device.RCC.constrain();
    let mut pwr = device.PWR.constrain(&mut rcc.apb1r1);

    // HSI48 required for RNG
    let clocks = rcc
        .cfgr
        .hsi48(true)
        .sysclk(64.MHz())
        .freeze(&mut flash.acr, &mut pwr);

    let mut timer = Delay::new(core.SYST, clocks);

    // Enable RNG peripheral
    let mut rng = device.RNG.enable(&mut rcc.ahb2, clocks);

    loop {
        let mut random_bytes = [0u8; 16];
        rng.read(&mut random_bytes).expect("RNG failed");
        // random_bytes now contains 16 random bytes

        timer.delay_ms(500_u32);
    }
}
```

--------------------------------

### Clock Configuration (RCC) with stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Configures system clocks including HSE, HSI, MSI, LSE, LSI oscillators, and PLL. Clock configuration must be frozen before using peripherals. This example sets up an 80MHz system clock and APB1/APB2 clocks, enabling the 48MHz HSI48 clock for USB/RNG.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::{prelude::*, stm32};

#[entry]
fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();

    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);

    // Configure clocks: 80MHz sysclk, 80MHz APB1/APB2
    let clocks = rcc
        .cfgr
        .sysclk(80.MHz())
        .pclk1(80.MHz())
        .pclk2(80.MHz())
        .hsi48(true)  // Enable 48MHz clock for USB/RNG
        .freeze(&mut flash.acr, &mut pwr);

    // clocks now contains the frozen clock configuration
    // clocks.sysclk() returns 80 MHz
    // clocks.pclk1() returns 80 MHz

    loop {}
}

```

--------------------------------

### Rust Prelude: Common Imports and Extension Traits

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

The prelude module in stm32l4xx-hal provides essential imports for common traits and extensions, simplifying access to functionalities like `constrain()` for peripheral configuration and unit conversions for clock settings. It is typically imported using `use stm32l4xx_hal::prelude::*;`.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::prelude::*;
use stm32l4xx_hal::stm32;

#[entry]
fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();

    // These methods are available via prelude imports:
    let mut flash = dp.FLASH.constrain();  // FlashExt trait
    let mut rcc = dp.RCC.constrain();      // RccExt trait
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);  // PwrExt trait

    // Unit conversions via prelude
    let clocks = rcc.cfgr
        .sysclk(80.MHz())   // U32Ext trait
        .hclk(80.MHz())
        .pclk1(40.MHz())
        .freeze(&mut flash.acr, &mut pwr);

    let mut gpioa = dp.GPIOA.split(&mut rcc.ahb2);  // GpioExt trait

    loop {}
}
```

--------------------------------

### Configure and Use SPI Communication in Rust

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Demonstrates setting up SPI in master mode with configurable clock polarity, phase, and frequency. It implements the embedded-hal FullDuplex trait for data transfer and allows for dynamic baud rate changes. Requires specific GPIO pins for SCK, MISO, MOSI, and an optional chip select.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use embedded_hal::spi::{Mode, Phase, Polarity};
use stm32l4xx_hal::{prelude::*, spi::Spi, stm32};

pub const SPI_MODE: Mode = Mode {
    phase: Phase::CaptureOnFirstTransition,
    polarity: Polarity::IdleLow,
};

#[entry]
fn main() -> ! {
    let p = stm32::Peripherals::take().unwrap();

    let mut flash = p.FLASH.constrain();
    let mut rcc = p.RCC.constrain();
    let mut pwr = p.PWR.constrain(&mut rcc.apb1r1);

    let clocks = rcc
        .cfgr
        .sysclk(80.MHz())
        .pclk2(80.MHz())
        .freeze(&mut flash.acr, &mut pwr);

    let mut gpioa = p.GPIOA.split(&mut rcc.ahb2);
    let mut gpiob = p.GPIOB.split(&mut rcc.ahb2);

    // Configure SPI1 pins
    let sck = gpioa.pa5.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);
    let miso = gpioa.pa6.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);
    let mosi = gpioa.pa7.into_alternate(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl);

    // Optional chip select (directly controlled GPIO)
    let mut cs = gpiob.pb0.into_push_pull_output(&mut gpiob.moder, &mut gpiob.otyper);
    cs.set_high();

    // Create SPI1 at 1 MHz
    let mut spi = Spi::spi1(
        p.SPI1,
        (sck, miso, mosi),
        SPI_MODE,
        1.MHz(),
        clocks,
        &mut rcc.apb2,
    );

    // Transfer data
    cs.set_low();
    spi.write(&[0x3C, 0x00]).unwrap();
    cs.set_high();

    // Change baud rate dynamically
    spi.reclock(4.MHz(), clocks);

    loop {}
}

```

--------------------------------

### Read Analog Values with ADC in Rust

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

Configures and utilizes the ADC peripheral for analog-to-digital conversion. Supports single-shot conversions and reading from multiple channels including temperature, Vref, and Vbat. Requires initialization of the ADC common block and specific analog pins.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::
    adc::{Adc, AdcCommon},
    delay::Delay,
    prelude::*,
    pac,
};

#[entry]
fn main() -> ! {
    let cp = pac::CorePeripherals::take().unwrap();
    let dp = pac::Peripherals::take().unwrap();

    let mut rcc = dp.RCC.constrain();
    let mut flash = dp.FLASH.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
    let clocks = rcc.cfgr.freeze(&mut flash.acr, &mut pwr);

    let mut delay = Delay::new(cp.SYST, clocks);

    // Initialize ADC common block and ADC1
    let adc_common = AdcCommon::new(dp.ADC_COMMON, &mut rcc.ahb2);
    let mut adc = Adc::adc1(dp.ADC1, adc_common, &mut rcc.ccipr, &mut delay);

    // Configure analog input on PC0
    let mut gpioc = dp.GPIOC.split(&mut rcc.ahb2);
    let mut analog_pin = gpioc.pc0.into_analog(&mut gpioc.moder, &mut gpioc.pupdr);

    loop {
        // Read 12-bit ADC value (0-4095)
        let value: u16 = adc.read(&mut analog_pin).unwrap();
        // value now contains the ADC reading
    }
}

```

--------------------------------

### Implement Delay Functions using stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

This code snippet illustrates how to use the `Delay` struct for precise blocking delays. It configures the system clock and then utilizes `delay_ms` for millisecond delays and `delay_us` for microsecond delays, both based on the SysTick timer.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use stm32l4xx_hal::{delay::Delay, prelude::*, stm32};

#[entry]
fn main() -> ! {
    let cp = cortex_m::Peripherals::take().unwrap();
    let dp = stm32::Peripherals::take().unwrap();

    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
    let clocks = rcc.cfgr.sysclk(80.MHz()).freeze(&mut flash.acr, &mut pwr);

    // Create delay using SysTick
    let mut delay = Delay::new(cp.SYST, clocks);

    loop {
        delay.delay_ms(1000_u32);    // 1 second delay
        delay.delay_us(500_u32);     // 500 microsecond delay
    }
}
```

--------------------------------

### Configure Timer with Interrupts using stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

This snippet demonstrates how to configure a hardware timer (TIM6) to generate periodic interrupts at a specified frequency (1 Hz). It involves enabling the timer interrupt in the NVIC and setting up the timer event. The interrupt handler (TIM7) is also shown, which increments a counter on each interrupt.

```rust
#![no_std]
#![no_main]

use cortex_m::peripheral::NVIC;
use cortex_m_rt::entry;
use stm32l4xx_hal::{
    interrupt,
    prelude::*,
    timer::{Event, Timer},
    stm32,
};

#[entry]
fn main() -> ! {
    let dp = stm32::Peripherals::take().unwrap();

    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);
    let clocks = rcc.cfgr.freeze(&mut flash.acr, &mut pwr);

    // Enable TIM7 interrupt in NVIC
    unsafe { NVIC::unmask(stm32::Interrupt::TIM7); }

    // Create timer at 1 Hz (1 second period)
    let mut timer = Timer::tim6(dp.TIM6, 1.Hz(), clocks, &mut rcc.apb1r1);
    timer.listen(Event::TimeOut);

    loop {}
}

#[interrupt]
fn TIM7() {
    static mut COUNT: u32 = 0;
    *COUNT += 1;
    // This runs every second
}
```

--------------------------------

### Configure RTC with LSE Clock Source using stm32l4xx-hal

Source: https://context7.com/stm32-rs/stm32l4xx-hal/llms.txt

This code configures the Real-Time Clock (RTC) on the STM32L4xx microcontroller. It enables the LSE (32.768 kHz crystal) as the clock source and sets the initial date and time. The snippet also demonstrates how to read back the current date and time from the RTC.

```rust
#![no_std]
#![no_main]

use cortex_m_rt::entry;
use time::{Date, Time};
use stm32l4xx_hal::{
    delay::Delay,
    prelude::*,
    rcc::{ClockSecuritySystem, CrystalBypass},
    rtc::{Rtc, RtcClockSource, RtcConfig},
    stm32,
};

#[entry]
fn main() -> ! {
    let cp = cortex_m::Peripherals::take().unwrap();
    let dp = stm32::Peripherals::take().unwrap();

    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut pwr = dp.PWR.constrain(&mut rcc.apb1r1);

    // Enable LSE for RTC
    let clocks = rcc
        .cfgr
        .lse(CrystalBypass::Disable, ClockSecuritySystem::Disable)
        .freeze(&mut flash.acr, &mut pwr);

    // Configure RTC with LSE clock source
    let mut rtc = Rtc::rtc(
        dp.RTC,
        &mut rcc.apb1r1,
        &mut rcc.bdcr,
        &mut pwr.cr1,
        RtcConfig::default().clock_config(RtcClockSource::LSE),
    );

    // Set date and time
    let time = Time::from_hms(21, 57, 32).unwrap();
    let date = Date::from_calendar_date(2024, time::Month::January.try_into().unwrap(), 15).unwrap();
    rtc.set_datetime(&date.with_time(time));

    let mut timer = Delay::new(cp.SYST, clocks);
    timer.delay_ms(3000_u32);

    // Read back date and time
    let rtc_datetime = rtc.get_datetime();
    let current_time = rtc_datetime.time();
    let current_date = rtc_datetime.date();

    loop {}
}
```
Tokens:
Raw