Added pll settings to nvstate

firmware/src/main.rs

@@ -41,7 +41,7 @@ mod app {
     use heapless::Vec;
     use postcard::{from_bytes_cobs, to_vec_cobs};
 
-    use cheapsdo_protocol::{DeviceMessage, HostMessage, StatusMessage};
+    use cheapsdo_protocol::{DeviceMessage, HostMessage, PLLSettings, StatusMessage};
 
     use crate::nvstate::{self, NVState};
     use crate::si5153;
@@ -54,8 +54,6 @@ mod app {
         tim2: TIM2,
         tim3: TIM3,
         pwm: PwmHz<TIM4, Tim4NoRemap, timer::Ch<0>, gpio::Pin<'B', 6, Alternate>>,
-        nvstate: NVState,
-        flash: flash::Parts,
     }
 
     #[shared]
@@ -64,6 +62,8 @@ mod app {
         serial: usbd_serial::SerialPort<'static, UsbBusType>,
         device_status: StatusMessage,
         buffer: Vec<u8, USB_BUFFER_SIZE>,
+        nvstate: NVState,
+        flash: flash::Parts,
     }
 
     const TARGET_FREQ: u64 = 10_000_000_000; // in millihertz
@@ -246,21 +246,21 @@ mod app {
                 usb_dev,
                 device_status: StatusMessage::default(),
                 buffer: Vec::new(),
+                nvstate,
+                flash,
             },
             Local {
                 board_led,
                 tim2,
                 tim3,
                 pwm,
-                nvstate,
-                flash,
             },
         )
     }
 
     const WINDOW_LEN: usize = 100;
 
-    #[task(local=[tim2, tim3, pwm, board_led, nvstate, flash], shared=[device_status])]
+    #[task(local=[tim2, tim3, pwm, board_led], shared=[device_status, nvstate, flash])]
     async fn update_pwm(mut cx: update_pwm::Context) {
         defmt::info!("Update Task started");
 
@@ -268,11 +268,14 @@ mod app {
         let tim3 = cx.local.tim3;
         let pwm = cx.local.pwm;
         let board_led = cx.local.board_led;
-        let mut nvstate = cx.local.nvstate;
-        let mut flash = cx.local.flash;
 
         let max_pwm = pwm.get_max_duty() as i32;
-        let mut cur_pwm = nvstate.pwm as i32;
+
+        let mut cur_pwm = 0i32;
+        cx.shared.nvstate.lock(|nvstate| {
+            cur_pwm = nvstate.pwm as i32;
+        });
+
         cur_pwm = if cur_pwm < 0 { 0 } else { cur_pwm };
         cur_pwm = if cur_pwm > max_pwm { max_pwm } else { cur_pwm };
 
@@ -362,39 +365,59 @@ mod app {
             pwm.set_duty(Channel::C1, cur_pwm as u16);
             defmt::info!("pwm:\t{}", cur_pwm);
 
-            nvstate.pwm = cur_pwm as u16;
-            nvstate.save(&mut flash);
+            {
+                (&mut cx.shared.nvstate, &mut cx.shared.flash).lock(|nvstate, flash| {
+                    nvstate.pwm = cur_pwm as u16;
+                    nvstate.save(flash);
+                });
+            }
 
             Systick::delay(500.millis()).await;
         }
     }
 
-    #[task(binds = USB_HP_CAN_TX, shared = [usb_dev, serial, buffer, device_status])]
+    #[task(binds = USB_HP_CAN_TX, shared = [usb_dev, serial, buffer, device_status, nvstate, flash])]
     fn usb_tx(cx: usb_tx::Context) {
         let mut usb_dev = cx.shared.usb_dev;
         let mut serial = cx.shared.serial;
         let mut buffer = cx.shared.buffer;
         let mut device_status = cx.shared.device_status;
+        let mut nvstate = cx.shared.nvstate;
+        let mut flash = cx.shared.flash;
 
-        (&mut usb_dev, &mut serial, &mut buffer, &mut device_status).lock(
-            |usb_dev, serial, buffer, device_status| {
-                usb_poll(usb_dev, serial, buffer, device_status);
-            },
-        );
+        (
+            &mut usb_dev,
+            &mut serial,
+            &mut buffer,
+            &mut device_status,
+            &mut nvstate,
+            &mut flash,
+        )
+            .lock(|usb_dev, serial, buffer, device_status, nvstate, flash| {
+                usb_poll(usb_dev, serial, buffer, device_status, nvstate, flash);
+            });
     }
 
-    #[task(binds = USB_LP_CAN_RX0, shared = [usb_dev, serial, buffer, device_status])]
+    #[task(binds = USB_LP_CAN_RX0, shared = [usb_dev, serial, buffer, device_status, nvstate, flash])]
     fn usb_rx0(cx: usb_rx0::Context) {
         let mut usb_dev = cx.shared.usb_dev;
         let mut serial = cx.shared.serial;
         let mut buffer = cx.shared.buffer;
         let mut device_status = cx.shared.device_status;
+        let mut nvstate = cx.shared.nvstate;
+        let mut flash = cx.shared.flash;
 
-        (&mut usb_dev, &mut serial, &mut buffer, &mut device_status).lock(
-            |usb_dev, serial, buffer, device_status| {
-                usb_poll(usb_dev, serial, buffer, device_status);
-            },
-        );
+        (
+            &mut usb_dev,
+            &mut serial,
+            &mut buffer,
+            &mut device_status,
+            &mut nvstate,
+            &mut flash,
+        )
+            .lock(|usb_dev, serial, buffer, device_status, nvstate, flash| {
+                usb_poll(usb_dev, serial, buffer, device_status, nvstate, flash);
+            });
     }
 
     fn usb_poll<B: usb_device::bus::UsbBus>(
@@ -402,6 +425,8 @@ mod app {
         serial: &mut usbd_serial::SerialPort<'static, B>,
         buffer: &mut Vec<u8, USB_BUFFER_SIZE>,
         device_status: &StatusMessage,
+        nvstate: &mut NVState,
+        flash: &mut flash::Parts,
     ) {
         if !usb_dev.poll(&mut [serial]) {
             return;
@@ -434,8 +459,9 @@ mod app {
                                 to_vec_cobs::<DeviceMessage, USB_BUFFER_SIZE>(&device_msg).unwrap();
                             serial.write(bytes.as_slice()).unwrap();
                         }
-                        HostMessage::SetPLLSettings(_) => {
-                            defmt::error!("PLL output is not implemented yet")
+                        HostMessage::SetPLLSettings(settings) => {
+                            nvstate.pll_settings = settings;
+                            nvstate.save(flash);
                         }
                         HostMessage::GetPllSettings => {
                             defmt::error!("PLL output is not implemented yet")

firmware/src/nvstate.rs

@@ -1,3 +1,4 @@
+use cheapsdo_protocol::PLLSettings;
 use postcard::{from_bytes_cobs, to_slice_cobs};
 use serde::{Deserialize, Serialize};
 use stm32f1xx_hal::flash::{self, FlashSize, FlashWriter, SectorSize};
@@ -5,11 +6,15 @@ use stm32f1xx_hal::flash::{self, FlashSize, FlashWriter, SectorSize};
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct NVState {
     pub pwm: u16,
+    pub pll_settings: PLLSettings,
 }
 
 impl Default for NVState {
     fn default() -> Self {
-        Self { pwm: 1500u16 }
+        Self {
+            pwm: 1500u16,
+            pll_settings: PLLSettings::default(),
+        }
     }
 }