增加多线程读取

src-tauri/src/lib.rs

@@ -1,6 +1,13 @@
+use std::sync::{Arc, Mutex, atomic::{AtomicBool, Ordering}};
 use std::thread;
 use hidapi::HidApi;
 use tauri::{Emitter,Window};
+// 全局停止标志和线程句柄
+lazy_static::lazy_static! {
+    static ref STOP_SIGNAL: AtomicBool = AtomicBool::new(false);
+    static ref THREAD_HANDLE: Mutex<Option<thread::JoinHandle<()>>> = Mutex::new(None);
+}
+// G923设备标识
 const LOGITECH_VID: u16 = 0x046D;  // 罗技厂商ID
 const G923_PIDS: &[u16] = &[
     0xC262,  // G923 PlayStation
@@ -11,8 +18,10 @@ const G923_PIDS: &[u16] = &[
 // 读取G923数据
 #[tauri::command]
 fn start_reading_data(window: Window) -> Result<(), String> {
+    // 停止现有线程
+    stop_reading_data();
     // 初始化HID API
-    let api = HidApi::new().map_err(|_| "HID设备初始化失败".to_string())?;
+    let api = HidApi::new().map_err(|_| "HID初始化失败".to_string())?;
     // 自动检测设备
     let device_info = api.device_list().find(|d| d.vendor_id() == LOGITECH_VID && G923_PIDS.contains(&d.product_id())).ok_or("未找到G923方向盘")?;
     // 打印检测到的设备信息
@@ -21,33 +30,63 @@ fn start_reading_data(window: Window) -> Result<(), String> {
         device_info.product_id());
     // 打开设备
     let device = device_info.open_device(&api).map_err(|e| format!("无法打开设备: {}", e))?;
+    // 发送初始化命令
+    // let init_report = [0x02u8, 0x00, 0x00, 0x00, 0x00]; // 根据实际协议调整
+    // device.send_feature_report(&init_report).map_err(|e| format!("设备初始化失败: {}", e))?;
+    // 设置非阻塞模式（可选）
+    device.set_blocking_mode(false).map_err(|e| format!("设置非阻塞模式失败: {}", e))?;
+    // 克隆Arc用于线程
+    let device = Arc::new(Mutex::new(device));
+    let thread_device = Arc::clone(&device);
+    let thread_window = window.clone();
     // 启动读取线程
-    thread::spawn(move || {
+    let handle = thread::spawn(move || {
         let mut buf = [0u8; 64];
         loop {
+            // 检查停止标志
+            if STOP_SIGNAL.load(Ordering::SeqCst) {
+                println!("停止读取线程");
+                break;
+            }
+
             // 使用带超时的读取（100ms）
-            let res = match device.read_timeout(&mut buf, 100) {
+            let res = match thread_device.lock().unwrap().read_timeout(&mut buf, 100) {
                 Ok(n) => n,
                 Err(e) => {
                     eprintln!("读取数据失败: {}", e);
-                    break;
+                    continue;
                 }
             };
 
             // 处理&发送数据
             let data = &buf[..res];
-            let _ = window.emit("g923-data", format!("{:?}", data));
+            let _ = thread_window.emit("g923-data", format!("{:?}", data));
         }
-    });
 
+        // 关闭设备
+        drop(thread_device.lock().unwrap());
+    });
+    // 存储线程句柄
+    *THREAD_HANDLE.lock().unwrap() = Some(handle);
+    // return
     Ok(())
 }
 
+// 设置停止
+#[tauri::command]
+fn stop_reading_data() {
+    STOP_SIGNAL.store(true, Ordering::SeqCst);
+    if let Some(handle) = THREAD_HANDLE.lock().unwrap().take() {
+       let _ = handle.join().map_err(|_| "无法等待线程退出".to_string());
+    }
+    STOP_SIGNAL.store(false, Ordering::SeqCst);
+}
+
 pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_mqtt::init())
-        .invoke_handler(tauri::generate_handler![start_reading_data])
+        .invoke_handler(tauri::generate_handler![start_reading_data,stop_reading_data])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }

src/pages/room/component/steering.vue

@@ -43,6 +43,7 @@ invoke('start_reading_data').then(() => {
   })
 }).catch((er) => {
   show.value = false
+  console.log('output->', er)
   notice.error({ title: er, duration: 3000 })
 })