【modbus】modbus java程序读取

已于 2023-09-14 10:01:47 修改
阅读量1.4k 收藏 8
点赞数 1
分类专栏： 代码-软件程序 文章标签： java python 网络 modbus
于 2023-09-14 09:59:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuewuyanhuang/article/details/132868886
版权

简介

本文介绍如何使用java程序简单读取modbus slave端程序。

相关代码、软件资源，可参考附录部分。

概念

Modbus是一种串行通信协议，是Modicon公司（现在的施耐德电气 Schneider Electric）于1979年为使用可编程逻辑控制器（PLC）通信而发表。Modbus已经成为工业领域通信协议的业界标准（De facto），并且现在是工业电子设备之间常用的连接方式。目前在和各大用电量采集厂商对接时，也几乎都用此协议进行沟通，因此对于做工业领域相关的技术人员，有必要对此协议进行一定的了解。

slave/master端 对于熟悉C/S、B/S模式的编程人员来说，modbus协议也同样分为两者，一个是slave端，一个是master端，我们一般编写采集程序可以认为是master端，而持续提供程序的端则称为slave端，常见的slave端可以使用modbus poll这类程序模拟，安装程序会放在文末附录最后。

modbus poll 常见的slave端模拟程序，可通过极简的配置模拟数据生成，方便数据采集人员本地调试。

modbus-master-tcp本文所采用的第三方数据读取包。

实例程序

1、编写读取程序（master端）

前面提到，读取程序一般充当master端，因此我们先编写主程序，用于采集指定slave端的数据。

这里slave端一般是我们本地的modbus poll工具，下一章节介绍此工具的简单使用。

pom

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>com.digitalpetri.modbus</groupId>
			<artifactId>modbus-master-tcp</artifactId>
			<version>1.1.1</version>
		</dependency>
	</dependencies>

主读取程序

package com.example.modbustest.md;

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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * Desc:
 * ModBus组件
 *
 * @author JoyBlack
 * @email 1016037677@qq.com
 * @date 2023/1/6 下午 3:27
 */
public class ModBus {
    private ModbusTcpMaster master;

    private static final Logger logger = LoggerFactory.getLogger(ModBus.class);

    public ModBus(String address, int port) {
        ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder(address)
                .setPort(port)
                .setTimeout(Duration.ofSeconds(20))
                .build();
        master = new ModbusTcpMaster(config);
    }

    /**
     * Desc:
     * 释放资源
     *
     * @author JoyBlack
     * @email 1016037677@qq.com
     * @date 2023/1/5 上午 10:04
     */
    public void release() {
        if (master != null) {
            master.disconnect();
        }
        // Modbus.releaseSharedResources();
    }

    /**
     * Desc:
     * 读取HoldingRegister数据(address: 寄存器地址; quantity: 寄存器数量; unitId: id)
     *
     * @author JoyBlack
     * @email 1016037677@qq.com
     * @date 2023/1/5 上午 10:04
     */
    public Number readHoldingRegister(int address, int quantity, int unitId) throws Exception {
        Number result = null;
        CompletableFuture<ReadHoldingRegistersResponse> future = master.sendRequest(new ReadHoldingRegistersRequest(address, quantity), unitId);
        ReadHoldingRegistersResponse response = future.get(8, TimeUnit.SECONDS);
        if (response != null) {
            ByteBuf registers = response.getRegisters();
            result = registers.readFloat();
            ReferenceCountUtil.release(response);
        }
        return result;
    }

    /**
     * Desc:
     * 读取InputRegisters模拟量数据(address: 寄存器地址; quantity: 寄存器数量; unitId: id)
     *
     * @author JoyBlack
     * @email 1016037677@qq.com
     * @date 2023/1/5 上午 10:04
     */
    public Number readInputRegister(int address, int quantity, int unitId) throws Exception {
        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;
    }

    /**
     * Desc:
     * 读取Coils开关量
     *
     * @author JoyBlack
     * @email 1016037677@qq.com
     * @date 2023/1/5 上午 10:04
     */
    public Boolean readCoils(int address, int quantity, int unitId)
            throws Exception {
        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;
    }

    /**
     * Desc:
     * 读取readDiscreteInputs开关量
     *
     * @author JoyBlack
     * @email 1016037677@qq.com
     * @date 2023/1/5 上午 10:04
     */
    public Boolean readDiscreteInputs(int address, int quantity, int unitId)
            throws Exception {
        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 Result<Map<Integer, Number>> run(int start, int end, int quantity, int unitId) {
        Map<Integer, Number> result = new HashMap<>();
        try {
            for (int i = start; i <= end; i += 2) {
                Number value = readHoldingRegister(i, quantity, unitId);
                if ("infinity".equals(value.toString().toLowerCase())) {
                    logger.error(String.format("点位[%s]数据转换失败,设置为默认值 null", i));
                    result.put(i, null);
                } else {
                    result.put(i, value);
                }
            }
            return new Result<Map<Integer, Number>>().ok(result);
        } catch (Exception e) {
            String msg = String.format("【监控数据采集任务】获取监控数据失败：%s, start = %d, end = %d.", e.getMessage(), start, end);
            logger.error(msg);
            Result<Map<Integer, Number>> error = new Result<Map<Integer, Number>>().error(msg);
            return error;
        }
    }

    public static void main(String[] args) {
        try {
            ModBus modBus = new ModBus("127.0.0.1", 502);
            for (int i = 0; i < 10; i++) {
                Result<Map<Integer, Number>> run = modBus.run(0, 9, 2, 1);
                System.out.println(run.getData());
                Thread.sleep(1000);
            }
            // 释放资源
            modBus.release();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

辅助返回类

package com.example.modbustest.md;

import java.io.Serializable;

/**
 * 响应数据
 */
public class Result<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * 编码：0表示成功，其他值表示失败
     */
    private int code = 0;
    /**
     * 消息内容
     */
    private String msg = "success";
    /**
     * 响应数据
     */
    private T data;

    public Result<T> ok(T data) {
        this.setData(data);
        return this;
    }

    public boolean success() {
        return code == 0;
    }

    public Result<T> error() {

        return this;
    }

    public Result<T> error(int code) {
        return this;
    }

    public Result<T> error(int code, String msg) {
        this.code = code;
        this.msg = msg;
        return this;
    }

    public Result<T> error(String msg) {
        this.code = 500;
        this.msg = msg;
        return this;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

2、配置数据生成（slave端）

主程序编写完成后，需要启动一个slave端，方便主程序读取数据。我们使用modbus poll充当。

1、安装modbus poll：下载附录指定的程序后，执行安装。

2、运行程序，可以得到如下图所示的界面
在这里插入图片描述
3、右键内容页面，选择Slave Definition，设置slave寄存器数量、读取数据方式（F=03）
在这里插入图片描述
在这里插入图片描述
4、点击OK后，初始化为10行的内容页
在这里插入图片描述
5、右键存储数据单元格：设置数据类型、大小端模式，我们一般设置为Float（占用两个寄存器，4个字节）以及大端模式
在这里插入图片描述

6、双击存储数据单元格：设置数据内容、自增（动态变化方便客户端查询）
在这里插入图片描述
点击OK，完成设置。发现数据在不停的增长，通过此方式可以依次设置不同地址的寄存器存储的数据。由于此数据使用了两个寄存器（地址0和地址1），因此我们只能从地址为2的寄存器开始设置.如下图所示：
在这里插入图片描述
7、按照步骤5和6，依次设置剩余4个数值的数据，刚好使用玩完10个寄存器（我们的采集程序刚好采集5个数值，对应0-9 10个寄存器地址）
在这里插入图片描述

3、测试数据读取

1、点击java程序中的ModBus类，执行其main方法，该程序会间隔1秒读取10次本地配置的modbus poll生成的10个数值，执行结果如下图所示：
在这里插入图片描述

结语

本文只是做了一个简单介绍，若需要将程序应用到实际项目，还需要将其进行拓展，比如数据的读取频率、多线程辅助、消息缓冲队列还实现实际的生产任务。相关代码、软件资源，可参考附录部分。

附录

  • modbus poll 安装程序：链接: https://pan.baidu.com/s/1a5eZpwYbCy60XuM12PlMpQ?pwd=zhao 提取码: zhao
  • 代码地址：https://github.com/joyblack/modbus-test.git
百花君
关注
专栏目录
java读取modbus(串口，DTU(WIFI )也可 DTU(gprs)也可）协议数据 解释详细 踩坑完整 拿来就可以用的demo（下）
请叫我书生的博客
08-05 2241
福兮祸所伏， 祸兮福所倚。（现在发生在你身上的都是好事，福祸相伴） 这些源码应该都可以看的懂 我就不解释了。 public void Connect(String comPort) throws Exception { // 类似于串口连接（个人理解） this.portIdentifier = CommPortIdentifier.getPortIdentifier(comPort); if (this.portIdentifier.isCu...
使用java获取modbus数据.zip
11-19
使用java获取modbus数据（附 Modbus Poll 、Modbus Slave、Configure Virtual Serial Port Driver按照工具）
modbus的读写java实现
06-07
modbus的读写java实现
modbustcp报文解析java
最新发布
weixin_40812281的博客
07-30 108
手把手教你实现ModbusTCP报文解析Java版 作为一名刚入行的开发者，你可能对Modbus协议和TCP/IP协议栈还不太熟悉。不过没关系，我会一步一步教你如何使用Java来解析ModbusTCP报文。 1. 理解ModbusTCP协议 首先，我们需要理解ModbusTCP协议。Modbus是一种应用层协议，用于工业自...
有关Java读取Modbus协议连接PLC的示例（使用modbus4j）
qq_29317911的博客
05-11 2720
我最近碰到一个项目，获取数据来方式很多，其中一种便是Modbus协议。这个协议分为Modbus-Tcp和Modbus-RTU两种，我是这么简单理解这个协议的，主要用于信息的采集与下发，而且信息的获取和下发需要对应硬件的物理地址。下面先讲一下一些实用的知识点，看完之后说不定你就不用开发了。网上也有卖集成485串口的类似交换机的东西，可以去某宝搜索一下。还可以把串口的Modbus协议转换为ModbusTCP协议，并实现双向通信，即可以获取数据，也可以下发指令。甚至可以把数据发送到消息队列中。
基于Java的Modbus通讯
10-15
使用Java通过Modbus读取任何Modbus设备的数据代码及使用案例
Java实现使用jlibmodbus读取Modbus TCP数据
weixin_38863607的博客
01-10 4186
本文使用jlibmodbus获取modbus tcp数据，下文展示代码以及遇到的问题。
java的modbus实现
07-19
Java 调用串口设备使用ModbusRTU 协议：modbus4J.jar、RXTXcomm.jar、seroUtils.jar版本1.1，附带资料
java读写Modbus RTU数据，java串口modbus通信，Modbus RTU与java通信 全开源
11-08
最近在研究处理java写modbus RTU通信，分别使用几套工具，模拟modbus从站、模拟串口等才能正常在电脑测试成功。 全开源，放心下载 可以查看运行内容https://blog.csdn.net/weijia3624/article/details/121216539
java通过com口采集读取modbus数据驱动程序
02-20
Java通过COM口采集读取Modbus数据驱动程序是一种在Java编程环境下实现的通信技术，用于与支持Modbus协议的设备进行交互。Modbus是一种广泛应用于工业自动化领域的通信协议，允许不同设备之间交换数据，比如PLC（可...
Java modbus读取手卡数据
09-20
主要是modbus 通过Socket读取手环下面的数据；优势在于可以读取30多个以上的基站，每个基站下面可以带5个以上的手卡，并且是实时读取的
Modbus通用数据读取工具
11-27
1.使用该软件，电脑需安装.net framework4，才能正常使用（如果是在XP上进行使用，建议.net 3.5也一起安装比较好）。 2.如果需要进行读取的Modbus协议的设备，是通过串口进行读取的，请选择通信协议为串口。 3.如果是通过TCP/IP的方式，进行数据读取的，请使用TCP Client的通信方式。 4.如果设备是通过UDP的方式进行通信的，请设通信 类型为UDP Client。 5.通信类型选择之后，并且打开相应的链接或端口之后，请选择 小工具--》Modbus数据解析命令。
JAVA实现Modbus RTU或Modbus TCPIP数据采集.rar
06-03
1.多线程可以提高资源的利用率，可以充分利用现代多核处理器的特性，让每个线程负责处理同类型的任务，更加容易维护，同时通过异步处理提高响应性。 2.多线程之间为更方便的实现数据共享采用了共享相同内存地址空间的形式，并且是并发运行，导致多个线程可能会同时访问或修改其他线程正在使用的变量值，导致安全性，同时如果线程之间相互等待对方拥有的锁，会出现活跃性即死锁问题。如果线程计算部分不多，更多的线程只会导致频繁的切换上下文，让CPU的时间更多的花在线程调度而不是任务执行上。 3.java同步的几种方式：synchronized,volatile,显示锁,原子变量,线程及对象的基础同步方法。 4.所谓线程安全就是当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为。 5.将复合操作放在一个原子操作中执行,或用相同的锁来保护每个共享的和可变的变量。 6.增加同步必然会导致代码的复杂性，为性能牺牲代码简单性时不要太盲目，因为越复杂的代码，其不安全性越大。
基于Java实现的Modbus通信模块电气设备数据采集.pdf
06-27
基于Java实现的Modbus通信模块电气设备数据采集.pdf
java实现modbus读写.pdf
09-30
java实现modbus读写.pdf
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串口通讯
02-12
Java应用程序的Modbus4j串口通讯是一种在Java平台上实现Modbus通信协议的库，它使得Java开发者能够方便地与支持Modbus协议的设备进行数据交换。Modbus是一种广泛使用的工业通讯协议，常用于PLC（可编程逻辑控制器）...
Java实现Modbus Tcp协议读写模拟工具数据
小样yx的博客
09-18 3736
Java实现Modbus Tcp协议读写模拟工具数据（SpringBoot）
java modbus rtu 读取数据
11-24
以下是Java Modbus RTU读取数据的步骤： 1. 导入相关的Java Modbus库，例如j2mod、jamod等。 2. 创建ModbusMaster实例，用于与Modbus从站通信。 3. 创建ModbusSerialTransaction实例，用于在串行通信中执行Modbus事务。 4. 创建读取寄存器的请求对象，例如ReadInputRegistersRequest或ReadMultipleRegistersRequest。 5. 设置请求对象的起始地址和寄存器数量。 6. 执行Modbus事务，发送请求并等待响应。 7. 从响应中获取读取到的数据。 下面是一个示例代码，演示如何使用j2mod库读取Modbus从站的保持寄存器： ```java import java.net.*; import java.io.*; import net.wimpi.modbus.*; import net.wimpi.modbus.io.*; import net.wimpi.modbus.msg.*; import net.wimpi.modbus.net.*; import net.wimpi.modbus.util.*; public class ModbusRTUReader { public static void main(String[] args) { try { // 创建串口连接 SerialConnection connection = new SerialConnection( new SerialParameters( "/dev/ttyUSB0", // 串口名称 9600, // 波特率 8, // 数据位 "None", // 奇偶校验 1 // 停止位 ) ); connection.open(); // 创建Modbus主站 ModbusMaster master = new ModbusMasterRTU(connection); // 创建读取保持寄存器的请求 ReadMultipleRegistersRequest request = new ReadMultipleRegistersRequest(0, 10); // 执行Modbus事务 ModbusSerialTransaction transaction = new ModbusSerialTransaction(master); transaction.setRequest(request); transaction.execute(); // 获取响应数据 ReadMultipleRegistersResponse response = (ReadMultipleRegistersResponse) transaction.getResponse(); int[] values = response.getRegisters().getValues(); // 输出读取到的数据 for (int i = 0; i < values.length; i++) { System.out.println("Register " + i + ": " + values[i]); } // 关闭连接 connection.close(); } catch (Exception e) { e.printStackTrace(); } } } ```
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值