also support bitrate configuration for Windows

Author: TuEmb

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "can-viewer"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 description = "view real-time CAN packages"
 
@@ -27,7 +27,7 @@ winresource = "0.1.17"
 [package.metadata.bundle]
 name = "can-viewer"
 icon = ["ui/images/can_viewer_32px.png", "ui/images/can_viewer_128px.png", "ui/images/can_viewer_256px.png"]
-version = "1.0.0"
+version = "0.2.1"
 copyright = "Copyright (c) Tu Nguyen 2024. All rights reserved."
 category = "Developer Tool"
 short_description = "view real-time CAN packages"
@@ -37,5 +37,5 @@ can-view can records real-time can packages and parse data with DBC input.
 """
 
 [package.metadata.winresource]
-OriginalFilename = "can-viewer.exe"
+OriginalFilename = "can-viewer_0.2.1.exe"
 LegalCopyright = "Copyright © 2024"

src/event_handler/can_handler.rs

@@ -138,13 +138,14 @@ impl<'a> CanHandler<'a> {
     }
     #[cfg(target_os = "windows")]
     fn process_ui_events(&mut self, dbc: DBC) {
-        use pcan_basic::socket::RecvCan;
+        use pcan_basic::{error::PcanError, socket::RecvCan};
         let mut start_bus_load = Instant::now();
         let mut total_bits = 0;
         loop {
+            let bitrate = self.bitrate().unwrap();
             let busload = if start_bus_load.elapsed() >= Duration::from_millis(1000) {
                 start_bus_load = Instant::now();
-                let bus_load = (total_bits as f64 / 250000_f64) * 100.0;
+                let bus_load = (total_bits as f64 / bitrate as f64) * 100.0;
                 total_bits = 0;
                 bus_load
             } else {
@@ -159,6 +160,7 @@ impl<'a> CanHandler<'a> {
                     }
                     ui.set_is_new_dbc(false);
                 }
+                ui.set_bitrate(bitrate as i32);
                 if busload > 0.0 {
                     ui.set_bus_load(busload as i32);
                 }
@@ -169,31 +171,43 @@ impl<'a> CanHandler<'a> {
                     break;
                 }
             }
-            if let Ok(frame) = self.iface.recv_frame() {
-                total_bits += (frame.dlc() as u32 + 6) * 8; // Data length + overhead (approximation)
-                let id = frame.can_id();
-                let frame_id = id & !0x80000000;
-                for message in dbc.messages() {
-                    if frame_id == (message.message_id().raw() & !0x80000000) {
-                        let padding_data = Self::pad_to_8_bytes(frame.data());
-                        let hex_string = Self::array_to_hex_string(frame.data());
-                        let signal_data = message.parse_from_can(&padding_data);
-                        let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
-                            let is_filter = ui.get_is_filter();
-                            let messages: ModelRc<CanData> = if !is_filter {
-                                ui.get_messages()
-                            } else {
-                                ui.get_filter_messages()
-                            };
-                            Self::update_ui_with_signals(
-                                &messages,
-                                frame_id,
-                                signal_data,
-                                hex_string,
-                            );
-                        });
+            match self.iface.recv_frame() {
+                Ok(frame) => {
+                    let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
+                        ui.set_state("OK".into());
+                    });
+                    total_bits += (frame.dlc() as u32 + 6) * 8; // Data length + overhead (approximation)
+                    let id = frame.can_id();
+                    let frame_id = id & !0x80000000;
+                    for message in dbc.messages() {
+                        if frame_id == (message.message_id().raw() & !0x80000000) {
+                            let padding_data = Self::pad_to_8_bytes(frame.data());
+                            let hex_string = Self::array_to_hex_string(frame.data());
+                            let signal_data = message.parse_from_can(&padding_data);
+                            let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
+                                let is_filter = ui.get_is_filter();
+                                let messages: ModelRc<CanData> = if !is_filter {
+                                    ui.get_messages()
+                                } else {
+                                    ui.get_filter_messages()
+                                };
+                                Self::update_ui_with_signals(
+                                    &messages,
+                                    frame_id,
+                                    signal_data,
+                                    hex_string,
+                                );
+                            });
+                        }
                     }
                 }
+                Err(e) => {
+                    let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
+                        if e != PcanError::QrcvEmpty {
+                            ui.set_state(format!("{:?}", e).into());
+                        }
+                    });
+                }
             }
         }
     }
@@ -295,14 +309,12 @@ impl<'a> CanHandler<'a> {
             ("800 kbit/s", 800_000),
             ("500 kbit/s", 500_000),
             ("250 kbit/s", 250_000),
-            ("200 kbit/s", 200_000),
             ("125 kbit/s", 125_000),
             ("100 kbit/s", 100_000),
             ("95.238 kbit/s", 95_238),
             ("83.333 kbit/s", 83_333),
             ("50 kbit/s", 50_000),
             ("47.619 kbit/s", 47_619),
-            ("40 kbit/s", 40_000),
             ("33.333 kbit/s", 33_333),
             ("20 kbit/s", 20_000),
             ("10 kbit/s", 10_000),

src/event_handler/mod.rs

@@ -5,7 +5,30 @@ pub(crate) mod packet_filter;
 pub use can_handler::CanHandler;
 pub use dbc_file::DBCFile;
 pub use packet_filter::PacketFilter;
+#[cfg(target_os = "windows")]
+use pcan_basic::socket::Baudrate;
 use slint::Color;
 
 const ODD_COLOR: Color = Color::from_rgb_u8(0x18, 0x1c, 0x27);
 const EVEN_COLOR: Color = Color::from_rgb_u8(0x13, 0x16, 0x1f);
+
+#[cfg(target_os = "windows")]
+pub fn p_can_bitrate(bitrate: &str) -> Option<Baudrate> {
+    match bitrate {
+        "1 Mbit/s" => Some(Baudrate::Baud1M),
+        "800 kbit/s" => Some(Baudrate::Baud800K),
+        "500 kbit/s" => Some(Baudrate::Baud500K),
+        "250 kbit/s" => Some(Baudrate::Baud250K),
+        "125 kbit/s" => Some(Baudrate::Baud125K),
+        "100 kbit/s" => Some(Baudrate::Baud100K),
+        "95.238 kbit/s" => Some(Baudrate::Baud95K),
+        "83.333 kbit/s" => Some(Baudrate::Baud83),
+        "50 kbit/s" => Some(Baudrate::Baud50K),
+        "47.619 kbit/s" => Some(Baudrate::Baud47K),
+        "33.333 kbit/s" => Some(Baudrate::Baud33K),
+        "20 kbit/s" => Some(Baudrate::Baud20K),
+        "10 kbit/s" => Some(Baudrate::Baud10K),
+        "5 kbit/s" => Some(Baudrate::Baud5K),
+        _ => None,
+    }
+}

src/main.rs

@@ -6,13 +6,11 @@ use std::time::Duration;
 
 mod event_handler;
 use can_dbc::DBC;
+#[cfg(target_os = "windows")]
+use event_handler::p_can_bitrate;
 use event_handler::{CanHandler, DBCFile, PacketFilter};
 #[cfg(target_os = "windows")]
-use pcan_basic::{
-    bus::UsbBus,
-    hw::attached_channels,
-    socket::{usb::UsbCanSocket, Baudrate},
-};
+use pcan_basic::{bus::UsbBus, hw::attached_channels, socket::usb::UsbCanSocket};
 #[cfg(target_os = "linux")]
 use privilege_rs::privilege_request;
 #[cfg(target_os = "windows")]
@@ -27,6 +25,7 @@ slint::include_modules!();
 
 #[tokio::main]
 async fn main() -> io::Result<()> {
+    #[cfg(target_os = "linux")]
     privilege_request();
     let ui = AppWindow::new().unwrap();
 
@@ -188,10 +187,11 @@ async fn main() -> io::Result<()> {
             };
             let usb_can = UsbBus::try_from(get_device_handle as u16).unwrap();
             let ui_handle = ui.as_weak();
-            match UsbCanSocket::open(usb_can, Baudrate::Baud250K) {
+            let baudrate = p_can_bitrate(&bitrate).unwrap();
+            match UsbCanSocket::open(usb_can, baudrate) {
                 Ok(socket) => {
                     ui_handle.unwrap().set_is_init(true);
-                    let _ = start_tx.send(socket);
+                    let _ = start_tx.send((socket, bitrate));
                 }
                 Err(e) => {
                     ui_handle

ui/init_page.slint

@@ -32,9 +32,9 @@ export component initPage inherits Rectangle {
                 }
             }
             bitrate_box := ComboBox {
-                model: ["1 Mbit/s", "800 kbit/s", "500 kbit/s", "250 kbit/s", "200 kbit/s", "125 kbit/s",
+                model: ["1 Mbit/s", "800 kbit/s", "500 kbit/s", "250 kbit/s", "125 kbit/s",
                         "100 kbit/s", "95.238 kbit/s", "83.333 kbit/s", "50 kbit/s", "47.619 kbit/s",
-                        "40 kbit/s", "33.333 kbit/s", "20 kbit/s", "10 kbit/s", "5 kbit/s"];
+                        "33.333 kbit/s", "20 kbit/s", "10 kbit/s", "5 kbit/s"];
                 current-value: "250 kbit/s";
             }
             Button {