src/main.rs

@@ -21,6 +21,9 @@ pub type MyInstant = Instant<u64, 1, { SYS_TICK_FREQ }>;
 
 #[rtic::app(device = stm32f4xx_hal::pac, peripherals = true, dispatchers = [USART1, USART6])]
 mod app {
+    use core::fmt::Write;
+
+    use arrayvec::ArrayString;
     use cortex_m::singleton;
     use hal::{
         adc::{config::AdcConfig, Adc},
@@ -129,8 +132,18 @@ mod app {
 
         // setup volt meter
         let volt_pin = gpioc.pc0.into_analog();
+        let sensor1 = gpioc.pc2.into_analog();
+        let sensor2 = gpioc.pc3.into_analog();
+        let sensor3 = gpioc.pc4.into_analog();
         let volt_adc = Adc::adc1(dp.ADC1, true, AdcConfig::default());
-        let mut volt_meter = VoltMeter::new(volt_pin, volt_adc, config.min_voltage.into());
+        let mut volt_meter = VoltMeter::new(
+            volt_pin,
+            sensor1,
+            sensor2,
+            sensor3,
+            volt_adc,
+            config.min_voltage.into(),
+        );
 
         // Detect if we're connected to USB or not
         let usb_detect = gpioa.pa5.into_pull_down_input();
@@ -306,7 +319,10 @@ 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 (sensors, voltage) = ctx
+                .shared
+                .volt_meter
+                .lock(|vm| (vm.sensors(), vm.voltage()));
             let temp = ctx
                 .shared
                 .radio
@@ -331,9 +347,9 @@ mod app {
                 })
                 .unwrap();
 
-                if !config.comment.is_empty() {
-                    cats.add_comment(&config.comment).unwrap();
-                }
+                let mut buf: ArrayString<64> = ArrayString::new();
+                write!(&mut buf, "{} {} {}", sensors[0], sensors[1], sensors[2]).unwrap();
+                cats.add_comment(&buf).unwrap();
 
                 cats.add_route(Route::new(config.max_hops)).unwrap();
 

src/shell.rs

@@ -256,6 +256,16 @@ impl Shell {
 
                             write!(ushell, "\r\n{volts:.2} V\r\n").ok();
                         }
+                        "sensors" => {
+                            let sensors = volt_meter.lock(|vm| vm.sensors());
+
+                            write!(
+                                ushell,
+                                "\r\nS1: {} mV\r\nS2: {} mV\r\nS3: {} mV\r\n",
+                                sensors[0], sensors[1], sensors[2]
+                            )
+                            .ok();
+                        }
                         "help" => {
                             write!(ushell, "{}", HELP_TEXT).ok();
                         }

src/voltage.rs

@@ -8,20 +8,49 @@ const FACTOR: f64 = 1.0 / 0.0757856;
 
 pub struct VoltMeter {
     pin: Pin<'C', 0, Analog>,
+    sensor1: Pin<'C', 2, Analog>,
+    sensor2: Pin<'C', 3, Analog>,
+    sensor3: Pin<'C', 4, Analog>,
     adc: Adc<ADC1>,
     threshold: Option<f32>,
 }
 
 impl VoltMeter {
-    pub fn new(pin: Pin<'C', 0, Analog>, mut adc: Adc<ADC1>, threshold: Option<f32>) -> Self {
+    pub fn new(
+        pin: Pin<'C', 0, Analog>,
+        sensor1: Pin<'C', 2, Analog>,
+        sensor2: Pin<'C', 3, Analog>,
+        sensor3: Pin<'C', 4, Analog>,
+        mut adc: Adc<ADC1>,
+        threshold: Option<f32>,
+    ) -> Self {
         adc.calibrate();
         Self {
             pin,
+            sensor1,
+            sensor2,
+            sensor3,
             adc,
             threshold,
         }
     }
 
+    pub fn sensors(&mut self) -> [u16; 3] {
+        let samples = [
+            self.adc.convert(&self.sensor1, SampleTime::Cycles_480),
+            self.adc.convert(&self.sensor2, SampleTime::Cycles_480),
+            self.adc.convert(&self.sensor3, SampleTime::Cycles_480),
+        ];
+
+        let mut out = [0; 3];
+
+        for (i, s) in samples.iter().enumerate() {
+            out[i] = self.adc.sample_to_millivolts(*s);
+        }
+
+        out
+    }
+
     pub fn voltage(&mut self) -> f64 {
         let sample = self.adc.convert(&self.pin, SampleTime::Cycles_480);
         let mv = self.adc.sample_to_millivolts(sample);