feat:themes, tactilea codec

src-tauri/src/serial_core/codecs/tactile_a.rs

@@ -3,7 +3,7 @@ use crate::serial_core::frame::{
     FrameHandler, TactileAFrameMetaData, TactileARepFrame, TactileAReqFrame,
 };
 use crate::serial_core::record::{write_csv, CsvExporter, CsvImporter, RecordedFrame, Recording};
-use crate::serial_core::utils::{calc_crc8_itu, elapsed_millis, usize_to_u16_le_bytes};
+use crate::serial_core::utils::{calc_crc8_itu, elapsed_millis};
 use crate::serial_core::{
     codec::Codec,
     frame::{TactileAFrame, TactileAFrameStatusCode},
@@ -12,12 +12,14 @@ use async_trait::async_trait;
 use csv::StringRecord;
 use anyhow::anyhow;
 use std::io::Read;
+use log::debug;
 
 const FRAME_BUFFER_MIN_LENGTH: usize = 15;
 
 pub struct TactileACodec {
     buffer: Vec<u8>,
     frame_nb: u64,
+    expected_data_len: usize,
 }
 
 pub struct TactileACsvExporter {
@@ -64,6 +66,7 @@ impl TactileACodec {
         Self {
             buffer: Vec::new(),
             frame_nb: 0,
+            expected_data_len: cols * rows * 2,
         }
     }
 
@@ -145,11 +148,33 @@ impl Codec<TactileAFrame> for TactileACodec {
             ]);
             let except_data_len = u16::from_le_bytes([self.buffer[11], self.buffer[12]]) as usize;
             let status = TactileAFrameStatusCode::from(self.buffer[13]);
+            if except_data_len != self.expected_data_len {
+                debug!(
+                    "unexpected payload length: expected {}, got {}, buffer_len={}",
+                    self.expected_data_len,
+                    except_data_len,
+                    self.buffer.len()
+                );
+                self.buffer.drain(0..1);
+                continue;
+            }
+
+            let frame_length = except_data_len + FRAME_BUFFER_MIN_LENGTH;
+            if self.buffer.len() < frame_length {
+                break;
+            }
+
+            let need_check_data = self.buffer[0..14 + except_data_len].to_vec();
             let payload = self.buffer[14..14 + except_data_len].to_vec();
             let crc8_itu_alg = crc::Crc::<u8>::new(&crc::CRC_8_I_432_1);
-            let checksum = crc8_itu_alg.checksum(&payload.as_slice());
-            let frame_length = except_data_len + FRAME_BUFFER_MIN_LENGTH;
+            let checksum = crc8_itu_alg.checksum(&need_check_data.as_slice());
             if self.buffer[frame_length - 1] != checksum {
+                debug!(
+                    "checksum mismatch: expected {:02X}, got {:02X}, frame_len={}",
+                    checksum,
+                    self.buffer[frame_length - 1],
+                    frame_length
+                );
                 self.buffer.drain(0..1);
                 continue;
             }
@@ -187,11 +212,13 @@ impl Codec<TactileAFrame> for TactileACodec {
             TactileAFrame::Req(f) => {
                 let mut req_bytes: Vec<u8> = Vec::new();
                 req_bytes.extend_from_slice(f.meta.header.as_slice());
-                req_bytes.extend_from_slice(usize_to_u16_le_bytes(f.meta.payload_len).as_slice());
+                req_bytes.extend_from_slice((f.meta.payload_len as u16).to_le_bytes().as_slice());
                 req_bytes.push(f.meta.device_addr);
                 req_bytes.push(f.meta.extend_code);
                 req_bytes.push(f.meta.func_code);
+                
                 req_bytes.extend_from_slice(f.meta.start_addr.to_le_bytes().as_slice());
+                req_bytes.extend_from_slice((f.meta.except_data_len as u16).to_le_bytes().as_slice());
                 let checksum = calc_crc8_itu(req_bytes.as_slice());
                 req_bytes.push(checksum);
                 Ok(req_bytes)
@@ -209,6 +236,7 @@ impl FrameHandler<TactileAFrame, i32> for TactileAHandler {
         match frame {
             TactileAFrame::Rep(rep) => {
                 let vals = TactileACodec::parse_data_frame(&rep.payload)?;
+                debug!("vals is {:?}", vals);
                 Ok(Some(vals))
             }
             _ => Ok(None),

src-tauri/src/serial_core/codecs/test.rs

@@ -6,7 +6,6 @@ use anyhow::anyhow;
 use async_trait::async_trait;
 use csv::StringRecord;
 use crate::serial_core::record::{write_csv, CsvExporter, CsvImporter, RecordedFrame, Recording};
-use crc::{Crc, CRC_8_SMBUS};
 use crate::serial_core::utils::{
     elapsed_millis,
     usize_to_u16_be_bytes

src-tauri/src/serial_core/serial.rs

@@ -12,7 +12,7 @@ use tokio_util::sync::CancellationToken;
 use std::future::pending;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
-use log::info;
+use log::{info, debug};
 use crate::serial_core::record::{FrameTiming, RecordedFrame};
 
 pub enum PollMode<F> {
@@ -211,6 +211,7 @@ where
     let mut prune_interval = time::interval(Duration::from_millis(450));
     prune_interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
 
+    
     loop {
         tokio::select! {
             _ = cancel.cancelled() => break,
@@ -239,6 +240,9 @@ where
             read_result = port.read(&mut buffer) => {
                 let n = read_result?;
                 if n == 0 {
+                    // Some serial drivers can resolve reads with 0 bytes repeatedly.
+                    // Yield here so timer-driven poll requests are not starved by a busy loop.
+                    tokio::task::yield_now().await;
                     continue;
                 }
 
@@ -261,7 +265,6 @@ where
 
                     let display_values = if let Some(vals) = decode_res.as_ref() {
                         let summary = vals.iter().copied().sum::<i32>();
-                        info!("dot value summary: {}", summary);
                         chart_state.record_summary(summary as f32);
                         chart_state.record_pressure_matrix(vals.as_slice());
                         Some(vec![summary])

src-tauri/src/serial_core/utils.rs

@@ -1,5 +1,4 @@
-use anyhow::Ok;
-use crc::{Crc, CRC_8_I_432_1, CRC_8_SMBUS};
+
 use std::time::Instant;
 
 pub fn usize_to_u16_be_bytes(n: usize) -> [u8; 2] {