ModBus/Tcp协议下的一次实机对接

悠悠 2022-12-20 14:55 198阅读 0赞

## 1.前言 ##

项目需要用到一个光线测温的仪器，用的是工业设备比较通用的ModBus协议，博主之前并无相关经验，故记录开发到对接时的各种问题和坑点。

## 2.坑点 ##

①。loader shabi 。  
懂的自然懂。

②。文档不全。  
这个是最大的问题，我开发时，厂家只给了一些通用的开发文档，涉及到数据具体的offset（地址），slaveId（机器id）等重点数据是实机对接时候才给我的。前期我让公司cto看了我的文档，说我的文档不全，后面向leader反应，被认为是我开发水平低，想gc我。

③。测试仪器不全。  
全套组合是主机 + 测温光纤，我前期只有一台主机，嗯。。。。

④。格式不对。  
我用的测试软件是modbus slave，测试软件的数据是有格式的，代码接收的数据也是有格式的，如果格式不对的话，轻则读出来的数据是浮点型的，重则直接报地址错误。

⑤。offset（地址值）的变化  
我所对接的主机，最多采取10项参数的数据值，而当使用操作减少读取参数的选项时，offset（地址值）会发生变化。  
比如：采集3个参数值 offset 1 ：高温，offset 2 ：低温，offset 3：均温。去掉第一个参数  
改变成采集2个桉树值offset 1 ：低温，offset 2 ：均温，

## 3.测试所需数据 ##

IP  
端口  
offset 数据地址 (厂家需要说明)  
slaeID 主机id (厂家需要说明)

## 4.实机对接步骤（仅具参考） ##

1.  用网线把测试主机和自己笔记本连接
2.  在自己的笔记本的网络选项里配置 ip ，使得自己的笔记本和测试主机连接在同一局域网中
3.  开始操作主机开始测温，得到温度信息和其他数据信息
4.  启动笔记本端的程序，开始读取数据

## 5.代码参考（测试，非springboot启动） ##

#### 5.1 Jlibmodbus方式 ####

package com.modbus.jlibmodbus;
    
    import com.intelligt.modbus.jlibmodbus.Modbus;
    import com.intelligt.modbus.jlibmodbus.master.ModbusMaster;
    import com.intelligt.modbus.jlibmodbus.master.ModbusMasterFactory;
    import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;
    
    import java.net.InetAddress;
    
    
    /** * 描述: * modbus测试一 * https://www.cnblogs.com/ioufev/p/10831289.html * @author XueGuCheng * @create 2020-11-08 15:14 */
    public class Jlibmodbus { 
    
        public static void main(String[] args) throws Exception { 
            // 设置主机TCP参数
            TcpParameters tcpParameters = new TcpParameters();
            //设置TCP的ip地址
            InetAddress address = InetAddress.getByName("127.0.0.1");
            //TCP参数设置ip地址
            tcpParameters.setHost(address);
            //TCP设置长连接
            tcpParameters.setKeepAlive(true);
            //TCP设置端口，这里设置是默认端口502
            tcpParameters.setPort(Modbus.TCP_PORT);
            //创建一个主机
            ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
            Modbus.setAutoIncrementTransactionId(true);
    
            //从机地址
            int slaveId = 1;
            //寄存器读取开始地址
            int offest = 0;
            //读取的寄存器数量
            int quantity = 10;
    
            if (!master.isConnected()){ 
                //开启连接
                master.connect();
            }
            //读取对应从机的数据，readInputRegisters读取的写寄存器，功能码04
            int[] registers = master.readInputRegisters(slaveId, offest, quantity);
            //控制台输出
            for (int register : registers) { 
    
                System.out.println("Address: " + offest++ + ", Value: " + register);
            }
    
    
        }
    
    }

#### 5.2Modbus4j ####

package com.modbus.modbus4j;
    
    
    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;
    
    
    /** * 描述: * Modbus4jUtils * * @author XueGuCheng * @create 2020-11-08 16:01 */
    public class Modbus4jUtils { 
    
        //工厂
        static ModbusFactory modbusFactory;
        static { 
            if (modbusFactory == null) { 
                modbusFactory = new ModbusFactory();
            }
        }
    
        //获取master
        public static ModbusMaster getMaster() throws ModbusInitException { 
            IpParameters params = new IpParameters();
            params.setHost("127.0.0.1");
            params.setPort(502);
            // modbusFactory.createRtuMaster(wapper); //RTU 协议
            // modbusFactory.createUdpMaster(params);//UDP 协议
            // modbusFactory.createAsciiMaster(wrapper);//ASCII 协议
            //TCP 协议
            ModbusMaster master = modbusFactory.createTcpMaster(params, false);
            master.init();
            return master;
        }
    
        /** * 读取[01 Coil Status 0x]类型 开关数据 * @param slaveId slaveId * @param offset 位置 * @return 读取值 * @throws ModbusInitException * @throws ErrorResponseException * @throws ModbusTransportException */
        public static Boolean readCoilStatus(int slaveId,int offset) throws ModbusInitException, ErrorResponseException, ModbusTransportException { 
            // 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 * @param offset * @param 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 * @param offset * @param 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;
        }
    
        public static void batchRead() throws ModbusInitException, ErrorResponseException, ModbusTransportException { 
            BatchRead<Integer> batch = new BatchRead<>();
            batch.addLocator(0,BaseLocator.holdingRegister(1,1, DataType.FOUR_BYTE_FLOAT));
            batch.addLocator(1,BaseLocator.inputStatus(1,0));
    
            ModbusMaster master = getMaster();
    
            BatchResults<Integer> results = master.send(batch);
    
            System.out.println(results.getValue(0));
            System.out.println(results.getValue(1));
        }
    
    }

#### 5.3 ModbusMasterTCP ####

package com.modbus.modbusMastertcp;
    
    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.*;
    import io.netty.buffer.ByteBuf;
    import io.netty.util.ReferenceCountUtil;
    
    import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.ExecutionException;
    
    /** * 描述: * modbus TCP协议Java通讯读取例子 * * @author XueGuCheng * @create 2020-11-08 16:32 */
    public class ModbusMasterTCPDemo { 
    
        static ModbusTcpMaster master;
    
        //获取TCP协议的Master
        public static void initModbusTcpMaster(){ 
            if (master == null){ 
                // 创建配置
                ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("127.0.0.1").setPort(502).build();
                master = new ModbusTcpMaster(config);
            }
        }
    
        //释放资源
        public static void release(){ 
            if (master != null){ 
                master.disconnect();
            }
            Modbus.releaseSharedResources();
        }
    
        /** * 读取Coils开关量 * @param address 寄存器开始地址 * @param quantity 数量 * @param unitId ID * @return 读取值 */
        public static Boolean readCoils(int address,int quantity,int unitId) throws ExecutionException, InterruptedException { 
            Boolean result = null;
            CompletableFuture<ModbusResponse> future = master.sendRequest(new ReadCoilsRequest(address, quantity), unitId);
            ReadCoilsResponse readCoilsResponse = (ReadCoilsResponse) future.get();
            if (readCoilsResponse != null){ 
                ByteBuf buf = readCoilsResponse.getCoilStatus();
                result = buf.readBoolean();
                ReferenceCountUtil.release(readCoilsResponse);
            }
            return result;
        }
    
        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 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;
        }
    
        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.readDouble();
                ReferenceCountUtil.release(readInputRegistersResponse);
            }
            return result;
        }
    
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            // 初始化资源
            initModbusTcpMaster();
    
            // 执行操作
    
            // 读取开关量
            System.out.println(readCoils(0, 1, 1));
    
            System.out.println(readDiscreteInputs(0, 1, 1));
            System.out.println(readDiscreteInputs(1, 1, 1));
    
            // 读取模拟量
            System.out.println(readHoldingRegisters(0, 2, 1));
            System.out.println(readHoldingRegisters(2, 2, 1));
            System.out.println(readHoldingRegisters(4, 2, 1));
    
            System.out.println(readInputRegisters(2, 4, 1));
            System.out.println(readInputRegisters(6, 4, 1));
    
            // 释放资源
            release();
    
        }
    
    }

## 6.代码参考（测试，springboot启动） ##

后续