fix: 修复打砖块游戏碰撞穿透bug，添加渐进提速机制

src-tauri/src/serial_core/serial.rs

@@ -2,12 +2,17 @@ use crate::serial_core::codec::Codec;
 use crate::serial_core::codecs::tactile_a::TactileACodec;
 use crate::serial_core::frame::{FrameHandler, TactileAFrame, TestFrame};
 use crate::serial_core::model::{HudChartState, HudPacket};
+#[cfg(feature = "multi-dim")]
+use crate::serial_core::multi_dim_force::PztProcessor;
 use crate::serial_core::record::Recording;
 use crate::serial_core::record::{FrameTiming, RecordedFrame};
 #[cfg(feature = "devkit")]
 use crate::devkit::{proto::SensorFrame, DevKitState};
 use anyhow::Result;
+use log::debug;
 use std::future::pending;
+#[cfg(feature = "devkit")]
+use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use tauri::{AppHandle, Emitter};
@@ -17,14 +22,19 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::time::{self, Duration, MissedTickBehavior};
 use tokio_serial::SerialStream;
 use tokio_util::sync::CancellationToken;
-#[cfg(feature = "devkit")]
-use std::sync::atomic::Ordering;
+
+const AUTO_SUB_INTERVAL: Duration = Duration::from_nanos(16_666_667);
 
 pub enum PollMode<F> {
     Disable,
     Enabled(Box<dyn PollRequester<F>>),
 }
 
+struct PendingSubFrame<F> {
+    frame: F,
+    values: Vec<i32>,
+}
+
 pub trait SerialFrame: Clone + Send + 'static {
     fn dts_ms(&self) -> u64;
 
@@ -215,10 +225,15 @@ where
         it.set_missed_tick_behavior(MissedTickBehavior::Skip);
         it
     });
+    let mut poll_sub_interval = time::interval(AUTO_SUB_INTERVAL);
+    poll_sub_interval.set_missed_tick_behavior(MissedTickBehavior::Skip);
 
     let mut chart_state = HudChartState::new();
     let mut buffer = [0u8; 1024];
     let mut prune_interval = time::interval(Duration::from_millis(450));
+    #[cfg(feature = "multi-dim")]
+    let mut pzt_processor = PztProcessor::new();
+    let mut pending_sub_frame: Option<PendingSubFrame<F>> = None;
     prune_interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
 
     loop {
@@ -246,6 +261,21 @@ where
                     app.emit("hud_stream", packet)?;
                 }
             }
+            _ = poll_sub_interval.tick() => {
+                if let Some(pending) = pending_sub_frame.take() {
+                    let display_values = build_display_values(
+                        &mut chart_state,
+                        pending.values.as_slice(),
+                    );
+
+                    if let Some(packet) = pending
+                        .frame
+                        .to_hud_packet(&mut chart_state, display_values.as_deref())
+                    {
+                        app.emit("hud_stream", packet)?;
+                    }
+                }
+            }
             read_result = port.read(&mut buffer) => {
                 let n = read_result?;
                 if n == 0 {
@@ -266,25 +296,38 @@ where
                         .await?
                         .map(|vals| vals.into_iter().map(Into::into).collect::<Vec<i32>>());
 
-                    let mut record = recording.lock().map_err(|_| anyhow::anyhow!("recording state poisoned"))?;
-                    record.push(RecordedFrame{
-                        timing: FrameTiming { pts_ms: None, dts_ms: frame.dts_ms() },
+                    let mut record = recording
+                        .lock()
+                        .map_err(|_| anyhow::anyhow!("recording state poisoned"))?;
+                    record.push(RecordedFrame {
+                        timing: FrameTiming {
+                            pts_ms: None,
+                            dts_ms: frame.dts_ms(),
+                        },
                         frame: frame.clone(),
                     });
+                    drop(record);
 
-                    let display_values = if let Some(vals) = decode_res.as_ref() {
-                        let summary = vals.iter().copied().sum::<i32>();
-                        let force = raw_to_g1(summary as u32);
-                        chart_state.record_summary(force as f32);
-                        chart_state.record_pressure_matrix(vals.as_slice());
+                    if let Some(vals) = decode_res {
+                        #[cfg(feature = "multi-dim")]
+                        {
+                            let pzt_values = vals.iter().map(|value| *value as f32).collect::<Vec<f32>>();
+                            if let Ok(angle) = pzt_processor.get_pzt_angle(&pzt_values) {
+                                // debug!("pzt angle: {:.2}", angle);
+                            }
+                        }
                         #[cfg(feature = "devkit")]
-                        push_devkit_frame(&app, vals.as_slice(), frame.dts_ms(), force);
-                        Some(vec![summary])
-                    } else {
-                        None
-                    };
+                        {
+                            let summary = vals.iter().copied().sum::<i32>();
+                            let force = raw_to_g1(summary as u32);
+                            push_devkit_frame(&app, vals.as_slice(), frame.dts_ms(), force);
+                        }
 
-                    if let Some(packet) = frame.to_hud_packet(&mut chart_state, display_values.as_deref()) {
+                        pending_sub_frame = Some(PendingSubFrame {
+                            frame: frame.clone(),
+                            values: vals,
+                        });
+                    } else if let Some(packet) = frame.to_hud_packet(&mut chart_state, None) {
                         app.emit("hud_stream", packet)?;
                     }
                 }
@@ -294,6 +337,14 @@ where
     Ok(())
 }
 
+fn build_display_values(chart_state: &mut HudChartState, values: &[i32]) -> Option<Vec<i32>> {
+    let summary = values.iter().copied().sum::<i32>();
+    let force = raw_to_g1(summary as u32);
+    chart_state.record_summary(force as f32);
+    chart_state.record_pressure_matrix(values);
+    Some(vec![summary])
+}
+
 #[cfg(feature = "devkit")]
 fn push_devkit_frame(app: &AppHandle, values: &[i32], dts_ms: u64, resultant_force: f64) {
     let devkit_state = app.state::<DevKitState>();