receive can frame from beginning

src/event_handler/can_handler.rs

@@ -24,27 +24,25 @@ pub struct CanHandler<'a> {
     pub mspc_rx: &'a Arc<Mutex<Receiver<DBC>>>,
     pub can_tx: Sender<CanFrame>,
     pub bitrate: String,
+    pub dbc: Option<DBC>,
 }
 
 static mut NEW_DBC_CHECK: bool = false;
 use super::{EVEN_COLOR, ODD_COLOR};
 
 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")]
-            {
-                let can_if = CanInterface::open(self.iface).unwrap();
-                let _ = can_if.bring_down();
-                let _ = can_if.set_bitrate(self.bitrate().unwrap(), None);
-                let _ = can_if.bring_up();
-                let can_socket = self.open_can_socket();
-                self.process_ui_events(dbc, can_socket, can_if);
-            }
-            #[cfg(target_os = "windows")]
-            self.process_ui_events(dbc);
+        #[cfg(target_os = "linux")]
+        {
+            let can_if = CanInterface::open(self.iface).unwrap();
+            let _ = can_if.bring_down();
+            let _ = can_if.set_bitrate(self.bitrate().unwrap(), None);
+            let _ = can_if.bring_up();
+            let can_socket = self.open_can_socket();
+            self.process_ui_events(can_socket, can_if);
         }
-        sleep(Duration::from_millis(10));
+        #[cfg(target_os = "windows")]
+        self.process_ui_events(dbc);
     }
     #[cfg(target_os = "linux")]
     fn open_can_socket(&self) -> CanSocket {
@@ -65,7 +63,7 @@ impl<'a> CanHandler<'a> {
         }
     }
     #[cfg(target_os = "linux")]
-    fn process_ui_events(&self, dbc: DBC, can_socket: CanSocket, can_if: CanInterface) {
+    fn process_ui_events(&mut self, can_socket: CanSocket, can_if: CanInterface) {
         let mut start_bus_load = Instant::now();
         let mut total_bits = 0;
         loop {
@@ -88,11 +86,7 @@ impl<'a> CanHandler<'a> {
             };
             let _ = self.ui_handle.upgrade_in_event_loop(move |ui| unsafe {
                 if ui.get_is_new_dbc() {
-                    if ui.get_is_first_open() {
-                        ui.set_is_first_open(false);
-                    } else {
-                        NEW_DBC_CHECK = true;
-                    }
+                    NEW_DBC_CHECK = true;
                     ui.set_is_new_dbc(false);
                 }
                 ui.set_state(bus_state.into());
@@ -103,33 +97,37 @@ impl<'a> CanHandler<'a> {
             });
             unsafe {
                 if NEW_DBC_CHECK {
-                    NEW_DBC_CHECK = false;
-                    break;
+                    if let Ok(dbc) = self.mspc_rx.lock().unwrap().try_recv() {
+                        self.dbc = Some(dbc);
+                        NEW_DBC_CHECK = false;
+                    }
                 }
             }
             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() {
-                    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,
-                            );
-                        });
+                if let Some(dbc) = &self.dbc {
+                    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,
+                                );
+                            });
+                        }
                     }
                 }
             } else {

src/event_handler/debug.rs

@@ -1,6 +1,12 @@
-use std::{collections::HashMap, rc::Rc, sync::mpsc::Receiver, time::Duration};
+use std::{
+    collections::HashMap,
+    rc::Rc,
+    sync::mpsc::{self, Receiver},
+    time::Duration,
+};
 
 use crate::slint_generatedAppWindow::{raw_can, AppWindow};
+use chrono::Local;
 use slint::{Model, SharedString, VecModel, Weak};
 use socketcan::{CanFrame, EmbeddedFrame, Frame};
 
@@ -14,32 +20,57 @@ pub struct DebugHandler<'a> {
 
 impl<'a> DebugHandler<'a> {
     pub fn run(&mut self) {
-        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();
-                let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
-                    ui.set_bitrate(bitrate as i32);
-                    let raw_data = ui.get_raw_data();
-                    let mut vec_data = Vec::default();
-                    for data in raw_data.iter() {
-                        vec_data.push(data);
-                    }
-                    if vec_data.len() > MAX_LEN {
-                        vec_data.remove(0);
+        let (tx, rx) = mpsc::channel();
+        let mut debug_enable = true;
+        loop {
+            if let Ok(en) = rx.try_recv() {
+                debug_enable = en;
+            }
+            if debug_enable {
+                if let Ok(frame) = self.can_rx.try_recv() {
+                    let frame_id = frame.raw_id() & !0x80000000;
+                    if frame_id >= self.filter.0 && frame_id <= self.filter.1 {
+                        let bitrate = self.bitrate().unwrap();
+                        let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
+                            ui.set_bitrate(bitrate as i32);
+                            let raw_data = ui.get_raw_data();
+                            let mut vec_data = Vec::default();
+                            for data in raw_data.iter() {
+                                vec_data.push(data);
+                            }
+                            if vec_data.len() > MAX_LEN {
+                                vec_data.remove(MAX_LEN);
+                            }
+                            vec_data.insert(
+                                0,
+                                raw_can {
+                                    time: SharedString::from(format!(
+                                        "{:?}",
+                                        Local::now().to_string().replace('"', "")
+                                    )),
+                                    data: SharedString::from(format!("{:?}", frame.data())),
+                                    id: SharedString::from(format!("0x{:08X}", frame_id)),
+                                    len: frame.len() as i32,
+                                },
+                            );
+                            let message_vec: Rc<VecModel<raw_can>> =
+                                Rc::new(VecModel::from(vec_data));
+                            ui.set_raw_data(message_vec.into());
+                        });
                     }
-                    vec_data.push(raw_can {
-                        data: SharedString::from(format!("{:?}", frame.data())),
-                        id: SharedString::from(frame_id.to_string()),
-                        len: frame.len() as i32,
-                    });
-                    vec_data.reverse();
-                    let message_vec: Rc<VecModel<raw_can>> = Rc::new(VecModel::from(vec_data));
-                    ui.set_raw_data(message_vec.into());
-                });
+                } else {
+                    std::thread::sleep(Duration::from_millis(1));
+                }
+            } else {
+                std::thread::sleep(Duration::from_millis(50));
             }
-        } else {
-            std::thread::sleep(Duration::from_millis(1));
+            let tx_clone = tx.clone();
+            let _ = self.ui_handle.upgrade_in_event_loop(move |ui| {
+                let enable = ui.get_is_debug_en();
+                if enable != debug_enable {
+                    let _ = tx_clone.send(enable);
+                }
+            });
         }
     }
 

src/main.rs

@@ -101,6 +101,7 @@ async fn main() -> io::Result<()> {
                 ui_handle: &ui_handle,
                 mspc_rx: &rx,
                 bitrate: bitrate.to_string(),
+                dbc: None,
                 can_tx,
             };
             loop {

ui/app.slint

@@ -12,8 +12,8 @@ import { raw_can, debugPage } from "debug_page.slint";
 export component AppWindow inherits Window {
     in property <bool> is_filter: false;
     in property <bool> is_new_dbc: false;
-    in property <bool> is_first_open: true;
     in property <bool> is_init: false;
+    out property <bool> is_debug_en: false;
     in property <string> init_string: "Please select CAN device to start";
     in property <socket_info> can_sockets;
     in property <[CanData]> messages;
@@ -114,10 +114,14 @@ export component AppWindow inherits Window {
             }
             if root.active-page == 2:
             debugPage {
+                en: is_debug_en;
                 state: state;
                 bus_load: bus_load;
                 bitrate: bitrate;
                 raw_data: raw_data;
+                change_state(en) => {
+                    is_debug_en = en;
+                }
             }
         }
     }

ui/debug_page.slint

@@ -2,11 +2,43 @@
 import { ListView, Button } from "std-widgets.slint";
 
 export struct raw_can {
+    time: string,
     id: string,
     len: int,
     data: string
 }
+
+
+export component StartPauseButton inherits Rectangle {
+    callback clicked();
+    in-out property <bool> en: false;
+    border-radius: 5px;
+    width: 30px;
+    height: 30px;
+    states [
+        pressed when touch-area.pressed : {
+        }
+
+        hover when touch-area.has-hover: {
+            background: #ffffff.darker(0.4);
+        }
+    ]
+    image := Image {
+        source: root.en ? @image-url("images/play.png") : @image-url("images/pause.png");
+        width: parent.width * 80%;
+        height: parent.height * 80%;
+        colorize: white;
+    }
+    touch-area := TouchArea {
+        pointer-event(event) => {
+            if (event.button == PointerEventButton.left && event.kind == PointerEventKind.down) {
+                clicked();
+            }
+        }
+    }
+}
 export component debugPage inherits Rectangle {
+    in-out property <bool> en;
     in property <string> state;
     in property <string> bitrate;
     in property <string> bus_load;
@@ -15,8 +47,17 @@ export component debugPage inherits Rectangle {
     {id: "181FF1FA", len: 4, data: "00 01 02 03 04 05 06 07"},
     {id: "181FF1FA", len: 4, data: "00 01 02 03 04 05 06 07"},
     {id: "181FF1FA", len: 4, data: "00 01 02 03 04 05 06 07"}];
+    callback change_state(bool);
+
     VerticalLayout {
         HorizontalLayout {
+            play_button:= StartPauseButton {
+                en: en;
+                clicked() => {
+                    en = !en;
+                    change_state(en);
+                }
+            }
             Rectangle {}
             Rectangle {
                 max-height: 30px;
@@ -63,21 +104,28 @@ export component debugPage inherits Rectangle {
                     for raw in raw_data: Rectangle {
                         HorizontalLayout {
                             Rectangle {
-                                width: parent.width * 30%;
+                                width: parent.width * 40%;
+                                Text {
+                                    text: raw.time;
+                                    color: white;
+                                }
+                            }
+                            Rectangle {
+                                width: parent.width * 10%;
                                 Text {
                                     text: raw.id;
                                     color: white;
                                 }
                             }
                             Rectangle {
-                                width: parent.width * 20%;
+                                width: parent.width * 10%;
                                 Text {
                                     text: raw.len;
                                     color: white;
                                 }
                             }
                             Rectangle {
-                                width: parent.width * 50%;
+                                width: parent.width * 40%;
                                 Text {
                                     text: raw.data;
                                     color: white;
@@ -135,4 +183,4 @@ export component debugPage inherits Rectangle {
             }
         }
     }
-}
+}