Persist the calibration parameter

Author: werediver

escale_fw_rs/.vscode/settings.json

@@ -9,6 +9,8 @@
         "libm",
         "pico",
         "plls",
+        "repr",
+        "rodata",
         "Uninit",
         "XOSC",
         "xtal"

escale_fw_rs/app/Cargo.toml

@@ -24,6 +24,7 @@ rp-pico = "0.4.1"
 # rp2040-hal = { version="0.4.0", features=["rt"] }
 # rp2040-boot2 = "0.2.0"
 
+rp2040-flash = "0.1.0"
 ssd1306 = "0.7.0"
 nau7802 = { git = "https://github.com/werediver/nau7802-rs.git", branch = "next" }
 

escale_fw_rs/app/src/flash.rs

@@ -0,0 +1,73 @@
+use core::mem::{size_of, MaybeUninit};
+
+use rp2040_flash::flash;
+
+const FLASH_ORIGIN: usize = 0x10000000;
+/// The erasable sector size.
+const FLASH_SECTOR_SIZE: usize = 4096;
+
+/// The payload type `T` must fit into a single flash sector
+/// and be `repr(C)` to have a stable layout.
+///
+/// This data type itself should be flash sector aligned.
+#[repr(C, align(4096))]
+pub union FlashSector<T>
+where
+    T: Copy,
+    // `FLASH_SECTOR_SIZE` must be a power of two
+    [(); 0 - !is_pwr_of_two(FLASH_SECTOR_SIZE) as usize]:,
+    // `T` must fit into a single sector size
+    [(); FLASH_SECTOR_SIZE - size_of::<T>()]:,
+{
+    data: [u8; FLASH_SECTOR_SIZE],
+    value: MaybeUninit<T>,
+}
+
+impl<T> FlashSector<T>
+where
+    T: Copy,
+    [(); FLASH_SECTOR_SIZE - size_of::<T>()]:,
+{
+    pub const fn uninit() -> Self {
+        Self {
+            value: MaybeUninit::uninit(),
+        }
+    }
+
+    const fn new(value: T) -> Self {
+        Self {
+            value: MaybeUninit::new(value),
+        }
+    }
+
+    fn mem_addr(&self) -> usize {
+        unsafe { &self.data as *const _ as usize }
+    }
+
+    pub fn read(&self) -> MaybeUninit<T> {
+        unsafe { self.value }
+    }
+
+    pub unsafe fn write(&mut self, value: T) {
+        let tmp_flash_block = FlashSector::new(value);
+        self.write_flash(&tmp_flash_block.data)
+    }
+
+    unsafe fn write_flash(&self, data: &[u8; FLASH_SECTOR_SIZE]) {
+        let flash_addr = self.mem_addr() - FLASH_ORIGIN;
+        assert!(is_aligned(flash_addr, FLASH_SECTOR_SIZE));
+
+        cortex_m::interrupt::free(|_cs| {
+            flash::flash_range_erase_and_program(flash_addr as u32, data, true);
+        });
+    }
+}
+
+const fn is_pwr_of_two(n: usize) -> bool {
+    n != 0 && (n & (n - 1) == 0)
+}
+
+const fn is_aligned(addr: usize, alignment: usize) -> bool {
+    assert!(is_pwr_of_two(alignment));
+    addr & (alignment - 1) == 0
+}

escale_fw_rs/app/src/main.rs

@@ -2,7 +2,10 @@
 #![no_main]
 #![feature(alloc_error_handler)]
 #![feature(trait_alias)]
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
 
+mod flash;
 mod ssd1306_terminal;
 mod uptime;
 mod uptime_delay;
@@ -15,6 +18,7 @@ use core::{alloc::Layout, cell::RefCell};
 use cortex_m_rt::entry;
 use embedded_hal::digital::v2::InputPin;
 use embedded_time::rate::Extensions;
+use flash::FlashSector;
 use panic_probe as _;
 
 use rp_pico as bsp;
@@ -55,6 +59,31 @@ fn oom(_: Layout) -> ! {
 #[global_allocator]
 static ALLOCATOR: CortexMHeap = CortexMHeap::empty();
 
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Conf {
+    format: u16,
+    scale_unit: f32,
+}
+
+impl Conf {
+    const fn initial() -> Self {
+        Self {
+            format: 1,
+            scale_unit: 1.0,
+        }
+    }
+}
+
+#[link_section = ".rodata"]
+static mut CONF_FLASH_SECTOR: FlashSector<Conf> = FlashSector::uninit();
+
+unsafe fn write_conf(conf: Conf) {
+    core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
+    CONF_FLASH_SECTOR.write(conf);
+    core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
+}
+
 fn init_heap() {
     use core::mem::MaybeUninit;
     const HEAP_SIZE: usize = 128 * 1024;
@@ -130,6 +159,17 @@ fn _main() -> ! {
         Uptime::get_instant,
     )));
 
+    let conf = {
+        let conf = unsafe { CONF_FLASH_SECTOR.read().assume_init() };
+
+        let init_conf = Conf::initial();
+        if conf.format == init_conf.format {
+            conf
+        } else {
+            init_conf
+        }
+    };
+
     let i2c1 = I2C::i2c1(
         pac.I2C1,
         pins.gpio2.into_mode(),
@@ -147,6 +187,7 @@ fn _main() -> ! {
     )
     .unwrap();
     let mut scale = Scale::<i32, f32, 20>::default();
+    scale.set_unit(conf.scale_unit);
 
     schedule.push(AppTask::Fn(FnTask::new(move |cx: &mut AppContext| {
         if nau7802.data_available().unwrap() {
@@ -155,11 +196,14 @@ fn _main() -> ! {
             if scale.is_filled() {
                 cx.mq.process(|m, _push| match m {
                     AppMessage::Tare => {
-                        scale.set_tare().unwrap();
+                        scale.capture_tare().unwrap();
                         MessageProcessingStatus::Processed
                     }
                     AppMessage::Calibrate => {
-                        scale.set_unit(100.0).unwrap();
+                        scale.capture_unit(100.0).unwrap();
+                        let mut conf = Conf::initial();
+                        conf.scale_unit = scale.get_unit();
+                        unsafe { write_conf(conf) }
                         MessageProcessingStatus::Processed
                     }
                     _ => MessageProcessingStatus::Ignored,

escale_fw_rs/lib/app-core/src/scale.rs

@@ -43,7 +43,7 @@ where
     /// Set the zero offset (tare) based on the current buffer.
     ///
     /// The buffer must be filled.
-    pub fn set_tare(&mut self) -> Result<(), Error> {
+    pub fn capture_tare(&mut self) -> Result<(), Error> {
         if self.is_filled() {
             self.tare = self.read_raw()?;
             Ok(())
@@ -58,7 +58,7 @@ where
     ///
     /// If the desired unit is 1 g and a 100 g weight is used for calibration,
     /// set `value` to 100.
-    pub fn set_unit(&mut self, value: U) -> Result<(), Error> {
+    pub fn capture_unit(&mut self, value: U) -> Result<(), Error> {
         assert!(value != U::zero());
         if self.is_filled() {
             let unit = (self.read_raw()? - self.tare) / value;
@@ -70,6 +70,15 @@ where
         }
     }
 
+    pub fn set_unit(&mut self, unit: U) {
+        assert!(unit != U::zero());
+        self.unit = unit;
+    }
+
+    pub fn get_unit(&self) -> U {
+        self.unit
+    }
+
     fn read_raw(&self) -> Result<U, Error> {
         if self.is_filled() {
             Ok(mean(self.ring.iter().copied()).unwrap())