static_cell

Author: burrbull

Cargo.toml

@@ -93,6 +93,7 @@ version = "0.5.0"
 optional = true
 
 [dev-dependencies]
+static_cell = "2.1.1"
 defmt = "1.0.1"
 defmt-rtt = "1.0"
 panic-probe = { version = "1.0", features = ["print-defmt"] }

examples/ltdc-screen/main.rs

@@ -13,6 +13,7 @@ use embedded_graphics::{
     text::Text,
 };
 
+use static_cell::ConstStaticCell;
 use stm32f4xx_hal::{
     ltdc::{BluePins, GreenPins, Layer, LtdcPins, PixelFormat, RedPins},
     pac,
@@ -28,7 +29,8 @@ const HEIGHT: u16 = 272;
 
 // Graphics framebuffer
 const FB_GRAPHICS_SIZE: usize = (WIDTH as usize) * (HEIGHT as usize);
-static mut FB_LAYER1: [u16; FB_GRAPHICS_SIZE] = [0; FB_GRAPHICS_SIZE];
+pub static FB_LAYER1: ConstStaticCell<[u16; FB_GRAPHICS_SIZE]> =
+    ConstStaticCell::new([0; FB_GRAPHICS_SIZE]);
 
 #[entry]
 fn main() -> ! {
@@ -85,7 +87,7 @@ fn main() -> ! {
     let mut display = screen::Stm32F7DiscoDisplay::new(perif.LTDC, perif.DMA2D, pins);
     display
         .controller
-        .config_layer(Layer::L1, unsafe { &mut FB_LAYER1 }, PixelFormat::RGB565);
+        .config_layer(Layer::L1, FB_LAYER1.take(), PixelFormat::RGB565);
 
     display.controller.enable_layer(Layer::L1);
     display.controller.reload();

examples/qspi-w25q.rs

@@ -18,6 +18,7 @@ pub struct W25Q<PINS: QspiPins> {
     qspi: Qspi<PINS>,
 }
 
+#[allow(unused)]
 pub struct DeviceId(u8);
 
 impl<PINS> W25Q<PINS>

examples/rtic-usb-cdc-echo.rs

@@ -5,6 +5,7 @@ use panic_halt as _;
 
 #[rtic::app(device = stm32f4xx_hal::pac, peripherals = true, dispatchers = [USART1])]
 mod app {
+    use static_cell::{ConstStaticCell, StaticCell};
     use stm32f4xx_hal::{
         gpio::{Output, PC13},
         otg_fs::{UsbBus, UsbBusType, USB},
@@ -33,8 +34,9 @@ mod app {
 
     #[init]
     fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
-        static mut EP_MEMORY: [u32; 1024] = [0; 1024];
-        static mut USB_BUS: Option<usb_device::bus::UsbBusAllocator<UsbBusType>> = None;
+        static EP_MEMORY: ConstStaticCell<[u32; 1024]> = ConstStaticCell::new([0; 1024]);
+        static USB_BUS: StaticCell<usb_device::bus::UsbBusAllocator<UsbBusType>> =
+            StaticCell::new();
 
         let dp = ctx.device;
 
@@ -59,22 +61,17 @@ mod app {
             pin_dp: gpioa.pa12.into(),
             hclk: rcc.clocks.hclk(),
         };
-        unsafe {
-            USB_BUS.replace(UsbBus::new(usb, &mut EP_MEMORY));
-        }
-
-        let usb_serial = usbd_serial::SerialPort::new(unsafe { USB_BUS.as_ref().unwrap() });
-        let usb_dev = UsbDeviceBuilder::new(
-            unsafe { USB_BUS.as_ref().unwrap() },
-            UsbVidPid(0x16c0, 0x27dd),
-        )
-        .device_class(usbd_serial::USB_CLASS_CDC)
-        .strings(&[StringDescriptors::default()
-            .manufacturer("Fake Company")
-            .product("Product")
-            .serial_number("TEST")])
-        .unwrap()
-        .build();
+        let usb_bus = USB_BUS.init(UsbBus::new(usb, EP_MEMORY.take()));
+
+        let usb_serial = usbd_serial::SerialPort::new(usb_bus);
+        let usb_dev = UsbDeviceBuilder::new(usb_bus, UsbVidPid(0x16c0, 0x27dd))
+            .device_class(usbd_serial::USB_CLASS_CDC)
+            .strings(&[StringDescriptors::default()
+                .manufacturer("Fake Company")
+                .product("Product")
+                .serial_number("TEST")])
+            .unwrap()
+            .build();
 
         (
             Shared {

examples/spi-dma.rs

@@ -9,6 +9,7 @@ use core::cell::RefCell;
 use cortex_m::interrupt::Mutex;
 use cortex_m_rt::entry;
 use embedded_hal_02::spi::{Mode, Phase, Polarity};
+use static_cell::ConstStaticCell;
 use stm32f4xx_hal::pac::interrupt;
 use stm32f4xx_hal::{
     dma::{config, MemoryToPeripheral, Stream4, StreamsTuple, Transfer},
@@ -105,12 +106,11 @@ fn DMA1_STREAM4() {
     // Its important to clear fifo errors as the transfer is paused until it is cleared
     transfer.clear_flags(DmaFlag::FifoError | DmaFlag::TransferComplete);
     if flags.is_transfer_complete() {
-        unsafe {
-            static mut BUFFER: [u8; ARRAY_SIZE] = [0; ARRAY_SIZE];
-            for (i, b) in BUFFER.iter_mut().enumerate() {
-                *b = (i + 1) as u8;
-            }
-            transfer.next_transfer(&mut BUFFER).unwrap();
+        pub static BUFFER: ConstStaticCell<[u8; ARRAY_SIZE]> =
+            ConstStaticCell::new([0; ARRAY_SIZE]);
+        for (i, b) in BUFFER.take().iter_mut().enumerate() {
+            *b = (i + 1) as u8;
         }
+        transfer.next_transfer(BUFFER.take()).unwrap();
     }
 }

examples/uart-dma.rs

@@ -8,6 +8,7 @@ use stm32f4xx_hal::dma::{DmaFlag, PeripheralToMemory, Stream1};
 use core::cell::RefCell;
 use cortex_m::interrupt::Mutex;
 use cortex_m_rt::entry;
+use static_cell::ConstStaticCell;
 use stm32f4xx_hal::dma::config::DmaConfig;
 use stm32f4xx_hal::pac::Interrupt;
 use stm32f4xx_hal::pac::{interrupt, DMA1};
@@ -74,7 +75,8 @@ pub static G_UART3_TX: Mutex<RefCell<Option<serial::Tx<pac::USART3>>>> =
     Mutex::new(RefCell::new(None));
 
 // dma buffer
-pub static mut RX_UART3_BUFFER: [u8; UART_BUFFER_SIZE] = [0; UART_BUFFER_SIZE];
+pub static RX_UART3_BUFFER: ConstStaticCell<[u8; UART_BUFFER_SIZE]> =
+    ConstStaticCell::new([0; UART_BUFFER_SIZE]);
 
 // a wrapper function that reads out of the uart ring buffer
 pub fn uart3_read_until(eol: u8) -> Option<[u8; UART_BUFFER_SIZE]> {
@@ -208,16 +210,14 @@ fn USART3() {
             if transfer.is_idle() {
                 // Calc received bytes count
                 let bytes_count = UART_BUFFER_SIZE - transfer.number_of_transfers() as usize;
-                unsafe {
-                    let mut buffer = [0; UART_BUFFER_SIZE];
-                    match transfer.next_transfer(&mut RX_UART3_BUFFER) {
-                        Ok((b, _)) => buffer = *b,
-                        Err(_err) => {}
-                    }
-                    if let Some(ring_buffer) = G_UART3_BUFFER.borrow(cs).borrow_mut().as_mut() {
-                        for i in 0..bytes_count {
-                            ring_buffer.push(buffer[i]);
-                        }
+                let mut buffer = [0; UART_BUFFER_SIZE];
+                match transfer.next_transfer(RX_UART3_BUFFER.take()) {
+                    Ok((b, _)) => buffer = *b,
+                    Err(_err) => {}
+                }
+                if let Some(ring_buffer) = G_UART3_BUFFER.borrow(cs).borrow_mut().as_mut() {
+                    for i in 0..bytes_count {
+                        ring_buffer.push(buffer[i]);
                     }
                 }
             }

examples/usb-serial-poll.rs

@@ -6,12 +6,14 @@
 use panic_halt as _;
 
 use cortex_m_rt::entry;
+use static_cell::ConstStaticCell;
 use stm32f4xx_hal::otg_fs::{UsbBus, USB};
 use stm32f4xx_hal::rcc::Config;
 use stm32f4xx_hal::{pac, prelude::*};
 use usb_device::prelude::*;
 
-static mut EP_MEMORY: [u32; 1024] = [0; 1024];
+// Statically allocate memory for a `u32`.
+static EP_MEMORY: ConstStaticCell<[u32; 1024]> = ConstStaticCell::new([0; 1024]);
 
 #[entry]
 fn main() -> ! {
@@ -29,7 +31,7 @@ fn main() -> ! {
         &rcc.clocks,
     );
 
-    let usb_bus = UsbBus::new(usb, unsafe { &mut EP_MEMORY });
+    let usb_bus = UsbBus::new(usb, EP_MEMORY.take());
 
     let mut serial = usbd_serial::SerialPort::new(&usb_bus);
 

examples/ws2812-spi.rs

@@ -10,7 +10,7 @@ use hal::{
     pac::{self, SPI1},
     prelude::*,
 };
-use smart_leds::{brightness, RGB8, SmartLedsWrite};
+use smart_leds::{brightness, SmartLedsWrite, RGB8};
 use ws2812_spi as ws2812;
 
 #[entry]

src/rng.rs

@@ -199,4 +199,4 @@ impl rand_core_06::RngCore for Rng {
         self.try_fill_bytes(buffer)?;
         Ok(())
     }
-}
+}

src/timer.rs

@@ -459,6 +459,7 @@ mod sealed {
         fn start_pwm(&mut self);
     }
 
+    #[allow(unused)]
     pub trait WithCapture: WithChannel {
         fn preload_capture(&mut self, c: u8, mode: CaptureMode);
         fn prescaler_capture(&mut self, c: u8, psc: CapturePrescaler);
@@ -476,6 +477,7 @@ mod sealed {
         fn split() -> Self::Channels;
     }
 
+    #[allow(unused)]
     pub trait SplitCapture {
         type CaptureChannels;
         fn split_capture() -> Self::CaptureChannels;
@@ -488,6 +490,7 @@ pub trait Instance:
 {
 }
 
+#[allow(unused)]
 use sealed::{Split, SplitCapture};
 macro_rules! split {
     ($TIM:ty: 1) => {