Improve coverage of NVMC example

Author: ia0

examples/nvmc-demo/Cargo.toml

@@ -12,6 +12,7 @@ cortex-m = "0.7.3"
 cortex-m-rt = "0.7.0"
 embedded-storage = "0.2.0"
 rtt-target = {version = "0.2.0", features = ["cortex-m"] }
+panic-probe = { version = "0.3.0", features = ["print-rtt"] }
 
 [dependencies.embedded-hal]
 version = "0.2.3"

examples/nvmc-demo/memory.x

@@ -1,8 +1,9 @@
 MEMORY
 {
-  /* NOTE 1 K = 1 KiBi = 1024 bytes */
-  FLASH : ORIGIN = 0x00000000, LENGTH = 1020K
-  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = 4K /* 4K is the flash page size */
+  /* NOTE 1 K = 1 KiB = 1024 bytes */
+  FLASH : ORIGIN = 0x00000000, LENGTH = 1024K - 16K
+  /* We use 4 pages of 4 KiB each, so 16 KiB */
+  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = 16K
   RAM : ORIGIN = 0x20000000, LENGTH = 256K
 }
 

examples/nvmc-demo/src/main.rs

@@ -6,18 +6,26 @@
 #[cfg(feature = "52840")]
 use nrf52840_hal as hal;
 
+use core::convert::TryInto;
 use embedded_storage::nor_flash::NorFlash;
 use embedded_storage::nor_flash::ReadNorFlash;
 use hal::nvmc::Nvmc;
+use hal::pac::NVMC;
+use panic_probe as _;
 use rtt_target::{rprintln, rtt_init_print};
 
-const CONFIG_SIZE: usize = 1024;
+// We use 4 pages to use non-zero offsets.
+const PAGE_SIZE: u32 = 4 * 1024;
+const LAST_PAGE: u32 = 3 * PAGE_SIZE;
+const CONFIG_SIZE: usize = 4 * PAGE_SIZE as usize / 4;
 extern "C" {
     #[link_name = "_config"]
     static mut CONFIG: [u32; CONFIG_SIZE];
 }
 
-// To run this: `cargo embed --features "52840" --target thumbv7em-none-eabihf`
+// To run this example:
+// cargo build --features=52840 --target=thumbv7em-none-eabi && \
+// probe-run --chip nRF52840_xxAA ../../target/thumbv7em-none-eabi/debug/nvmc-demo
 
 #[cortex_m_rt::entry]
 fn main() -> ! {
@@ -28,23 +36,79 @@ fn main() -> ! {
     #[cfg(feature = "52840")]
     let mut nvmc = Nvmc::new(p.NVMC, unsafe { &mut CONFIG });
 
-    assert!(nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
-    let write_buf: [u8; 4] = [1, 2, 3, 4];
-    assert!(nvmc.write(0, &write_buf).is_ok());
-    let mut read_buf = [0u8; 2];
-    assert!(nvmc.read(0, &mut read_buf).is_ok());
-    assert_eq!(read_buf, write_buf[0..2]);
+    erase_if_needed(&mut nvmc, LAST_PAGE);
 
-    rprintln!("What was written to flash was read!");
+    let mut write_buf: [u8; 32] = [0; 32];
+    for (i, x) in write_buf.iter_mut().enumerate() {
+        *x = i as u8;
+    }
+    rprintln!("Writing at {:#x}: {:02x?}", LAST_PAGE, write_buf);
+    nvmc.write(LAST_PAGE, &write_buf).unwrap();
+
+    for i in 0..4 {
+        compare_read::<11>(&mut nvmc, LAST_PAGE + i);
+        compare_read::<10>(&mut nvmc, LAST_PAGE + i);
+        compare_read::<9>(&mut nvmc, LAST_PAGE + i + 4);
+        compare_read::<8>(&mut nvmc, LAST_PAGE + i + 4);
+        compare_read::<7>(&mut nvmc, LAST_PAGE + i + 8);
+        compare_read::<6>(&mut nvmc, LAST_PAGE + i + 8);
+        compare_read::<5>(&mut nvmc, LAST_PAGE + i + 16);
+        compare_read::<4>(&mut nvmc, LAST_PAGE + i + 16);
+        compare_read::<3>(&mut nvmc, LAST_PAGE + i + 20);
+        compare_read::<2>(&mut nvmc, LAST_PAGE + i + 20);
+        compare_read::<1>(&mut nvmc, LAST_PAGE + i + 24);
+    }
+
+    erase_if_needed(&mut nvmc, LAST_PAGE);
 
     loop {
         cortex_m::asm::wfe();
     }
 }
 
-#[panic_handler] // panicking behavior
-fn panic(_: &core::panic::PanicInfo) -> ! {
-    loop {
-        cortex_m::asm::bkpt();
+fn compare_read<const LENGTH: usize>(nvmc: &mut Nvmc<NVMC>, offset: u32) {
+    let actual = read::<LENGTH>(nvmc, offset);
+    let expected = unsafe { direct_read::<LENGTH>(offset) };
+    if actual == expected {
+        rprintln!("Read at {:#x}: {:02x?} as expected", offset, actual);
+    } else {
+        rprintln!(
+            "Error: Read at {:#x}: {:02x?} instead of {:02x?}",
+            offset,
+            actual,
+            expected,
+        );
     }
 }
+
+fn read<const LENGTH: usize>(nvmc: &mut Nvmc<NVMC>, offset: u32) -> [u8; LENGTH] {
+    let mut buf = [0; LENGTH];
+    nvmc.read(offset, &mut buf).unwrap();
+    buf
+}
+
+unsafe fn direct_read<const LENGTH: usize>(offset: u32) -> [u8; LENGTH] {
+    let ptr = &CONFIG as *const u32 as *const u8;
+    let slice = core::slice::from_raw_parts(ptr, CONFIG_SIZE * 4);
+    slice[offset as usize..][..LENGTH].try_into().unwrap()
+}
+
+fn erase_if_needed(nvmc: &mut Nvmc<NVMC>, offset: u32) {
+    let mut page = [0; PAGE_SIZE as usize];
+    nvmc.read(offset, &mut page).unwrap();
+    if page_is_erased(&page) {
+        return;
+    }
+    rprintln!("Erasing at {:#x}", offset);
+    nvmc.erase(offset, offset + PAGE_SIZE).unwrap();
+    nvmc.read(offset, &mut page).unwrap();
+    if page_is_erased(&page) {
+        rprintln!("The page was correctly erased.");
+    } else {
+        rprintln!("Error: The page was not correctly erased.");
+    }
+}
+
+fn page_is_erased(page: &[u8; PAGE_SIZE as usize]) -> bool {
+    page.iter().all(|&x| x == 0xff)
+}