fix read

src/modbus_client.rs

@@ -43,7 +43,7 @@ impl ModbusClient {
         }
     }
 
-    pub async fn request(&mut self, slave_id: u8, address: u16) -> Result<(), Box<dyn std::error::Error>> {
+    pub async fn request(&mut self, slave_id: u8, address: u16, cnt: u16) -> Result<Vec<u16>, Box<dyn std::error::Error>> {
         let slave = Slave(slave_id);
         let mut ctx = rtu::attach_slave(&mut self.stream, slave);
 
@@ -52,15 +52,31 @@ impl ModbusClient {
             // 保持寄存器（Holding Registers）: 40000-49999
             40000..=49999 => {
                 let modbus_addr = address - 40000;  // 转换为 Modbus 协议地址（0-9999）
-                let response = ctx.read_holding_registers(modbus_addr, 1).await?;
+                let response = ctx.read_holding_registers(modbus_addr, cnt).await?;
                 println!("Holding Register {}: {:?}", modbus_addr, response);
+                match response {
+                    Ok(bytes) => {
+                        Ok(bytes)
+                    }
+                    Err(e) => {
+                        Err(e.into())
+                    }
+                }
             }
 
             // 输入寄存器（Input Registers）: 30000-39999
             30000..=39999 => {
                 let modbus_addr = address - 30000;
-                let response = ctx.read_input_registers(modbus_addr, 1).await?;
+                let response = ctx.read_input_registers(modbus_addr, cnt).await?;
                 println!("Input Register {}: {:?}", modbus_addr, response);
+                match response {
+                    Ok(bytes) => {
+                        Ok(bytes)
+                    }
+                    Err(e) => {
+                        Err(e.into())
+                    }
+                }
             }
 
             // 离散输入（Discrete Inputs）: 10000-19999
@@ -68,19 +84,42 @@ impl ModbusClient {
                 let modbus_addr = address - 10000;
                 let response = ctx.read_discrete_inputs(modbus_addr, 1).await?;
                 println!("Discrete Input {}: {:?}", modbus_addr, response);
+                match response {
+                    Ok(bytes) => {
+                        Ok(Self::bool_to_u16(bytes[0]))
+                    }
+                    Err(e) => {
+                        Err(e.into())
+                    }
+                }
             }
 
             // 线圈（Coils）: 0-9999
             0..=9999 => {
                 let response = ctx.read_coils(address, 1).await?;
                 println!("Coil {}: {:?}", address, response);
+                match response {
+                    Ok(bytes) => {
+                        Ok(Self::bool_to_u16(bytes[0]))
+                    }
+                    Err(e) => {
+                        Err(e.into())
+                    }
+                }
             }
 
             _ => {
                 return Err("Invalid Modbus address".into());
             }
         }
+    }
 
-        Ok(())
+    pub fn bool_to_u16(val: bool) -> Vec<u16> {
+        if val {
+            vec![1]
+        } else {
+            vec![0]
         }
     }
+
+}