后端请求串口实现

怼烎@ 2023-06-16 10:38 8阅读 0赞

**一、采用easymodbus4j**

import java.time.LocalDateTime;
    import java.time.ZoneOffset;
    import java.time.format.DateTimeFormatter;
    import java.util.Random;
    import com.github.zengfr.easymodbus4j.app.common.DeviceCommand;
    
    public class DeviceClient extends UdpClient { 
    	private static final int MAX = 10000 * 999;
    	private static final int MIN = 10000 * 100;
    	private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
    	private static Random rnd = new Random();
    	private static class DeviceClientHolder { 
    		private static final DeviceClient INSTANCE = new DeviceClient();
    	}
    
    	public static DeviceClient getInstance() { 
    		return DeviceClientHolder.INSTANCE;
    	}
    	private DeviceClient() { 
    		
    	}
    	public <T> String sendCommand(String host, int port, DeviceCommand<T> cmd) throws InterruptedException { 
    		String uuid = getUUID();
    		getSender().send(host, port, buildCommandMessage(uuid, cmd));
    		return uuid;
    	}
    	public <T> String sendCommand(String host, int port, String msg) throws InterruptedException   { 
    		String uuid = getUUID();
    		getSender().send(host, port, buildCommandMessage(uuid, msg));
    		return uuid;
    	}
    	protected <T> String buildCommandMessage(String uuid, DeviceCommand<T> cmd) { 
    		return buildCommandMessage(uuid, cmd.toString());
    	}
    	protected <T> String buildCommandMessage(String uuid, String cmd) { 
    		return String.format("%s;%s", uuid, cmd);
    	}
    	protected String getUUID() { 
    		int randNumber = rnd.nextInt(MAX - MIN + 1) + MIN;
    		return String.format("%s%s", LocalDateTime.now(ZoneOffset.of("+8")).format(formatter), randNumber);
    	}
    }

import org.apache.commons.lang3.StringUtils;
    
    public class DeviceCommand<T> { 
    	/** 设备标识id(必选) */
    	private String deviceId;
    	/** 设备ip(可选) */
    	private String ip;
    	/** 设备port(可选) */
    	private int port;
    
    	/** 设备型号(可选) */
    	private String version;
    	/** 见classFunctionCode */
    	private int functionCode;
    	/** 寄存器地址 */
    	private int address;
    	/** 寄存器地址值 */
    	private T value;
    	/** 寄存器地址值 */
    	private T[] values;
    	/** 值类型 */
    	private String valueType;
    
    	public String getDeviceId() { 
    		return this.deviceId;
    	}
    
    	public void setDeviceId(String deviceId) { 
    		this.deviceId = deviceId;
    	}
    
    	public String getIp() { 
    		return this.ip;
    	}
    
    	public void setIp(String ip) { 
    		this.ip = ip;
    	}
    
    	public int getPort() { 
    		return this.port;
    	}
    
    	public void setPort(int port) { 
    		this.port = port;
    	}
    
    	public String getVersion() { 
    		return this.version;
    	}
    
    	public void setVersion(String version) { 
    		this.version = version;
    	}
    
    	public int getFunctionCode() { 
    		return this.functionCode;
    	}
    
    	public void setFunctionCode(int functionCode) { 
    		this.functionCode = functionCode;
    	}
    
    	public int getAddress() { 
    		return this.address;
    	}
    
    	public void setAddress(int address) { 
    		this.address = address;
    	}
    
    	public T getValue() { 
    		return this.value;
    	}
    
    	public void setValue(T value) { 
    		this.value = value;
    		syncValueType();
    	}
    
    	public T[] getValues() { 
    		return this.values;
    	}
    
    	public void setValues(T[] values) { 
    		this.values = values;
    		syncValueType();
    	}
    
    	public void setValueType(String valueType) { 
    		this.valueType = valueType;
    	}
    
    	public String getValueType() { 
    		return valueType;
    	}
    
    	public void syncValueType() { 
    		setValueType(getValueType(this.value, this.values));
    	}
    
    	@Override
    	public String toString() { 
    		return String.format("%s;%s;%s;%s;%s;%s;%s;%s;%s", deviceId, ip, port, version, functionCode, address,
    				getValueType(), value, StringUtils.join(values, ','));
    	}
    
    	private static <T> String getValueType(T v, T[] vv) { 
    		if (v != null && !v.toString().isEmpty()) { 
    			return v.getClass().getSimpleName();
    		} else if (vv != null && vv.length > 0) { 
    			return vv[0].getClass().getSimpleName();
    		}
    		return "";
    	}
    
    }

import java.net.InetSocketAddress;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.Channel;
    import io.netty.channel.socket.DatagramPacket;
    import io.netty.util.CharsetUtil;
    
    public class UdpSender { 
    	protected Channel channel;
    
    	public UdpSender(Channel channel) { 
    		this.channel = channel;
    	}
    
    	public void send(DatagramPacket packet) throws InterruptedException { 
    		channel.writeAndFlush(packet).sync();
    	}
    
    	public void send(String host, int port, String msg) throws InterruptedException { 
    		send(new InetSocketAddress(host, port), msg);
    	}
    
    	public void send(InetSocketAddress address, String msg) throws InterruptedException { 
    		send(address, Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8));
    	}
    
    	public void send(String host, int port, ByteBuf byteBuf) throws InterruptedException { 
    		send(new InetSocketAddress(host, port), byteBuf);
    	}
    
    	public void send(InetSocketAddress address, ByteBuf byteBuf) throws InterruptedException { 
    		send(new DatagramPacket(byteBuf, address));
    	}
    }

**二、使用modbus4j的jar包**

<dependency>
                <groupId>com.digitalpetri.modbus</groupId>
                <artifactId>modbus-master-tcp</artifactId>
                <version>1.1.0</version>
            </dependency>
             <dependency>
    		    <groupId>com.infiniteautomation</groupId>
    		    <artifactId>modbus4j</artifactId>
    		    <version>3.0.5</version>
    		</dependency>

import com.serotonin.modbus4j.BatchRead;
    import com.serotonin.modbus4j.BatchResults;
    import com.serotonin.modbus4j.ModbusFactory;
    import com.serotonin.modbus4j.ModbusMaster;
    import com.serotonin.modbus4j.code.DataType;
    import com.serotonin.modbus4j.exception.ErrorResponseException;
    import com.serotonin.modbus4j.exception.ModbusInitException;
    import com.serotonin.modbus4j.exception.ModbusTransportException;
    import com.serotonin.modbus4j.ip.IpParameters;
    import com.serotonin.modbus4j.locator.BaseLocator;
    
    
    /** * modbus通讯工具类,采用modbus4j实现 * * @author lxq * @dependencies modbus4j-3.0.3.jar * @website https://github.com/infiniteautomation/modbus4j */
    public class Modbus4jUtils { 
    	/** * 工厂。 */
    	static ModbusFactory modbusFactory;
    	static { 
    		if (modbusFactory == null) { 
    			modbusFactory = new ModbusFactory();
    		}
    	}
    
    	/** * 获取master * * @return * @throws ModbusInitException */
    	public static ModbusMaster getMaster() throws ModbusInitException { 
    		IpParameters params = new IpParameters();
    		params.setHost("localhost");
    		params.setPort(502);
    		//
    		// modbusFactory.createRtuMaster(wapper); //RTU 协议
    		// modbusFactory.createUdpMaster(params);//UDP 协议
    		// modbusFactory.createAsciiMaster(wrapper);//ASCII 协议
    		ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 协议
    		master.init();
    
    		return master;
    	}
    
    	/** * 读取[01 Coil Status 0x]类型 开关数据 * * @param slaveId * slaveId * @param offset * 位置 * @return 读取值 * @throws ModbusTransportException * 异常 * @throws ErrorResponseException * 异常 * @throws ModbusInitException * 异常 */
    	public static Boolean readCoilStatus(int slaveId, int offset)
    			throws ModbusTransportException, ErrorResponseException, ModbusInitException { 
    		// 01 Coil Status
    		BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
    		Boolean value = getMaster().getValue(loc);
    		return value;
    	}
    
    	/** * 读取[02 Input Status 1x]类型 开关数据 * * @param slaveId * @param offset * @return * @throws ModbusTransportException * @throws ErrorResponseException * @throws ModbusInitException */
    	public static Boolean readInputStatus(int slaveId, int offset)
    			throws ModbusTransportException, ErrorResponseException, ModbusInitException { 
    		// 02 Input Status
    		BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
    		Boolean value = getMaster().getValue(loc);
    		return value;
    	}
    
    	/** * 读取[03 Holding Register类型 2x]模拟量数据 * * @param slaveId * slave Id * @param offset * 位置 * @param dataType * 数据类型,来自com.serotonin.modbus4j.code.DataType * @return * @throws ModbusTransportException * 异常 * @throws ErrorResponseException * 异常 * @throws ModbusInitException * 异常 */
    	public static Number readHoldingRegister(int slaveId, int offset, int dataType)
    			throws ModbusTransportException, ErrorResponseException, ModbusInitException { 
    		// 03 Holding Register类型数据读取
    		BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
    		Number value = getMaster().getValue(loc);
    		return value;
    	}
    
    	/** * 读取[04 Input Registers 3x]类型 模拟量数据 * * @param slaveId * slaveId * @param offset * 位置 * @param dataType * 数据类型,来自com.serotonin.modbus4j.code.DataType * @return 返回结果 * @throws ModbusTransportException * 异常 * @throws ErrorResponseException * 异常 * @throws ModbusInitException * 异常 */
    	public static Number readInputRegisters(int slaveId, int offset, int dataType)
    			throws ModbusTransportException, ErrorResponseException, ModbusInitException { 
    		// 04 Input Registers类型数据读取
    		BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
    		Number value = getMaster().getValue(loc);
    		return value;
    	}
    
    	/** * 批量读取使用方法 * * @throws ModbusTransportException * @throws ErrorResponseException * @throws ModbusInitException */
    	public static void batchRead() throws ModbusTransportException, ErrorResponseException, ModbusInitException { 
    
    		BatchRead<Integer> batch = new BatchRead<Integer>();
    
    		batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.FOUR_BYTE_FLOAT));
    		batch.addLocator(1, BaseLocator.inputStatus(1, 0));
    
    		ModbusMaster master = getMaster();
    
    		batch.setContiguousRequests(false);
    		BatchResults<Integer> results = master.send(batch);
    		System.out.println(results.getValue(0));
    		System.out.println(results.getValue(1));
    	}
    
    	/** * 测试 * * @param args */
    	public static void main(String[] args) { 
    		try { 
    			// 01测试
    			Boolean v011 = readCoilStatus(1, 0);
    			Boolean v012 = readCoilStatus(1, 1);
    			Boolean v013 = readCoilStatus(1, 6);
    			System.out.println("v011:" + v011);
    			System.out.println("v012:" + v012);
    			System.out.println("v013:" + v013);
    			// 02测试
    			Boolean v021 = readInputStatus(1, 0);
    			Boolean v022 = readInputStatus(1, 1);
    			Boolean v023 = readInputStatus(1, 2);
    			System.out.println("v021:" + v021);
    			System.out.println("v022:" + v022);
    			System.out.println("v023:" + v023);
    
    			// 03测试
    			Number v031 = readHoldingRegister(1, 1, DataType.FOUR_BYTE_FLOAT);// 注意,float
    			Number v032 = readHoldingRegister(1, 3, DataType.FOUR_BYTE_FLOAT);// 同上
    			System.out.println("v031:" + v031);
    			System.out.println("v032:" + v032);
    
    			// 04测试
    			Number v041 = readInputRegisters(1, 0, DataType.FOUR_BYTE_FLOAT);//
    			Number v042 = readInputRegisters(1, 2, DataType.FOUR_BYTE_FLOAT);//
    			System.out.println("v041:" + v041);
    			System.out.println("v042:" + v042);
    			// 批量读取
    			batchRead();
    
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    }

import com.serotonin.modbus4j.locator.BaseLocator;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    import com.serotonin.modbus4j.ModbusFactory;
    import com.serotonin.modbus4j.ModbusMaster;
    import com.serotonin.modbus4j.code.DataType;
    import com.serotonin.modbus4j.exception.ErrorResponseException;
    import com.serotonin.modbus4j.exception.ModbusInitException;
    import com.serotonin.modbus4j.exception.ModbusTransportException;
    import com.serotonin.modbus4j.ip.IpParameters;
    import com.serotonin.modbus4j.msg.ModbusResponse;
    import com.serotonin.modbus4j.msg.WriteCoilRequest;
    import com.serotonin.modbus4j.msg.WriteCoilResponse;
    import com.serotonin.modbus4j.msg.WriteCoilsRequest;
    import com.serotonin.modbus4j.msg.WriteCoilsResponse;
    import com.serotonin.modbus4j.msg.WriteRegisterRequest;
    import com.serotonin.modbus4j.msg.WriteRegisterResponse;
    import com.serotonin.modbus4j.msg.WriteRegistersRequest;
    
    /** * modbus4j写入数据 * * @author xq * */
    public class Modbus4jWriteUtils { 
    	static Log log = LogFactory.getLog(Modbus4jWriteUtils.class);
    	/** * 工厂。 */
    	static ModbusFactory modbusFactory;
    	static { 
    		if (modbusFactory == null) { 
    			modbusFactory = new ModbusFactory();
    		}
    	}
    
    	/** * 获取tcpMaster * * @return * @throws ModbusInitException */
    	public static ModbusMaster getMaster() throws ModbusInitException { 
    		IpParameters params = new IpParameters();
    		params.setHost("localhost");
    		params.setPort(502);
    
    		ModbusMaster tcpMaster = modbusFactory.createTcpMaster(params, false);
    		tcpMaster.init();
    
    		return tcpMaster;
    	}
    
    	/** * 写 [01 Coil Status(0x)]写一个 function ID = 5 * * @param slaveId * slave的ID * @param writeOffset * 位置 * @param writeValue * 值 * @return 是否写入成功 * @throws ModbusTransportException * @throws ModbusInitException */
    	public static boolean writeCoil(int slaveId, int writeOffset, boolean writeValue)
    			throws ModbusTransportException, ModbusInitException { 
    		// 获取master
    		ModbusMaster tcpMaster = getMaster();
    		// 创建请求
    		WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
    		// 发送请求并获取响应对象
    		WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
    		if (response.isException()) { 
    			return false;
    		} else { 
    			return true;
    		}
    	}
    
    	/** * 写[01 Coil Status(0x)] 写多个 function ID = 15 * * @param slaveId * slaveId * @param startOffset * 开始位置 * @param bdata * 写入的数据 * @return 是否写入成功 * @throws ModbusTransportException * @throws ModbusInitException */
    	public static boolean writeCoils(int slaveId, int startOffset, boolean[] bdata)
    			throws ModbusTransportException, ModbusInitException { 
    		// 获取master
    		ModbusMaster tcpMaster = getMaster();
    		// 创建请求
    		WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, bdata);
    		// 发送请求并获取响应对象
    		WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
    		if (response.isException()) { 
    			return false;
    		} else { 
    			return true;
    		}
    
    	}
    
    	/*** * 写[03 Holding Register(4x)] 写一个 function ID = 6 * * @param slaveId * @param writeOffset * @param writeValue * @return * @throws ModbusTransportException * @throws ModbusInitException */
    	public static boolean writeRegister(int slaveId, int writeOffset, short writeValue)
    			throws ModbusTransportException, ModbusInitException { 
    		// 获取master
    		ModbusMaster tcpMaster = getMaster();
    		// 创建请求对象
    		WriteRegisterRequest request = new WriteRegisterRequest(slaveId, writeOffset, writeValue);
    		WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.send(request);
    		if (response.isException()) { 
    			log.error(response.getExceptionMessage());
    			return false;
    		} else { 
    			return true;
    		}
    
    	}
    
    	/** * * 写入[03 Holding Register(4x)]写多个 function ID=16 * * @param slaveId * modbus的slaveID * @param startOffset * 起始位置偏移量值 * @param sdata * 写入的数据 * @return 返回是否写入成功 * @throws ModbusTransportException * @throws ModbusInitException */
    	public static boolean writeRegisters(int slaveId, int startOffset, short[] sdata)
    			throws ModbusTransportException, ModbusInitException { 
    		// 获取master
    		ModbusMaster tcpMaster = getMaster();
    		// 创建请求对象
    		WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, sdata);
    		// 发送请求并获取响应对象
    		ModbusResponse response = tcpMaster.send(request);
    		if (response.isException()) { 
    			log.error(response.getExceptionMessage());
    			return false;
    		} else { 
    			return true;
    		}
    	}
    
    	/** * 写入数字类型的模拟量（如:写入Float类型的模拟量、Double类型模拟量、整数类型Short、Integer、Long） * * @param slaveId * @param offset * @param value * 写入值,Number的子类,例如写入Float浮点类型,Double双精度类型,以及整型short,int,long * ,com.serotonin.modbus4j.code.DataType * @throws ModbusTransportException * @throws ErrorResponseException * @throws ModbusInitException */
    	public static void writeHoldingRegister(int slaveId, int offset, Number value, int dataType)
    			throws ModbusTransportException, ErrorResponseException, ModbusInitException { 
    		// 获取master
    		ModbusMaster tcpMaster = getMaster();
    		// 类型
    		BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
    		tcpMaster.setValue(locator, value);
    	}
    
    	public static void main(String[] args) { 
    		try { 
    			//@formatter:off
    			// 测试01
    // boolean t01 = writeCoil(1, 0, true);
    // System.out.println("T01:" + t01);
    
    			// 测试02
    // boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
    // System.out.println("T02:" + t02);
    
    			// 测试03
    // short v = -3;
    // boolean t03 = writeRegister(1, 0, v);
    // System.out.println("T03:" + t03);
    			// 测试04
    // boolean t04 = writeRegisters(1, 0, new short[] { -3, 3, 9 });
    // System.out.println("t04:" + t04);
    			//写模拟量
    			writeHoldingRegister(1,0, 10.1f, DataType.FOUR_BYTE_FLOAT);
    			
    			//@formatter:on
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    
    	}
    
    }

import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.ExecutionException;
    import com.digitalpetri.modbus.codec.Modbus;
    import com.digitalpetri.modbus.master.ModbusTcpMaster;
    import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
    import com.digitalpetri.modbus.requests.ReadCoilsRequest;
    import com.digitalpetri.modbus.requests.ReadDiscreteInputsRequest;
    import com.digitalpetri.modbus.requests.ReadHoldingRegistersRequest;
    import com.digitalpetri.modbus.requests.ReadInputRegistersRequest;
    import com.digitalpetri.modbus.responses.ReadCoilsResponse;
    import com.digitalpetri.modbus.responses.ReadDiscreteInputsResponse;
    import com.digitalpetri.modbus.responses.ReadHoldingRegistersResponse;
    import com.digitalpetri.modbus.responses.ReadInputRegistersResponse;
    import io.netty.buffer.ByteBuf;
    import io.netty.util.ReferenceCountUtil;
    
    /*** * modbus TCP协议Java通讯读取例子 * * @author xqlee * */
    public class SimpleMasterExample { 
    
    	static ModbusTcpMaster master;
    
    	/** * 获取TCP协议的Master * * @return */
    	public static void initModbusTcpMaster() { 
    		if (master == null) { 
    			// 创建配置
    			ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("localhost").setPort(502).build();
    			master = new ModbusTcpMaster(config);
    		}
    	}
    
    	/*** * 释放资源 */
    	public static void release() { 
    		if (master != null) { 
    			master.disconnect();
    		}
    		Modbus.releaseSharedResources();
    	}
    
    	/** * 读取HoldingRegister数据 * * @param address * 寄存器地址 * @param quantity * 寄存器数量 * @param unitId * id * @return 读取结果 * @throws InterruptedException * 异常 * @throws ExecutionException * 异常 */
    	public static Number readHoldingRegisters(int address, int quantity, int unitId)
    			throws InterruptedException, ExecutionException { 
    		Number result = null;
    		CompletableFuture<ReadHoldingRegistersResponse> future = master
    				.sendRequest(new ReadHoldingRegistersRequest(address, quantity), unitId);
    		ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();
    		// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
    		if (readHoldingRegistersResponse != null) { 
    			ByteBuf buf = readHoldingRegistersResponse.getRegisters();
    			result = buf.readFloat();
    			ReferenceCountUtil.release(readHoldingRegistersResponse);
    		}
    		return result;
    	}
    
    	/** * 读取InputRegisters模拟量数据 * * @param address * 寄存器开始地址 * @param quantity * 数量 * @param unitId * ID * @return 读取值 * @throws InterruptedException * 异常 * @throws ExecutionException * 异常 */
    	public static Number readInputRegisters(int address, int quantity, int unitId)
    			throws InterruptedException, ExecutionException { 
    		Number result = null;
    		CompletableFuture<ReadInputRegistersResponse> future = master
    				.sendRequest(new ReadInputRegistersRequest(address, quantity), unitId);
    		ReadInputRegistersResponse readInputRegistersResponse = future.get();
    		// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
    		if (readInputRegistersResponse != null) { 
    			ByteBuf buf = readInputRegistersResponse.getRegisters();
    			result = buf.readFloat();
    			ReferenceCountUtil.release(readInputRegistersResponse);
    		}
    		return result;
    	}
    
    	/** * 读取Coils开关量 * * @param address * 寄存器开始地址 * @param quantity * 数量 * @param unitId * ID * @return 读取值 * @throws InterruptedException * 异常 * @throws ExecutionException * 异常 */
    	public static Boolean readCoils(int address, int quantity, int unitId)
    			throws InterruptedException, ExecutionException { 
    		Boolean result = null;
    		CompletableFuture<ReadCoilsResponse> future = master.sendRequest(new ReadCoilsRequest(address, quantity),
    				unitId);
    		ReadCoilsResponse readCoilsResponse = future.get();
    		// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
    		if (readCoilsResponse != null) { 
    			ByteBuf buf = readCoilsResponse.getCoilStatus();
    			result = buf.readBoolean();
    			ReferenceCountUtil.release(readCoilsResponse);
    		}
    		return result;
    	}
    
    	/** * 读取readDiscreteInputs开关量 * * @param address * 寄存器开始地址 * @param quantity * 数量 * @param unitId * ID * @return 读取值 * @throws InterruptedException * 异常 * @throws ExecutionException * 异常 */
    	public static Boolean readDiscreteInputs(int address, int quantity, int unitId)
    			throws InterruptedException, ExecutionException { 
    		Boolean result = null;
    		CompletableFuture<ReadDiscreteInputsResponse> future = master
    				.sendRequest(new ReadDiscreteInputsRequest(address, quantity), unitId);
    		ReadDiscreteInputsResponse discreteInputsResponse = future.get();
    		// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
    		if (discreteInputsResponse != null) { 
    			ByteBuf buf = discreteInputsResponse.getInputStatus();
    			result = buf.readBoolean();
    			ReferenceCountUtil.release(discreteInputsResponse);
    		}
    		return result;
    	}
    
    	public static void main(String[] args) { 
    		try { 
    			// 初始化资源
    			initModbusTcpMaster();
    			// 执行操作
    			// 读取模拟量
    			System.out.println(readHoldingRegisters(0, 4, 1));
    			System.out.println(readInputRegisters(0, 4, 1));
    
    			// 读取开关量
    			System.out.println(readCoils(0, 1, 1));
    			System.out.println(readDiscreteInputs(0, 1, 1));
    			System.out.println(readDiscreteInputs(2, 1, 1));
    
    			// 释放资源
    			release();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    }

**三、socket实现工具类**

public static byte[] sendRequest(String serverIp, int port, byte[] bytes) { 
            try (Socket socket = new Socket(serverIp, port);
                 InputStream in = socket.getInputStream();
                 OutputStream out = socket.getOutputStream()) { 
                socket.setTcpNoDelay(true);
                if (bytes != null) { 
                    out.write(bytes);
                }
                socket.shutdownOutput();
                byte[] resultBytes = IOUtils.toByteArray(in);
                socket.shutdownInput();
                return resultBytes;
            } catch (Exception e) { 
                logger.error("错误", e);
            }
            return new byte[0];
        }
    
    
        public static String getCrc16(byte[] arr_buff) { 
            int len = arr_buff.length;
            //预置 1 个 16 位的寄存器为十六进制FFFF, 称此寄存器为 CRC寄存器。
            int crc = 0xFFFF;
            int i, j;
            for (i = 0; i < len; i++) { 
                //把第一个 8 位二进制数据 与 16 位的 CRC寄存器的低 8 位相异或, 把结果放于 CRC寄存器
                crc = ((crc & 0xFF00) | (crc & 0x00FF) ^ (arr_buff[i] & 0xFF));
                for (j = 0; j < 8; j++) { 
                    //把 CRC 寄存器的内容右移一位( 朝低位)用 0 填补最高位, 并检查右移后的移出位
                    if ((crc & 0x0001) > 0) { 
                        //如果移出位为 1, CRC寄存器与多项式A001进行异或
                        crc = crc >> 1;
                        crc = crc ^ 0xA001;
                    } else
                    //如果移出位为 0,再次右移一位
                    { 
                        crc = crc >> 1;
                    }
                }
            }
            return Integer.toHexString(crc);
        }
    
     //计算CRC16校验和
        private static String calculateCRC(byte[] bytes) { 
            int crc = 0x0000ffff;
            for (byte aByte : bytes) { 
                crc ^= ((int) aByte & 0x000000ff);
                for (int j = 0; j < 8; j++) { 
                    if ((crc & 0x00000001) != 0) { 
                        crc >>= 1;
                        crc ^= 0x0000a001;
                    } else { 
                        crc >>= 1;
                    }
                }
            }
            return Integer.toHexString(crc);
        }