再次提交

界面修改兼容is11
2024-08-21 14:19:40 +08:00 · 2024-08-21 14:16:54 +08:00
47 changed files with 1171 additions and 468 deletions
--- a/README.md
+++ b/README.md
@ -1,3 +1,5 @@
 # 通用光谱采集软件
 插入复选框
 aaa <input disabled="" type="checkbox"> Checkbox 1
--- a/README.png
+++ b/README.png
--- 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>> {
+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 x: Vec<f64> = x_t.iter().map(|&x| x.into()).collect();
-    let y: Vec<f64> = y_T.iter().map(|&y| y.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>> {
+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 x: Vec<f64> = x_t.iter().map(|&x| x.into()).collect();
-    let y: Vec<f64> = y_T.iter().map(|&y| y.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,
+#[tauri::command]
-}
+fn savecalibratefile(gain: Vec<f32>, shutter: u32, direction: bool, filepath: String) -> String {
-#[serde_as]
+    irishypersptral::savecalibratefile_iris(gain, shutter, direction, filepath)
 #[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 {
+fn sendcalibratetodev(gain: Vec<f32>, shutter: u32, direction: bool) -> String {
-    let mut data = IS11DataStruct::default();
+    irishypersptral::sendcalibratetodev_iris(gain, shutter, direction)
    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()
 }
 #[tauri::command]
-fn closecome() -> String {
+fn __sendto_portbinary(data: Vec<u8>, command: u8) -> String {
-    closeport()
+    irishypersptral::sendtoportbinary_iris(data, command)
 }
 #[tauri::command]
 fn sendtoport(data: serde_json::Value, datatype: serde_json::Value) -> String {
-    // println!("sendtoport data:{}",data.to_string());
+   irishypersptral::sendtoport_iris(data, datatype)
    //判断是否存在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()
 }
 #[tauri::command]
 fn readformport(commanid: serde_json::Value, wait_time_json: serde_json::Value) -> String {
-    let mut waittime = 50;
+  irishypersptral::readformport_iris(commanid, wait_time_json)
    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();
 }
 #[tauri::command]
-fn sendtoportAndgetreturn(
+fn sendtoport_andgetreturn(
    data: serde_json::Value,
    datatype: serde_json::Value,
 ) -> Result<RetStruct, String> {
-    // println!("sendtoport data:{}",data.to_string());
+    //irishypersptral::sendtoport_andgetreturn_iris(data, datatype)
-    //判断是否存在data
+    jianzhiis11::sendtoport_andgetreturn(data, datatype)
-    // 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()));
+// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
    }
    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")
 }
 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_rust: Arc<Mutex<Logger>>,
-    LOGGER_JS:  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_rust:Arc::new( Mutex::new(Logger::new())),
-        LOGGER_JS:  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) {
+pub fn change_log_path(path: &str,string: &str) {
-    if String=="RUST"{
+    if string=="RUST"{
-        let mut loggerglobel = LOGERGloble.lock().unwrap();
+        let mut loggerglobel = LOGERGLOBLE.lock().unwrap();
-        let mut log=loggerglobel.LOGGER_RUST.lock().unwrap();
+        let mut log=loggerglobel.logger_rust.lock().unwrap();
        log.set_cutmode_by_time(path, MODE::DAY, 10, false);      
-    }else if String=="JS"{
+    }else if string=="JS"{
-        let mut loggerglobel=LOGERGloble.lock().unwrap();
+        let mut loggerglobel=LOGERGLOBLE.lock().unwrap();
-        let mut log=loggerglobel.LOGGER_JS.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 loggerglobel = LOGERGLOBLE.lock().unwrap();
-    let mut log=loggerglobel.LOGGER_RUST.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 loggerglobe=LOGERGLOBLE.lock().unwrap();
-    let mut log=Arc::clone(&loggerglobe.LOGGER_RUST);
+    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 loggerglobe=LOGERGLOBLE.lock().unwrap();
-    let mut log=Arc::clone(&loggerglobe.LOGGER_JS);
+    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 port_name: String,
-    pub BaudRate: u32,
+    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"),
+        port_name: String::from("NON"),
-        BaudRate: 9600,
+        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.port_name = portname.to_string();
-    port_info.BaudRate = baudrate;
+    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/1.jpg",
-        "icons/128x128.png",
+        "icons/1.jpg",
-        "icons/128x128@2x.png",
+        "icons/1.jpg",
-        "icons/icon.icns",
+        "icons/1.jpg",
-        "icons/icon.ico"
+        "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);
@ -152,6 +152,7 @@ export default {
    </select>
    <input type="checkbox" v-model="Statusnow.isopen" />
    <button @click="opencom" >{{Statusnow.buttonstring }}</button>
    <select v-model="datatype" >
--- 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">
+      <b-input-group prepend="滤波" size="sm">
-        <div style="margin: auto; margin-left: 10px;"><input type="checkbox" v-model="dataprocessconfig.useSG" ></div>
+              <div style="margin: auto; margin-left: 10px;">SG<input type="checkbox" v-model="dataprocessconfig.useSG" ></div>
-        <div style="margin: auto; margin-left: 10px;"><input type="checkbox" v-model="dataprocessconfig.usehighpass" ></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>
Author	SHA1	Message	Date
任立新	6d47134dac	再次提交	2024-08-21 14:19:40 +08:00
任立新	fb3257bb75	界面修改兼容is11	2024-08-21 14:16:54 +08:00
		`@ -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}`
		`@ -0,0 +1,2 @@`
							`copy ..\\myis11\\project\\is11\\cmake-build-release-visual-studio-2022\\is11lib.dll ./src-tauri`