panda: switch to new bitrate API

Author: pd0wm

src/can/adapter.rs

@@ -4,7 +4,15 @@
 pub fn get_adapter() -> Result<crate::can::AsyncCanAdapter, crate::error::Error> {
     #[cfg(feature = "panda")]
     {
-        if let Ok(panda) = crate::panda::Panda::new_async() {
+        let bitrate_cfg = crate::can::bitrate::BitrateBuilder::new::<crate::panda::Panda>()
+            .bitrate(500_000)
+            .sample_point(0.8)
+            .data_bitrate(2_000_000)
+            .data_sample_point(0.8)
+            .build()
+            .unwrap();
+
+        if let Ok(panda) = crate::panda::Panda::new_async(bitrate_cfg) {
             return Ok(panda);
         }
     }
@@ -24,10 +32,8 @@ pub fn get_adapter() -> Result<crate::can::AsyncCanAdapter, crate::error::Error>
         let bitrate_cfg = crate::can::bitrate::BitrateBuilder::new::<crate::vector::VectorCan>()
             .bitrate(500_000)
             .sample_point(0.8)
-            .sjw(1)
             .data_bitrate(2_000_000)
             .data_sample_point(0.8)
-            .data_sjw(1)
             .build()
             .unwrap();
 

src/panda/constants.rs

@@ -20,13 +20,15 @@ pub enum HwType {
 pub enum Endpoint {
     CanWrite = 0x3,
     HwType = 0xc1,
+    CanSpeed = 0xde,
     SafetyModel = 0xdc,
     CanResetCommunications = 0xc0,
     CanRead = 0x81,
     PacketsVersions = 0xdd,
     PowerSave = 0xe7,
     CanFDAuto = 0xe8,
     HeartbeatDisabled = 0xf8,
+    CanDataSpeed = 0xf9,
 }
 
 #[repr(u8)]

src/panda/mod.rs

@@ -7,9 +7,8 @@ mod usb_protocol;
 pub use error::Error;
 use std::collections::VecDeque;
 
-use crate::can::AsyncCanAdapter;
-use crate::can::CanAdapter;
-use crate::can::Frame;
+use crate::can::bitrate::{AdapterTimingConst, BitTimingConst, BitrateConfig};
+use crate::can::{AsyncCanAdapter, CanAdapter, Frame};
 use crate::panda::constants::{Endpoint, HwType, SafetyModel};
 use crate::Result;
 use tracing::{info, warn};
@@ -19,6 +18,34 @@ const USB_PIDS: &[u16] = &[0xddee, 0xddcc];
 const EXPECTED_CAN_PACKET_VERSION: u8 = 4;
 const MAX_BULK_SIZE: usize = 16384;
 const PANDA_BUS_CNT: usize = 3;
+const PANDA_NOMINAL_SAMPLE_POINT: f64 = 0.8;
+const SUPPORTED_CAN_BITRATES_BPS: &[u32] = &[
+    10_000, 20_000, 50_000, 100_000, 125_000, 250_000, 500_000, 1_000_000,
+];
+const SUPPORTED_CAN_DATA_BITRATES_BPS: &[u32] = &[
+    10_000, 20_000, 50_000, 100_000, 125_000, 250_000, 500_000, 1_000_000, 2_000_000, 5_000_000,
+];
+const PANDA_BIT_TIMING_CONST: BitTimingConst = BitTimingConst {
+    clock_hz: 80_000_000,
+    tseg1_min: 1,
+    tseg1_max: 1 << 8,
+    tseg2_min: 1,
+    tseg2_max: 1 << 7,
+    sjw_max: 1 << 7,
+    brp_min: 1,
+    brp_max: 1 << 10,
+    brp_inc: 1,
+};
+const PANDA_TIMING_CONST: AdapterTimingConst = AdapterTimingConst {
+    nominal: PANDA_BIT_TIMING_CONST,
+    data: Some(PANDA_BIT_TIMING_CONST),
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct PandaBitrateConfig {
+    nominal_kbps: u16,
+    data_kbps: Option<u16>,
+}
 
 /// Blocking implementation of the panda CAN adapter
 pub struct Panda {
@@ -38,13 +65,16 @@ unsafe impl Send for Panda {}
 
 impl Panda {
     /// Convenience function to create a new panda adapter and wrap in an [`AsyncCanAdapter`]
-    pub fn new_async() -> Result<AsyncCanAdapter> {
-        let panda = Panda::new()?;
+    pub fn new_async(bitrate_cfg: BitrateConfig) -> Result<AsyncCanAdapter> {
+        let panda = Panda::new(bitrate_cfg)?;
         Ok(AsyncCanAdapter::new(panda))
     }
 
     /// Connect to the first available panda. This function will set the safety mode to ALL_OUTPUT and clear all buffers.
-    pub fn new() -> Result<Panda> {
+    pub fn new(bitrate_cfg: BitrateConfig) -> Result<Panda> {
+        let resolved_bitrate_cfg = resolve_bitrate_config(&bitrate_cfg)?;
+        warn_if_non_default_sample_points(&bitrate_cfg);
+
         for device in rusb::devices().unwrap().iter() {
             let device_desc = device.device_descriptor().unwrap();
 
@@ -69,19 +99,25 @@ impl Panda {
                 return Err(Error::WrongFirmwareVersion.into());
             }
 
+            let hw_type = panda.get_hw_type()?;
+            warn_if_fd_unsupported(hw_type, resolved_bitrate_cfg.data_kbps.is_some());
+
             panda.set_safety_model(SafetyModel::AllOutput)?;
             panda.set_power_save(false)?;
             panda.set_heartbeat_disabled()?;
             panda.can_reset_communications()?;
 
             for i in 0..PANDA_BUS_CNT {
+                panda.set_can_speed_kbps(i, resolved_bitrate_cfg.nominal_kbps)?;
+                if let Some(data_kbps) = resolved_bitrate_cfg.data_kbps {
+                    panda.set_can_data_speed_kbps(i, data_kbps)?;
+                }
                 panda.set_canfd_auto(i, false)?;
             }
 
             // can_reset_communications() doesn't work properly, flush manually
             panda.flush_rx()?;
 
-            let hw_type = panda.get_hw_type()?;
             info!("Connected to Panda ({:?})", hw_type);
 
             return Ok(panda);
@@ -125,6 +161,20 @@ impl Panda {
         self.usb_write_control(Endpoint::CanFDAuto, bus as u16, auto as u16)
     }
 
+    fn set_can_speed_kbps(&self, bus: usize, speed_kbps: u16) -> Result<()> {
+        if bus >= PANDA_BUS_CNT {
+            return Err(crate::Error::NotSupported);
+        }
+        self.usb_write_control(Endpoint::CanSpeed, bus as u16, speed_kbps * 10)
+    }
+
+    fn set_can_data_speed_kbps(&self, bus: usize, speed_kbps: u16) -> Result<()> {
+        if bus >= PANDA_BUS_CNT {
+            return Err(crate::Error::NotSupported);
+        }
+        self.usb_write_control(Endpoint::CanDataSpeed, bus as u16, speed_kbps * 10)
+    }
+
     /// Get the hardware type of the panda. Usefull to detect if it supports CAN-FD.
     pub fn get_hw_type(&self) -> Result<HwType> {
         let hw_type = self.usb_read_control(Endpoint::HwType, 1)?;
@@ -217,4 +267,98 @@ impl CanAdapter for Panda {
             }
         }
     }
+
+    fn timing_const() -> AdapterTimingConst
+    where
+        Self: Sized,
+    {
+        PANDA_TIMING_CONST
+    }
+}
+
+fn resolve_bitrate_config(bitrate_cfg: &BitrateConfig) -> Result<PandaBitrateConfig> {
+    Ok(PandaBitrateConfig {
+        nominal_kbps: validate_supported_bitrate(
+            bitrate_cfg.nominal.bitrate,
+            SUPPORTED_CAN_BITRATES_BPS,
+            "Panda arbitration bitrate",
+        )?,
+        data_kbps: bitrate_cfg
+            .data
+            .map(|data| {
+                validate_supported_bitrate(
+                    data.bitrate,
+                    SUPPORTED_CAN_DATA_BITRATES_BPS,
+                    "Panda data bitrate",
+                )
+            })
+            .transpose()?,
+    })
+}
+
+fn validate_supported_bitrate(bitrate_bps: u32, supported: &[u32], label: &str) -> Result<u16> {
+    if !supported.contains(&bitrate_bps) {
+        return Err(crate::Error::InvalidBitrate(format!(
+            "{label} {bitrate_bps} bps is unsupported; expected one of {supported:?}"
+        )));
+    }
+
+    Ok((bitrate_bps / 1000) as u16)
+}
+
+fn warn_if_non_default_sample_points(bitrate_cfg: &BitrateConfig) {
+    if !sample_point_matches(bitrate_cfg.nominal.sample_point, PANDA_NOMINAL_SAMPLE_POINT) {
+        warn!(
+            bitrate = bitrate_cfg.nominal.bitrate,
+            requested_sample_point = bitrate_cfg.nominal.sample_point,
+            panda_sample_point = PANDA_NOMINAL_SAMPLE_POINT,
+            "Panda ignores the requested nominal sample point"
+        );
+    }
+
+    if let Some(data) = bitrate_cfg.data {
+        let panda_sample_point = default_data_sample_point(data.bitrate);
+        if !sample_point_matches(data.sample_point, panda_sample_point) {
+            warn!(
+                bitrate = data.bitrate,
+                requested_sample_point = data.sample_point,
+                panda_sample_point,
+                "Panda ignores the requested CAN-FD data sample point"
+            );
+        }
+    }
+}
+
+fn warn_if_fd_unsupported(hw_type: HwType, using_fd_bitrate: bool) {
+    if using_fd_bitrate && !supports_can_fd(hw_type) {
+        warn!(
+            ?hw_type,
+            "Configured CAN-FD bitrate on panda hardware that does not support CAN-FD"
+        );
+    }
+}
+
+fn supports_can_fd(hw_type: HwType) -> bool {
+    !matches!(
+        hw_type,
+        HwType::Unknown
+            | HwType::WhitePanda
+            | HwType::GreyPanda
+            | HwType::BlackPanda
+            | HwType::Pedal
+            | HwType::Uno
+            | HwType::Dos
+    )
+}
+
+fn default_data_sample_point(data_bitrate: u32) -> f64 {
+    if data_bitrate == 5_000_000 {
+        0.75
+    } else {
+        0.8
+    }
+}
+
+fn sample_point_matches(actual: f64, expected: f64) -> bool {
+    (actual - expected).abs() < 1e-9
 }

tests/adapter_tests.rs

@@ -10,6 +10,15 @@ static BULK_NUM_FRAMES_ASYNC: usize = 0x1000;
 static BULK_SYNC_TIMEOUT_MS: u64 = 1000;
 static BULK_ASYNC_TIMEOUT_MS: u64 = 5000;
 
+#[cfg(feature = "test-panda")]
+fn panda_bitrate_config() -> automotive::can::bitrate::BitrateConfig {
+    automotive::can::bitrate::BitrateBuilder::new::<automotive::panda::Panda>()
+        .bitrate(500_000)
+        .sample_point(0.8)
+        .build()
+        .unwrap()
+}
+
 #[cfg(feature = "test-vector")]
 fn vector_bitrate_config() -> automotive::can::bitrate::BitrateConfig {
     automotive::can::bitrate::BitrateBuilder::new::<automotive::vector::VectorCan>()
@@ -107,15 +116,15 @@ async fn bulk_send(adapter: &AsyncCanAdapter) {
 #[test]
 #[serial_test::serial]
 fn panda_bulk_send_sync() {
-    let mut panda = Panda::new().unwrap();
+    let mut panda = Panda::new(panda_bitrate_config()).unwrap();
     bulk_send_sync(&mut panda);
 }
 
 #[cfg(feature = "test-panda")]
 #[tokio::test]
 #[serial_test::serial]
 async fn panda_bulk_send_async() {
-    let panda = automotive::panda::Panda::new_async().unwrap();
+    let panda = automotive::panda::Panda::new_async(panda_bitrate_config()).unwrap();
     bulk_send(&panda).await;
 }