deps(circuit-playground-express): Update dependencies and HAL to 0.23.0 (#953)

wt · web-flow · commit 20b17d2c6d84 · 2025-11-20T11:22:58.000+01:00
diff --git a/boards/circuit_playground_express/Cargo.toml b/boards/circuit_playground_express/Cargo.toml
@@ -1,42 +1,48 @@
 [package]
 name = "circuit_playground_express"
+categories = ["embedded", "hardware-support", "no-std"]
 version = "0.11.1"
 authors = ["Paul Sajna <paulsajna@gmail.com>"]
 description = "Board Support crate for the Adafruit Circuit Playground Express"
 keywords = ["no-std", "arm", "cortex-m", "embedded-hal"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/atsamd-rs/atsamd"
 readme = "README.md"
-edition = "2018"
+edition = "2024"
 
 [dependencies.cortex-m-rt]
 version = "0.7"
 optional = true
 
 [dependencies.atsamd-hal]
-version = "0.14"
+version = "0.23.0"
 default-features = false
 
+[dependencies.cortex-m]
+features = ["critical-section-single-core"]
+version = "0.7"
+
 [dependencies.usb-device]
-version = "0.2"
+version = "0.3.2"
 optional = true
 
 [dev-dependencies]
-cortex-m = "0.7"
 panic-halt = "0.2"
-panic-semihosting = "0.5"
-usbd-serial = "0.1"
+panic-semihosting = "0.6"
+usbd-serial = "0.2"
 smart-leds = "0.3.0"
+heapless = "0.9.2"
 
 [dev-dependencies.ws2812-timer-delay]
 features = ["slow"]
 version = "0.3.0"
 
 [features]
 # ask the HAL to enable atsamd21g support
-default = ["rt", "atsamd-hal/samd21g"]
+# CPE uses all kinds of undoc'd i2c functionality.
+default = ["rt", "atsamd-hal/samd21g", "atsamd-hal/undoc-features"]
+dma = ["atsamd-hal/dma"]
 rt = ["cortex-m-rt", "atsamd-hal/samd21g-rt"]
-unproven = ["atsamd-hal/unproven"]
 usb = ["atsamd-hal/usb", "usb-device"]
 use_semihosting = []
 
@@ -53,3 +59,4 @@ name = "uart"
 [[example]]
 name = "usb_serial"
 required-features = ["usb"]
+edition = "2021"
diff --git a/boards/circuit_playground_express/examples/blinky_basic.rs b/boards/circuit_playground_express/examples/blinky_basic.rs
@@ -21,12 +21,12 @@ fn main() -> ! {
     let mut peripherals = Peripherals::take().unwrap();
     let core = CorePeripherals::take().unwrap();
     let mut clocks = GenericClockController::with_internal_32kosc(
-        peripherals.GCLK,
-        &mut peripherals.PM,
-        &mut peripherals.SYSCTRL,
-        &mut peripherals.NVMCTRL,
+        peripherals.gclk,
+        &mut peripherals.pm,
+        &mut peripherals.sysctrl,
+        &mut peripherals.nvmctrl,
     );
-    let pins = bsp::Pins::new(peripherals.PORT);
+    let pins = bsp::Pins::new(peripherals.port);
     let mut red_led: bsp::RedLed = pins.d13.into();
     let mut delay = Delay::new(core.SYST, &mut clocks);
     loop {
diff --git a/boards/circuit_playground_express/examples/neopixel_rainbow.rs b/boards/circuit_playground_express/examples/neopixel_rainbow.rs
@@ -20,13 +20,14 @@ use circuit_playground_express as bsp;
 use bsp::entry;
 use hal::clock::GenericClockController;
 use hal::delay::Delay;
-use hal::prelude::*;
+use hal::fugit::ExtU32;
 use hal::timer::TimerCounter;
+use hal::timer_traits::InterruptDrivenTimer;
 use pac::{CorePeripherals, Peripherals};
 
 use smart_leds::{
-    hsv::{hsv2rgb, Hsv},
     SmartLedsWrite,
+    hsv::{Hsv, hsv2rgb},
 };
 use ws2812_timer_delay as ws2812;
 
@@ -35,24 +36,25 @@ fn main() -> ! {
     let mut peripherals = Peripherals::take().unwrap();
     let core = CorePeripherals::take().unwrap();
     let mut clocks = GenericClockController::with_internal_32kosc(
-        peripherals.GCLK,
-        &mut peripherals.PM,
-        &mut peripherals.SYSCTRL,
-        &mut peripherals.NVMCTRL,
+        peripherals.gclk,
+        &mut peripherals.pm,
+        &mut peripherals.sysctrl,
+        &mut peripherals.nvmctrl,
     );
-    let pins = bsp::Pins::new(peripherals.PORT);
+    let pins = bsp::Pins::new(peripherals.port);
     let mut delay = Delay::new(core.SYST, &mut clocks);
 
     let gclk0 = clocks.gclk0();
     let timer_clock = clocks.tcc2_tc3(&gclk0).unwrap();
-    let mut timer = TimerCounter::tc3_(&timer_clock, peripherals.TC3, &mut peripherals.PM);
-    timer.start(3.mhz());
+    let mut timer = TimerCounter::tc3_(&timer_clock, peripherals.tc3, &mut peripherals.pm);
+    timer.start(1.micros());
 
     let neopixel_pin: bsp::NeoPixel = pins.d8.into();
     let mut neopixel = ws2812::Ws2812::new(timer, neopixel_pin);
 
     // Loop through all of the available hue values (colors) to make a
     // rainbow effect from the onboard neopixel
+    use hal::ehal::delay::DelayNs;
     loop {
         for j in 0..255u8 {
             let colors = [hsv2rgb(Hsv {
@@ -61,7 +63,7 @@ fn main() -> ! {
                 val: 2,
             }); 10];
             neopixel.write(colors.iter().cloned()).unwrap();
-            delay.delay_ms(5u8);
+            delay.delay_ms(5);
         }
     }
 }
diff --git a/boards/circuit_playground_express/examples/uart.rs b/boards/circuit_playground_express/examples/uart.rs
@@ -1,3 +1,6 @@
+//! This example shows how to use the UART to perform transfers using the
+//! embedded-hal-nb traits.
+
 #![no_std]
 #![no_main]
 
@@ -9,58 +12,62 @@ use panic_semihosting as _;
 use bsp::hal;
 use bsp::pac;
 use circuit_playground_express as bsp;
+use hal::nb;
 
-use bsp::entry;
+use bsp::{entry, periph_alias, pin_alias};
 use hal::clock::GenericClockController;
-use hal::prelude::*;
+use hal::ehal_nb::serial::{Read, Write};
+use hal::fugit::RateExtU32;
 
-use pac::{CorePeripherals, Peripherals};
+use pac::Peripherals;
 
 #[entry]
 fn main() -> ! {
     let mut peripherals = Peripherals::take().unwrap();
-    let core = CorePeripherals::take().unwrap();
     let mut clocks = GenericClockController::with_internal_32kosc(
-        peripherals.GCLK,
-        &mut peripherals.PM,
-        &mut peripherals.SYSCTRL,
-        &mut peripherals.NVMCTRL,
+        peripherals.gclk,
+        &mut peripherals.pm,
+        &mut peripherals.sysctrl,
+        &mut peripherals.nvmctrl,
     );
 
-    let mut pm = peripherals.PM;
-    let pins = bsp::Pins::new(peripherals.PORT);
-    let mut delay = hal::delay::Delay::new(core.SYST, &mut clocks);
+    let mut pm = peripherals.pm;
+    let pins = bsp::Pins::new(peripherals.port);
 
-    let mut red_led = pins.d13.into_push_pull_output();
+    // Take peripheral and pins
+    let uart_sercom = periph_alias!(peripherals.uart_sercom);
+    let uart_rx = pin_alias!(pins.uart_rx);
+    let uart_tx = pin_alias!(pins.uart_tx);
 
-    // Setup UART peripheral.
-    let (rx_pin, tx_pin) = (pins.a6, pins.a7);
-    let mut uart = bsp::uart(
+    // Setup UART peripheral
+    let uart = bsp::uart(
         &mut clocks,
-        9600.hz(),
-        peripherals.SERCOM4,
+        9600.Hz(),
+        uart_sercom,
         &mut pm,
-        rx_pin,
-        tx_pin,
+        uart_rx,
+        uart_tx,
     );
 
-    // Write out a message on start up.
-    for byte in b"Hello world!\r\n" {
-        nb::block!(uart.write(*byte)).unwrap();
-    }
+    // Split uart in rx + tx halves
+    let (mut rx, mut tx) = uart.split();
+
+    // Make buffers to store data to send/receive
+    let mut rx_buffer = [0x00; 50];
+    let tx_buffer = b"Hello, world!";
 
     loop {
-        match uart.read() {
-            Ok(byte) => {
-                // Echo all received characters.
-                nb::block!(uart.write(byte)).unwrap();
+        // Send data. We block on each byte, but we could also perform some tasks while
+        // waiting for the byte to finish sending.
+        for c in tx_buffer.iter() {
+            nb::block!(tx.write(*c)).unwrap();
+        }
 
-                // Blink the red led to show that a character has arrived.
-                red_led.set_high().unwrap();
-                delay.delay_ms(2u16);
-                red_led.set_low().unwrap();
-            }
-            Err(_) => delay.delay_ms(5u16),
-        };
+        // Receive data. We block on each byte, but we could also perform some tasks
+        // while waiting for the byte to finish sending.
+        rx.flush_rx_buffer();
+        for c in rx_buffer.iter_mut() {
+            *c = nb::block!(rx.read()).unwrap();
+        }
     }
 }
diff --git a/boards/circuit_playground_express/examples/usb_serial.rs b/boards/circuit_playground_express/examples/usb_serial.rs
@@ -16,7 +16,7 @@ use bsp::hal;
 use bsp::pac;
 use circuit_playground_express as bsp;
 
-use bsp::entry;
+use bsp::{entry, pin_alias};
 use hal::clock::GenericClockController;
 use hal::prelude::*;
 use hal::usb::UsbBus;
@@ -27,32 +27,34 @@ fn main() -> ! {
     let mut peripherals = Peripherals::take().unwrap();
     let mut core = CorePeripherals::take().unwrap();
     let mut clocks = GenericClockController::with_internal_32kosc(
-        peripherals.GCLK,
-        &mut peripherals.PM,
-        &mut peripherals.SYSCTRL,
-        &mut peripherals.NVMCTRL,
+        peripherals.gclk,
+        &mut peripherals.pm,
+        &mut peripherals.sysctrl,
+        &mut peripherals.nvmctrl,
     );
-    let pins = bsp::Pins::new(peripherals.PORT);
-    let mut red_led: bsp::RedLed = pins.d13.into();
+    let pins = bsp::Pins::new(peripherals.port);
+    let mut red_led: bsp::RedLed = pin_alias!(pins.red_led).into();
 
     let bus_allocator = unsafe {
         USB_ALLOCATOR = Some(bsp::usb_allocator(
-            peripherals.USB,
+            peripherals.usb,
             &mut clocks,
-            &mut peripherals.PM,
+            &mut peripherals.pm,
             pins.usb_dm,
             pins.usb_dp,
         ));
         USB_ALLOCATOR.as_ref().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(&bus_allocator));
+        USB_SERIAL = Some(SerialPort::new(bus_allocator));
         USB_BUS = Some(
-            UsbDeviceBuilder::new(&bus_allocator, UsbVidPid(0x16c0, 0x27dd))
-                .manufacturer("Fake company")
-                .product("Serial port")
-                .serial_number("TEST")
+            UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
+                .strings(&[StringDescriptors::new(LangID::EN)
+                    .manufacturer("Fake company")
+                    .product("Serial port")
+                    .serial_number("TEST")])
+                .expect("Failed to set strings")
                 .device_class(USB_CLASS_CDC)
                 .build(),
         );
@@ -67,9 +69,7 @@ fn main() -> ! {
     // entirely interrupt driven.
     loop {
         cycle_delay(15 * 1024 * 1024);
-        red_led.set_high().ok();
-        cycle_delay(15 * 1024 * 1024);
-        red_led.set_low().ok();
+        red_led.toggle().ok();
     }
 }
 
@@ -79,8 +79,8 @@ static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
 
 fn poll_usb() {
     unsafe {
-        USB_BUS.as_mut().map(|usb_dev| {
-            USB_SERIAL.as_mut().map(|serial| {
+        if let Some(usb_dev) = USB_BUS.as_mut() {
+            if let Some(serial) = USB_SERIAL.as_mut() {
                 usb_dev.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
@@ -89,11 +89,11 @@ fn poll_usb() {
                         if i >= count {
                             break;
                         }
-                        serial.write(&[c.clone()]).ok();
+                        serial.write(&[*c]).ok();
                     }
                 };
-            });
-        });
+            };
+        };
     };
 }
 
diff --git a/boards/circuit_playground_express/src/lib.rs b/boards/circuit_playground_express/src/lib.rs
