MQTT settings and telemetry

Cargo.toml

@@ -36,7 +36,6 @@ panic-semihosting = { version = "0.5", optional = true }
 panic-halt = "0.2"
 serde = { version = "1.0", features = ["derive"], default-features = false }
 heapless = { version = "0.5", features = ["serde"] }
-serde-json-core = "0.2"
 cortex-m-rtic = "0.5.5"
 embedded-hal = "0.2.4"
 nb = "1.0.0"
@@ -46,13 +45,16 @@ paste = "1"
 dsp = { path = "dsp" }
 ad9959 = { path = "ad9959" }
 
+[dependencies.miniconf]
+git = "https://github.com/vertigo-designs/miniconf.git"
+branch = "develop"
+
 [dependencies.mcp23017]
 git = "https://github.com/mrd0ll4r/mcp23017.git"
 
-[dependencies.smoltcp]
-version = "0.7"
-features = ["ethernet", "proto-ipv4", "socket-tcp", "proto-ipv6"]
-default-features = false
+[dependencies.smoltcp-nal]
+git = "https://github.com/vertigo-designs/smoltcp-nal.git"
+branch = "main"
 
 [dependencies.stm32h7xx-hal]
 features = ["stm32h743v", "rt", "unproven", "ethernet", "quadspi"]

dsp/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2018"
 [dependencies]
 libm = "0.2.1"
 serde = { version = "1.0", features = ["derive"], default-features = false }
+serde-json-core = "0.1"
 generic-array = "0.14"
 
 [dev-dependencies]

dsp/src/iir.rs

@@ -1,4 +1,5 @@
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use miniconf::StringSet;
 
 use super::{abs, copysign, macc, max, min};
 use core::f32;
@@ -11,8 +12,7 @@ use core::f32;
 /// To represent the IIR coefficients, this contains the feed-forward
 /// coefficients (b0, b1, b2) followd by the negated feed-back coefficients
 /// (-a1, -a2), all five normalized such that a0 = 1.
-#[derive(Copy, Clone, Default, Deserialize, Serialize)]
-pub struct Vec5(pub [f32; 5]);
+pub type Vec5 = [f32; 5];
 
 /// IIR configuration.
 ///
@@ -39,7 +39,7 @@ pub struct Vec5(pub [f32; 5]);
 ///   Therefore it can trivially implement bump-less transfer.
 /// * Cascading multiple IIR filters allows stable and robust
 ///   implementation of transfer functions beyond bequadratic terms.
-#[derive(Copy, Clone, Default, Deserialize, Serialize)]
+#[derive(Copy, Clone, Debug, Default, Deserialize, StringSet)]
 pub struct IIR {
     pub ba: Vec5,
     pub y_offset: f32,
@@ -50,7 +50,7 @@ pub struct IIR {
 impl IIR {
     pub const fn new(gain: f32, y_min: f32, y_max: f32) -> Self {
         Self {
-            ba: Vec5([gain, 0., 0., 0., 0.]),
+            ba: [gain, 0., 0., 0., 0.],
             y_offset: 0.,
             y_min,
             y_max,
@@ -84,13 +84,13 @@ impl IIR {
             }
             (a1, b0, b1)
         };
-        self.ba.0.copy_from_slice(&[b0, b1, 0., a1, 0.]);
+        self.ba.copy_from_slice(&[b0, b1, 0., a1, 0.]);
         Ok(())
     }
 
     /// Compute the overall (DC feed-forward) gain.
     pub fn get_k(&self) -> f32 {
-        self.ba.0[..3].iter().sum()
+        self.ba[..3].iter().sum()
     }
 
     /// Compute input-referred (`x`) offset from output (`y`) offset.
@@ -118,21 +118,21 @@ impl IIR {
     /// * `xy` - Current filter state.
     /// * `x0` - New input.
     pub fn update(&self, xy: &mut Vec5, x0: f32) -> f32 {
-        let n = self.ba.0.len();
-        debug_assert!(xy.0.len() == n);
+        let n = self.ba.len();
+        debug_assert!(xy.len() == n);
         // `xy` contains       x0 x1 y0 y1 y2
         // Increment time      x1 x2 y1 y2 y3
         // Shift               x1 x1 x2 y1 y2
         // This unrolls better than xy.rotate_right(1)
-        xy.0.copy_within(0..n - 1, 1);
+        xy.copy_within(0..n - 1, 1);
         // Store x0            x0 x1 x2 y1 y2
-        xy.0[0] = x0;
+        xy[0] = x0;
         // Compute y0 by multiply-accumulate
-        let y0 = macc(self.y_offset, &xy.0, &self.ba.0);
+        let y0 = macc(self.y_offset, xy, &self.ba);
         // Limit y0
         let y0 = max(self.y_min, min(self.y_max, y0));
         // Store y0            x0 x1 y0 y1 y2
-        xy.0[n / 2] = y0;
+        xy[n / 2] = y0;
         y0
     }
 }