修复连续采集时没有时间间隔导致通讯失败从而导致无有法正常连续采集的问题 修改如下

src-tauri/Cargo.lock

@@ -1691,6 +1691,7 @@ dependencies = [
  "find_peaks",
  "lazy_static",
  "libc",
+ "nalgebra 0.33.2",
  "ndarray",
  "ndarray-ndimage",
  "ndarray-stats",
@@ -1730,7 +1731,7 @@ checksum = "3ea4908d4f23254adda3daa60ffef0f1ac7b8c3e9a864cf3cc154b251908a2ef"
 dependencies = [
  "approx",
  "matrixmultiply",
- "nalgebra-macros 0.2.1",
+ "nalgebra-macros 0.2.2",
  "num-complex",
  "num-rational",
  "num-traits",
@@ -1738,6 +1739,22 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "nalgebra"
+version = "0.33.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26aecdf64b707efd1310e3544d709c5c0ac61c13756046aaaba41be5c4f66a3b"
+dependencies = [
+ "approx",
+ "matrixmultiply",
+ "nalgebra-macros 0.2.2",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba 0.9.0",
+ "typenum",
+]
+
 [[package]]
 name = "nalgebra-macros"
 version = "0.1.0"
@@ -1751,13 +1768,13 @@ dependencies = [
 
 [[package]]
 name = "nalgebra-macros"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91761aed67d03ad966ef783ae962ef9bbaca728d2dd7ceb7939ec110fffad998"
+checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.64",
 ]
 
 [[package]]
@@ -1870,6 +1887,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-complex"
 version = "0.4.6"
@@ -1900,6 +1927,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
 dependencies = [
+ "num-bigint",
  "num-integer",
  "num-traits",
 ]
@@ -2863,6 +2891,19 @@ dependencies = [
  "wide",
 ]
 
+[[package]]
+name = "simba"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3a386a501cd104797982c15ae17aafe8b9261315b5d07e3ec803f2ea26be0fa"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.7"

src-tauri/Cargo.toml

@@ -28,6 +28,7 @@ csv = "1.3.0"
 tklog = "0.0.8"
 libc = "0.2.156"
 chrono = "0.4.38"
+nalgebra = "0.33.2"
 
 
 

src-tauri/config.json

@@ -1 +1 @@
-{"pathofsave":"D:\\06Learn\\rust\\tarui","Filename":"testaa","caijiavgNumber":"1","useSG":false,"usehighpass":false,"Dispatcher":{"isenable":true,"begin":"14:25","end":"23:59"}}
+{"pathofsave":"C:\\Users\\xin\\Desktop\\test\\123","Filename":"testaa","caijiavgNumber":"1","useSG":false,"usehighpass":false,"Dispatcher":{"isenable":true,"begin":"06:25","end":"23:59"},"sensor_typeforset":"IS3"}

src-tauri/debug_pre-build.ps1

@@ -0,0 +1,2 @@
+copy .\\myis11\\project\\is11\\cmake-build-release-visual-studio-2022\\is11lib.dll ./src-tauri
+copy .\\myis11\\project\\is3\\cmake-build-debug-visual-studio\\iris_is3lib.dll ./src-tauri

src-tauri/pre-build.ps1

@@ -1,2 +1,2 @@
 copy ..\\myis11\\project\\is11\\cmake-build-release-visual-studio-2022\\is11lib.dll ./src-tauri 
-
+copy myis11\\project\\is3\\cmake-build-release-visual-studio\\iris_is3lib.dll ./src-tauri

src-tauri/src/algorithm/mod.rs

@@ -25,4 +25,9 @@ pub fn gaussian_filter_high(data: Vec<f64>, sigma: f64) -> Vec<f64> {
 #[tauri::command]
 pub fn find_peek(data: Vec<f64>, minheigh: f64) -> Vec<(u32, f64)> {
     spectraltools::find_peek(data, minheigh)
-}
+}
+
+#[tauri::command]
+pub fn compute_weave_coeff(x: Vec<f64>, y: Vec<f64>) -> Vec<f64> {
+    spectraltools::compute_weave_coeff(x, y)
+}

src-tauri/src/algorithm/spectraltools.rs

@@ -128,7 +128,51 @@ fn read_csv_to_vec(file_path: &str) -> Result<Vec<f64>, Box<dyn Error>> {
     Ok(values)
 }
 
+use nalgebra::{DMatrix, DVector};
 
+pub fn compute_weave_coeff(x_data:Vec<f64>,y_data:Vec<f64>)->Vec<f64>{
+
+    assert_eq!(x_data.len(), y_data.len());
+
+    let n = x_data.len();
+
+    // 构建设计矩阵 X 和观测向量 y
+    let mut x_matrix = DMatrix::zeros(n, 4); // 三阶多项式有 4 个系数
+    let mut y_vector = DVector::from_vec(y_data.clone());
+
+    for (i, &x) in x_data.iter().enumerate() {
+        x_matrix[(i, 0)] = 1.0;       // 常数项
+        x_matrix[(i, 1)] = x;         // x
+        x_matrix[(i, 2)] = x.powi(2); // x²
+        x_matrix[(i, 3)] = x.powi(3); // x³
+    }
+
+    // 使用正规方程求解最小二乘问题： (XᵀX)β = Xᵀy
+    let xt = x_matrix.transpose();
+    let xtx = &xt * &x_matrix;
+    let xty = &xt * &y_vector;
+
+    // 求解方程 (XᵀX)β = Xᵀy
+    let beta = xtx
+        .lu()
+        .solve(&xty)
+        .expect("无法求解正规方程，可能是矩阵奇异");
+
+    // 输出拟合系数
+    println!("拟合的三阶多项式系数：");
+    println!("y = {:.4} + {:.4}x + {:.4}x² + {:.4}x³", beta[0], beta[1], beta[2], beta[3]);
+
+    // 示例：使用拟合的多项式进行预测
+    let x_test = 6.0;
+    let y_pred = beta[0] + beta[1]*x_test + beta[2]*x_test.powi(2) + beta[3]*x_test.powi(3);
+    println!("对于 x = {:.2}, 预测的 y = {:.4}", x_test, y_pred);
+    let mut retvec=Vec::new();
+    for i in 0..4{
+        retvec.push(beta[i]);
+    }
+    retvec
+   
+}
 
 #[test]
 fn test_find_peek(){

src-tauri/src/iris_spectral/mod.rs

@@ -0,0 +1,361 @@
+use super::mydefine::*;
+pub mod spectralserver;
+pub mod spectralbase;
+use std::fmt::format;
+use std::fs;
+use std::fs::File;
+use super::mylog::*;
+use serde_json::json;
+use spectralserver::calibrate_file;
+use std::ffi::CStr;
+use std::path::Path;
+pub fn delete_file(filepath: String) -> String {
+    let file_path = Path::new(&filepath);
+    if file_path.exists() {
+        fs::remove_file(file_path).unwrap();
+        "OK".to_string()
+    } else {
+        "文件不存在".to_string()
+    }
+}
+pub fn sendtoport_andgetreturn(
+    data: serde_json::Value,
+    datatype: serde_json::Value,
+) -> Result<RetStruct, String> {
+    let command = data.get("command").unwrap().to_string();
+    //println!("start_collect data:{}", data.to_string());
+    match command.as_str() {
+
+        "\"start_collect_flat\"" => {
+            return start_collect_flat(data, datatype);
+        },  
+
+        "\"start_collect_dark\"" => {
+            return start_collect_dark(data, datatype);
+        },
+        "\"get_sensor_info\"" => {
+            spectralserver::is11_init();
+            logtorust("init sensor ok".to_string());
+            let sensor_info = spectralserver::is11_get_sensor_info();
+            let shuttertime = spectralserver::get_shuttertime();
+            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,
+                "bandnum":sensor_info.BandNum,
+                "bandsum":sensor_info.BandNum,
+                
+                "name":sensor_name,
+                // "name":sensor_name,
+                "version":"1.0.0",
+                "return_data_type":0,
+                "work_mode":"advanced_mode",
+                "sensor_type":"IRIS-Sensor",
+                "fiber_type":"Single",
+                "shutter_time":shuttertime,
+
+
+            });
+            let califiename=format!("calibratefile/{}_{}_upgain.bin",sensor_name,serilnumber);
+            spectralserver::load_all_calibrate_file(califiename);
+            logtorust(format!("get_sensor_info:{}", jsonforret.to_string()));
+            return Ok(RetStruct {
+                datatype: 0,
+                content: jsonforret.to_string(),
+                data: IS11DataStruct::default(),
+            });
+        }
+        "\"start_opt\"" => {
+            spectralserver::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,percent) = spectralserver::get_now_stat();
+            let jsonforret = json!({
+                "caiji_state":caiji_state,
+                "info":caiji_state_str,
+                "percent":percent,
+                "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);
+        },
+        "\"get_data_flat\"" => {
+            return get_data_flat(data, datatype);
+        },
+        "\"get_data_dark\"" => {
+            return get_data_dark(data, datatype);
+        },
+        "\"set_shutter_time\"" => {
+            return set_shutter_time(data, datatype);
+        },
+        _ => {
+            return Err("command not found ".to_string() + "command is:" + &command);
+        }
+    }
+
+
+}
+
+pub fn get_opt_result() -> Result<RetStruct, String> {
+    let shuttertime = spectralserver::get_shuttertime();
+
+    let jsonret = json!({
+        "opt":shuttertime,
+
+    });
+
+
+
+    return Ok(RetStruct {
+        datatype: 0,
+        content: jsonret.to_string(),
+        data: IS11DataStruct::default(),
+    });
+}
+pub fn set_shutter_time(data: serde_json::Value,
+    datatype: serde_json::Value) -> Result<RetStruct, String> {
+
+    
+        let shuttertime: u32;
+        if data.get("shutter_time").is_none() {
+            shuttertime = spectralserver::get_shuttertime() as u32;
+        } else {
+            shuttertime = data.get("shutter_time").unwrap().as_u64().unwrap() as u32;
+            spectralserver::set_shutter_time(shuttertime);
+        }
+
+
+    let jsonret = json!({
+        "shuttertime":"ok",
+
+    });
+
+
+
+    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: u32;
+    if data.get("shutter_time").is_none() {
+        shuttertime =spectralserver::get_shuttertime() as u32;
+    } else {
+        shuttertime = data.get("shutter_time").unwrap().as_u64().unwrap() as u32;
+    }
+    //判断是否有这个参数
+
+    let removedark: bool;
+    if data.get("remove_dark").is_none() {
+        removedark = false;
+    } else {
+        if data.get("remove_dark").unwrap().is_boolean() {
+            removedark = data.get("remove_dark").unwrap().as_bool().unwrap();
+        } else if data.get("remove_dark").unwrap().is_string() {
+            let remove_dark_str = data.get("remove_dark").unwrap().as_str().unwrap();
+            if remove_dark_str == "yes" {
+                removedark = true;
+            } else {
+                removedark = false;
+            }
+        } else {
+            removedark = false;
+        }
+    }
+
+    let computeflat = spectralserver::get_is_computeref();
+    logtorust(format!("start_collect,shutter time is:{}", shuttertime));
+    if !data.get("collect_times").is_none() {
+        if data.get("collect_times").unwrap().is_u64() {
+            let collect_times = data.get("collect_times").unwrap().as_u64().unwrap() as u32;
+            spectralserver::set_average_number(collect_times,collect_times,collect_times );
+        } 
+         
+
+        
+    }
+
+
+    spectralserver::collect(shuttertime, removedark, computeflat);
+    let jsonret = json!({
+        "command":"start_collect"
+
+    });
+    return Ok(RetStruct {
+        datatype: 0,
+        content: jsonret.to_string(),
+        data: IS11DataStruct::default(),
+    });
+}
+
+pub fn start_collect_dark(
+    data: serde_json::Value,
+    datatype: serde_json::Value,
+) -> Result<RetStruct, String> {
+    let shuttertime: u32;
+    if data.get("shutter_time").is_none() {
+        shuttertime = spectralserver::get_shuttertime() as u32;
+    } else {
+        shuttertime = data.get("shutter_time").unwrap().as_u64().unwrap() as u32;
+    }
+    //判断是否有这个参数
+    if !data.get("collect_times").is_none() {
+        if data.get("collect_times").unwrap().is_u64() {
+            let collect_times = data.get("collect_times").unwrap().as_u64().unwrap() as u32;
+            spectralserver::set_average_number(collect_times,collect_times,collect_times );
+        }      
+    }
+
+    spectralserver::collcect_dark(shuttertime);
+    let jsonret = json!({
+        "command":"start_collect_dark"
+
+    });
+    return Ok(RetStruct {
+        datatype: 0,
+        content: jsonret.to_string(),
+        data: IS11DataStruct::default(),
+    });
+
+}
+
+
+pub fn start_collect_flat(
+    data: serde_json::Value,
+    datatype: serde_json::Value,
+) -> Result<RetStruct, String> {
+    let shuttertime: u32;
+    if data.get("shutter_time").is_none() {
+        shuttertime = spectralserver::get_shuttertime() as u32;
+    } else {
+        shuttertime = data.get("shutter_time").unwrap().as_u64().unwrap() as u32;
+    }
+    //判断是否有这个参数
+    if !data.get("collect_times").is_none() {
+        if data.get("collect_times").unwrap().is_u64() {
+            let collect_times = data.get("collect_times").unwrap().as_u64().unwrap() as u32;
+            spectralserver::set_average_number(collect_times,collect_times,collect_times );
+        }      
+    }
+
+    spectralserver::collcect_flat(shuttertime);
+    let jsonret = json!({
+        "command":"start_collect_flat"
+
+    });
+    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 mut is11_data = spectralserver::get_data();
+    println!("get_data datatype:{}", data["return_data_type"]);
+    let retrun_data_type = data["return_data_type"].as_u64().unwrap();
+    if retrun_data_type ==0x12 || retrun_data_type ==0x13 {
+
+        is11_data=calibrate_file(&is11_data)
+    }
+
+    let jsonret = json!({
+        "command":"get_data"
+
+    });
+
+    return Ok(RetStruct {
+        datatype: 2,
+        content: jsonret.to_string(),
+        data: is11_data,
+    });
+}
+
+pub fn get_data_flat(data: serde_json::Value, datatype: serde_json::Value) -> Result<RetStruct, String> {
+    let is11_data = spectralserver::get_data_flat();
+
+    let jsonret = json!({
+        "command":"get_data_flat"
+
+    });
+
+    return Ok(RetStruct {
+        datatype: 2,
+        content: jsonret.to_string(),
+        data: is11_data,
+    });
+}
+
+pub fn get_data_dark(data: serde_json::Value, datatype: serde_json::Value) -> Result<RetStruct, String> {
+    let is11_data = spectralserver::get_data_dark();
+
+    let jsonret = json!({
+        "command":"get_data_dark"
+
+    });
+
+    return Ok(RetStruct {
+        datatype: 2,
+        content: jsonret.to_string(),
+        data: is11_data,
+    });
+}
+
+pub fn set_weave_coeff(
+    specnumber: i32,
+    a0: f64,
+    a1: f64,
+    a2: f64,
+    a3: f64,
+) -> String {
+    println!("set_weave_coeff:specnumber:{},a0:{},a1:{},a2:{},a3:{}", specnumber, a0, a1, a2, a3);
+    spectralserver::set_weave_coeff(specnumber, a0, a1, a2, a3);
+    "OK".to_string()
+
+}

src-tauri/src/iris_spectral/spectralbase/IS11_sensor/mod.rs

@@ -0,0 +1,78 @@
+use libc::{c_uchar,c_char,c_long,c_float, size_t};
+use std::ffi::CStr;
+use std::slice;
+
+use crate::serport::serport::*;
+use super::STRSensorInfo;
+
+
+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" {
+    pub fn Set_Serial_FUN(writefunc:SerialWrite,readfunc:SerialWrite);
+    pub fn abs1(input: i32) -> i32;
+    pub fn test();
+    pub fn IS11SensorInit() -> i32;
+    pub fn Get_SensorInfo() -> STRSensorInfo;
+    pub fn IS11OptSnenser(percent:i32) -> i32;
+    pub fn IS11GetData(outdata: *mut u16, shuttertime: i32) -> i32;
+
+}
+
+pub 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;
+pub 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
+}

src-tauri/src/iris_spectral/spectralbase/IS3_sensor/mod.rs

@@ -0,0 +1,89 @@
+use libc::{c_uchar,c_char,c_long,c_float, size_t};
+use std::ffi::CStr;
+use std::slice;
+
+use crate::serport::serport::*;
+use super::STRSensorInfo;
+
+
+type SerialWrite = Option<unsafe extern "C" fn(data: *mut c_uchar, length: size_t) -> size_t>;
+#[link(
+    name = "D:\\06Learn\\rust\\tarui\\myfirst_tauri\\myis11\\project\\is3\\cmake-build-debug-visual-studio/iris_is3lib",
+    kind = "dylib"
+)]
+extern "C" {
+    pub fn IS3Set_Serial_FUN(writefunc:SerialWrite,readfunc:SerialWrite);
+    pub fn IS3SensorInit() -> i32;
+    pub fn IS3Get_SensorInfo() -> STRSensorInfo;
+    pub fn IS3OptSnenser(percent:i32) -> i32;
+    pub fn IS3GetData(outdata: *mut u16, shuttertime: i32) -> i32;
+    pub fn IS3SetWeaveLenthCoeff(a:*mut f64,length:i32) -> i32;
+
+}
+
+pub 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;
+pub 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 is3_init() -> i32 {
+    unsafe {
+        IS3Set_Serial_FUN(Some(serialsenddata), Some(serialreaddate));
+        IS3SensorInit()
+    }
+}
+
+pub fn is3_get_sensor_info() -> STRSensorInfo {
+    unsafe { IS3Get_SensorInfo() }
+}
+
+pub fn is3_opt_snenser(percent: i32) -> i32 {
+    unsafe { IS3OptSnenser(percent) }
+}
+
+pub fn is3_get_data(shuttertime: i32) -> Vec<u16> {
+    let mut outdata: Vec<u16> = vec![0; 2048];
+
+    unsafe {
+
+        let len = IS3GetData(outdata.as_mut_ptr(), shuttertime);
+        outdata.truncate(len as usize);
+
+
+    }
+
+    outdata
+}
+
+pub fn is3_set_weave_length_coeff(a: Vec<f64>) -> i32 {
+    let mut a = a.clone();
+    let a_ptr = a.as_mut_ptr();
+    let length = a.len() as i32;
+    println!("a_ptr: {:?}", a_ptr);
+    println!("length: {:?}", length);
+    unsafe { IS3SetWeaveLenthCoeff(a_ptr, length) }
+}

src-tauri/src/iris_spectral/spectralbase/mod.rs

@@ -0,0 +1,233 @@
+
+use libc::{c_uchar,c_char,c_long,c_float, size_t};
+type SerialWrite = Option<unsafe extern "C" fn(data: *mut c_uchar, length: size_t) -> size_t>;
+use lazy_static::lazy_static;
+use std::{
+    sync::{Arc, Mutex}, 
+};
+mod IS3_sensor;
+mod IS11_sensor;
+
+// 定义emun 不同光谱仪
+#[derive(Copy, Clone)]
+pub enum Senortype {
+    IS11,
+    IS1,
+    IS2,
+    OSIF,
+    IS3
+    
+}
+
+//全局变量 传感器类型 用lazy_static宏定义 原子变量
+lazy_static! {
+    static ref SENSORTYPE: Arc<Mutex<Senortype>> = Arc::new(Mutex::new(Senortype::IS3));
+   
+}
+
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+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,
+        }
+    }
+    
+}
+
+lazy_static! {
+    static ref SENSOR_INFO: Arc<Mutex<STRSensorInfo>> = Arc::new(Mutex::new(STRSensorInfo::default()));
+   
+}
+
+pub fn sensor_set_sensor_type(senortype:String)
+{
+    let mut data = SENSORTYPE.lock().unwrap();
+    match senortype.as_str() {
+        "IS11" => *data = Senortype::IS11,
+        "IS1" => *data = Senortype::IS1,
+        "IS2" => *data = Senortype::IS2,
+        "OSIF" => *data = Senortype::OSIF,
+        "IS3" => *data = Senortype::IS3,
+        _ => *data = Senortype::IS11,
+    }
+}
+
+
+
+
+pub fn abs1(input: i32) -> i32
+{
+    return 0;
+
+}
+pub fn test()
+{
+
+}
+pub fn sensor_init() -> i32
+{   
+    let senortype = SENSORTYPE.lock().unwrap();
+    match *senortype {
+        Senortype::IS11 => {
+            unsafe {
+                IS11_sensor::Set_Serial_FUN(Some(IS11_sensor::serialsenddata), Some(IS11_sensor::serialreaddate));
+                return IS11_sensor::IS11SensorInit();
+            }
+
+        },
+        Senortype::IS3 => {
+            unsafe {
+                IS3_sensor::IS3Set_Serial_FUN(Some(IS3_sensor::serialsenddata), Some(IS3_sensor::serialreaddate));
+                return IS3_sensor::IS3SensorInit();
+            }
+
+        },
+        _ => {
+            return 0;
+        },
+
+    }
+
+
+
+
+}
+pub  fn sensor_get_sensor_info() -> STRSensorInfo{
+    let senortype = SENSORTYPE.lock().unwrap();
+    let mut Sensorinfo= SENSOR_INFO.lock().unwrap();
+    match *senortype {
+        Senortype::IS11 => {
+            unsafe {
+                let info = IS11_sensor::Get_SensorInfo();
+                *Sensorinfo = info.clone();
+                return info;
+            }
+
+        },
+        Senortype::IS3 => {
+            unsafe {
+                let info = IS3_sensor::IS3Get_SensorInfo();
+                *Sensorinfo = info.clone();
+                return info;
+               
+            }
+
+        },
+        _ => {
+            return STRSensorInfo::default();
+        },
+    }
+    
+}
+pub fn sensor_opt_sensor(percent:i32) -> i32{
+    let senortype = SENSORTYPE.lock().unwrap();
+    match *senortype {
+        Senortype::IS11 => {
+            unsafe {
+                return IS11_sensor::IS11OptSnenser(percent);
+            }
+
+        },
+        Senortype::IS3 => {
+            unsafe {
+                return IS3_sensor::IS3OptSnenser(percent);
+            }
+
+        },
+        _ => {
+            return 0;
+        },
+    }
+  
+}
+pub fn sensor_get_data_base(outdata: *mut u16, shuttertime: i32) -> i32
+{
+    let senortype = SENSORTYPE.lock().unwrap();
+    match *senortype {
+        Senortype::IS11 => {
+            unsafe {
+                return IS11_sensor::IS11GetData(outdata, shuttertime);
+            }
+
+        },
+        Senortype::IS3 => {
+            unsafe {
+                return IS3_sensor::IS3GetData(outdata, shuttertime);
+            }
+
+        },
+
+        _ => {
+            return 0;
+        },
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+pub fn sensor_get_data(shuttertime: i32) -> Vec<u16> {
+    let sensor_info= SENSOR_INFO.lock().unwrap();
+    let bandSum = sensor_info.BandNum as usize;
+    let mut outdata: Vec<u16> = vec![0; bandSum];
+
+    unsafe {
+
+        let len = sensor_get_data_base(outdata.as_mut_ptr(), shuttertime);
+        outdata.truncate(len as usize);
+
+
+    }
+
+    outdata
+}
+
+pub fn set_sensor_weave_length_coeff(a: Vec<f64>) -> i32 {
+    let senortype = SENSORTYPE.lock().unwrap();
+    match *senortype {
+        Senortype::IS11 => {
+            
+            0
+
+        },
+        Senortype::IS3 => {
+            IS3_sensor::is3_set_weave_length_coeff(a);
+            0
+          
+
+        },
+        _ => {
+            return 0;
+        },
+    }
+}

src-tauri/src/iris_spectral/spectralserver.rs

@@ -0,0 +1,467 @@
+use super::spectralbase;
+use super::spectralbase::*;
+use super::super::mydefine::*;
+use lazy_static::lazy_static;
+use chrono::{self, format, Datelike, Timelike};
+use serde::de;
+use tauri::http::header::UPGRADE;
+use std::thread;
+use std::fs;
+use std::fs::File;
+use std::mem;
+use std::path::Path;
+use std::io::Read;
+#[derive(PartialEq)]
+enum WorkStat {
+    IDLE,
+    WOKING,
+    STOP,
+    OPTING,
+    
+}
+
+
+use std::vec;
+use std::{
+    sync::{Arc, Mutex}, 
+};
+struct is11_dev_data {
+    sensor_info: super::spectralbase::STRSensorInfo,
+    shuttertime: i32,
+    stat: WorkStat,
+    percent: i32,
+    workname: String,
+    hasdark: bool,
+    hasflat: bool,
+    removedark: bool,
+    computeflat: bool,
+    average_number_data: u32,
+    average_number_dark: u32,
+    average_number_flat: u32,
+    has_CalidataUP: bool,
+    
+}
+
+lazy_static! {
+    static ref DEV_STAT: Arc<Mutex<is11_dev_data>> = Arc::new(Mutex::new(is11_dev_data {
+        sensor_info: super::spectralbase::STRSensorInfo::default(),
+        shuttertime: 0,
+        stat: WorkStat::IDLE,
+        percent: 0,
+        workname: "noting".to_string(),
+        hasdark: false,
+        hasflat: false,
+        removedark: false,
+        computeflat: true,
+        average_number_data: 1,
+        average_number_dark: 1,
+        average_number_flat: 1,
+        has_CalidataUP: false,
+
+    }));
+}
+
+
+// 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()));
+    static ref CALIDATAUP: Arc<Mutex<IS11DataStruct>> = Arc::new(Mutex::new(IS11DataStruct::default()));
+    static ref CALIOFFSETUP: Arc<Mutex<IS11DataStruct>> = Arc::new(Mutex::new(IS11DataStruct::default()));
+}
+
+
+
+pub fn is11_get_sensor_info() -> STRSensorInfo {
+    return super::spectralbase::sensor_get_sensor_info();
+}
+pub fn is11_init(){
+    super::spectralbase::sensor_init();
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+   let sensorinfo= is11_get_sensor_info();
+    dev_stat.sensor_info=sensorinfo;
+    
+
+}
+
+
+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.percent=0;
+    dev_stat.workname="opting".to_string();
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+
+      let shuttertime=  super::spectralbase::sensor_opt_sensor(90); //多线程设置曝光时间
+        let mut dev_statnow=DEV_STAT.lock().unwrap();
+        dev_statnow.stat=WorkStat::IDLE;
+        dev_statnow.shuttertime=shuttertime; 
+        dev_statnow.workname="finish".to_string();
+        dev_statnow.percent=100;
+        dev_statnow.hasdark=false;
+        dev_statnow.hasflat=false;
+       }
+    );
+
+    
+    return 0;
+
+
+
+}
+
+pub fn get_now_stat()->(String,String,i32){
+
+
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    match dev_stat.stat {
+        WorkStat::IDLE => {
+            return ("finish".to_string(),dev_stat.workname.clone(),100);
+        },
+        WorkStat::WOKING => {
+            return ("working".to_string(),dev_stat.workname.clone(),dev_stat.percent);
+        },
+        WorkStat::STOP => {
+            return ("finish".to_string(),dev_stat.workname.clone(),dev_stat.percent);
+        },
+        WorkStat::OPTING => {
+            return ("opting".to_string(),dev_stat.workname.clone(),dev_stat.percent);
+        },
+        
+    }
+
+
+}
+
+pub fn collect(shuttertime:u32,removedark:bool,computeflat:bool){
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    if dev_stat.stat != WorkStat::IDLE {
+        return ;
+    }
+   
+    let averagenumber=dev_stat.average_number_data;
+    dev_stat.stat=WorkStat::WOKING;
+    dev_stat.percent=0;
+
+    dev_stat.workname="采集中".to_string();
+    let bandsunm=dev_stat.sensor_info.BandNum  as usize;
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+        
+
+        let mut datasum:Vec<u32>=vec![0;bandsunm];
+        for _i in 0..averagenumber {
+            let data=super::spectralbase::sensor_get_data(shuttertime as i32);
+            for i in 0..bandsunm {
+                datasum[i]=datasum[i]+data[i] as u32;
+            }
+            let mut dev_stat=DEV_STAT.lock().unwrap();
+            let info=format!("采集中,{}%",_i as f32/averagenumber as f32*100 as f32*0.9);
+            dev_stat.workname=info;
+            dev_stat.percent=((_i+1) as f32/averagenumber as f32*100 as f32*0.9) as i32;
+            drop(dev_stat); //释放锁
+
+
+        }
+        let data=datasum.iter().map(|x| *x as f32/averagenumber as f32).collect::<Vec<f32>>();
+        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();
+        let darkdata=DARK_DATA.lock().unwrap();
+        *data1=tempis11data;
+        if removedark && dev_stat.hasdark {
+           
+            for i in 0.._lenth {
+                data1.data[i]=data1.data[i]-darkdata.data[i];
+
+            }          
+        }
+
+        if computeflat && dev_stat.hasflat {
+            let flatdata=FLAT_DATA.lock().unwrap();
+            for i in 0.._lenth {
+
+                let temp=flatdata.data[i]-darkdata.data[i];
+                if temp<=0.0 {
+                    data1.data[i]=10000.0;
+                }else{
+                    data1.data[i]=data1.data[i]/temp*10000.0;
+                }
+                if data1.data[i]<0.0 {
+                    data1.data[i]=0.0;
+                    
+                }
+                if data1.data[i]>15000.0 {
+                    data1.data[i]=15000.0;
+                }
+
+               // data1.data[i]=data1.data[i]/(flatdata.data[i]-darkdata.data[i])*10000.0;
+            }          
+        }
+
+
+        dev_stat.stat=WorkStat::IDLE;
+        dev_stat.percent=100;
+        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 ;
+    }
+    let averagenumber=dev_stat.average_number_dark;
+    dev_stat.stat=WorkStat::WOKING;
+    dev_stat.percent=0;
+    dev_stat.workname="采集Dark中".to_string();
+    let bandsunm=dev_stat.sensor_info.BandNum  as usize;
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+        let mut datasum:Vec<u32>=vec![0;bandsunm];
+        for _i in 0..averagenumber {
+            let data=super::spectralbase::sensor_get_data(shuttertime as i32);
+            for i in 0..bandsunm {
+                datasum[i]=datasum[i]+data[i] as u32;
+            }
+            let mut dev_stat=DEV_STAT.lock().unwrap();
+            let info=format!("采集Dark中,{}%",_i as f32/averagenumber as f32*100 as f32*0.9);
+            dev_stat.workname=info;
+            dev_stat.percent=((_i+1) as f32/averagenumber as f32*100 as f32*0.9) as i32;
+            drop(dev_stat); //释放锁
+        }
+        let data=datasum.iter().map(|x| *x as f32/averagenumber as f32).collect::<Vec<f32>>();
+
+
+        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.percent=100;
+        dev_stat.workname="finish".to_string();
+        dev_stat.hasdark=true;
+    });
+
+
+}
+
+pub fn collcect_flat(shuttertime:u32)
+{
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    if dev_stat.stat != WorkStat::IDLE {
+        return ;
+    }
+    let averagenumber=dev_stat.average_number_flat;
+    dev_stat.stat=WorkStat::WOKING;
+    dev_stat.percent=0;
+    dev_stat.workname="采集中".to_string();
+    let bandsunm=dev_stat.sensor_info.BandNum as usize;
+    drop(dev_stat); //释放锁
+    thread::spawn(move || {
+        let mut datasum:Vec<u32>=vec![0;bandsunm];
+        for _i in 0..averagenumber {
+            let data=super::spectralbase::sensor_get_data(shuttertime as i32);
+            for i in 0..bandsunm {
+                datasum[i]=datasum[i]+data[i] as u32;
+            }
+            let mut dev_stat=DEV_STAT.lock().unwrap();
+            let info=format!("采集白板中,{}%",_i as f32/averagenumber as f32*100 as f32*0.9);
+            dev_stat.workname=info;
+            dev_stat.percent=((_i+1) as f32/averagenumber as f32*100 as f32*0.9) as i32;
+            drop(dev_stat); //释放锁
+        }
+        let data=datasum.iter().map(|x| *x as f32/averagenumber as f32).collect::<Vec<f32>>();
+
+        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.percent=100;
+        dev_stat.workname="finish".to_string();
+        dev_stat.hasflat=true;
+    });
+}
+
+
+pub fn get_data()->IS11DataStruct{
+    let data1=DATA_IS11.lock().unwrap();
+    return data1.clone();
+}
+pub fn get_data_flat()->IS11DataStruct{
+    let data1=FLAT_DATA.lock().unwrap();
+    return data1.clone();
+}
+pub fn get_data_dark()->IS11DataStruct{
+    let data1=DARK_DATA.lock().unwrap();
+    return data1.clone();
+}
+pub fn get_is_computeref()->bool{
+    let dev_stat=DEV_STAT.lock().unwrap();
+    return dev_stat.computeflat;
+}
+
+pub fn set_shutter_time(shuttertime:u32){
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    dev_stat.shuttertime=shuttertime as i32;
+    dev_stat.hasdark=false;
+    dev_stat.hasflat=false;
+}
+
+
+pub fn set_average_number(arverage_number_data:u32,arverage_number_dark:u32,arverage_number_flat:u32){
+    let mut dev_stat=DEV_STAT.lock().unwrap();
+    dev_stat.average_number_data=arverage_number_data;
+    dev_stat.average_number_dark=arverage_number_dark;
+    dev_stat.average_number_flat=arverage_number_flat;
+}
+
+
+
+
+pub fn calibrate_file(orgdata: &IS11DataStruct) -> IS11DataStruct {
+    let dev_stat=DEV_STAT.lock().unwrap();
+    if !dev_stat.has_CalidataUP {
+        return orgdata.clone();
+    }
+    drop(dev_stat);
+    ;
+    let calidata=CALIDATAUP.lock().unwrap();
+    let offsetdata=CALIOFFSETUP.lock().unwrap();
+
+    let mut data = IS11DataStruct::default();
+    let collect_gaindb = orgdata.temprature[0];
+    let collect_shutter = orgdata.shutter_time;
+    let cali_gaindb = calidata.temprature[0];
+    let cali_shutter = calidata.shutter_time;
+    //db 转系数
+    let mut collect_gain = 10.0_f32.powf(collect_gaindb / 20.0);
+    let mut cali_gain = 10.0_f32.powf(cali_gaindb / 20.0);
+    //计算增益
+    let mut Scale_gain = cali_gain / collect_gain;
+    let mut Scale_shutter = cali_shutter as f32/ collect_shutter as f32;
+    let mut SCale = Scale_gain * Scale_shutter as f32;
+    let len = orgdata.data.len();
+    for i in 0..len {
+        data.data[i] = orgdata.data[i] * SCale * calidata.data[i]+offsetdata.data[i];
+    }
+    return data;
+}
+
+
+pub fn  load_all_calibrate_file(filepath: String) -> String {
+    let file_path = Path::new(&filepath);
+    if file_path.exists() {
+        let mut up_gain_data=CALIDATAUP.lock().unwrap();
+        *up_gain_data=load_calibrate_file(file_path.to_str().unwrap().to_string()).unwrap();
+        let mut dev_stat=DEV_STAT.lock().unwrap();
+        dev_stat.has_CalidataUP=true;
+        return "ok".to_string();
+    } else {
+        println!("文件不存在: {:?}", file_path);
+        return "文件不存在".to_string();
+        
+    }
+
+}
+
+
+
+
+
+
+
+fn load_calibrate_file(filepath: String) -> Result<IS11DataStruct, String> {
+    let mut data = IS11DataStruct::default();
+    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];
+    let mut file = File::open(filepath).unwrap();
+    file.read_exact(&mut buffer).unwrap();
+    unsafe {
+        let ptr = &mut data as *mut IS11DataStruct as *mut u8;
+        std::ptr::copy_nonoverlapping(buffer.as_ptr(), ptr, mem::size_of::<IS11DataStruct>());
+    }
+    return Ok(data);
+}
+
+pub fn set_weave_coeff(specnumber: i32, a0: f64, a1: f64, a2: f64, a3: f64) -> String {
+   let vecdata=vec![a0,a1,a2,a3];
+   spectralbase::set_sensor_weave_length_coeff(vecdata);
+    "ok".to_string()
+}
+

src-tauri/src/irishypersptral/mod.rs

@@ -19,7 +19,14 @@ 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();
+    let lenthofgain = gain.len() ;
+    for i in 0..lenthofgain {
+        
+    
+        data.data[i] = gain[i];
+    } 
+    
+
     data.shutter_time = shutter as u32;
     data.direction = if direction { 1 } else { 0 };
     data.datatype = 0x04;

src-tauri/src/main.rs

@@ -4,18 +4,19 @@
 mod algorithm;
 mod mylog;
 mod serport;
+mod iris_spectral;
 mod irishypersptral;
 mod mydefine;
 mod comman1;
-mod jianzhiis11;
 use comman1::*;
 use algorithm::interpolate_spline;
 use algorithm::sg_smooth;
 use mydefine::*;
+use iris_spectral::spectralbase::Senortype;
 
 enum DevName {
     IRIS_IS11,
-    JZ_IS11
+    IRIS_SENSOR(Senortype),
     
 }
 
@@ -25,7 +26,7 @@ use std::sync::Mutex;
 use std::sync::Arc;
 //设置一个可修改的全局变量
 lazy_static! {
-    static ref DEVNAME: Mutex<DevName> = Mutex::new(DevName::IRIS_IS11);
+    static ref DEVNAME: Mutex<DevName> = Mutex::new(DevName::IRIS_SENSOR(Senortype::IS3));
 }
 
 #[tauri::command]
@@ -51,7 +52,7 @@ fn savecalibratefile(gain: Vec<f32>, shutter: u32, direction: bool, filepath: St
         DevName::IRIS_IS11=>{
             return irishypersptral::savecalibratefile_iris(gain, shutter, direction, filepath);
         },
-        DevName::JZ_IS11=>{
+        DevName::IRIS_SENSOR(sensor_type)=>{
             return irishypersptral::savecalibratefile_iris(gain, shutter, direction, filepath);
            //return  jianzhiis11::s(gain, shutter, direction, filepath);
         }
@@ -68,7 +69,7 @@ fn sendcalibratetodev(gain: Vec<f32>, shutter: u32, direction: u32) -> String {
         DevName::IRIS_IS11=>{
             return irishypersptral::sendcalibratetodev_iris(gain, shutter, direction !=0);
         },
-        DevName::JZ_IS11=>{
+        DevName::IRIS_SENSOR(sensor_type)=>{
             return irishypersptral::sendcalibratetodev_iris(gain, shutter, direction !=0);
            //return  jianzhiis11::s(gain, shutter, direction, filepath);
         }
@@ -83,8 +84,18 @@ fn sendcalibratetodev(gain: Vec<f32>, shutter: u32, direction: u32) -> String {
 
 
 
-
-
+#[tauri::command]
+fn setdevtype(devtype: String)->String {
+    let mut devname1 = DEVNAME.lock().unwrap();
+    match devtype.as_str() {
+        "IRIS-IS11" => *devname1 = DevName::IRIS_IS11,
+        "IS3" => *devname1 = DevName::IRIS_SENSOR(Senortype::IS3),
+        "IS11" => *devname1 = DevName::IRIS_SENSOR(Senortype::IS11),
+        _ => *devname1 = DevName::IRIS_SENSOR(Senortype::IS3),
+    }
+    mylog::logtorust("set dev to ".to_string()+&devtype);
+    return "ok".to_string();
+}
 
 
 
@@ -104,6 +115,17 @@ fn sendtoport(data: serde_json::Value, datatype: serde_json::Value) -> String {
 fn readformport(commanid: serde_json::Value, wait_time_json: serde_json::Value) -> String {
   irishypersptral::readformport_iris(commanid, wait_time_json)
 }
+#[tauri::command]
+fn set_weave_coeff(specnumber: i32, a0: f64, a1: f64, a2: f64, a3: f64) -> String {
+    let devname=DEVNAME.lock().unwrap();
+    match *devname{
+        DevName::IRIS_SENSOR(sensor_type) =>{
+            iris_spectral::set_weave_coeff(specnumber, a0, a1, a2, a3);
+        }  ,
+        _ => {},
+    }
+    "OK".to_string()
+}
 
 #[tauri::command]
  fn opencom(portname: serde_json::Value, baudrate: serde_json::Value) -> String {
@@ -115,7 +137,7 @@ fn readformport(commanid: serde_json::Value, wait_time_json: serde_json::Value)
         DevName::IRIS_IS11=>{
              baudrate =115200 as u32;
         },
-        DevName::JZ_IS11=>{
+        DevName::IRIS_SENSOR(sensor_type)=>{
             baudrate =921600 as u32;
 
         }
@@ -144,8 +166,8 @@ fn sendtoport_andgetreturn(
         DevName::IRIS_IS11=>{
             return irishypersptral::sendtoport_andgetreturn_iris(data, datatype);
         },
-        DevName::JZ_IS11=>{
-            return jianzhiis11::sendtoport_andgetreturn(data, datatype);
+        DevName::IRIS_SENSOR(sensor_type)=>{
+            return iris_spectral::sendtoport_andgetreturn(data, datatype);
         }
         
     }
@@ -153,6 +175,20 @@ fn sendtoport_andgetreturn(
 
     //jianzhiis11::sendtoport_andgetreturn(data, datatype)
    
+}
+#[tauri::command]
+fn delete_file_by_path(filepath: String) -> String {
+    let devname=DEVNAME.lock().unwrap();
+    match *devname {
+        DevName::IRIS_IS11=>{
+            "delete_file_by_path_iris(filepath)".to_string()
+        },
+        DevName::IRIS_SENSOR(sensor_type)=>{
+            return iris_spectral::delete_file(filepath)
+        }
+    }
+        
+    
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
@@ -180,9 +216,13 @@ fn main() {
             sg_smooth,
             savecalibratefile,
             sendcalibratetodev,
+            setdevtype,
+            set_weave_coeff,
+            delete_file_by_path,
             algorithm::gaussian_filter_high,
             algorithm::interpolate_spline_at_points,
-            algorithm::find_peek
+            algorithm::find_peek,
+            algorithm::compute_weave_coeff
         ])
         .setup(|app| {
 

src-tauri/src/serport/serport.rs

@@ -103,11 +103,12 @@ pub fn sendtoprot(data: Vec<u8>) -> String {
     if port_info.port_name == "NON" {
         return format!("Port is not set");
     }
-
+    println!("{:?}", data.iter().map(|&byte| format!("{:02X}", byte)).collect::<Vec<String>>().join(" "));
     match &mut port_info.port {
         Some(p) => match p.write(&data) {
             Ok(_) => {
                 println!("Data sent");
+               
                 return String::from("Data sent");
             }
             Err(e) => {

src-tauri/tauri.conf.json

@@ -10,7 +10,7 @@
 
   "package": {
     "productName": "SpectralPlot",
-    "version": "0.5.57"
+    "version": "0.6.59"
   },
   "tauri": {
 
@@ -59,7 +59,11 @@
       "targets": "all",
       "identifier": "lele.rlx",
       "resources": [
-        "config.json","is11lib.dll"
+        "config.json","is11lib.dll"  , "iris_is3lib.dll", 
+        "msvcp140.dll",
+        "vcruntime140.dll",
+        "vcruntime140_1.dll",
+        "ucrtbase.dll"
       ],
       "windows": {