vector-xl: switch to new bitrate API (#103)

Author: pd0wm

examples/configure_bitrate.rs

@@ -14,7 +14,7 @@ pub async fn run() -> automotive::Result<()> {
         .build()
         .unwrap();
 
-    let adapter = VectorCan::new_async(0, &Some(bitrate_cfg.into()))?;
+    let adapter = VectorCan::new_async(0, Some(bitrate_cfg))?;
     let mut stream = adapter.recv();
 
     while let Some(frame) = stream.next().await {

src/can/adapter.rs

@@ -21,9 +21,15 @@ pub fn get_adapter() -> Result<crate::can::AsyncCanAdapter, crate::error::Error>
 
     #[cfg(all(target_os = "windows", feature = "vector-xl"))]
     {
-        if let Ok(adapter) =
-            crate::vector::VectorCan::new_async(0, &Some(crate::vector::CONFIG_500K_2M_80))
-        {
+        let bitrate_cfg = crate::can::bitrate::BitrateBuilder::new::<crate::vector::VectorCan>()
+            .bitrate(500_000)
+            .sample_point(0.8)
+            .data_bitrate(2_000_000)
+            .data_sample_point(0.8)
+            .build()
+            .unwrap();
+
+        if let Ok(adapter) = crate::vector::VectorCan::new_async(0, Some(bitrate_cfg)) {
             return Ok(adapter);
         };
     }

src/error.rs

@@ -11,6 +11,8 @@ pub enum Error {
     NotSupported,
     #[error("Malformed Frame")]
     MalformedFrame,
+    #[error("Invalid bitrate: {0}")]
+    InvalidBitrate(String),
     #[error("Timeout")]
     Timeout,
     #[error("Disconnected")]

src/vector/mod.rs

@@ -8,30 +8,14 @@ pub use error::Error;
 
 use std::collections::VecDeque;
 
-use crate::can::bitrate::{AdapterTimingConst, BitTimingConst};
+use crate::can::bitrate::{AdapterTimingConst, BitTimingConst, BitrateConfig};
 use crate::can::{AsyncCanAdapter, CanAdapter, Frame};
-pub use crate::vector::types::XLcanFdConf;
+use crate::vector::bindings::XLcanFdConf;
 use crate::vector::types::{PortHandle, XLaccess, XLcanTxEvent};
 use crate::vector::vxlapi::*;
 use crate::Result;
 use tracing::info;
 
-/// Predefined configuration for 500 kbps arbitration bitrate and 2 Mbps data bitrate
-pub const CONFIG_500K_2M_80: XLcanFdConf = XLcanFdConf {
-    arbitrationBitRate: 500_000,
-    sjwAbr: 1,
-    tseg1Abr: 127,
-    tseg2Abr: 32,
-    dataBitRate: 2_000_000,
-    sjwDbr: 1,
-    tseg1Dbr: 31,
-    tseg2Dbr: 8,
-    reserved: 0,
-    options: 0,
-    reserved1: [0, 0],
-    reserved2: 0,
-};
-
 /// Vector XL timing capabilities used for bitrate helper calculations.
 pub const VECTOR_TIMING_CONST: AdapterTimingConst = AdapterTimingConst {
     nominal: BitTimingConst {
@@ -66,7 +50,7 @@ pub struct VectorCan {
 
 impl VectorCan {
     /// Convenience function to create a new adapter and wrap in an [`AsyncCanAdapter`]
-    pub fn new_async(channel_idx: usize, conf: &Option<XLcanFdConf>) -> Result<AsyncCanAdapter> {
+    pub fn new_async(channel_idx: usize, conf: Option<BitrateConfig>) -> Result<AsyncCanAdapter> {
         let vector = VectorCan::new(channel_idx, conf)?;
         Ok(AsyncCanAdapter::new(vector))
     }
@@ -75,7 +59,13 @@ impl VectorCan {
     /// If conf is provided, the channel will be initialized with the provided configuration.
     /// If not, the channel will be opened without requesting init (exclusive) access,
     /// and can be configured using other tools (e.g. Vector's CANalyzer).
-    pub fn new(channel_idx: usize, conf: &Option<XLcanFdConf>) -> Result<VectorCan> {
+    pub fn new(channel_idx: usize, conf: Option<BitrateConfig>) -> Result<VectorCan> {
+        if conf.as_ref().is_some_and(|conf| conf.data.is_none()) {
+            return Err(crate::Error::InvalidBitrate(
+                "Vector bitrate configuration requires a CAN-FD data phase".to_string(),
+            ));
+        }
+
         xl_open_driver()?;
 
         // Get config based on global channel number
@@ -92,7 +82,8 @@ impl VectorCan {
 
         // Configure bitrate
         if let Some(conf) = conf {
-            xl_can_fd_set_configuration(&port_handle, channel_mask, conf)?;
+            let conf: XLcanFdConf = conf.into();
+            xl_can_fd_set_configuration(&port_handle, channel_mask, &conf)?;
         }
 
         xl_activate_channel(&port_handle, channel_mask)?;
@@ -158,6 +149,21 @@ mod tests {
     use super::*;
     use crate::can::bitrate::BitrateBuilder;
 
+    const CONFIG_500K_2M_80: XLcanFdConf = XLcanFdConf {
+        arbitrationBitRate: 500_000,
+        sjwAbr: 1,
+        tseg1Abr: 127,
+        tseg2Abr: 32,
+        dataBitRate: 2_000_000,
+        sjwDbr: 1,
+        tseg1Dbr: 31,
+        tseg2Dbr: 8,
+        reserved: 0,
+        options: 0,
+        reserved1: [0, 0],
+        reserved2: 0,
+    };
+
     #[test]
     fn bitrate_builder_matches_predefined_config() {
         let bitrate_cfg = BitrateBuilder::new::<VectorCan>()
@@ -173,4 +179,25 @@ mod tests {
         let conf: XLcanFdConf = bitrate_cfg.into();
         assert_eq!(conf, CONFIG_500K_2M_80);
     }
+
+    #[test]
+    fn rejects_nominal_only_bitrate_config() {
+        let bitrate_cfg = BitrateBuilder::new::<VectorCan>()
+            .bitrate(500_000)
+            .sample_point(0.8)
+            .sjw(1)
+            .build()
+            .unwrap();
+
+        match VectorCan::new(0, Some(bitrate_cfg)) {
+            Err(crate::Error::InvalidBitrate(msg)) => {
+                assert_eq!(
+                    msg,
+                    "Vector bitrate configuration requires a CAN-FD data phase"
+                );
+            }
+            Err(err) => panic!("unexpected error: {err}"),
+            Ok(_) => panic!("expected invalid bitrate error"),
+        }
+    }
 }

tests/adapter_tests.rs

@@ -10,6 +10,19 @@ static BULK_NUM_FRAMES_ASYNC: usize = 0x1000;
 static BULK_SYNC_TIMEOUT_MS: u64 = 1000;
 static BULK_ASYNC_TIMEOUT_MS: u64 = 5000;
 
+#[cfg(feature = "test-vector")]
+fn vector_bitrate_config() -> automotive::can::bitrate::BitrateConfig {
+    automotive::can::bitrate::BitrateBuilder::new::<automotive::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()
+}
+
 fn get_test_frames(amount: usize) -> Vec<Frame> {
     let mut frames = vec![];
 
@@ -110,15 +123,16 @@ async fn panda_bulk_send_async() {
 #[test]
 #[serial_test::serial]
 fn vector_bulk_send_sync() {
-    let mut vector = automotive::vector::VectorCan::new(0).unwrap();
+    let mut vector = automotive::vector::VectorCan::new(0, Some(vector_bitrate_config())).unwrap();
     bulk_send_sync(&mut vector);
 }
 
 #[cfg(feature = "test-vector")]
 #[tokio::test]
 #[serial_test::serial]
 async fn vector_bulk_send_async() {
-    let vector = automotive::vector::VectorCan::new_async(0).unwrap();
+    let vector =
+        automotive::vector::VectorCan::new_async(0, Some(vector_bitrate_config())).unwrap();
     bulk_send(&vector).await;
 }