improved sensor canbus code

Software/MainBoard/rust/src/hal/v4_sensor.rs

@@ -10,12 +10,12 @@ use canapi::id::{classify, plant_id, MessageKind, IDENTIFY_CMD_OFFSET};
 use canapi::SensorSlot;
 use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy_time::{Duration, Timer, WithTimeout};
+use embassy_time::{Duration, Instant, Timer, WithTimeout};
 use embedded_can::{Frame, Id};
 use esp_hal::gpio::Output;
 use esp_hal::i2c::master::I2c;
 use esp_hal::pcnt::unit::Unit;
-use esp_hal::twai::{EspTwaiFrame, StandardId, Twai, TwaiConfiguration};
+use esp_hal::twai::{EspTwaiError, EspTwaiFrame, StandardId, Twai, TwaiConfiguration};
 use esp_hal::{Async, Blocking};
 use log::{error, info, warn};
 use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
@@ -129,10 +129,12 @@ impl SensorImpl {
                 // Power on CAN transceiver and start controller
                 can_power.set_high();
                 let config = twai_config.take().expect("twai config not set");
+                info!("convert can");
                 let mut as_async = config.into_async().start();
                 // Give CAN some time to stabilize
                 Timer::after_millis(10).await;
 
+                info!("Sending info messages now");
                 // Send a few test messages per potential sensor node
                 for plant in 0..crate::hal::PLANT_COUNT {
                     for sensor in [Sensor::A, Sensor::B] {
@@ -145,7 +147,7 @@ impl SensorImpl {
                         let can_buffer = [0_u8; 0];
                         if let Some(frame) = EspTwaiFrame::new(target, &can_buffer) {
                             // Try a few times; we intentionally ignore rx here and rely on stub logic
-                            let resu = as_async.transmit_async(&frame).await;
+                            let resu = as_async.transmit_async(&frame).with_timeout(Duration::from_millis(1000)).await;
                             match resu {
                                 Ok(_) => {
                                     info!("Sent test message to plant {plant} sensor {sensor:?}");
@@ -164,7 +166,7 @@ impl SensorImpl {
 
                 let mut moistures = Moistures::default();
                 let _ = Self::wait_for_can_measurements(&mut as_async, &mut moistures)
-                    .with_timeout(Duration::from_millis(5000))
+                    .with_timeout(Duration::from_millis(1000))
                     .await;
 
                 let config = as_async.stop().into_blocking();
@@ -200,15 +202,18 @@ impl SensorImpl {
                                     let plant = msg.1 as usize;
                                     let sensor = msg.2;
                                     let data = can_frame.data();
-
-                                    match sensor {
-                                        SensorSlot::A => {
-                                            moistures.sensor_a_hz[plant] = data[0] as f32;
-                                        }
-                                        SensorSlot::B => {
-                                            moistures.sensor_b_hz[plant] = data[0] as f32;
+                                    if data.len() == 2 {
+                                        let  frequency = u16::from_be_bytes([data[0], data[1]]);
+                                        match sensor {
+                                            SensorSlot::A => {
+                                                moistures.sensor_a_hz[plant] =  frequency as f32;
+                                            }
+                                            SensorSlot::B => {
+                                                moistures.sensor_b_hz[plant] = frequency as f32;
+                                            }
                                         }
                                     }
+
                                 }
                             }
                         }
@@ -218,6 +223,13 @@ impl SensorImpl {
                     }
                 },
                 Err(err) => {
+                    match err {
+                        EspTwaiError::BusOff => {
+                            bail!("Bus offline")
+                        }
+                        EspTwaiError::NonCompliantDlc(_) => {}
+                        EspTwaiError::EmbeddedHAL(_) => {}
+                    }
                     error!("Error receiving CAN message: {err:?}");
                 }
             }