add configuration for other info

Cargo.lock

@@ -297,7 +297,7 @@ dependencies = [
 [[package]]
 name = "ham-cats"
 version = "0.1.0"
-source = "git+https://gitlab.scd31.com/cats/ham-cats#b9c0f3a6bd123262454e5e56758f8a0c0db8da89"
+source = "git+https://gitlab.scd31.com/cats/ham-cats#2662fd88ededffad2598ece932a58e1049325aaa"
 dependencies = [
  "arrayvec",
  "bitvec",

src/config.rs

@@ -21,6 +21,9 @@ pub struct Config {
     pub enable_transmit: bool,
     pub enable_digipeating: bool,
     pub black_hole: MaybeBlackHole,
+    pub antenna_height: Maybe<u8>,
+    pub antenna_gain: Maybe<f32>,
+    pub tx_power: Maybe<f32>,
 }
 
 impl Config {
@@ -31,19 +34,19 @@ impl Config {
         NorFlash::erase(&mut unlocked, 384 * 1024, 512 * 1024).unwrap();
 
         // Write our config
-        let mut buf = [0; 827];
+        let mut buf = [0; 839];
         self.serialize(&mut buf);
         NorFlash::write(&mut unlocked, 384 * 1024, &buf).unwrap();
     }
 
     pub fn load_from_flash(flash: &mut LockedFlash) -> Option<Self> {
-        let mut buf = [0; 827];
+        let mut buf = [0; 839];
         ReadNorFlash::read(flash, 384 * 1024, &mut buf).unwrap();
 
         Self::deserialize(&buf)
     }
 
-    fn serialize(&self, buf: &mut [u8; 827]) {
+    fn serialize(&self, buf: &mut [u8; 839]) {
         // version
         // allows us to update the config structure in the future
         // while maintaining backwards compatibility
@@ -81,21 +84,47 @@ impl Config {
         self.black_hole
             .encode((&mut buf[798..823]).try_into().unwrap());
 
+        match self.antenna_height {
+            Maybe::Some(height) => {
+                buf[823] = 1;
+                buf[824] = height;
+            }
+            Maybe::None => buf[823] = 0,
+        }
+
+        match self.antenna_gain {
+            Maybe::Some(gain) => {
+                buf[825] = 1;
+                buf[826..830].copy_from_slice(&gain.to_le_bytes());
+            }
+            Maybe::None => buf[825] = 0,
+        }
+
+        match self.tx_power {
+            Maybe::Some(power) => {
+                buf[830] = 1;
+                buf[831..835].copy_from_slice(&power.to_le_bytes());
+            }
+            Maybe::None => {
+                buf[830] = 0;
+            }
+        }
+
         // Checksum
-        let checksum = CASTAGNOLI.checksum(&buf[0..823]);
-        buf[823..827].copy_from_slice(&checksum.to_le_bytes());
+        let checksum = CASTAGNOLI.checksum(&buf[0..835]);
+        buf[835..839].copy_from_slice(&checksum.to_le_bytes());
     }
 
-    fn deserialize(buf: &[u8; 827]) -> Option<Self> {
+    fn deserialize(buf: &[u8; 839]) -> Option<Self> {
         match buf[0] {
             0 => Self::deserialize_v0(buf),
             _ => None,
         }
     }
 
-    fn deserialize_v0(buf: &[u8; 827]) -> Option<Self> {
-        let expected_checksum = CASTAGNOLI.checksum(&buf[0..823]);
-        let actual_checksum = u32::from_le_bytes(buf[823..827].try_into().unwrap());
+    fn deserialize_v0(buf: &[u8; 839]) -> Option<Self> {
+        let expected_checksum = CASTAGNOLI.checksum(&buf[0..835]);
+        let actual_checksum = u32::from_le_bytes(buf[835..839].try_into().unwrap());
         if expected_checksum != actual_checksum {
             return None;
         }
@@ -132,6 +161,24 @@ impl Config {
 
         let black_hole = MaybeBlackHole::decode(&buf[798..823].try_into().unwrap())?;
 
+        let antenna_height = if buf[823] > 0 {
+            Maybe::Some(buf[824])
+        } else {
+            Maybe::None
+        };
+
+        let antenna_gain = if buf[825] > 0 {
+            Maybe::Some(f32::from_le_bytes(buf[826..830].try_into().unwrap()))
+        } else {
+            Maybe::None
+        };
+
+        let tx_power = if buf[830] > 0 {
+            Maybe::Some(f32::from_le_bytes(buf[831..835].try_into().unwrap()))
+        } else {
+            Maybe::None
+        };
+
         Some(Config {
             callsign,
             icon,
@@ -143,6 +190,9 @@ impl Config {
             enable_transmit,
             enable_digipeating,
             black_hole,
+            antenna_height,
+            antenna_gain,
+            tx_power,
         })
     }
 }
@@ -160,6 +210,9 @@ impl Default for Config {
             enable_transmit: false,
             enable_digipeating: true,
             black_hole: MaybeBlackHole::None,
+            antenna_height: Maybe::None,
+            antenna_gain: Maybe::None,
+            tx_power: Maybe::Some(30.0),
         }
     }
 }
@@ -268,3 +321,22 @@ impl Display for BlackHoleSetting {
         )
     }
 }
+
+// Like Option, but local, so we can implement Display on it
+#[derive(Copy, Clone)]
+pub enum Maybe<T> {
+    Some(T),
+    None,
+}
+
+impl<T> Display for Maybe<T>
+where
+    T: Display,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Maybe::Some(x) => write!(f, "{x}"),
+            Maybe::None => write!(f, "<None>"),
+        }
+    }
+}

src/main.rs

@@ -40,7 +40,7 @@ mod app {
     use usb_device::prelude::*;
 
     use crate::{
-        config::{Config, GpsSetting},
+        config::{Config, GpsSetting, Maybe},
         gps::{GpsModule, GpsPos},
         radio::RadioManager,
         shell::Shell,
@@ -292,6 +292,23 @@ mod app {
             let mut buf = [0; MAX_PACKET_LEN];
             let mut cats = Packet::new(&mut buf);
 
+            let voltage = ctx.shared.volt_meter.lock(|vm| vm.voltage());
+            let temp = ctx
+                .shared
+                .radio
+                .lock(|r| r.as_mut().unwrap().get_temp().unwrap());
+            let uptime_secs = (monotonics::now() - *ctx.local.bootup_time)
+                .to_secs()
+                .try_into()
+                .unwrap_or(0);
+
+            let mut info_builder = NodeInfoBuilder::default()
+                .hardware_id(HARDWARE_ID)
+                .software_id(SOFTWARE_ID)
+                .uptime(uptime_secs)
+                .voltage(voltage)
+                .xcvr_temperature(temp);
+
             config.lock(|config| {
                 cats.add_identification(ham_cats::whisker::Identification {
                     icon: config.icon,
@@ -305,27 +322,21 @@ mod app {
                 }
 
                 cats.add_route(Route::new(config.max_hops)).unwrap();
-            });
 
-            let voltage = ctx.shared.volt_meter.lock(|vm| vm.voltage());
-            let temp = ctx
-                .shared
-                .radio
-                .lock(|r| r.as_mut().unwrap().get_temp().unwrap());
-            let uptime_secs = (monotonics::now() - *ctx.local.bootup_time)
-                .to_secs()
-                .try_into()
-                .unwrap_or(0);
+                if let Maybe::Some(antenna_height) = config.antenna_height {
+                    info_builder = info_builder.antenna_height(antenna_height);
+                }
 
-            let info = NodeInfoBuilder::default()
-                .hardware_id(HARDWARE_ID)
-                .software_id(SOFTWARE_ID)
-                .uptime(uptime_secs)
-                .voltage(voltage)
-                .xcvr_temperature(temp)
-                .build();
+                if let Maybe::Some(gain) = config.antenna_gain {
+                    info_builder = info_builder.antenna_gain(gain as f64);
+                }
+
+                if let Maybe::Some(power) = config.tx_power {
+                    info_builder = info_builder.tx_power(power as f64);
+                }
+            });
 
-            cats.add_node_info(info).unwrap();
+            cats.add_node_info(info_builder.build()).unwrap();
 
             if let Some(pos) = pos {
                 cats.add_gps(Gps::new(

src/shell.rs

@@ -10,7 +10,7 @@ use usbd_serial::SerialPort;
 use ushell::{autocomplete::StaticAutocomplete, history::LRUHistory, Input, ShellError, UShell};
 
 use crate::{
-    config::{BlackHoleSetting, Config, GpsSetting, MaybeBlackHole},
+    config::{BlackHoleSetting, Config, GpsSetting, Maybe, MaybeBlackHole},
     voltage::VoltMeter,
 };
 
@@ -72,6 +72,9 @@ impl Shell {
                                 enable_transmit,
                                 enable_digipeating,
                                 black_hole,
+                                antenna_height,
+                                antenna_gain,
+                                tx_power,
                             } = self.config;
 
                             let comment = if comment.is_empty() {
@@ -94,6 +97,13 @@ impl Shell {
 							 enable_transmit    {enable_transmit}\r\n\
 							 enable_digipeating {enable_digipeating}\r\n\
 							 \r\n\
+							 The following settings do not change the behaviour of the transceiver.\r\n\
+							 Instead, they only change the contents of the NodeInfo whisker.\r\n\
+							 Info configuration:\r\n\
+							 antenna_height     {antenna_height:.1} (meters)\r\n\
+							 antenna_gain       {antenna_gain:.1} (dBi)\r\n\
+							 tx_power           {tx_power} (dBm)\r\n\
+							 \r\n\
 							 To change a setting, type `set <property> <value>`\r\n\
 							 For example, `set transmit_period 300`\r\n"
                             )
@@ -179,6 +189,27 @@ impl Shell {
                                     }
                                     Err(e) => Err(e),
                                 },
+                                "antenna_height" => match parse_maybe_u8(value) {
+                                    Ok(v) => {
+                                        self.config.antenna_height = v;
+                                        Ok(())
+                                    }
+                                    Err(e) => Err(e),
+                                },
+                                "antenna_gain" => match parse_maybe_f32(value) {
+                                    Ok(v) => {
+                                        self.config.antenna_gain = v;
+                                        Ok(())
+                                    }
+                                    Err(e) => Err(e),
+                                },
+                                "tx_power" => match parse_maybe_f32(value) {
+                                    Ok(v) => {
+                                        self.config.tx_power = v;
+                                        Ok(())
+                                    }
+                                    Err(e) => Err(e),
+                                },
                                 "" => {
                                     write!(ushell, "\r\nUsage: set <property> <value>\r\n").ok();
                                     break 'inner;
@@ -225,12 +256,19 @@ impl Shell {
                                 icon: 0,
                                 ssid: 255,
                                 max_hops: 0,
-                                comment: ArrayString::from("Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibu").unwrap(),
+                                comment: ArrayString::from("Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. \
+                                                            Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. \
+                                                            Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. \
+                                                            Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, \
+                                                            venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibu").unwrap(),
                                 transmit_period_seconds: 3,
                                 gps: GpsSetting::Receiver,
                                 enable_transmit: true,
                                 enable_digipeating: true,
                                 black_hole: MaybeBlackHole::None,
+                                antenna_height: Maybe::None,
+                                antenna_gain: Maybe::None,
+                                tx_power: Maybe::Some(30.0)
                             };
                             self.config.save_to_flash(flash);
 
@@ -265,6 +303,16 @@ fn parse_u8(val: &str) -> Result<u8, &'static str> {
         .map_err(|_| "Invalid value. Expected a number between 0 and 255.")
 }
 
+fn parse_maybe_u8(val: &str) -> Result<Maybe<u8>, &'static str> {
+    if val.is_empty() {
+        return Ok(Maybe::None);
+    }
+
+    val.parse()
+        .map_err(|_| "Invalid value. Expected a number between 0 and 255.")
+        .map(Maybe::Some)
+}
+
 fn parse_u16(val: &str) -> Result<u16, &'static str> {
     val.parse()
         .map_err(|_| "Invalid value. Expected a number between 0 and 65535.")
@@ -275,6 +323,23 @@ fn parse_u64(val: &str) -> Result<u64, &'static str> {
         .map_err(|_| "Invalid value. Expected a positive integer.")
 }
 
+// Only in a range of 0 - 63
+fn parse_maybe_f32(val: &str) -> Result<Maybe<f32>, &'static str> {
+    const ERR: &str = "Invalid value. Expected a number between 0 and 63.";
+
+    if val.is_empty() {
+        return Ok(Maybe::None);
+    }
+
+    let x = val.parse().map_err(|_| ERR)?;
+
+    if !(0.0..=63.0).contains(&x) {
+        return Err(ERR);
+    }
+
+    Ok(Maybe::Some(x))
+}
+
 fn parse_gps(val: &str) -> Result<GpsSetting, &'static str> {
     const GENERIC_ERR: &str = "Invalid value. Expected one of the following options:\r\n\
 							   The literal `disabled` (set gps disable) - Do not set GPS data in transmitted packets\r\n\