喵喵爱编程

这个屌丝很懒，什么也没留下！

热门标签

Java modbus 实现RTU串口作为slave（服务端）读写数据_java modbus rtu

作者：喵喵爱编程 | 2024-07-18 05:40:59

踩

java modbus rtu

这里要了解下modbus的RTU和TCP 的几个名称关系：

Modbus/RTU：主站和从站关系

Modbus/TCP：客户端和服务端关系

关系

主站主动找从站读写数据
客户端主动找服务端读写数据

所以当使用Modbus/TCP时，主站一般作为客户端，从站一般作为服务端

modbus poll和modbus slave模拟软件

当使用Modbus/TCP时，modbus poll一般模拟客户端，modbus slave一般模拟服务端。

以上这几个关系必须了解，否则容易搞混乱。

modbus协议是工业使用比较多的协议，大部分设备都支持modbus的，也就是说，通过modbus可以获取市场上90%的设备，一般新设备都支持modbus。

modbus有几种协议：

modbusTCP、modbusRTU、modbusRTUOVERTCP（本质tcp,需要单独解析）、ASCII（不常用，可以忽略）

Modbus RTU和Modbus TCP两个协议的本质都是Modbus协议，都是靠Modbus寄存器地址来交换数据；但所用的硬件接口不一样，Modbus RTU一般采用串口RS232C或RS485/422，而Modbus TCP一般采用以太网口。现在市场上有很多协议转换器，可以轻松的将这些不同的协议相互转换。
实际上Modbus协议包括ASCII、RTU、TCP。
Modbus协议需要对数据进行校验，串行协议中除有奇偶校验外，ASCII模式采用LRC校验，RTU模式采用16位CRC校验.
Modbus TCP模式没有额外规定校验，因为TCP协议是一个面向连接的可靠协议。
TCP和RTU协议非常类似，只要把RTU协议的两个字节的校验码去掉，然后在RTU协议的开始加上5个0和一个6并通过TCP/IP网络协议发送出去即可。

以上应该可以理解modbus到底干啥的了，明白后，我们开始做测试，整理流程比较长。

先说工具准备情况：

1、虚拟串口工具 vspd，正常安装即可（目的是模拟串口，如果是tcp 协议用不到它）

2、modbus 仿真工具，这个工具很好用，也经常使用

3、java依赖，该依赖比较强大，强推


       <dependency>
            <groupId>com.intelligt.modbus</groupId>
            <artifactId>jlibmodbus</artifactId>
            <version>1.2.9.11</version>
        </dependency>

模拟工具和仿真工具下载。

1、串口模拟工具正常安装即可，然后把补丁进行覆盖安装目录，否则只有14天试用期，建议覆盖，永久使用（安装过程省略）

安装成功后，添加串口，默认是COM2和COM3 两个端口，就用这两个就可以了。

我这边是COM2个slave用，也就是tcp的服务端哈，COM3给master用，也就是tcp的客户端。

其实这块在写代码之前可以进行用modbus 仿真工具进行测试下，例如：

1、打开modbus slave；选择串口

协议类型选择:串口

串口设置，这块根据你的串口模拟工具，我把COM2 slave了，如果是真实设备，具体连接到真实设备的串口即可。

其他的设置，根据具体情况来即可。

点击ok，

应该可以看到模拟工具在跑数据了哈

可以看到串口模拟工具已经被modbus slave模拟器连上了 9600-N-8-1 就是刚才配置的其他参数信息，了解就行。

可以看到COM3的Port 是closed状态，我们这时开始启动poll模拟器。

和slave设置很像，我这边细节就不说了，有个注意点串口要连COM3，因为COM2已经被slave占用了（这里因为是模拟的设备，COM2和COM3 模拟器帮我们进行连接了）。

看modbus模拟器数据已经连上了，也获取到数据了：

串口模拟器也显示连上了：

如果报错，请检查内存起止地址和内存数量。这里通过工具进行模拟的，整体是没问题的，说明环境都是没问题的，确保在编码前环境一定没问题，否则只用用代码容易出问题；可以进行编码了。

用java进行连接，其实我的理解，哪种语言连接都是差不多的，比较简单，直接上代码了哈：

监听接口：


public interface ModbusEventListener {
 
    /**
     * 描述
     * 单个线圈写入监听  function=01 、 02
     *
     * @param address 内存地址
     * @param value   值
     * @return void
     * @author
     * @date 2024/5/11 15:30:31
     */
    default void onWriteToSingleCoil(int address, boolean value) {
        System.out.print("onWriteToSingleCoil: address " + address + ", value " + value);
    }
 
    /**
     * 描述
     * 批量线圈写入监听  function=01 、 02
     *
     * @param address  地址
     * @param quantity 数量
     * @param values   值
     * @return void
     * @author
     * @date 2024/5/11 15:31:20
     */
    default void onWriteToMultipleCoils(int address, int quantity, boolean[] values) {
        System.out.print("onWriteToMultipleCoils: address " + address + ", quantity " + quantity);
    }
 
    /**
     * 描述
     * 读保持寄存器	  function=03
     *
     * @param address 地址
     * @param value   值
     * @return void
     * @author 
     * @date 2024/5/11 15:32:26
     */
    void onWriteToSingleHoldingRegister(int address, int value);
 
    /**
     * 描述
     * 读保持寄存器	  function=03
     *
     * @param address  地址
     * @param quantity 数量
     * @param values   多个值
     * @return void
     * @author
     * @date 2024/5/11 15:49:22
     */
    void onWriteToMultipleHoldingRegisters(int address, int quantity, int[] values);
 
    /**
     * 描述
     * 获取监听类型
     *
     * @param
     * @return com.goldstar.common.utils.constants.GlobalConstants.ModbusListenerType
     * @author 
     * @date 2024/5/13 10:54:14
     */
    String getListenerType();
 
 
}

dataholder：


/**
 * 从机的寄存器
 */
public class CustomDataHolder extends DataHolder {
 
    final List<ModbusEventListener> modbusEventListenerList = new ArrayList();
 
 
    public CustomDataHolder() {
        // you can place the initialization code here
            /*
            something like that:
            setHoldingRegisters(new SimpleHoldingRegisters(10));
            setCoils(new Coils(128));
            ...
            etc.
             */
    }
 
    public void addEventListener(ModbusEventListener listener) {
        modbusEventListenerList.add(listener);
    }
 
    public boolean removeEventListener(ModbusEventListener listener) {
        return modbusEventListenerList.remove(listener);
    }
 
    @Override
    public void writeHoldingRegister(int offset, int value) throws IllegalDataAddressException, IllegalDataValueException {
        System.out.println("writeHoldingRegister: offset " + offset + ", value " + value);
        for (ModbusEventListener l : modbusEventListenerList) {
            l.onWriteToSingleHoldingRegister(offset, value);
        }
        super.writeHoldingRegister(offset, value);
    }
 
    @Override
    public void writeHoldingRegisterRange(int offset, int[] range) throws IllegalDataAddressException, IllegalDataValueException {
        System.out.println("writeHoldingRegisterRange: offset " + offset + ", range " + range);
        for (ModbusEventListener l : modbusEventListenerList) {
            l.onWriteToMultipleHoldingRegisters(offset, range.length, range);
        }
        super.writeHoldingRegisterRange(offset, range);
    }
 
    @Override
    public void writeCoil(int offset, boolean value) throws IllegalDataAddressException, IllegalDataValueException {
        System.out.println("writeCoil: offset " + offset + ", value " + value);
        for (ModbusEventListener l : modbusEventListenerList) {
            l.onWriteToSingleCoil(offset, value);
        }
        super.writeCoil(offset, value);
    }
 
    @Override
    public void writeCoilRange(int offset, boolean[] range) throws IllegalDataAddressException, IllegalDataValueException {
        System.out.println("writeCoilRange: offset " + offset + ", range " + range);
        for (ModbusEventListener l : modbusEventListenerList) {
            l.onWriteToMultipleCoils(offset, range.length, range);
        }
        super.writeCoilRange(offset, range);
    }
}

modbus slave服务


public class ModbusSlaveService {
 
 
    private String modbusType = "";
 
    private ModbusSlave modbusSlave;
 
    // 创建从机的寄存器
    private CustomDataHolder dataHolder = new CustomDataHolder();
 
    //禁止无参构造函数创建对象
    private ModbusSlaveService() {
    }
 
    public ModbusSlaveService(@NonNull TcpParameters tcpParameters, @NonNull Integer serverId) {
        this.modbusSlave = ModbusSlaveFactory.createModbusSlaveTCP(tcpParameters);
        modbusSlave.setReadTimeout(0); // if not set default timeout is 1000ms, I think this mus
        // 为从机寄存器添加监听事件，这里的监听事件主要是主机如果发送写命令修改从机则进行业务处理
        //  dataHolder.addEventListener(new DefaultModbusEventListener());
        modbusSlave.setDataHolder(dataHolder);
        modbusSlave.setServerAddress(serverId);
        modbusType = "协议类型：tcp, ip: " + tcpParameters.getHost() + ":" + tcpParameters.getPort();
    }
 
    public ModbusSlaveService(@NonNull SerialParameters serialParameters, @NonNull Integer serverId) throws SerialPortException {
        this.modbusSlave = ModbusSlaveFactory.createModbusSlaveRTU(serialParameters);
        modbusSlave.setReadTimeout(0); // if not set default timeout is 1000ms, I think this mus
        // 为从机寄存器添加监听事件，这里的监听事件主要是主机如果发送写命令修改从机则进行业务处理
        //  dataHolder.addEventListener(new DefaultModbusEventListener());
        modbusSlave.setDataHolder(dataHolder);
        modbusSlave.setServerAddress(serverId);
 
        modbusType = "协议类型：RTU(串口), 串口号: " + serialParameters.getDevice();
    }
 
    /**
     * 注册相关点位数据；用来服务端写到客户端数据
     *
     * @param modbusHoldingRegisters
     * @return
     */
    public ModbusSlaveService addHoldingRegisters(ModbusHoldingRegisters modbusHoldingRegisters) {
        if (modbusHoldingRegisters == null) {
            return this;
        }
        modbusSlave.getDataHolder().setHoldingRegisters(modbusHoldingRegisters);
        return this;
    }
 
    /**
     * 注册相关点位数据；用来服务端写到客户端数据
     *
     * @param modbusCoils
     * @return
     */
    public ModbusSlaveService addModbusCoils(ModbusCoils modbusCoils) {
        if (modbusCoils == null) {
            return this;
        }
        modbusSlave.getDataHolder().setCoils(modbusCoils);
        return this;
    }
 
    public ModbusSlaveService addModbusInputRegisters(ModbusHoldingRegisters inputRegisters) {
        if (inputRegisters == null) {
            return this;
        }
        modbusSlave.getDataHolder().setInputRegisters(inputRegisters);
        return this;
    }
 
    /**
     * 数据监听器，用来监听 客户端写入到数据，进行相关处理
     *
     * @param listener
     * @return
     */
    public ModbusSlaveService addEventListener(ModbusEventListener listener) {
        dataHolder.addEventListener(listener);
        return this;
    }
 
    public ModbusSlaveService removeEventListener(ModbusEventListener listener) {
        dataHolder.removeEventListener(listener);
        return this;
    }
 
    /**
     * 开启监听
     *
     * @return
     * @throws Exception
     */
    public ModbusSlaveService startListen() throws Exception {
        modbusSlave.listen();
        log.info("{} ----当前服务已启动", modbusType);
        closeSlave();
        return this;
    }
 
    /**
     * 关闭modbus 服务
     *
     * @throws InterruptedException
     * @throws ModbusIOException
     */
    private void closeSlave() throws InterruptedException, ModbusIOException {
        //这部分代码主要是设置Java虚拟机关闭的时候需要做的事情，即本程序关闭的时候需要做的事情，直接使用即可
        if (modbusSlave.isListening()) {
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                synchronized (modbusSlave) {
                    modbusSlave.notifyAll();
                }
            }));
 
            synchronized (modbusSlave) {
                modbusSlave.wait();
            }
            modbusSlave.shutdown();
            log.info("{} ----当前服务已关闭", modbusType);
 
        }
    }
 
    /**
     * 手动进行关闭服务
     */
    public void closeModbusSlave() {
        try {
            modbusSlave.shutdown();
            log.info("{} ----当前服务已手动关闭", modbusType);
        } catch (ModbusIOException e) {
            throw new RuntimeException(e);
        }
 
    }
 
    public static void main(String[] args) throws Exception {      
 
       SerialParameters serialParameters = new SerialParameters();
        serialParameters.setDevice("COM2");
        serialParameters.setParity(SerialPort.Parity.NONE);
        //  SerialPort.BaudRate baudrate = new SerialPort.BaudRate(921600);
        // serialParameters.setBaudRate(baudrate);
        serialParameters.setBaudRate(SerialPort.BaudRate.BAUD_RATE_9600);
        serialParameters.setDataBits(8);
        serialParameters.setStopBits(1);
 
        ModbusSlaveService modbusSlaveService1 = new ModbusSlaveService(serialParameters, 1);
        //modbusSlaveService1.addEventListener(new DefaultModbusEventListener());
        modbusSlaveService1.addEventListener(new ModbusEventListener() {
            @Override
            public void onWriteToSingleCoil(int address, boolean value) {
                log.info("onWriteToSingleCoil({},{})", address, value);
            }
 
            @Override
            public void onWriteToMultipleCoils(int address, int quantity, boolean[] values) {
                log.info("onWriteToMultipleCoils({},{},{})", address, quantity, values);
            }
 
            @Override
            public void onWriteToSingleHoldingRegister(int address, int value) {
                log.info("onWriteToSingleHoldingRegister({},{})", address, value);
            }
 
            @Override
            public void onWriteToMultipleHoldingRegisters(int address, int quantity, int[] values) {
                log.info("onWriteToMultipleHoldingRegisters({},{},{})", address, quantity, values);
            }
 
 
            @Override
            public String getListenerType() {
                return "";
            }
 
        });
        //更新寄存器值
        ModbusHoldingRegisters hr1 = new ModbusHoldingRegisters(10);
        //主机发送数据
        ThreadUtil.execute(() -> {
            while (true) {
                ThreadUtil.sleep(1000);
                try {
                    hr1.set(0, RandomUtil.randomInt(0, 10000));
                    hr1.set(1, RandomUtil.randomInt(0, 10000));
                    hr1.set(2, RandomUtil.randomInt(0, 10000));
                    hr1.set(3, RandomUtil.randomInt(0, 10000));
                    hr1.set(4, RandomUtil.randomInt(0, 10000));
                    log.info("COM数据：{}", JSONUtil.toJsonStr(hr1));
                    modbusSlaveService1.addHoldingRegisters(hr1);
                } catch (IllegalDataAddressException e) {
                    throw new RuntimeException(e);
                } catch (IllegalDataValueException e) {
                    throw new RuntimeException(e);
                }
 
            }
        });
 
        modbusSlaveService1.startListen();
        
 
 
    }
 
 
}

测试代码说明：


 public static void main(String[] args) throws Exception { 
//串口参数实体类
        SerialParameters serialParameters = new SerialParameters();
        //这是设置串口 刚才上面说了，用COM2作为slave
        serialParameters.setDevice("COM2");
        //用模拟器时的其他几个参数设置
        serialParameters.setParity(SerialPort.Parity.NONE);
        //  SerialPort.BaudRate baudrate = new SerialPort.BaudRate(921600);
        // serialParameters.setBaudRate(baudrate);
        serialParameters.setBaudRate(SerialPort.BaudRate.BAUD_RATE_9600);
        serialParameters.setDataBits(8);
        serialParameters.setStopBits(1);
        //new modbus slave 对象
        ModbusSlaveService modbusSlaveService1 = new ModbusSlaveService(serialParameters, 1);
        //modbusSlaveService1.addEventListener(new DefaultModbusEventListener());
        //添加监听；此处监听是为了让 master写数据时，slave能监听到，这样就可以相互通信了，这是扩展项
        modbusSlaveService1.addEventListener(new ModbusEventListener() {
            @Override
            public void onWriteToSingleCoil(int address, boolean value) {
                log.info("onWriteToSingleCoil({},{})", address, value);
            }
 
            @Override
            public void onWriteToMultipleCoils(int address, int quantity, boolean[] values) {
                log.info("onWriteToMultipleCoils({},{},{})", address, quantity, values);
            }
 
            @Override
            public void onWriteToSingleHoldingRegister(int address, int value) {
                log.info("onWriteToSingleHoldingRegister({},{})", address, value);
            }
 
            @Override
            public void onWriteToMultipleHoldingRegisters(int address, int quantity, int[] values) {
                log.info("onWriteToMultipleHoldingRegisters({},{},{})", address, quantity, values);
            }
 
 
            @Override
            public String getListenerType() {
                return "";
            }
 
        });
        //更新寄存器值，每个一秒更新一次数据
        ModbusHoldingRegisters hr1 = new ModbusHoldingRegisters(10);
        //主机发送数据；这里如果是真实场景的业务，就是业务数据了，我这边通过随机生成的数据进行模拟的，大家根据自己的情况进行设置即可
        ThreadUtil.execute(() -> {
            while (true) {
                ThreadUtil.sleep(1000);
                try {
                    hr1.set(0, RandomUtil.randomInt(0, 10000));
                    hr1.set(1, RandomUtil.randomInt(0, 10000));
                    hr1.set(2, RandomUtil.randomInt(0, 10000));
                    hr1.set(3, RandomUtil.randomInt(0, 10000));
                    hr1.set(4, RandomUtil.randomInt(0, 10000));
                    log.info("COM数据：{}", JSONUtil.toJsonStr(hr1));
                    modbusSlaveService1.addHoldingRegisters(hr1);
                } catch (IllegalDataAddressException e) {
                    throw new RuntimeException(e);
                } catch (IllegalDataValueException e) {
                    throw new RuntimeException(e);
                }
 
            }
        });
        //启动监听
        modbusSlaveService1.startListen();
      }

上面明白后，咱们运行起来：

1、开发工具日志：

已经启动了，再看看串口模拟器：

这里可以看到，COM2已经换成了java.exe了，这就对了

在看poll工具：

数据实时读取到了，我们测试下poll也就是master 发送数据，slave能否接收到：

Ok，slave 发送master（poll）和master（poll）发送slave 都是没问题的，完美解决，后面进行业务集成即可。

总结说明：

其实工业的协议要比TCP简单很多，逻辑不复杂，大家尝试下就明白了，modbusTCP 相互通信更简单了，这里不进行演示了，上面代码其实我已经写了，大家可以写下测试代码就支持tcp了，Ok到此结束。

后续会深入研究modbus协议，争取用java进行实现modbus协议，也就是上面用的库文件，已经进行实现了，进行尝试手动实现，这样后期可以深入定制业务以及各类定制化modbus协议。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/843815