再次提交

2024-08-21 14:19:40 +08:00
parent fb3257bb75
commit 6d47134dac
46 changed files with 1170 additions and 468 deletions
--- a/README.md
+++ b/README.md
@ -1,3 +1,5 @@
 # 通用光谱采集软件

+插入复选框

+aaa <input disabled="" type="checkbox"> Checkbox 1
--- a/index.html
+++ b/index.html
@ -23,7 +23,7 @@
              padding: 0px;
          }
      </style>
-      <script src="http://172.16.0.84:8098"></script>
+<script src="http://localhost:8098"></script>
  </head>

  <body>
--- a/package.json
+++ b/package.json
@ -6,6 +6,7 @@
  "scripts": {
    "dev": "vite",
    "build": "vite build",
+    "mybuild": "node -e \"require('child_process').exec('powershell -ExecutionPolicy Bypass -File ./src-tauri/pre-build.ps1')\"",
    "preview": "vite preview",
    "tauri": "tauri"
  },
--- a/src-tauri/.cargo/config.toml
+++ b/src-tauri/.cargo/config.toml
@ -0,0 +1,4 @@
+[unstable]
+features = ["warn-unused"]
+warn-unused-features = false
+
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@ -1497,9 +1497,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.153"
+version = "0.2.156"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+checksum = "a5f43f184355eefb8d17fc948dbecf6c13be3c141f20d834ae842193a448c72a"

 [[package]]
 name = "libredox"
@ -1686,9 +1686,11 @@ dependencies = [
 name = "myfirst_tauri"
 version = "0.0.0"
 dependencies = [
+ "chrono",
 "csv",
 "find_peaks",
 "lazy_static",
+ "libc",
 "ndarray",
 "ndarray-ndimage",
 "ndarray-stats",
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@ -26,6 +26,8 @@ ndarray-ndimage = "0.4.0"
 find_peaks = "0.1.5"
 csv = "1.3.0"
 tklog = "0.0.8"
+libc = "0.2.156"
+chrono = "0.4.38"



--- a/src-tauri/aaa.iss
+++ b/src-tauri/aaa.iss
@ -0,0 +1,12 @@
+[Setup]
+AppName=MyApp
+AppVersion=1.0
+DefaultDirName={pf}\MyApp
+OutputDir=.
+OutputBaseFilename=MyAppInstaller
+
+[Files]
+Source: "src-tauri/target/release/bundle/msi/*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Run]
+Filename: "{app}\path\to\vsruntime\installer.exe"; Parameters: "/quiet /norestart"; Flags: waituntilterminated
--- a/src-tauri/config.json
+++ b/src-tauri/config.json
@ -1 +1 @@
-{"pathofsave":"D:\\01Hydata\\123123123\\test2","Filename":"test","caijiavgNumber":"1","useSG":false,"usehighpass":true}
+{"pathofsave":"D:\\06Learn\\rust\\tarui\\testdarta","Filename":"test","caijiavgNumber":"1","useSG":true,"usehighpass":true}
--- a/src-tauri/icons/128x128.png
+++ b/src-tauri/icons/128x128.png
--- a/src-tauri/icons/128x128@2x.png
+++ b/src-tauri/icons/128x128@2x.png
--- a/src-tauri/icons/32x32.png
+++ b/src-tauri/icons/32x32.png
--- a/src-tauri/icons/Square107x107Logo.png
+++ b/src-tauri/icons/Square107x107Logo.png
--- a/src-tauri/icons/Square142x142Logo.png
+++ b/src-tauri/icons/Square142x142Logo.png
--- a/src-tauri/icons/Square150x150Logo.png
+++ b/src-tauri/icons/Square150x150Logo.png
--- a/src-tauri/icons/Square284x284Logo.png
+++ b/src-tauri/icons/Square284x284Logo.png
--- a/src-tauri/icons/Square30x30Logo.png
+++ b/src-tauri/icons/Square30x30Logo.png
--- a/src-tauri/icons/Square310x310Logo.png
+++ b/src-tauri/icons/Square310x310Logo.png
--- a/src-tauri/icons/Square44x44Logo.png
+++ b/src-tauri/icons/Square44x44Logo.png
--- a/src-tauri/icons/Square71x71Logo.png
+++ b/src-tauri/icons/Square71x71Logo.png
--- a/src-tauri/icons/Square89x89Logo.png
+++ b/src-tauri/icons/Square89x89Logo.png
--- a/src-tauri/icons/StoreLogo.png
+++ b/src-tauri/icons/StoreLogo.png
--- a/src-tauri/icons/icon.icns
+++ b/src-tauri/icons/icon.icns
--- a/src-tauri/icons/icon.ico
+++ b/src-tauri/icons/icon.ico
--- a/src-tauri/icons/icon.png
+++ b/src-tauri/icons/icon.png
--- a/src-tauri/is11lib.dll
+++ b/src-tauri/is11lib.dll
--- a/src-tauri/pre-build.ps1
+++ b/src-tauri/pre-build.ps1
@ -0,0 +1,2 @@
+copy ..\\myis11\\project\\is11\\cmake-build-release-visual-studio-2022\\is11lib.dll ./src-tauri 
+
--- a/src-tauri/src/algorithm/mod.rs
+++ b/src-tauri/src/algorithm/mod.rs
@ -18,7 +18,7 @@ pub fn sg_smooth(data: Vec<f64>, window: usize, order: usize) -> Vec<f64> {
    smoothmethod::savgol(data, window, order)
 }
 #[tauri::command]
-pub fn Gaussian_filter_high(data: Vec<f64>, sigma: f64) -> Vec<f64> {
+pub fn gaussian_filter_high(data: Vec<f64>, sigma: f64) -> Vec<f64> {
    sharpmethod::high_pass_gaussian_filter(data, sigma)
 }

--- a/src-tauri/src/algorithm/spectraltools.rs
+++ b/src-tauri/src/algorithm/spectraltools.rs
@ -5,9 +5,9 @@ use std::error::Error;

 use find_peaks::PeakFinder;

-pub fn interpolate_spline<T: Copy + Into<f64>,>(x_T: Vec<T>, y_T: Vec<T>, step: f64) -> Result<Vec<(f64, f64)>, Box<dyn Error>> {
-    let x: Vec<f64> = x_T.iter().map(|&x| x.into()).collect();
-    let y: Vec<f64> = y_T.iter().map(|&y| y.into()).collect();
+pub fn interpolate_spline<T: Copy + Into<f64>,>(x_t: Vec<T>, y_t: Vec<T>, step: f64) -> Result<Vec<(f64, f64)>, Box<dyn Error>> {
+    let x: Vec<f64> = x_t.iter().map(|&x| x.into()).collect();
+    let y: Vec<f64> = y_t.iter().map(|&y| y.into()).collect();

    if x.len() != y.len() {
        return Err("x and y must have the same length".into());
@ -39,9 +39,9 @@ pub fn interpolate_spline<T: Copy + Into<f64>,>(x_T: Vec<T>, y_T: Vec<T>, step:
    Ok(result)
 }

-pub fn interpolate_spline_at_points<T: Copy + Into<f64>>(x_T: Vec<T>, y_T: Vec<T>, x_target: Vec<f64>) -> Result<Vec<(f64)>, Box<dyn Error>> {
-    let x: Vec<f64> = x_T.iter().map(|&x| x.into()).collect();
-    let y: Vec<f64> = y_T.iter().map(|&y| y.into()).collect();
+pub fn interpolate_spline_at_points<T: Copy + Into<f64>>(x_t: Vec<T>, y_t: Vec<T>, x_target: Vec<f64>) -> Result<Vec<(f64)>, Box<dyn Error>> {
+    let x: Vec<f64> = x_t.iter().map(|&x| x.into()).collect();
+    let y: Vec<f64> = y_t.iter().map(|&y| y.into()).collect();

    if x.len() != y.len() {
        return Err("x and y must have the same length".into());
--- a/src-tauri/src/comman.rs
+++ b/src-tauri/src/comman.rs
@ -0,0 +1,51 @@
+
+use super::serport::serport::*;
+use super::mylog::*;
+
+
+#[tauri::command]
+pub fn greet(name: &str) -> String {
+    format!("Hello, {}! You've been greeted from Rust!", name)
+}
+ #[tauri::command]
+ pub fn getportnames() -> Vec<String> {
+    get_port_name()
+}
+#[tauri::command]
+pub fn opencom(portname: serde_json::Value, baudrate: serde_json::Value) -> String {
+    //tauri
+    let portname = portname.as_str().unwrap();
+    let baudrate = baudrate.as_u64().unwrap() as u32;
+    set_port_info(&portname.to_string(), baudrate);
+
+    println!("opencom portname:{} baudrate:{}", portname, baudrate);
+    logtorust(format!(
+        "opencom portname:{} baudrate:{}",
+        portname, baudrate
+    ));
+    tryuseport()
+}
+#[tauri::command]
+pub fn clearportbuff() -> String {
+    clearserilport()
+}
+
+#[tauri::command]
+pub fn setport(data: serde_json::Value) -> String {
+    //判断是否存在portname和baudrate
+    if !data.is_object() {
+        return String::from("Invalid data");
+    }
+    if !data["portname"].is_string() || !data["baudrate"].is_u64() {
+        return String::from("Invalid data");
+    }
+    let portname = data["portname"].as_str().unwrap();
+    let baudrate = data["baudrate"].as_u64().unwrap() as u32;
+    set_port_info(&portname.to_string(), baudrate);
+    //println!("{}",readdatafromport(1000));
+    String::from("Port set ok")
+}
+#[tauri::command]
+pub fn closecome() -> String {
+    closeport()
+}
--- a/src-tauri/src/irishypersptral/mod.rs
+++ b/src-tauri/src/irishypersptral/mod.rs
@ -0,0 +1,376 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+use core::str;
+use std::fs;
+use std::fs::File;
+use std::io::{self, Read, Write};
+// use std::sync::WaitTimeoutResult;
+use std::path::Path;
+use super::algorithm::interpolate_spline;
+use super::algorithm::sg_smooth;
+use std::mem;
+
+use super::mylog::*;
+use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
+use super::serport::serport::*;
+use super::mydefine::*;
+
+
+
+pub fn savecalibratefile_iris(gain: Vec<f32>, shutter: u32, direction: bool, filepath: String) -> String {
+    let mut data = IS11DataStruct::default();
+    data.data = gain.as_slice().try_into().unwrap();
+    data.shutter_time = shutter as u32;
+    data.direction = if direction { 1 } else { 0 };
+    data.datatype = 0x04;
+    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];
+
+    // 序列化为二进制数据
+    unsafe {
+        let ptr = &data as *const IS11DataStruct as *const u8;
+        std::ptr::copy_nonoverlapping(ptr, buffer.as_mut_ptr(), mem::size_of::<IS11DataStruct>());
+    }
+    // 序列化为二进制数据
+    let file_path = Path::new(&filepath);
+
+    // 获取文件路径的父目录
+    if let Some(parent) = file_path.parent() {
+        // 确保父目录存在
+        if !parent.exists() {
+            fs::create_dir_all(parent).unwrap();
+            println!("父目录已创建: {:?}", parent);
+        } else {
+            println!("父目录已存在: {:?}", parent);
+        }
+    } else {
+        println!("文件路径没有父目录");
+    }
+    let mut file = File::create(filepath).unwrap();
+    file.write_all(&buffer).unwrap();
+
+    "OK".to_string()
+}
+
+
+
+pub fn sendcalibratetodev_iris(gain: Vec<f32>, shutter: u32, direction: bool) -> String {
+    let mut data = IS11DataStruct::default();
+    data.data = gain.as_slice().try_into().unwrap();
+    data.shutter_time = shutter as u32;
+    data.direction = if direction { 1 } else { 0 };
+    data.datatype = 0x04;
+    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];
+    // 序列化为二进制数据
+    unsafe {
+        let ptr = &data as *const IS11DataStruct as *const u8;
+        std::ptr::copy_nonoverlapping(ptr, buffer.as_mut_ptr(), mem::size_of::<IS11DataStruct>());
+    }
+    sendtoportbinary_iris(buffer, 0x03);
+    "OK".to_string()
+}
+
+pub fn sendtoportbinary_iris(data: Vec<u8>, command: u8) -> String {
+    let lenth = data.len() as u16;
+    let high: u8 = (lenth >> 8) as u8;
+    let low: u8 = (lenth & 0xFF) as u8;
+    let mut header = vec![];
+    header.push(0x55);
+    header.push(0xAA);
+    let mut crcbody = vec![];
+    // crcbody.push(high);
+    // crcbody.push(low);
+    crcbody.extend(data);
+    let crc = iris_calc_crc(&crcbody);
+    let crchigh: u8 = (crc >> 8) as u8;
+    let crclow: u8 = (crc & 0xFF) as u8;
+    let mut senddata = vec![];
+    senddata.extend(header);
+    senddata.push(command);
+    senddata.push(high);
+    senddata.push(low);
+    senddata.extend(crcbody);
+    senddata.push(crchigh);
+    senddata.push(crclow);
+
+    //  println!("sendtoport data:{}",senddata.len());
+    println!(
+        "sendtoport data content:{:X?}",
+        senddata
+            .iter()
+            .map(|&byte| format!("{:02X}", byte))
+            .collect::<Vec<String>>()
+            .join(" ")
+    );
+    sendtoprot(senddata);
+    "send ok".to_string()
+}
+
+// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
+
+pub fn greet_iris(name: &str) -> String {
+    format!("Hello, {}! You've been greeted from Rust!", name)
+}
+
+pub fn getportnames_iris() -> Vec<String> {
+    get_port_name()
+}
+
+
+pub fn opencom_iris(portname: serde_json::Value, baudrate: serde_json::Value) -> String {
+    //tauri
+    let portname = portname.as_str().unwrap();
+    let baudrate = baudrate.as_u64().unwrap() as u32;
+    set_port_info(&portname.to_string(), baudrate);
+
+    println!("opencom portname:{} baudrate:{}", portname, baudrate);
+    logtorust(format!(
+        "opencom portname:{} baudrate:{}",
+        portname, baudrate
+    ));
+    tryuseport()
+}
+
+pub fn closecome_iris() -> String {
+    closeport()
+}
+
+pub fn sendtoport_iris(data: serde_json::Value, datatype: serde_json::Value) -> String {
+    // println!("sendtoport data:{}",data.to_string());
+    //判断是否存在data
+    // if !data.is_object() {
+    //     return String::from("Invalid data");
+    // }
+    println!("sendtoport data:{}", data.to_string());
+    logtorust(format!("sendtoport data:{}", data.to_string()));
+    let data = data.to_string().as_bytes().to_vec();
+    let lenth = data.len() as u16;
+    let high: u8 = (lenth >> 8) as u8;
+    let low: u8 = (lenth & 0xFF) as u8;
+    let mut header = vec![];
+    header.push(0x55);
+    header.push(0xAA);
+    let mut command: u8 = 0;
+    let datatype = datatype.as_str().unwrap();
+    println!("datatype:{}", datatype);
+    if datatype == "hex" {
+        command = 0x03;
+    }
+    if datatype == "string" {
+        command = 0x01;
+    }
+    if datatype == "json" {
+        command = 0x00;
+    }
+    let mut crcbody = vec![];
+    // crcbody.push(high);
+    // crcbody.push(low);
+    crcbody.extend(data);
+    let crc = iris_calc_crc(&crcbody);
+    let crchigh: u8 = (crc >> 8) as u8;
+    let crclow: u8 = (crc & 0xFF) as u8;
+    let mut senddata = vec![];
+    senddata.extend(header);
+    senddata.push(command);
+    senddata.push(high);
+    senddata.push(low);
+    senddata.extend(crcbody);
+    senddata.push(crchigh);
+    senddata.push(crclow);
+
+    //  println!("sendtoport data:{}",senddata.len());
+    // println!(
+    //     "sendtoport data content:{:X?}",
+    //     senddata
+    //         .iter()
+    //         .map(|&byte| format!("{:02X}", byte))
+    //         .collect::<Vec<String>>()
+    //         .join(" ")
+    // );
+    logtorust(format!(
+        "sendtoport data content:{:X?}",
+        senddata
+            .iter()
+            .map(|&byte| format!("{:02X}", byte))
+            .collect::<Vec<String>>()
+            .join(" ")
+    ));
+
+    sendtoprot(senddata);
+    "send ok".to_string()
+}
+
+
+pub fn readformport_iris(commanid: serde_json::Value, wait_time_json: serde_json::Value) -> String {
+    let mut waittime = 50;
+    if wait_time_json.is_u64() {
+        waittime = wait_time_json.as_u64().unwrap() as u32;
+    }
+
+    let commanid = commanid.as_u64().unwrap() as u8;
+    let ret = readdatafromport(waittime as u64, commanid);
+    let str = String::from_utf8_lossy(&ret);
+    println!("read data: {}", str);
+    return str.to_string();
+}
+
+
+pub fn sendtoport_andgetreturn_iris(
+    data: serde_json::Value,
+    datatype: serde_json::Value,
+) -> Result<RetStruct, String> {
+    // println!("sendtoport data:{}",data.to_string());
+    //判断是否存在data
+    // if !data.is_object() {
+    //     return String::from("Invalid data");
+    // }
+
+    //println!("sendtoport data:{}", data.to_string());
+
+    let command = data.get("command").unwrap().to_string();
+    let mut isneedlog = true;
+    let mut isgetdata = false;
+    if command == "\"get_caiji_state\"" {
+        isneedlog = false;
+    }
+if command == "\"get_data\"" {
+    isgetdata = true;
+    
+}
+
+    if isneedlog {
+        logtorust(format!("sendtoport data:{}", data.to_string()));
+    }
+
+    let data = data.to_string().as_bytes().to_vec();
+    let lenth = data.len() as u16;
+    let high: u8 = (lenth >> 8) as u8;
+    let low: u8 = (lenth & 0xFF) as u8;
+    let mut header = vec![];
+    header.push(0x55);
+    header.push(0xAA);
+    let mut command: u8 = 0;
+    let datatype = datatype.as_str().unwrap();
+    println!("datatype:{}", datatype);
+    if datatype == "hex" {
+        command = 0x03;
+    }
+    if datatype == "string" {
+        command = 0x01;
+    }
+    if datatype == "json" {
+        command = 0x00;
+    }
+    let mut crcbody = vec![];
+    // crcbody.push(high);
+    // crcbody.push(low);
+    crcbody.extend(data);
+    let crc = iris_calc_crc(&crcbody);
+    let crchigh: u8 = (crc >> 8) as u8;
+    let crclow: u8 = (crc & 0xFF) as u8;
+    let mut senddata = vec![];
+    senddata.extend(header);
+    senddata.push(command);
+    senddata.push(high);
+    senddata.push(low);
+    senddata.extend(crcbody);
+    senddata.push(crchigh);
+    senddata.push(crclow);
+
+    println!("sendtoport data:{}", senddata.len());
+    // println!(
+    //     "sendtoport data content:{:X?}",
+    //     senddata
+    //         .iter()
+    //         .map(|&byte| format!("{:02X}", byte))
+    //         .collect::<Vec<String>>()
+    //         .join(" ")
+    // );
+    if isneedlog {
+        logtorust(format!(
+            "sendtoport data content:{:X?}",
+            senddata
+                .iter()
+                .map(|&byte| format!("{:02X}", byte))
+                .collect::<Vec<String>>()
+                .join(" ")
+        ));
+    }
+
+    sendtoprot(senddata);
+    let mut ret = readdatafromport(50, 0xff);
+    let datatype = ret[0];
+  
+    if isneedlog {
+        if !isgetdata{
+        logtorust(format!(
+            "read content: {:X?}",
+            ret.iter()
+                .map(|&byte| format!("{:02X}", byte))
+                .collect::<Vec<String>>()
+                .join(" ")
+        ));
+        }
+    }
+    if isgetdata{
+        logtorust("Get data Back SUCCESS".to_string());
+        logtorust("_____________________________one_data_over_____________________________\n".to_string());
+    }
+
+
+    ret.remove(0);
+    ret.remove(0);
+    ret.remove(0);
+    if datatype == 0x02 {
+        let mut is11data = IS11DataStruct::default();
+        unsafe {
+            let mut is11data_ptr = &mut is11data as *mut IS11DataStruct;
+            let mut ret_ptr = &mut ret[0] as *mut u8;
+            std::ptr::copy_nonoverlapping(
+                ret_ptr,
+                is11data_ptr as *mut u8,
+                std::mem::size_of::<IS11DataStruct>(),
+            );
+            return Ok(RetStruct {
+                datatype: datatype,
+                content: "null".to_string(),
+                data: is11data,
+            });
+        }
+    }
+
+    let str = String::from_utf8_lossy(&ret);
+    // println!("read data: {}", str);
+    if datatype==0x00 &&isneedlog {
+        logtorust(format![
+            "read string: {}",
+            str.to_string()
+        ]);
+        
+    }
+    return Ok(RetStruct {
+        datatype: datatype,
+        content: str.to_string(),
+        data: IS11DataStruct::default(),
+    });
+
+    //    return str.to_string();
+}
+
+pub fn clearportbuff_iris() -> String {
+    clearserilport()
+}
+
+pub fn setport_iris(data: serde_json::Value) -> String {
+    //判断是否存在portname和baudrate
+    if !data.is_object() {
+        return String::from("Invalid data");
+    }
+    if !data["portname"].is_string() || !data["baudrate"].is_u64() {
+        return String::from("Invalid data");
+    }
+    let portname = data["portname"].as_str().unwrap();
+    let baudrate = data["baudrate"].as_u64().unwrap() as u32;
+    set_port_info(&portname.to_string(), baudrate);
+    //println!("{}",readdatafromport(1000));
+    String::from("Port set ok")
+}
--- a/src-tauri/src/jianzhiis11/is11base.rs
+++ b/src-tauri/src/jianzhiis11/is11base.rs
@ -0,0 +1,101 @@
+use libc::{c_uchar,c_char,c_long,c_float, size_t};
+use std::ffi::CStr;
+use std::slice;
+
+use super::super::serport::serport::*;
+#[repr(C)]
+pub struct STRSensorInfo {
+ pub   SensorName: [c_char; 100],
+ pub  maxValue: c_long,
+ pub   BandNum: c_long,
+ pub   serialnumber: [c_char; 100],
+ pub  a1: c_float,
+ pub a2: c_float,
+ pub  a3: c_float,
+ pub  a4: c_float,
+ pub  issensorinit: c_uchar,
+}
+
+impl Default for STRSensorInfo {
+    fn default() -> Self {
+        STRSensorInfo {
+            SensorName: [0; 100],
+            maxValue: 0,
+            BandNum: 0,
+            serialnumber: [0; 100],
+            a1: 0.0,
+            a2: 0.0,
+            a3: 0.0,
+            a4: 0.0,
+            issensorinit: 0,
+        }
+    }
+    
+}
+
+
+type SerialWrite = Option<unsafe extern "C" fn(data: *mut c_uchar, length: size_t) -> size_t>;
+#[link(name = "D:/06Learn/rust/tarui/myis11/project/is11/cmake-build-release-visual-studio-2022/is11lib",kind = "dylib")]
+extern "C" {
+    fn Set_Serial_FUN(writefunc:SerialWrite,readfunc:SerialWrite);
+    fn abs1(input: i32) -> i32;
+    fn test();
+    fn IS11SensorInit() -> i32;
+    fn Get_SensorInfo() -> STRSensorInfo;
+    fn IS11OptSnenser(percent:i32) -> i32;
+    fn IS11GetData(outdata: *mut u16, shuttertime: i32) -> i32;
+
+}
+
+unsafe extern "C" fn serialsenddata(data: *mut c_uchar, length: size_t) -> size_t {
+    // 处理数据
+    let data_slice = slice::from_raw_parts(data, length as usize).to_vec();
+    // data_slice转换为Vec<u8>
+
+    // 打印数据
+    // for byte in data_slice.clone() {
+    //     print!("{:02X} ", byte);
+    // }
+    // println!();
+    sendtoprot(data_slice);
+    length
+}
+use core::ptr;
+unsafe extern "C" fn serialreaddate(data: *mut c_uchar, length: size_t) -> size_t {
+
+    let  dataout=readforport();
+    let length1: usize = dataout.len();
+    // 将结果复制给c_uchar
+    // for byte in dataout.clone() {
+    //     print!("{:02X} ", byte);
+    // }
+    // println!();
+    
+    ptr::copy_nonoverlapping(dataout.as_ptr(), data, length1);
+   // println!("{:?}",data);
+    length1
+}
+
+pub fn is11_init() -> i32 {
+    unsafe {
+        Set_Serial_FUN(Some(serialsenddata), Some(serialreaddate));
+        IS11SensorInit()
+    }
+}
+
+pub fn is11_get_sensor_info() -> STRSensorInfo {
+    unsafe { Get_SensorInfo() }
+}
+
+pub fn _is11_opt_snenser(percent: i32) -> i32 {
+    unsafe { IS11OptSnenser(percent) }
+}
+
+pub fn is11_get_data(shuttertime: i32) -> Vec<u16> {
+    let mut outdata: Vec<u16> = vec![0; 2048];
+    unsafe {
+        let len = IS11GetData(outdata.as_mut_ptr(), shuttertime);
+        outdata.truncate(len as usize);
+    }
+    outdata
+}
--- a/src-tauri/src/jianzhiis11/is11server.rs
+++ b/src-tauri/src/jianzhiis11/is11server.rs
@ -0,0 +1,233 @@
+use super::is11base;
+use super::super::mydefine::*;
+use lazy_static::lazy_static;
+use chrono::{self, Datelike, Timelike};
+use std::thread;
+#[derive(PartialEq)]
+enum WorkStat {
+    IDLE,
+    WOKING,
+    STOP,
+    OPTING,
+    
+}
+
+use std::{
+    sync::{Arc, Mutex}, 
+};
+struct is11_dev_data {
+    sensor_info: is11base::STRSensorInfo,
+    shuttertime: i32,
+    stat: WorkStat,
+    workname: String,
+    
+}
+
+lazy_static! {
+    static ref DEV_STAT: Arc<Mutex<is11_dev_data>> = Arc::new(Mutex::new(is11_dev_data {
+        sensor_info: is11base::STRSensorInfo::default(),
+        shuttertime: 0,
+        stat: WorkStat::IDLE,
+        workname: "noting".to_string(),
+    }));
+}
+
+// lazy_static! {
+//     static ref DATA: Arc<Mutex<Vec<u16>>> = Arc::new(Mutex::new(Vec::new()));
+// }
+
+lazy_static! {
+    static ref DATA_IS11: Arc<Mutex<IS11DataStruct>> = Arc::new(Mutex::new(IS11DataStruct::default()));
+    static ref DARK_DATA: Arc<Mutex<IS11DataStruct>> = Arc::new(Mutex::new(IS11DataStruct::default()));
+    static ref FLAT_DATA: Arc<Mutex<IS11DataStruct>> = Arc::new(Mutex::new(IS11DataStruct::default()));
+}
+
+
+
+
+
+
+
+pub fn get_shuttertime() -> i32 {
+    let dev_stat=DEV_STAT.lock().unwrap();
+    return dev_stat.shuttertime;
+}
+
+
+pub fn opt_sensor(percent: i32) -> i32 {
+
+    
+
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    if dev_stat.stat != WorkStat::IDLE {
+        return -1;
+    }
+
+    dev_stat.stat=WorkStat::OPTING;
+    dev_stat.workname="opting".to_string();
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+
+      let shuttertime=  is11base::_is11_opt_snenser(90); //多线程设置曝光时间
+        let mut dev_statnow=DEV_STAT.lock().unwrap();
+        dev_statnow.stat=WorkStat::IDLE;
+        dev_statnow.shuttertime=shuttertime; 
+        dev_statnow.workname="finish".to_string();
+       }
+    );
+
+    
+    return 0;
+
+
+
+}
+
+pub fn get_now_stat()->(String,String){
+
+
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    match dev_stat.stat {
+        WorkStat::IDLE => {
+            return ("finish".to_string(),dev_stat.workname.clone());
+        },
+        WorkStat::WOKING => {
+            return ("working".to_string(),dev_stat.workname.clone());
+        },
+        WorkStat::STOP => {
+            return ("finish".to_string(),dev_stat.workname.clone());
+        },
+        WorkStat::OPTING => {
+            return ("opting".to_string(),dev_stat.workname.clone());
+        },
+        
+    }
+
+
+}
+
+pub fn collect(shuttertime:u32){
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    if dev_stat.stat != WorkStat::IDLE {
+        return ;
+    }
+    dev_stat.stat=WorkStat::WOKING;
+    dev_stat.workname="采集中".to_string();
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+
+        let data=is11base::is11_get_data(shuttertime as i32);
+        let mut dev_stat=DEV_STAT.lock().unwrap();
+        let _lenth=data.len();
+        println!("data len={}",_lenth);
+        let mut tempis11data=IS11DataStruct::default();
+       for i in 0.._lenth {
+            tempis11data.data[i]=data[i] as f32;
+        }
+        // 获取当前时间
+        let now = chrono::Local::now();
+        tempis11data.year=(now.year()-2000) as u8;
+        tempis11data.month=now.month() as u8;
+        tempis11data.day=now.day() as u8;
+        tempis11data.hour=now.hour() as u8;
+        tempis11data.minute=now.minute() as u8;
+        tempis11data.second=now.second() as u8;
+        tempis11data.shutter_time=shuttertime;
+        tempis11data.index=0;
+        tempis11data.datatype=0;
+
+        let mut data1=DATA_IS11.lock().unwrap();
+        *data1=tempis11data;
+        dev_stat.stat=WorkStat::IDLE;
+        dev_stat.workname="finish".to_string();
+    });
+
+
+
+
+  
+}
+
+pub fn collcect_dark(shuttertime:u32)
+{
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    if dev_stat.stat != WorkStat::IDLE {
+        return ;
+    }
+    dev_stat.stat=WorkStat::WOKING;
+    dev_stat.workname="采集中".to_string();
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+
+        let data=is11base::is11_get_data(shuttertime as i32);
+        let mut dev_stat=DEV_STAT.lock().unwrap();
+        let _lenth=data.len();
+        println!("data len={}",_lenth);
+        let mut tempis11data=IS11DataStruct::default();
+       for i in 0.._lenth {
+            tempis11data.data[i]=data[i] as f32;
+        }
+        //获取当前时间
+        let now = chrono::Local::now();
+        tempis11data.year=(now.year()-2000) as u8;
+        tempis11data.month=now.month() as u8;
+        tempis11data.day=now.day() as u8;
+        tempis11data.hour=now.hour() as u8;
+        tempis11data.minute=now.minute() as u8;
+        tempis11data.second=now.second() as u8;
+        tempis11data.shutter_time=shuttertime;
+        tempis11data.index=0;
+        tempis11data.datatype=0;
+
+        let mut data1=DARK_DATA.lock().unwrap();
+        *data1=tempis11data;
+        dev_stat.stat=WorkStat::IDLE;
+        dev_stat.workname="finish".to_string();
+    });
+
+
+}
+
+pub fn collcect_flat(shuttertime:u32)
+{
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    if dev_stat.stat != WorkStat::IDLE {
+        return ;
+    }
+    dev_stat.stat=WorkStat::WOKING;
+    dev_stat.workname="采集中".to_string();
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+
+        let data=is11base::is11_get_data(shuttertime as i32);
+        let mut dev_stat=DEV_STAT.lock().unwrap();
+        let _lenth=data.len();
+        println!("data len={}",_lenth);
+        let mut tempis11data=IS11DataStruct::default();
+       for i in 0.._lenth {
+            tempis11data.data[i]=data[i] as f32;
+        }
+        //获取当前时间
+        let now = chrono::Local::now();
+        tempis11data.year=(now.year()-2000) as u8;
+        tempis11data.month=now.month() as u8;
+        tempis11data.day=now.day() as u8;
+        tempis11data.hour=now.hour() as u8;
+        tempis11data.minute=now.minute() as u8;
+        tempis11data.second=now.second() as u8;
+        tempis11data.shutter_time=shuttertime;
+        tempis11data.index=0;
+        tempis11data.datatype=0;
+
+        let mut data1=FLAT_DATA.lock().unwrap();
+        *data1=tempis11data;
+        dev_stat.stat=WorkStat::IDLE;
+        dev_stat.workname="finish".to_string();
+    });
+}
+
+
+pub fn get_data()->IS11DataStruct{
+    let data1=DATA_IS11.lock().unwrap();
+    return data1.clone();
+}
--- a/src-tauri/src/jianzhiis11/mod.rs
+++ b/src-tauri/src/jianzhiis11/mod.rs
@ -0,0 +1,169 @@
+use super::mydefine::*;
+pub mod is11server;
+pub mod is11base;
+use serde_json::json;
+use std::ffi::CStr;
+use super::mylog::*;
+
+
+
+
+
+
+pub fn sendtoport_andgetreturn(
+    data: serde_json::Value,
+    datatype: serde_json::Value,
+) -> Result<RetStruct, String> {
+
+    let command = data.get("command").unwrap().to_string();
+
+    match command.as_str() {
+        "\"get_sensor_info\"" => {
+            is11base::is11_init();
+            logtorust("init is11 ok".to_string());
+            let sensor_info = is11base::is11_get_sensor_info();
+            let sensor_name_cstr = unsafe { CStr::from_ptr(sensor_info.SensorName.as_ptr()) };
+            let sensor_name = sensor_name_cstr.to_str().unwrap();
+            let serilnumber_cstr = unsafe { CStr::from_ptr(sensor_info.serialnumber.as_ptr()) };
+            let serilnumber = serilnumber_cstr.to_str().unwrap();
+            //定义一个json对象
+            let jsonforret= json!({
+                "bochangxishu":{
+                    "a0":sensor_info.a1,
+                    "a1":sensor_info.a2,
+                    "a2":sensor_info.a3,
+                    "a3":sensor_info.a4,
+                },
+                "serialnumber":serilnumber,
+                "name":sensor_name,
+                "version":"1.0.0",
+                "return_data_type":0,
+                "work_mode":"advanced_mode",
+
+            });
+            logtorust(format!("get_sensor_info:{}",jsonforret.to_string()));
+            return Ok(RetStruct {
+                datatype: 0,
+                content: jsonforret.to_string(),
+                data:IS11DataStruct::default() ,
+            });
+        }
+        "\"start_opt\"" => {
+            is11server::opt_sensor(90);
+            let jsonforret= json!({
+                "command":"start_opt"
+
+            });
+            return Ok(RetStruct {
+                datatype: 0,
+                content: jsonforret.to_string(),
+                data: IS11DataStruct::default(),
+            });
+    
+           
+        }
+        "\"get_opt\"" => {
+            println!("get_opt");
+            let ret=get_opt_result();
+            return ret;
+
+        }
+        "\"start_collect\"" => {
+           return start_collect(data,datatype);
+
+        }
+       
+        "\"get_caiji_state\"" =>{
+            let (caiji_state,caiji_state_str)=is11server::get_now_stat();
+            let jsonforret= json!({
+                "caiji_state":caiji_state,
+                "info":caiji_state_str,
+                "return_data_type":0,
+            });
+            logtorust(format!("get_caiji_state:{}",jsonforret.to_string()));
+            return Ok(RetStruct {
+                datatype: 0,
+                content: jsonforret.to_string(),
+                data:IS11DataStruct::default() ,
+            });
+
+        }
+        "\"get_data\""=>{
+            return get_data(data,datatype);
+        }
+        _ => {
+            return Err("command not found ".to_string()+"command is:"+&command);
+        }
+    }
+
+
+
+
+
+
+
+    return Ok(RetStruct {
+        datatype: 0,
+        content: "指令未实现".to_string(),
+        data: IS11DataStruct::default(),
+    });
+    
+   
+}
+
+
+pub fn get_opt_result() -> Result<RetStruct, String> {
+
+
+    let shuttertime = is11server::get_shuttertime();
+
+    let jsonret = json!({
+        "opt":shuttertime,
+
+    });
+    return Ok(RetStruct {
+        datatype: 0,
+        content: jsonret.to_string(),
+        data: IS11DataStruct::default(),
+    });
+
+}
+
+pub fn start_collect(    data: serde_json::Value,
+    datatype: serde_json::Value) -> Result<RetStruct, String> {
+        let shuttertime = data.get("shutter_time").unwrap().as_u64().unwrap() as u32;
+    logtorust(format!("start_collect,shutter time is:{}",shuttertime));
+
+    is11server::collect(shuttertime);
+    let jsonret = json!({
+        "command":"start_collect"
+
+    });
+    return Ok(RetStruct {
+        datatype: 0,
+        content: jsonret.to_string(),
+        data: IS11DataStruct::default(),
+    });
+
+}
+
+
+pub fn get_data(    data: serde_json::Value,
+    datatype: serde_json::Value) -> Result<RetStruct, String> {
+
+    let is11_data=is11server::get_data()    ;
+      
+
+
+    let jsonret = json!({
+        "command":"get_data"
+
+    });
+
+
+    return Ok(RetStruct {
+        datatype: 2,
+        content:jsonret.to_string(),
+        data: is11_data,
+    });
+        }
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@ -1,418 +1,59 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
-use core::str;
-use serialport::new;
-use std::ffi::c_float;
-use std::fmt::format;
-use std::fs;
-use std::fs::File;
-use std::io::{self, Read, Write};
-// use std::sync::WaitTimeoutResult;
-use std::path::Path;
+
 mod algorithm;
 mod mylog;
 mod serport;
+mod irishypersptral;
+mod mydefine;
+mod comman;
+mod jianzhiis11;
+use comman::*;
 use algorithm::interpolate_spline;
 use algorithm::sg_smooth;
-use std::mem;
+use mydefine::*;

-use mylog::*;
-use serde::{Deserialize, Serialize};
-use serde_with::serde_as;
-use serport::serport::*;

-#[derive(Serialize, Deserialize)]
-struct RetStruct {
-    datatype: u8,
-    content: String,
-    data: IS11DataStruct,
-}
-#[serde_as]
-#[derive(Serialize, Deserialize)]
-#[repr(C)]
-struct IS11DataStruct {
-    datatype: u8, // Using r# to allow the use of the keyword 'type'
-    direction: u8,
-    tuigan_stat: u8,
-    shutter_time: u32,
-    index: u64,
-    temprature: [f32; 8],
-    #[serde_as(as = "[_; 2048]")]
-    data: [f32; 2048],
-}
-impl Default for IS11DataStruct {
-    fn default() -> Self {
-        IS11DataStruct {
-            datatype: 0,
-            direction: 10,
-            tuigan_stat: 0,
-            shutter_time: 0,
-            index: 0,
-            temprature: [0.0; 8],
-            data: [0.0; 2048],
-        }
-    }
+
+
+
+
+#[tauri::command]
+fn savecalibratefile(gain: Vec<f32>, shutter: u32, direction: bool, filepath: String) -> String {
+    irishypersptral::savecalibratefile_iris(gain, shutter, direction, filepath)
 }

 #[tauri::command]
-fn savecalibratefile(Gain: Vec<f32>, shutter: u32, direction: bool, filepath: String) -> String {
-    let mut data = IS11DataStruct::default();
-    data.data = Gain.as_slice().try_into().unwrap();
-    data.shutter_time = shutter as u32;
-    data.direction = if direction { 1 } else { 0 };
-    data.datatype = 0x04;
-    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];
-
-    // 序列化为二进制数据
-    unsafe {
-        let ptr = &data as *const IS11DataStruct as *const u8;
-        std::ptr::copy_nonoverlapping(ptr, buffer.as_mut_ptr(), mem::size_of::<IS11DataStruct>());
-    }
-    // 序列化为二进制数据
-    let file_path = Path::new(&filepath);
-
-    // 获取文件路径的父目录
-    if let Some(parent) = file_path.parent() {
-        // 确保父目录存在
-        if !parent.exists() {
-            fs::create_dir_all(parent).unwrap();
-            println!("父目录已创建: {:?}", parent);
-        } else {
-            println!("父目录已存在: {:?}", parent);
-        }
-    } else {
-        println!("文件路径没有父目录");
-    }
-    let mut file = File::create(filepath).unwrap();
-    file.write_all(&buffer).unwrap();
-
-    "OK".to_string()
-}
-
-#[tauri::command]
-fn sendcalibratetodev(Gain: Vec<f32>, shutter: u32, direction: bool) -> String {
-    let mut data = IS11DataStruct::default();
-    data.data = Gain.as_slice().try_into().unwrap();
-    data.shutter_time = shutter as u32;
-    data.direction = if direction { 1 } else { 0 };
-    data.datatype = 0x04;
-    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];
-    // 序列化为二进制数据
-    unsafe {
-        let ptr = &data as *const IS11DataStruct as *const u8;
-        std::ptr::copy_nonoverlapping(ptr, buffer.as_mut_ptr(), mem::size_of::<IS11DataStruct>());
-    }
-    sendtoportbinary(buffer, 0x03);
-    "OK".to_string()
-}
-
-fn sendtoportbinary(data: Vec<u8>, command: u8) -> String {
-    let lenth = data.len() as u16;
-    let high: u8 = (lenth >> 8) as u8;
-    let low: u8 = (lenth & 0xFF) as u8;
-    let mut header = vec![];
-    header.push(0x55);
-    header.push(0xAA);
-    let mut crcbody = vec![];
-    // crcbody.push(high);
-    // crcbody.push(low);
-    crcbody.extend(data);
-    let crc = iris_calc_crc(&crcbody);
-    let crchigh: u8 = (crc >> 8) as u8;
-    let crclow: u8 = (crc & 0xFF) as u8;
-    let mut senddata = vec![];
-    senddata.extend(header);
-    senddata.push(command);
-    senddata.push(high);
-    senddata.push(low);
-    senddata.extend(crcbody);
-    senddata.push(crchigh);
-    senddata.push(crclow);
-
-    //  println!("sendtoport data:{}",senddata.len());
-    println!(
-        "sendtoport data content:{:X?}",
-        senddata
-            .iter()
-            .map(|&byte| format!("{:02X}", byte))
-            .collect::<Vec<String>>()
-            .join(" ")
-    );
-    sendtoprot(senddata);
-    "send ok".to_string()
-}
-
-// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
-#[tauri::command]
-fn greet(name: &str) -> String {
-    format!("Hello, {}! You've been greeted from Rust!", name)
-}
-
-#[tauri::command]
-fn getportnames() -> Vec<String> {
-    get_port_name()
-}
-
-#[tauri::command]
-fn opencom(portname: serde_json::Value, baudrate: serde_json::Value) -> String {
-    //tauri
-    let portname = portname.as_str().unwrap();
-    let baudrate = baudrate.as_u64().unwrap() as u32;
-    set_port_info(&portname.to_string(), baudrate);
-
-    println!("opencom portname:{} baudrate:{}", portname, baudrate);
-    logtorust(format!(
-        "opencom portname:{} baudrate:{}",
-        portname, baudrate
-    ));
-    tryuseport()
+fn sendcalibratetodev(gain: Vec<f32>, shutter: u32, direction: bool) -> String {
+    irishypersptral::sendcalibratetodev_iris(gain, shutter, direction)
 }
 #[tauri::command]
-fn closecome() -> String {
-    closeport()
+fn __sendto_portbinary(data: Vec<u8>, command: u8) -> String {
+    irishypersptral::sendtoportbinary_iris(data, command)
 }
+
 #[tauri::command]
 fn sendtoport(data: serde_json::Value, datatype: serde_json::Value) -> String {
-    // println!("sendtoport data:{}",data.to_string());
-    //判断是否存在data
-    // if !data.is_object() {
-    //     return String::from("Invalid data");
-    // }
-    println!("sendtoport data:{}", data.to_string());
-    logtorust(format!("sendtoport data:{}", data.to_string()));
-    let data = data.to_string().as_bytes().to_vec();
-    let lenth = data.len() as u16;
-    let high: u8 = (lenth >> 8) as u8;
-    let low: u8 = (lenth & 0xFF) as u8;
-    let mut header = vec![];
-    header.push(0x55);
-    header.push(0xAA);
-    let mut command: u8 = 0;
-    let datatype = datatype.as_str().unwrap();
-    println!("datatype:{}", datatype);
-    if datatype == "hex" {
-        command = 0x03;
-    }
-    if datatype == "string" {
-        command = 0x01;
-    }
-    if datatype == "json" {
-        command = 0x00;
-    }
-    let mut crcbody = vec![];
-    // crcbody.push(high);
-    // crcbody.push(low);
-    crcbody.extend(data);
-    let crc = iris_calc_crc(&crcbody);
-    let crchigh: u8 = (crc >> 8) as u8;
-    let crclow: u8 = (crc & 0xFF) as u8;
-    let mut senddata = vec![];
-    senddata.extend(header);
-    senddata.push(command);
-    senddata.push(high);
-    senddata.push(low);
-    senddata.extend(crcbody);
-    senddata.push(crchigh);
-    senddata.push(crclow);
-
-    //  println!("sendtoport data:{}",senddata.len());
-    // println!(
-    //     "sendtoport data content:{:X?}",
-    //     senddata
-    //         .iter()
-    //         .map(|&byte| format!("{:02X}", byte))
-    //         .collect::<Vec<String>>()
-    //         .join(" ")
-    // );
-    logtorust(format!(
-        "sendtoport data content:{:X?}",
-        senddata
-            .iter()
-            .map(|&byte| format!("{:02X}", byte))
-            .collect::<Vec<String>>()
-            .join(" ")
-    ));
-
-    sendtoprot(senddata);
-    "send ok".to_string()
+   irishypersptral::sendtoport_iris(data, datatype)
 }

 #[tauri::command]
 fn readformport(commanid: serde_json::Value, wait_time_json: serde_json::Value) -> String {
-    let mut waittime = 50;
-    if wait_time_json.is_u64() {
-        waittime = wait_time_json.as_u64().unwrap() as u32;
-    }
-
-    let commanid = commanid.as_u64().unwrap() as u8;
-    let ret = readdatafromport(waittime as u64, commanid);
-    let str = String::from_utf8_lossy(&ret);
-    println!("read data: {}", str);
-    return str.to_string();
+  irishypersptral::readformport_iris(commanid, wait_time_json)
 }

 #[tauri::command]
-fn sendtoportAndgetreturn(
+fn sendtoport_andgetreturn(
    data: serde_json::Value,
    datatype: serde_json::Value,
 ) -> Result<RetStruct, String> {
-    // println!("sendtoport data:{}",data.to_string());
-    //判断是否存在data
-    // if !data.is_object() {
-    //     return String::from("Invalid data");
-    // }
-
-    //println!("sendtoport data:{}", data.to_string());
-
-    let command = data.get("command").unwrap().to_string();
-    let mut isneedlog = true;
-    let mut isgetdata = false;
-    if command == "\"get_caiji_state\"" {
-        isneedlog = false;
-    }
-if command == "\"get_data\"" {
-    isgetdata = true;
-    
+    //irishypersptral::sendtoport_andgetreturn_iris(data, datatype)
+    jianzhiis11::sendtoport_andgetreturn(data, datatype)
+   
 }

-    if isneedlog {
-        logtorust(format!("sendtoport data:{}", data.to_string()));
-    }
-
-    let data = data.to_string().as_bytes().to_vec();
-    let lenth = data.len() as u16;
-    let high: u8 = (lenth >> 8) as u8;
-    let low: u8 = (lenth & 0xFF) as u8;
-    let mut header = vec![];
-    header.push(0x55);
-    header.push(0xAA);
-    let mut command: u8 = 0;
-    let datatype = datatype.as_str().unwrap();
-    println!("datatype:{}", datatype);
-    if datatype == "hex" {
-        command = 0x03;
-    }
-    if datatype == "string" {
-        command = 0x01;
-    }
-    if datatype == "json" {
-        command = 0x00;
-    }
-    let mut crcbody = vec![];
-    // crcbody.push(high);
-    // crcbody.push(low);
-    crcbody.extend(data);
-    let crc = iris_calc_crc(&crcbody);
-    let crchigh: u8 = (crc >> 8) as u8;
-    let crclow: u8 = (crc & 0xFF) as u8;
-    let mut senddata = vec![];
-    senddata.extend(header);
-    senddata.push(command);
-    senddata.push(high);
-    senddata.push(low);
-    senddata.extend(crcbody);
-    senddata.push(crchigh);
-    senddata.push(crclow);
-
-    println!("sendtoport data:{}", senddata.len());
-    // println!(
-    //     "sendtoport data content:{:X?}",
-    //     senddata
-    //         .iter()
-    //         .map(|&byte| format!("{:02X}", byte))
-    //         .collect::<Vec<String>>()
-    //         .join(" ")
-    // );
-    if isneedlog {
-        logtorust(format!(
-            "sendtoport data content:{:X?}",
-            senddata
-                .iter()
-                .map(|&byte| format!("{:02X}", byte))
-                .collect::<Vec<String>>()
-                .join(" ")
-        ));
-    }
-
-    sendtoprot(senddata);
-    let mut ret = readdatafromport(50, 0xff);
-    let datatype = ret[0];
-  
-    if isneedlog {
-        if !isgetdata{
-        logtorust(format!(
-            "read content: {:X?}",
-            ret.iter()
-                .map(|&byte| format!("{:02X}", byte))
-                .collect::<Vec<String>>()
-                .join(" ")
-        ));
-        }
-    }
-    if isgetdata{
-        logtorust("Get data Back SUCCESS".to_string());
-        logtorust("_____________________________one_data_over_____________________________\n".to_string());
-    }
-
-
-    ret.remove(0);
-    ret.remove(0);
-    ret.remove(0);
-    if datatype == 0x02 {
-        let mut is11data = IS11DataStruct::default();
-        unsafe {
-            let mut is11data_ptr = &mut is11data as *mut IS11DataStruct;
-            let mut ret_ptr = &mut ret[0] as *mut u8;
-            std::ptr::copy_nonoverlapping(
-                ret_ptr,
-                is11data_ptr as *mut u8,
-                std::mem::size_of::<IS11DataStruct>(),
-            );
-            return Ok(RetStruct {
-                datatype: datatype,
-                content: "null".to_string(),
-                data: is11data,
-            });
-        }
-    }
-
-    let str = String::from_utf8_lossy(&ret);
-    // println!("read data: {}", str);
-    if datatype==0x00 &&isneedlog {
-        logtorust(format![
-            "read string: {}",
-            str.to_string()
-        ]);
-        
-    }
-    return Ok(RetStruct {
-        datatype: datatype,
-        content: str.to_string(),
-        data: IS11DataStruct::default(),
-    });
-
-    //    return str.to_string();
-}
-#[tauri::command]
-fn clearportbuff() -> String {
-    clearserilport()
-}
-
-#[tauri::command]
-fn setport(data: serde_json::Value) -> String {
-    //判断是否存在portname和baudrate
-    if !data.is_object() {
-        return String::from("Invalid data");
-    }
-    if !data["portname"].is_string() || !data["baudrate"].is_u64() {
-        return String::from("Invalid data");
-    }
-    let portname = data["portname"].as_str().unwrap();
-    let baudrate = data["baudrate"].as_u64().unwrap() as u32;
-    set_port_info(&portname.to_string(), baudrate);
-    //println!("{}",readdatafromport(1000));
-    String::from("Port set ok")
-}
+////////////////////////////////////////////////////////////////////////////////////////
+// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command

 use tauri::{LogicalSize, Manager, Size};

@ -430,14 +71,14 @@ fn main() {
            opencom,
            setport,
            closecome,
-            sendtoportAndgetreturn,
+            sendtoport_andgetreturn,
            readformport,
            sendtoport,
            interpolate_spline,
            sg_smooth,
            savecalibratefile,
            sendcalibratetodev,
-            algorithm::Gaussian_filter_high,
+            algorithm::gaussian_filter_high,
            algorithm::interpolate_spline_at_points,
            algorithm::find_peek
        ])
--- a/src-tauri/src/mydefine/mod.rs
+++ b/src-tauri/src/mydefine/mod.rs
@ -0,0 +1,77 @@
+
+use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
+
+
+
+#[derive(Serialize, Deserialize)]
+pub struct RetStruct {
+/// 0x00 json 0x01 string 0x02 data binary
+ pub   datatype: u8,
+ pub   content: String,
+ pub   data: IS11DataStruct,
+}
+
+#[serde_as]
+#[derive(Serialize, Deserialize)]
+#[repr(C)]
+pub struct IS11DataStruct {
+    pub datatype: u8, // Using r# to allow the use of the keyword 'type'
+    pub direction: u8,
+    pub tuigan_stat: u8,
+    pub year:u8,
+    pub  month:u8,
+    pub day:u8,
+    pub hour:u8,
+    pub minute:u8,
+    pub  second:u8,
+    pub shutter_time: u32,
+    pub  index: u64,
+    pub  temprature: [f32; 8],
+    #[serde_as(as = "[_; 2048]")]
+    pub data: [f32; 2048],
+}
+
+
+ impl Default for IS11DataStruct {
+      fn default() -> Self {
+        IS11DataStruct {
+            datatype: 0,
+            direction: 10,
+            tuigan_stat: 0,
+            year:24,
+            month:1,
+            day:1,
+            hour:0,
+            minute:0,
+            second:0,
+
+            shutter_time: 0,
+            index: 0,
+            temprature: [0.0; 8],
+            data: [0.0; 2048],
+        }
+    }
+   
+}
+
+impl IS11DataStruct {
+    pub fn clone(&self) -> IS11DataStruct {
+        IS11DataStruct {
+            datatype: self.datatype,
+            direction: self.direction,
+            tuigan_stat: self.tuigan_stat,
+            year: self.year,
+            month: self.month,
+            day: self.day,
+            hour: self.hour,
+            minute: self.minute,
+            second: self.second,
+            shutter_time: self.shutter_time,
+            index: self.index,
+            temprature: self.temprature,
+            data: self.data,
+        }
+    }
+    
+}
--- a/src-tauri/src/mylog.rs
+++ b/src-tauri/src/mylog.rs
@ -6,19 +6,19 @@ use tklog::{
 use lazy_static::lazy_static;
 use std::{
    // fmt::format,
-    borrow::{Borrow, BorrowMut}, sync::{Arc, Mutex}, thread::sleep
+    borrow::{ BorrowMut}, sync::{Arc, Mutex}, thread::sleep
 };

 struct LOGERME{
-    LOGGER_RUST: Arc<Mutex<Logger>>,
-    LOGGER_JS:  Arc<Mutex<Logger>>,
+    logger_rust: Arc<Mutex<Logger>>,
+    logger_js:  Arc<Mutex<Logger>>,
 }
 lazy_static! {

-    static ref LOGERGloble: Arc<Mutex<LOGERME>> = Arc::new(Mutex::new(
+    static ref LOGERGLOBLE: Arc<Mutex<LOGERME>> = Arc::new(Mutex::new(
        LOGERME{
-        LOGGER_RUST:Arc::new( Mutex::new(Logger::new())),
-        LOGGER_JS:  Arc::new( Mutex::new(Logger::new())),
+        logger_rust:Arc::new( Mutex::new(Logger::new())),
+        logger_js:  Arc::new( Mutex::new(Logger::new())),
     }
 ));

@ -29,14 +29,14 @@ lazy_static! {



-pub fn change_log_path(path: &str,String: &str) {
-    if String=="RUST"{
-        let mut loggerglobel = LOGERGloble.lock().unwrap();
-        let mut log=loggerglobel.LOGGER_RUST.lock().unwrap();
+pub fn change_log_path(path: &str,string: &str) {
+    if string=="RUST"{
+        let mut loggerglobel = LOGERGLOBLE.lock().unwrap();
+        let mut log=loggerglobel.logger_rust.lock().unwrap();
        log.set_cutmode_by_time(path, MODE::DAY, 10, false);      
-    }else if String=="JS"{
-        let mut loggerglobel=LOGERGloble.lock().unwrap();
-        let mut log=loggerglobel.LOGGER_JS.lock().unwrap();
+    }else if string=="JS"{
+        let mut loggerglobel=LOGERGLOBLE.lock().unwrap();
+        let mut log=loggerglobel.logger_js.lock().unwrap();
        log.set_cutmode_by_time(path, MODE::DAY, 10, false);            
    }
 }
@ -44,13 +44,13 @@ pub fn change_log_path(path: &str,String: &str) {
 pub fn initlog() {

    //let mut logger = LOGERGloble.lock().unwrap().LOGGER_RUST;
-    let mut loggerglobel = LOGERGloble.lock().unwrap();
-    let mut log=loggerglobel.LOGGER_RUST.lock().unwrap();
+    let mut loggerglobel = LOGERGLOBLE.lock().unwrap();
+    let mut log=loggerglobel.logger_rust.lock().unwrap();
    log.set_console(true).set_format(Format::Date|Format::Time).set_formatter("{time} {file}{level}:{message}\n")
    .set_cutmode_by_time("rust_log.log",MODE::DAY, 10, false);
   // let mut logger = LOGERGloble.lock().unwrap().LOGGER_JS;
   //let mut loggerglobel = LOGERGloble.lock().unwrap();
-   let mut log=loggerglobel.LOGGER_JS.lock().unwrap();
+   let mut log=loggerglobel.logger_js.lock().unwrap();
   log.set_console(false).set_format(Format::Date|Format::Time).set_formatter("{time}:\t{message}\n")
    .set_cutmode_by_time("js_log.log",MODE::DAY, 10, false);

@ -59,8 +59,8 @@ pub fn initlog() {
 pub fn logtorust<T>(str:T)
 where T: std::fmt::Display
 {
-    let mut loggerglobe=LOGERGloble.lock().unwrap();
-    let mut log=Arc::clone(&loggerglobe.LOGGER_RUST);
+    let mut loggerglobe=LOGERGLOBLE.lock().unwrap();
+    let mut log=Arc::clone(&loggerglobe.logger_rust);

    let log1 = log.borrow_mut();
    infos!( log1, str);
@ -69,8 +69,8 @@ where T: std::fmt::Display
 pub fn logtojs<T>(str:T)
 where T: std::fmt::Display
 {
-    let mut loggerglobe=LOGERGloble.lock().unwrap();
-    let mut log=Arc::clone(&loggerglobe.LOGGER_JS);
+    let mut loggerglobe=LOGERGLOBLE.lock().unwrap();
+    let mut log=Arc::clone(&loggerglobe.logger_js);

    let log1 = log.borrow_mut();
    infos!( log1, str);
--- a/src-tauri/src/serport/serport.rs
+++ b/src-tauri/src/serport/serport.rs
@ -8,16 +8,16 @@ use std::{
    thread::sleep,
 };
 struct SeriesSettings {
-    pub PortName: String,
-    pub BaudRate: u32,
+    pub port_name: String,
+    pub band_rate: u32,
    pub port: Option<Box<dyn serialport::SerialPort>>,
    pub isopen: bool,
 }

 lazy_static! {
    static ref PORT_INFO: Arc<Mutex<SeriesSettings>> = Arc::new(Mutex::new(SeriesSettings {
-        PortName: String::from("NON"),
-        BaudRate: 9600,
+        port_name: String::from("NON"),
+        band_rate: 9600,
        port: None,
        isopen: false,
    }));
@ -25,7 +25,7 @@ lazy_static! {

 pub fn tryuseport() -> String {
    let mut port_info = PORT_INFO.lock().unwrap();
-    if port_info.PortName == "NON" {
+    if port_info.port_name == "NON" {
        return format!("Port is not set");
    }
    if port_info.isopen {
@ -36,7 +36,7 @@ pub fn tryuseport() -> String {



-    port_info.port = match serialport::new(port_info.PortName.clone(), port_info.BaudRate).open() {
+    port_info.port = match serialport::new(port_info.port_name.clone(), port_info.band_rate).open() {
        Ok(p) => Some(p),
        Err(e) => {
            eprintln!("Failed to open  Error: {}", e);
@ -50,8 +50,8 @@ pub fn tryuseport() -> String {

 pub fn set_port_info(portname: &String, baudrate: u32) {
    let mut port_info = PORT_INFO.lock().unwrap();
-    port_info.PortName = portname.to_string();
-    port_info.BaudRate = baudrate;
+    port_info.port_name = portname.to_string();
+    port_info.band_rate = baudrate;

 }

@ -66,13 +66,13 @@ pub fn get_port_name() -> Vec<String> {

 pub fn _reopenport() -> String {
    let mut port_info = PORT_INFO.lock().unwrap();
-    if port_info.PortName == "NON" {
+    if port_info.port_name == "NON" {
        return format!("Port is not set");
    }
    //关闭端口
    port_info.port = None;
    //重新打开端口
-    port_info.port = match serialport::new(port_info.PortName.clone(), port_info.BaudRate).open() {
+    port_info.port = match serialport::new(port_info.port_name.clone(), port_info.band_rate).open() {
        Ok(p) => Some(p),
        Err(e) => {
            eprintln!("Failed to open  Error: {}", e);
@ -85,7 +85,7 @@ pub fn _reopenport() -> String {

 pub fn closeport() -> String {
    let mut port_info = PORT_INFO.lock().unwrap();
-    if port_info.PortName == "NON" {
+    if port_info.port_name == "NON" {
        return format!("Port is not set");
    }
    //关闭端口
@ -96,7 +96,7 @@ pub fn closeport() -> String {

 pub fn sendtoprot(data: Vec<u8>) -> String {
    let mut port_info = PORT_INFO.lock().unwrap();
-    if port_info.PortName == "NON" {
+    if port_info.port_name == "NON" {
        return format!("Port is not set");
    }

@ -119,7 +119,7 @@ pub fn sendtoprot(data: Vec<u8>) -> String {

 pub fn clearserilport() -> String{
    let mut port_info = PORT_INFO.lock().unwrap();
-    if port_info.PortName == "NON" {
+    if port_info.port_name == "NON" {
        return "Port is not set".to_string();
    }
    let mut buf: Vec<u8> = vec![0; 1000];
@ -148,7 +148,7 @@ pub fn clearserilport() -> String{

 pub fn readdatafromport(waittime: u64, commanid: u8) -> Vec<u8> {
    let mut port_info = PORT_INFO.lock().unwrap();
-    if port_info.PortName == "NON" {
+    if port_info.port_name == "NON" {
        return "Port is not set".as_bytes().to_vec();
    }
    let mut buf: Vec<u8> = vec![0; 1000];
@ -236,7 +236,27 @@ pub fn iris_calc_crc(p_buffer: &[u8]) -> u16 {

    crc
 }
-
+pub fn readforport()->Vec<u8>{
+    let mut port_info = PORT_INFO.lock().unwrap();
+    if port_info.port_name == "NON" {
+        return "Port is not set".as_bytes().to_vec();
+    }
+    let mut buf: Vec<u8> = vec![0; 1000];
+    match &mut port_info.port {
+        Some(p) => {
+            p.set_timeout(Duration::from_millis(100)).unwrap();
+            let sizeread =match  p.read(&mut buf){
+                Ok(size)=>{size},
+                Err(_e)=>{0}
+            };
+            buf.truncate(sizeread);
+            return buf;
+        }
+        None => {
+            return Vec::new();
+        }
+    }
+}
 #[test]
 fn test() {
    tryuseport();
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@ -1,14 +1,16 @@
 {
  "build": {
    "beforeDevCommand": "npm run dev",
-    "beforeBuildCommand": "npm run build",
+    "beforeBuildCommand": " npm run mybuild & npm run build",
    "devPath": "http://localhost:1420",
    "distDir": "../dist",
    "withGlobalTauri": true
+
  },
+
  "package": {
    "productName": "SpectralPlot",
-    "version": "0.4.141"
+    "version": "0.5.1"
  },
  "tauri": {

@ -56,14 +58,18 @@
      "targets": "all",
      "identifier": "lele.rlx",
      "resources": [
-        "config.json"
+        "config.json","is11lib.dll"
      ],
+      "windows": {
+
+      },
+      
      "icon": [
-        "icons/32x32.png",
-        "icons/128x128.png",
-        "icons/128x128@2x.png",
-        "icons/icon.icns",
-        "icons/icon.ico"
+        "icons/1.jpg",
+        "icons/1.jpg",
+        "icons/1.jpg",
+        "icons/1.jpg",
+        "icons/1.jpg"
      ]
    }

--- a/src-tauri/test.nsi
+++ b/src-tauri/test.nsi
--- a/src/components/Greet.vue
+++ b/src/components/Greet.vue
@ -63,7 +63,7 @@ export default {
      var that = this;
      console.log(this.jsondata);
 
-      invoke("sendtoportAndgetreturn",{data:this.jsondata,datatype:"json"}).then((message) => {
+      invoke("sendtoport_andgetreturn",{data:this.jsondata,datatype:"json"}).then((message) => {
        that.greetMsg = message;
        that.jsonoutdata = JSON.parse(message.content);
        console.log(message);
--- a/src/components/SerialPort/SerialportMethod.js
+++ b/src/components/SerialPort/SerialportMethod.js
@ -8,7 +8,7 @@ async  function Dev_Opt() {
        data:Command,
        datatype:"json"
    }
-    let message=await invoke("sendtoportAndgetreturn",data);
+    let message=await invoke("sendtoport_andgetreturn",data);
    if (message.datatype==0x00)
    {
        let ret=JSON.parse(message.content);
@ -16,7 +16,7 @@ async  function Dev_Opt() {
    }
    await EnsureNotWorking();
    data.data.command="get_opt";
-    message=await invoke("sendtoportAndgetreturn",data);
+    message=await invoke("sendtoport_andgetreturn",data);
    var shuttertimes=0;
    if (message.datatype==0x00)
    {
@ -58,7 +58,7 @@ async  function Get_Date_on_Derction(drection,shuttertimes,autoremovedark=false,
        data.data.remove_dark="no";
    }
    data.data.collect_times=avgnumber;
-    let message=await invoke("sendtoportAndgetreturn",data);
+    let message=await invoke("sendtoport_andgetreturn",data);
    await EnsureNotWorking();


@ -81,10 +81,10 @@ async  function Get_Date_on_Derction(drection,shuttertimes,autoremovedark=false,
        data.data.return_data_type=CommanDeffine.DataTypeforSend.UpDarkDN;
    }

-    message=await invoke("sendtoportAndgetreturn",data);
+    message=await invoke("sendtoport_andgetreturn",data);
    while (message.datatype!=0x02)
    {
-        message=await invoke("sendtoportAndgetreturn",data);
+        message=await invoke("sendtoport_andgetreturn",data);
    }
    return message.data
 }
@ -95,7 +95,7 @@ async function Get_Device_Info() {
        data:Command,
        datatype:"json"
    }
-    let message=await invoke("sendtoportAndgetreturn",data);
+    let message=await invoke("sendtoport_andgetreturn",data);
    if (message.datatype==108)
    {
        return {error:"error"};
@ -122,7 +122,7 @@ async function EnsureNotWorking(){
        },
        datatype:"json"
    }
-    let message=await invoke("sendtoportAndgetreturn",data);
+    let message=await invoke("sendtoport_andgetreturn",data);
    let ret=JSON.parse(message.content);

    while (ret.caiji_state!="finish")
@ -135,7 +135,7 @@ async function EnsureNotWorking(){
        }
        EventBus.emit('setprogressbar',dataforprocess);
        await delay(1000);
-        message=await invoke("sendtoportAndgetreturn",data);
+        message=await invoke("sendtoport_andgetreturn",data);

        if (message.content=="g time no data retrun")
        {
--- a/src/components/SiderleftSerilportMethod.js
+++ b/src/components/SiderleftSerilportMethod.js
@ -39,7 +39,8 @@ export  default {
        // let buffer = Buffer.alloc(0);
        let portinfo ={
            portname: this.Comname,
-            baudrate: 115200,
+            // baudrate: 115200,
+            baudrate: 921600,
        }
        let ret= await invoke("opencom",portinfo);
        if (ret!="Port is open")
@ -153,7 +154,7 @@ export  default {
        }
        if (this.dataprocessconfig.usehighpass)
        {
-            datatoshow.data=await invoke("Gaussian_filter_high",{data:datatoshow.data,sigma:30});
+            datatoshow.data=await invoke("gaussian_filter_high",{data:datatoshow.data,sigma:30});
            //console.log(aaa);
        }

@ -217,7 +218,7 @@ export  default {
            },
            datatype:"json"
        }
-        let message=await invoke("sendtoportAndgetreturn",data);
+        let message=await invoke("sendtoport_andgetreturn",data);
        let ret=JSON.parse(message.content);

        while (ret.caiji_state!="finish")
@ -230,7 +231,7 @@ export  default {
            }
            EventBus.emit('setprogressbar',dataforprocess);
            await delay(100);
-            message=await invoke("sendtoportAndgetreturn",data);
+            message=await invoke("sendtoport_andgetreturn",data);

            if (message.content=="g time no data retrun")
            {
@ -282,10 +283,10 @@ export  default {
            },
            datatype: "json"
        }
-       let message1=await invoke("sendtoportAndgetreturn",data);
+       let message1=await invoke("sendtoport_andgetreturn",data);
        while (message1.datatype!=0x02)
        {
-            message1=await invoke("sendtoportAndgetreturn",data);
+            message1=await invoke("sendtoport_andgetreturn",data);
        }

        let datatoshowup=message1.data;
@ -321,10 +322,10 @@ export  default {
            },
            datatype: "json"
        }
-        let messagedown=await invoke("sendtoportAndgetreturn",data);
+        let messagedown=await invoke("sendtoport_andgetreturn",data);
        while (messagedown.datatype!=0x02)
        {
-            messagedown=await invoke("sendtoportAndgetreturn",data);
+            messagedown=await invoke("sendtoport_andgetreturn",data);
        }
        let datatoshowdown=messagedown.data;
        this.datadown=datatoshowdown;
@ -379,7 +380,7 @@ export  default {
            datatype:"json"
        }
        let that = this;
-        let message=await invoke("sendtoportAndgetreturn",data);
+        let message=await invoke("sendtoport_andgetreturn",data);
        if (message.datatype==108)
        {
            return false;
--- a/src/components/commentep.vue
+++ b/src/components/commentep.vue
@ -16,7 +16,7 @@ export default {
        data: Command,
        datatype: "json"
      }
-      let message = await invoke("sendtoportAndgetreturn", data);
+      let message = await invoke("sendtoport_andgetreturn", data);
      this.Devinfo = JSON.parse(message);

    }
--- a/src/components/menubox/SetWavelenth.vue
+++ b/src/components/menubox/SetWavelenth.vue
@ -46,7 +46,7 @@ export default {
        data: Command,
        datatype: "json"
      }
-      let message = await invoke("sendtoportAndgetreturn", data);
+      let message = await invoke("sendtoport_andgetreturn", data);
      this.Devinfo = JSON.parse(message.content);

    },
--- a/src/components/menubox/SetWorkmode.vue
+++ b/src/components/menubox/SetWorkmode.vue
@ -24,7 +24,7 @@ export default {
        data: Command,
        datatype: "json"
      }
-      let message = await invoke("sendtoportAndgetreturn", data);
+      let message = await invoke("sendtoport_andgetreturn", data);
      this.Devinfo = JSON.parse(message.content);
      this.Devinfo.start_time = this.convertimetostr(this.Devinfo.start_time);
      this.Devinfo.stop_time = this.convertimetostr(this.Devinfo.stop_time);
@ -99,7 +99,7 @@ export default {
        data: command,
        datatype: "json"
      }
-     await invoke("sendtoportAndgetreturn", data);
+     await invoke("sendtoport_andgetreturn", data);


    }
--- a/src/components/siderleft.vue
+++ b/src/components/siderleft.vue
@ -147,15 +147,17 @@ export default {
 <!--       <div style="margin: auto; margin-left: 10px;">SG<input type="checkbox" v-model="dataprocessconfig.useSG" ></div>-->
 <!--        <div style="margin: auto; margin-left: 10px;"> HighPass<input type="checkbox" v-model="dataprocessconfig.usehighpass" ></div>-->
 <!--      </b-input-group>-->
-      <b-input-group prepend="aa" size="sm" style="width: 100%">
+      <b-input-group prepend="平均次数" size="sm" style="width: 100%">
        <b-form-input type="number" v-model="caijiavgNumber"></b-form-input>
        <b-input-group-append>

        </b-input-group-append>
      </b-input-group>
-      <b-input-group prepend="bb" size="sm">
-        <div style="margin: auto; margin-left: 10px;"><input type="checkbox" v-model="dataprocessconfig.useSG" ></div>
-        <div style="margin: auto; margin-left: 10px;"><input type="checkbox" v-model="dataprocessconfig.usehighpass" ></div>
+      <b-input-group prepend="滤波" size="sm">
+              <div style="margin: auto; margin-left: 10px;">SG<input type="checkbox" v-model="dataprocessconfig.useSG" ></div>
+       <div style="margin: auto; margin-left: 10px;"> HighPass<input type="checkbox" v-model="dataprocessconfig.usehighpass" ></div>
+        <!-- <div style="margin: auto; margin-left: 10px;"><input type="checkbox" v-model="dataprocessconfig.useSG" ></div>
+        <div style="margin: auto; margin-left: 10px;"><input type="checkbox" v-model="dataprocessconfig.usehighpass" ></div> -->
      </b-input-group>
      <b-button @click="saveconfig" variant="light" size="sm">保存</b-button>
    </BAccordionItem>
				`@ -0,0 +1,2 @@`
				`copy ..\\myis11\\project\\is11\\cmake-build-release-visual-studio-2022\\is11lib.dll ./src-tauri`