【modbus】modbus java程序读取

已于 2023-09-14 10:01:47 修改
阅读量1.2k 收藏 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
百花君
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java 基于jlibmodbus 实现 ModBusTCP
人生一张西的博客
06-07 1581
依赖 <dependency> <groupId>com.intelligt.modbus</groupId> <artifactId>jlibmodbus</artifactId> <version>1.2.9.7</version> </dependency> public static void main(String[] args) throws ModbusInitException, Err
java通过com口采集读取modbus数据驱动程序
02-20
Java通过COM口采集读取Modbus数据驱动程序是一种在Java编程环境下实现的通信技术，用于与支持Modbus协议的设备进行交互。Modbus是一种广泛应用于工业自动化领域的通信协议，允许不同设备之间交换数据，比如PLC（可...
java整合modbus RTU，以及使用虚拟串口测试。一站到底
sinat_43097407的博客
06-27 582
java使用modbus RTU协议读取寄存器数据，以及modbus测试工具
基于java的modbus TCP通信
06-13
在 socket 通信/数据采集程序中，需要根据 Modbus TCP 协议的报文格式编码报文，发送到设备端，并解析响应报文的内容。例如，假设现在需要读取保持寄存器的数值，已知设备的地址、寄存器地址和数量，对应上述的 TCP ...
使用java获取modbus数据.zip
11-19
本教程将围绕如何使用Java语言来实现对Modbus设备的数据读取进行讲解。 首先，我们需要理解Modbus协议。Modbus是一种串行通信协议，它定义了主设备（通常是一台计算机或控制器）与从设备（如PLC）之间交换信息的...
Java modbus读取手卡数据
09-20
主要是modbus 通过Socket读取手环下面的数据；优势在于可以读取30多个以上的基站，每个基站下面可以带5个以上的手卡，并且是实时读取的
Java应用程序的Modbus4j串口通讯
02-12
Java应用程序的Modbus4j串口通讯是一种在Java平台上实现Modbus通信协议的库，它使得Java开发者能够方便地与支持Modbus协议的设备进行数据交换。Modbus是一种广泛使用的工业通讯协议，常用于PLC（可编程逻辑控制器）...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 565
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 422
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 467
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 381
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 333
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 949
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 832
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 913
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 83
④创建artifact。②点击加号创建，选择。
安装ElasticSearch
diffiii
07-31 573
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
java中static关键字的作用
weixin_41020960的博客
08-01 464
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 248
新建springboot项目找不到java版本8?
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、付费专栏及课程。

余额充值