only 1 task handles CAN data and upgrade privilege-rs

Author: TuEmb

Cargo.toml

@@ -17,7 +17,7 @@ winapi = { version = "0.3.9", features = ["winuser"] }
 pcan-basic = { git = "https://github.com/TuEmb/pcan-basic.git", branch="main"}
 
 [target.'cfg(unix)'.dependencies]
-privilege-rs = "0.1.2"
+privilege-rs = "0.1.3"
 socketcan = { git = "https://github.com/socketcan-rs/socketcan-rs.git", rev="e0d7760eca8085b247f37ea22f0aa41e00fa25fa", features = ["enumerate"] }
 
 [build-dependencies]

src/event_handler/view.rs renamed to src/event_handler/can_handler.rs

@@ -4,31 +4,32 @@ use chrono::Utc;
 use pcan_basic::socket::usb::UsbCanSocket;
 use slint::{Model, ModelRc, SharedString, VecModel, Weak};
 #[cfg(target_os = "linux")]
-use socketcan::{CanInterface, CanSocket, EmbeddedFrame, Frame, Socket};
+use socketcan::{CanFrame, CanInterface, CanSocket, EmbeddedFrame, Frame, Socket};
 use std::{
     collections::HashMap,
     fmt::Write,
     rc::Rc,
-    sync::{mpsc::Receiver, Arc, Mutex},
+    sync::{mpsc::Receiver, mpsc::Sender, Arc, Mutex},
     thread::sleep,
     time::{Duration, Instant},
 };
 
 use crate::slint_generatedAppWindow::{AppWindow, CanData, CanSignal};
-pub struct ViewHandler<'a> {
+pub struct CanHandler<'a> {
     #[cfg(target_os = "linux")]
     pub iface: &'a str,
     #[cfg(target_os = "windows")]
     pub iface: UsbCanSocket,
     pub ui_handle: &'a Weak<AppWindow>,
     pub mspc_rx: &'a Arc<Mutex<Receiver<DBC>>>,
+    pub can_tx: Sender<CanFrame>,
     pub bitrate: String,
 }
 
 static mut NEW_DBC_CHECK: bool = false;
 use super::{EVEN_COLOR, ODD_COLOR};
 
-impl<'a> ViewHandler<'a> {
+impl<'a> CanHandler<'a> {
     pub fn process_can_messages(&mut self) {
         if let Ok(dbc) = self.mspc_rx.lock().unwrap().try_recv() {
             #[cfg(target_os = "linux")]
@@ -107,6 +108,7 @@ impl<'a> ViewHandler<'a> {
                 }
             }
             if let Ok(frame) = can_socket.read_frame() {
+                let _ = self.can_tx.send(frame);
                 total_bits += (frame.len() + 6) * 8; // Data length + overhead (approximation)
                 let frame_id = frame.raw_id() & !0x80000000;
                 for message in dbc.messages() {

src/event_handler/debug.rs

@@ -1,22 +1,20 @@
-use std::{collections::HashMap, rc::Rc, time::Duration};
+use std::{collections::HashMap, rc::Rc, sync::mpsc::Receiver, time::Duration};
 
 use crate::slint_generatedAppWindow::{raw_can, AppWindow};
 use slint::{Model, SharedString, VecModel, Weak};
-use socketcan::{CanSocket, EmbeddedFrame, Frame, Socket};
+use socketcan::{CanFrame, EmbeddedFrame, Frame};
+
+const MAX_LEN: usize = 1000;
 pub struct DebugHandler<'a> {
-    #[cfg(target_os = "linux")]
-    pub iface: &'a str,
-    #[cfg(target_os = "windows")]
-    pub iface: UsbCanSocket,
     pub ui_handle: &'a Weak<AppWindow>,
     pub bitrate: String,
     pub filter: (u32, u32),
+    pub can_rx: Receiver<CanFrame>,
 }
 
 impl<'a> DebugHandler<'a> {
     pub fn run(&mut self) {
-        let can_socket = CanSocket::open(self.iface).unwrap();
-        if let Ok(frame) = can_socket.read_frame() {
+        if let Ok(frame) = self.can_rx.recv() {
             let frame_id = frame.raw_id() & !0x80000000;
             if frame_id >= self.filter.0 && frame_id <= self.filter.1 {
                 let bitrate = self.bitrate().unwrap();
@@ -27,6 +25,9 @@ impl<'a> DebugHandler<'a> {
                     for data in raw_data.iter() {
                         vec_data.push(data);
                     }
+                    if vec_data.len() > MAX_LEN {
+                        vec_data.remove(0);
+                    }
                     vec_data.push(raw_can {
                         data: SharedString::from(format!("{:?}", frame.data())),
                         id: SharedString::from(frame_id.to_string()),

src/event_handler/mod.rs

@@ -1,17 +1,17 @@
+pub(crate) mod can_handler;
 pub(crate) mod dbc_file;
 pub(crate) mod debug;
 pub(crate) mod filter;
 pub(crate) mod init;
-pub(crate) mod view;
 
+pub use can_handler::CanHandler;
 pub use dbc_file::DBCFile;
 pub use debug::DebugHandler;
 pub use filter::PacketFilter;
 pub use init::Init;
 #[cfg(target_os = "windows")]
 use pcan_basic::socket::Baudrate;
 use slint::Color;
-pub use view::ViewHandler;
 
 const ODD_COLOR: Color = Color::from_rgb_u8(0x18, 0x1c, 0x27);
 const EVEN_COLOR: Color = Color::from_rgb_u8(0x13, 0x16, 0x1f);

src/main.rs

@@ -4,7 +4,7 @@ use std::sync::{Arc, Mutex};
 
 mod event_handler;
 use can_dbc::DBC;
-use event_handler::{DBCFile, DebugHandler, Init, PacketFilter, ViewHandler};
+use event_handler::{CanHandler, DBCFile, DebugHandler, Init, PacketFilter};
 #[cfg(target_os = "windows")]
 use pcan_basic::{bus::UsbBus, socket::usb::UsbCanSocket};
 #[cfg(target_os = "linux")]
@@ -20,7 +20,10 @@ slint::include_modules!();
 #[tokio::main]
 async fn main() -> io::Result<()> {
     #[cfg(target_os = "linux")]
-    privilege_request();
+    if privilege_request()? == privilege_rs::Privilege::User {
+        println!("Failed to request the privilege");
+        std::process::exit(0);
+    }
     let ui = AppWindow::new().unwrap();
 
     let (tx, rx) = mpsc::channel::<DBC>();
@@ -86,17 +89,19 @@ async fn main() -> io::Result<()> {
         }
     });
 
+    let (can_tx, can_rx) = mpsc::channel();
     let ui_handle = ui.as_weak();
     tokio::spawn(async move {
         if let Ok((can_if, bitrate)) = start_rx_1.recv() {
-            let mut can_handler = ViewHandler {
+            let mut can_handler = CanHandler {
                 #[cfg(target_os = "windows")]
                 iface: can_if,
                 #[cfg(target_os = "linux")]
                 iface: &can_if,
                 ui_handle: &ui_handle,
                 mspc_rx: &rx,
                 bitrate: bitrate.to_string(),
+                can_tx,
             };
             loop {
                 can_handler.process_can_messages();
@@ -106,15 +111,12 @@ async fn main() -> io::Result<()> {
 
     let ui_handle = ui.as_weak();
     tokio::spawn(async move {
-        if let Ok((can_if, bitrate)) = start_rx_2.recv() {
+        if let Ok((_can_if, bitrate)) = start_rx_2.recv() {
             let mut can_handler = DebugHandler {
-                #[cfg(target_os = "windows")]
-                iface: can_if,
-                #[cfg(target_os = "linux")]
-                iface: &can_if,
                 ui_handle: &ui_handle,
                 bitrate: bitrate.to_string(),
                 filter: (0, 0xFFFFFFFF),
+                can_rx,
             };
             loop {
                 can_handler.run();

ui/app.slint

@@ -114,6 +114,8 @@ export component AppWindow inherits Window {
             }
             if root.active-page == 2:
             debugPage {
+                state: state;
+                bus_load: bus_load;
                 bitrate: bitrate;
                 raw_data: raw_data;
             }