Java使用Modbus4j实现TCP通信

最新推荐文章于 2024-09-13 21:59:18 发布
最新推荐文章于 2024-09-13 21:59:18 发布
阅读量635 收藏 7
点赞数 4
分类专栏： Java 其他 文章标签： java tcp/ip 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHUSHANGLIN/article/details/141168408
版权
Java 同时被 2 个专栏收录
79 篇文章 0 订阅
订阅专栏
其他
35 篇文章 0 订阅
订阅专栏

常用功能码

modbus 4个常用功能码，仿真软件上面有F=01，F=02，F=03和F=04来显示
在这里插入图片描述

0x01：读线圈
0x02：读离散量输入
0x03：读保持寄存器
0x04：读输入寄存器

注意：0x03：读保持寄存器 和 0x04：读输入寄存器 需要修改对应数据类型为float
在这里插入图片描述

Java读数据

依赖

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13-beta-3</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.infiniteautomation</groupId>
            <artifactId>modbus4j</artifactId>
            <version>3.0.3</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

        <dependency>
            <groupId>com.digitalpetri.modbus</groupId>
            <artifactId>modbus-master-tcp</artifactId>
            <version>1.1.0</version>
        </dependency>
    </dependencies>

    <!-- 若想引用modbus4j需要引入下列repository id:ias-snapshots id:ias-releases 两个 ，使用默认仓库下载，不要使用阿里云仓库-->
    <repositories>
        <repository>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
            <id>ias-snapshots</id>
            <name>Infinite Automation Snapshot Repository</name>
            <url>https://maven.mangoautomation.net/repository/ias-snapshot/</url>
        </repository>
        <repository>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
            <id>ias-releases</id>
            <name>Infinite Automation Release Repository</name>
            <url>https://maven.mangoautomation.net/repository/ias-release/</url>
        </repository>
    </repositories>

代码

package com.ioufev;

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实现
 *
 */
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();
        }
    }
}

输出结果
在这里插入图片描述

Java写数据

package com.ioufev;

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.locator.BaseLocator;
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写入数据
 *
 */
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
     * @param dataType
     *            ,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();
        }

    }

}

仿真软件ModbusSlaveSetup64Bit.exe下载地址
链接：https://pan.baidu.com/s/1hglcBhC7GbRjsKFVpzGcXA?pwd=5t00
提取码：5t00

一个不回家的男人
关注
专栏目录
Java 整合 Modbus TCP
SSL 的博客
03-05 5428
使用Java整合Modbus TCP，实现代码控制Modbus设备模拟器。
java与modbusTcp通讯
碎银几两能解世间惆怅
01-07 5641
java与modbus通讯用途 工厂中通讯模块大多数都用modbus或者opcua与plc建立通讯，实现工厂设备的控制及数据采集等 需要引入的jar文件 点击获取 依赖包文件 提取码 7gnz 点击获取 modbus测试工具 提取码 nm7j 建立通讯的代码 import com.serotonin.modbus4j.ModbusFactory; import com.serotonin.modbus4j.ModbusMaster; import com.serotonin.modbus
Java应用程序的Modbus4j串口通讯
12-07
该文档详细介绍modbus4j的java应用程序，使用串口通讯的技术 该文档详细介绍modbus4j的java应用程序，使用串口通讯的技术
Modbus4j 安装和配置指南
最新发布
gitblog_09195的博客
09-13 268
Modbus4j 安装和配置指南 modbus4j 项目地址: https://gitcode.com/gh_mirrors/mod/modbus4j 1. 项目基础介绍和...
基于java的modbus TCP通信
06-13
基于java的modbus TCP通信
Java实现ModbusTCP通信
热门推荐
云逸
01-19 1万+
Java实现ModbusTCP通信
Modbus4j
zsj777的专栏
11-12 1778
项目上使用继电器控制器对供电、断电进行控制，继电器使用Modbus协议， java代码使用框架Modbus4j对继电器进行控制。 maven的pox引入 <dependency> <groupId>com.infiniteautomation</groupId> <artifactId&...
Java基于Modbus4j实现Modbus Tcp
l19991112的博客
04-12 1986
Modbus Tcp
modbusTCP协议java实现（带注释）
05-02
modbusTCP协议java实现（带注释）
Java实现Modbus Tcp协议读写模拟工具数据
小样yx的博客
09-18 3851
Java实现Modbus Tcp协议读写模拟工具数据（SpringBoot）
使用JAVA实现MODBUS协议通信
07-20
使用JAVA实现MODBUS协议通信.。。。。。。。。
完整版modbus+tcp+ java开发代码
10-31
对寄存器 hoilding request 读写操作，对线圈 coil request读写操作。
modbus TCP连接 java工具包
10-25
Modbus for Java JAVA应用程序通过MODBUS TCP协议读写设备
JAVA modbus TCP
01-09
ADT
Java_Modbus的操作(实例)
05-14
est类用于接收数采仪数据，然后核对其CRC校验是否正确，不正确便丢弃，不作任何操作，正确就查找其设备号对应哪个站点，以及其检测指标。然后到DB中查找实时检测值，若未有实时数据可用本实例中的随机数代替，然后保存发送数据到数据库中。得到值后通过CRC16得到其校验码组成其要发送的字节，发送完毕。
Java实现modbus tcp协议数据读写，项目内包含modbus slave仿真软件
09-28
可运行的java项目，分别用两种方案实现modbus协议读写1、jlibmodbus 2、modbus4j 有问题可联系QQ：361440206
java读写Modbus TCP UDP数据，java与modbus通信，Modbus TCP UDP与java通信 全开源
11-13
java读写Modbus TCP UDP数据，java与modbus通信，Modbus TCP UDP与java通信 全开源 这是一个能正常通过Modbus TCP UDP协议读写项目 请放心下载，完全开源，在多个项目中已经使用
java使用modbus4j实现modbustcp通信
m0_37547159的博客
03-12 1844
modbus协议的一些基础知识我在另一篇文章里提到过 https://blog.csdn.net/m0_37547159/article/details/109689872 可以参考，今天主要说一下java和modbus的通信，之前和modbus通信主要采用的netty框架，通过netty构建tcp通信来实现，但是有个缺点，需要自己构建modbus的包和解析modbus返回的数据，虽然netty底层封装了bytebuf可以供我们使用，但是对于我这种不懂底层的人还是很头疼。特别是输入寄存器和保持寄存器使用按位
java modbus4j_java使用modbus4j来实现modbusTCP通信
weixin_31488273的博客
02-26 872
以下是代码：读取寄存器数据：public class readRegisters {/*** 工厂。*/static ModbusFactory modbusFactory;static {if (modbusFactory == null) {modbusFactory = new ModbusFactory();}}/*** 获取master** @return* @throws Modbus...
用java编写modbustcp主站
05-28
下面是一个简单的Java程序，用于实现ModbusTCP主站的读取功能： ```java import java.net.InetAddress; import java.net.Socket; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.Arrays; public class ModbusTCPMaster { private Socket socket; private ByteBuffer buffer; private int transactionId = 0; public ModbusTCPMaster(String ipAddress, int port) throws Exception { socket = new Socket(InetAddress.getByName(ipAddress), port); buffer = ByteBuffer.allocate(1024); buffer.order(ByteOrder.BIG_ENDIAN); } private int getNextTransactionId() { return transactionId++; } public int[] readHoldingRegisters(int slaveId, int startAddress, int numRegisters) throws Exception { // Modbus TCP Header buffer.clear(); buffer.putInt(getNextTransactionId()); // Transaction ID buffer.putShort((short) 0); // Protocol ID buffer.putShort((short) 6); // Length buffer.put((byte) slaveId); // Slave ID buffer.put((byte) 3); // Function Code buffer.putShort((short) startAddress); // Start Address buffer.putShort((short) numRegisters); // Number of Registers // Send request socket.getOutputStream().write(buffer.array(), 0, 12); // Wait for response buffer.clear(); int bytesRead = socket.getInputStream().read(buffer.array(), 0, 1024); if (bytesRead < 9) { throw new Exception("Invalid response"); } // Parse response int responseTransactionId = buffer.getInt(); int responseProtocolId = buffer.getShort(); int responseLength = buffer.getShort() & 0xFFFF; int responseSlaveId = buffer.get() & 0xFF; int responseFunctionCode = buffer.get() & 0xFF; int responseNumBytes = buffer.get() & 0xFF; if (responseFunctionCode == 0x83) { int exceptionCode = buffer.get() & 0xFF; throw new Exception("Exception code: " + exceptionCode); } if (responseFunctionCode != 0x03 || responseSlaveId != slaveId) { throw new Exception("Invalid response"); } if (responseNumBytes != numRegisters * 2) { throw new Exception("Invalid response"); } int[] values = new int[numRegisters]; for (int i = 0; i < numRegisters; i++) { values[i] = buffer.getShort() & 0xFFFF; } return values; } public void close() throws Exception { socket.close(); } public static void main(String[] args) { try { ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100", 502); int[] values = master.readHoldingRegisters(1, 0, 10); System.out.println(Arrays.toString(values)); master.close(); } catch (Exception e) { e.printStackTrace(); } } } ``` 这个程序实现了读取从站的保持寄存器（Holding Registers）的功能。主要步骤如下： 1. 创建Socket连接到从站的IP地址和端口号。 2. 构造Modbus TCP请求消息，并发送到从站。 3. 等待从站的响应消息。 4. 解析从站的响应消息，提取保持寄存器的值。 5. 关闭Socket连接。 在实现实际应用中，需要根据具体的Modbus通讯协议和应用场景进行修改和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一个不回家的男人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值