Added changes systec-ms

- Linter fixes
- Added code comment that clarifies the need to write double words
- Added an example called flash_with_rtic.rs to show flash memory use
case.

Author: amcelroy

examples/flash_with_rtic.rs

@@ -0,0 +1,177 @@
+#![allow(unsafe_code)]
+#![allow(warnings)]
+#![allow(missing_docs)]
+#![allow(unused_variables)]
+#![no_main]
+#![no_std]
+
+#[rtic::app(device = stm32g4xx_hal::stm32g4::stm32g474, peripherals = true)]
+mod app {
+    use stm32g4xx_hal::flash::{FlashExt, FlashSize, FlashWriter, Parts};
+    use stm32g4xx_hal::prelude::*;
+    use stm32g4xx_hal::rcc::{PllConfig, RccExt};
+
+    use panic_halt as _; // you can put a breakpoint on `rust_begin_unwind` to catch panics
+
+    // Resources shared between tasks
+    #[shared]
+    struct Shared {}
+
+    // Local resources to specific tasks (cannot be shared)
+    #[local]
+    struct Local {}
+
+    fn compare_arrays(a: &[u8], b: &[u8]) -> bool {
+        if a.len() != b.len() {
+            return false;
+        }
+        for i in 0..a.len() {
+            if a[i] != b[i] {
+                return false;
+            }
+        }
+        true
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
+        // let dp = Peripherals::take().unwrap();
+        // let cp = cortex_m::Peripherals::take().expect("cannot take core peripherals");
+
+        let dp = cx.device;
+        let cp = cx.core;
+
+        let rcc = dp.RCC.constrain();
+        let mut pll_config = stm32g4xx_hal::rcc::PllConfig::default();
+
+        // Sysclock is based on PLL_R
+        pll_config.mux = stm32g4xx_hal::rcc::PLLSrc::HSI; // 16MHz
+        pll_config.n = stm32g4xx_hal::rcc::PllNMul::MUL_32;
+        pll_config.m = stm32g4xx_hal::rcc::PllMDiv::DIV_2; // f(vco) = 16MHz*32/2 = 256MHz
+        pll_config.r = Some(stm32g4xx_hal::rcc::PllRDiv::DIV_2); // f(sysclock) = 256MHz/2 = 128MHz
+
+        // Note to future self: The AHB clock runs the timers, among other things.
+        // Please refer to the Clock Tree manual to determine if it is worth
+        // changing to a lower speed for battery life savings.
+        let mut clock_config = stm32g4xx_hal::rcc::Config::default()
+            .pll_cfg(pll_config)
+            .clock_src(stm32g4xx_hal::rcc::SysClockSrc::PLL);
+
+        // After clock configuration, the following should be true:
+        // Sysclock is 128MHz
+        // AHB clock is 128MHz
+        // APB1 clock is 128MHz
+        // APB2 clock is 128MHz
+        // The ADC will ultimately be put into synchronous mode and will derive
+        // its clock from the AHB bus clock, with a prescalar of 2 or 4.
+
+        let mut rcc = rcc.freeze(clock_config);
+
+        unsafe {
+            let mut flash = &(*stm32g4xx_hal::stm32::FLASH::ptr());
+            flash.acr.modify(|_, w| {
+                w.latency().bits(0b1000) // 8 wait states
+            });
+        }
+
+        // *** FLASH Memory ***
+        //let mut data = [0xBE, 0xEF, 0xCA, 0xFE];
+        let one_byte = [0x12 as u8];
+        let two_bytes = [0xAB, 0xCD as u8];
+        let three_bytes = [0x12, 0x34, 0x56 as u8];
+        let four_bytes = [0xAB, 0xCD, 0xEF, 0xBA as u8];
+        let eight_bytes = [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0 as u8];
+        let sixteen_bytes = [
+            0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC,
+            0xDE, 0xF0 as u8,
+        ];
+        let mut flash = dp.FLASH.constrain();
+        let mut flash_writer = flash.writer::<2048>(FlashSize::Sz256K);
+        const FLASH_SPACING: usize = 16; // Separate flash writes by 16 bytes
+
+        flash_writer.erase(0x1FC00, 128).unwrap(); // Erase entire page
+
+        for i in 0..6 {
+            match i {
+                0 => flash_writer
+                    .write(0x1FC00 + i * FLASH_SPACING, &one_byte)
+                    .unwrap(),
+                1 => flash_writer
+                    .write(0x1FC00 + i * FLASH_SPACING, &two_bytes)
+                    .unwrap(),
+                2 => flash_writer
+                    .write(0x1FC00 + i * FLASH_SPACING, &three_bytes)
+                    .unwrap(),
+                3 => flash_writer
+                    .write(0x1FC00 + i * FLASH_SPACING, &four_bytes)
+                    .unwrap(),
+                4 => flash_writer
+                    .write(0x1FC00 + i * FLASH_SPACING, &eight_bytes)
+                    .unwrap(),
+                5 => flash_writer
+                    .write(0x1FC00 + i * 16, &sixteen_bytes)
+                    .unwrap(),
+                _ => (),
+            }
+        }
+
+        for i in 0..6 {
+            match i {
+                0 => {
+                    let bytes = flash_writer.read(0x1FC00 as u32, one_byte.len()).unwrap();
+                    assert!(compare_arrays(&bytes, &one_byte));
+                }
+                1 => {
+                    let bytes = flash_writer
+                        .read(0x1FC00 + i * FLASH_SPACING, two_bytes.len())
+                        .unwrap();
+                    assert!(compare_arrays(&bytes, &two_bytes));
+                }
+                2 => {
+                    let bytes = flash_writer
+                        .read(0x1FC00 + i * FLASH_SPACING, three_bytes.len())
+                        .unwrap();
+                    assert!(compare_arrays(&bytes, &three_bytes));
+                }
+                3 => {
+                    let bytes = flash_writer
+                        .read(0x1FC00 + i * FLASH_SPACING, four_bytes.len())
+                        .unwrap();
+                    assert!(compare_arrays(&bytes, &four_bytes));
+                }
+                4 => {
+                    let bytes = flash_writer
+                        .read(0x1FC00 + i * FLASH_SPACING, eight_bytes.len())
+                        .unwrap();
+                    assert!(compare_arrays(&bytes, &eight_bytes));
+                }
+                5 => {
+                    let bytes = flash_writer
+                        .read(0x1FC00 + i * FLASH_SPACING, sixteen_bytes.len())
+                        .unwrap();
+                    assert!(compare_arrays(&bytes, &sixteen_bytes));
+                }
+                _ => (),
+            }
+        }
+
+        (
+            // Initialization of shared resources
+            Shared {},
+            // Initialization of task local resources
+            Local {},
+            // Move the monotonic timer to the RTIC run-time, this enables
+            // scheduling
+            init::Monotonics(),
+        )
+    }
+
+    // Background task, runs whenever no other tasks are running
+    #[idle]
+    fn idle(mut cx: idle::Context) -> ! {
+        loop {
+            // Sleep until next interrupt
+            cortex_m::asm::wfi();
+        }
+    }
+}

src/flash.rs

@@ -255,6 +255,7 @@ impl<'a, const SECTOR_SZ_KB: u32> FlashWriter<'a, SECTOR_SZ_KB> {
         // Unlock Flash
         self.unlock()?;
 
+        // According to RM0440 Rev 7, "It is only possible to program double word (2 x 32-bit data)"
         for idx in (0..data.len()).step_by(8) {
             // Check the starting address
             self.valid_address(offset + idx as u32)?;
@@ -264,8 +265,8 @@ impl<'a, const SECTOR_SZ_KB: u32> FlashWriter<'a, SECTOR_SZ_KB> {
             let write_address1 = (FLASH_START + offset + idx as u32) as *mut u32;
             let write_address2 = (FLASH_START + offset + 4 + idx as u32) as *mut u32;
 
-            let mut word1: u32 = 0;
-            let mut word2: u32 = 0;
+            let word1: u32;
+            let word2: u32;
 
             // Check if there is enough data to make 2 words, if there isn't, pad the data with 0xFF
             if idx + 8 > data.len() {