springboot 整合 modbus4j

最新推荐文章于 2025-04-28 11:16:28 发布
最新推荐文章于 2025-04-28 11:16:28 发布
阅读量4.2k 收藏 19
点赞数 2
分类专栏： modbus 文章标签： java modbus
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37377082/article/details/120495612
版权

pom.xml

<dependency>
   	<groupId>com.serotonim</groupId>
    <artifactId>modbus4j</artifactId>
</dependency>

配置类

@Slf4j
@Configuration
@Component
@Import(com.serotonin.modbus4j.ModbusFactory.class)
public class ModbusConfig {

    @Value("${modbus.host}")
    private String host;

    @Value("${modbus.port}")
    private Integer port;

    /*@Autowired
    private ModbusFactory modbusFactory;*/

    /*@Resource
    private BeginPowerExchangeService beginPowerExchangeService;*/

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Bean
    public TcpMasterExtend modbusMaster() {
        IpParameters ipParameters = new IpParameters();
        ipParameters.setHost(host);
        ipParameters.setPort(port);

        /*// 原生TCP 协议
        ModbusMaster master = modbusFactory.createTcpMaster(ipParameters, true);*/
        //自定处理
        TcpMasterExtend master = new TcpMasterExtend(ipParameters,true,stringRedisTemplate);

        //设置超时时间
        master.setTimeout(3 * 1000);
        //设置重连次数
        master.setRetries(6);
        //初始化
        try {
            master.init();
        } catch (ModbusInitException e) {
            log.error("modbus 初始化异常:{}", e.getMessage());
        }
        return master;
    }
}

自定义 TcpMaster

import cn.hutool.core.util.ReflectUtil;
import com.sany.swap.vo.RedisModule;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.ip.tcp.TcpMaster;
import com.serotonin.modbus4j.msg.*;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.time.Duration;
import java.time.LocalDateTime;


/**
 * @Method
 * @Author xuyuhao
 * @Version 1.0
 * @Description
 * @Return
 * @Exception
 * @Date 2021/4/14
 */
@Getter
@Setter
@Slf4j
public class TcpMasterExtend extends TcpMaster {
    //在线标识
    private volatile static boolean online = false;
    //异常时间
    private static LocalDateTime exceptionTime = null;
    //redis
    private StringRedisTemplate redisTemplate;

    /**
     * 初始构造方法
     *
     * @param params
     * @param keepAlive
     * @param redisTemplate
     */
    public TcpMasterExtend(IpParameters params,boolean keepAlive,
                           StringRedisTemplate redisTemplate) {
        super(params, keepAlive);
        this.redisTemplate = redisTemplate;
    }

    /**
     * 发送消息
     *
     * @param request
     * @return
     */
    public ModbusResponse sendEx(ModbusRequest request) throws ModbusTransportException {
        try {
            ModbusResponse response = null;

            if (request instanceof ReadHoldingRegistersRequest) {
                Integer startOffset = (Integer) ReflectUtil.getFieldValue(request, "startOffset");
                response = send(request);
                log.warn("PLC读取寄存器数据 ------> 位置:{},结果:{}", startOffset, null != response ? ((ReadHoldingRegistersResponse) response).getShortData() : "无");
            } else if (request instanceof WriteRegisterRequest || request instanceof WriteRegistersRequest) {
                response = send(request);
            }
            if (!online) {
                log.warn("PLC设备上线---------->断线时长:{}分钟", null == exceptionTime ? 0 : Duration.between(exceptionTime, LocalDateTime.now()).toMinutes());
            }
            redisTemplate.opsForValue().set(RedisModule.PLC_ONLINE_STATUS.get(), "true");
            online = true;
            return response;
        } catch (Exception e) {
            //如果是连接异常手动处理一下
            if (e.getCause() instanceof ConnectException || e.getCause() instanceof SocketTimeoutException) {
                if (online) {
                    exceptionTime = LocalDateTime.now();
                    log.warn("PLC设备发生连接异常------->{}", e);
                }
                destroy();
                online = false;
                redisTemplate.opsForValue().set(RedisModule.PLC_ONLINE_STATUS.get(), "false");
                return null;
            }
            //否则直接抛出
            throw e;
        }
    }
}

modbus操作类

import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.msg.*;
import com.sany.swap.api.plc.service.BeginPowerExchangeService;
import com.sany.swap.service.plc.bean.TcpMasterExtend;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * <p></p>
 *
 * @author zhangliang@gjkjjt.com
 * @version 1.0.0
 * @date 2020/6/26 9:43
 * <p>
 */
@Slf4j
@Configuration
public class Modbus4jUtils {

    @Autowired
    private TcpMasterExtend tcpMaster;

    @Resource
    private BeginPowerExchangeService beginPowerExchangeService;

    /**
     * @Title readCoilStatus
     * @Description: 读（线圈）开关量数据，相当于功能码：01H-读线圈状态
     * @params: [ip, slaveId, offset, numberOfRegister]
     * @return: boolean[]
     * @throws:
     */
    public boolean[] readCoilStatus(int slaveId, int offset, int numberOfRegister) {

        boolean[] booleans = null;
        try {
            ReadCoilsRequest request = new ReadCoilsRequest(slaveId, offset, numberOfRegister);
            ReadCoilsResponse response = (ReadCoilsResponse) tcpMaster.sendEx(request);
            if (response.isException()) {
                log.error("readCoilStatus response: message=" + response.getExceptionMessage());
            } else {
                booleans = response.getBooleanData();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            beginPowerExchangeService.changePlcOnlineStatus(0);
            log.error("modbus 连接异常:{}", e.getMessage());
        }
        return valueRegroup(numberOfRegister, booleans);
    }

    /**
     * @Title readInputStatus
     * @Description: 读取外围设备输入的开关量，相当于功能码：02H-读离散输入状态
     * @params: [ip, offset, numberOfRegister]
     * @return: boolean[]
     * @throws:
     */
    public boolean[] readInputStatus(int slaveId, int offset, int numberOfRegister) {
        boolean[] booleans = null;
        try {
            ReadDiscreteInputsRequest request = new ReadDiscreteInputsRequest(slaveId, offset, numberOfRegister);
            ReadDiscreteInputsResponse response = (ReadDiscreteInputsResponse) tcpMaster.sendEx(request);
            if (response.isException()) {
                log.error("readInputStatus response: message=" + response.getExceptionMessage());
            } else {
                booleans = response.getBooleanData();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            beginPowerExchangeService.changePlcOnlineStatus(0);
            log.error("modbus连接异常:{}", e.getMessage());
        }
        return valueRegroup(numberOfRegister, booleans);
    }

    /**
     * @Title readHoldingRegister
     * @Description: 读取保持寄存器数据，相当于功能码：03H-读保持寄存器
     * @params: [ip, offset, numberOfRegister]
     * @return: short[]
     * @throws:
     */
    public short[] readHoldingRegister(int slaveId, int offset, int numberOfRegister) {
        short[] result = null;
        try {
            ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(slaveId, offset, numberOfRegister);
            ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) tcpMaster.sendEx(request);
            if (response.isException()) {
                log.error("readHoldingRegister response: message=" + response.getExceptionMessage());
            } else {
                result = response.getShortData();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            log.error("modbus 连接异常:{}", e.getMessage());
            beginPowerExchangeService.changePlcOnlineStatus(0);
        }
        return result;
    }

    /**
     * @Title readInputRegisters
     * @Description: 读取外围设备输入的数据，相当于功能码：04H-读输入寄存器
     * @params: [ip, offset, numberOfRegister]
     * @return: short[]
     * @throws:
     */
    public short[] readInputRegisters(int slaveId, int offset, int numberOfRegister) {
        short[] result = null;
        try {
            ReadInputRegistersRequest request = new ReadInputRegistersRequest(slaveId, offset, numberOfRegister);
            ReadInputRegistersResponse response = (ReadInputRegistersResponse) tcpMaster.sendEx(request);

            if (response.isException()) {
                log.error("readInputRegisters response: message=" + response.getExceptionMessage());
            } else {
                result = response.getShortData();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            log.error("modbus 连接异常:{}", e.getMessage());
            beginPowerExchangeService.changePlcOnlineStatus(0);
        }
        return result;
    }

    /**
     * @Title writeCoil
     * @Description: 写单个（线圈）开关量数据，相当于功能码：05H-写单个线圈
     * @params: [ip, writeOffset, writeValue]
     * @return: boolean
     * @throws:
     */
    public boolean writeCoil(int slaveId, int writeOffset, boolean writeValue) {
        boolean result = false;
        try {
            WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
            WriteCoilResponse response = (WriteCoilResponse) tcpMaster.sendEx(request);
            if (response.isException()) {
                log.error("writeCoil response: message=" + response.getExceptionMessage());
            } else {
                result = !response.isException();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            log.error("modbus 连接异常:{}", e.getMessage());
            beginPowerExchangeService.changePlcOnlineStatus(0);
        }
        return result;
    }

    /**
     * @Title writeCoils
     * @Description: 写多个开关量数据（线圈），相当于功能码：0FH-写多个线圈
     * @params: [ip, startOffset, data]
     * @return: boolean
     * @throws:
     */
    public boolean writeCoils(int slaveId, int startOffset, boolean[] data) {
        boolean result = false;
        try {
            WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, data);
            WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.sendEx(request);

            if (response.isException()) {
                log.error("writeCoils response: message=" + response.getExceptionMessage());
            } else {
                result = !response.isException();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            log.error("modbus 连接异常:{}", e.getMessage());
            beginPowerExchangeService.changePlcOnlineStatus(0);
        }
        return result;
    }

    /**
     * @Title writeHoldingRegister
     * @Description: 写单个保持寄存器，相当于功能码：06H-写单个保持寄存器
     * @params: [slaveId, writeOffset, writeValue]
     * @return: boolean true 成功  false 失败
     * @throws:
     */
    public boolean writeHoldingRegister(int slaveId, int writeOffset, short writeValue) {
        boolean result = false;
        try {
            WriteRegisterRequest request = new WriteRegisterRequest(slaveId, writeOffset, writeValue);
            WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.sendEx(request);
            if (response.isException()) {
                log.error("writeHoldingRegister response: message=" + response.getExceptionMessage());
            } else {
                result = !response.isException();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            log.error("modbus 连接异常:{}", e.getMessage());
            beginPowerExchangeService.changePlcOnlineStatus(0);
        }
        return result;

    }

    /**
     * @Title writeHoldingRegisters
     * @Description: 写多个保持寄存器，相当于功能码：10H-写多个保持寄存器
     * @params: [ip, slaveId, startOffset, data]
     * @return: boolean
     * @throws:
     */
    public boolean writeHoldingRegisters(int slaveId, int startOffset, short[] data) {
        boolean result = false;
        try {
            WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, data);
            WriteRegistersResponse response = (WriteRegistersResponse) tcpMaster.sendEx(request);
            if (response.isException()) {
                log.error("writeHoldingRegisters response: message=" + response.getExceptionMessage());
            } else {
                result = !response.isException();
            }
            beginPowerExchangeService.changePlcOnlineStatus(1);
        } catch (ModbusTransportException e) {
            log.error("modbus 连接异常:{}", e.getMessage());
            beginPowerExchangeService.changePlcOnlineStatus(0);
        }
        return result;
    }


    /**
     * @Title valueRegroup
     * @Description: 转换工具，将Boolean转换成0，1
     * @params: [numberOfBits, values]
     * @return: boolean[]
     * @throws:
     */
    private boolean[] valueRegroup(int numberOfBits, boolean[] values) {
        boolean[] bs = new boolean[numberOfBits];
        int temp = 1;
        for (boolean b : values) {
            bs[temp - 1] = b;
            temp++;
            if (temp > numberOfBits) {
                break;
            }
        }
        return bs;
    }
}
SpringBoot+modbus4j实现ModebusTCP通讯读取数据
BADAO_LIUMANG_QIZHI的博客
12-29 4654
这是因为功能码不对应，使用Modbus Slave Definition定义的功能码为03 Holding Register(4x),而在代码中连接后执行的是读取线圈状态的功能码。标准的Modbus协议物理层接口有RS232、RS422、RS485和以太网接口，采用master/slave方式通信。Serotonin Software用Java编写的Modbus协议的高性能且易于使用的实现。ModbusPal是一个正在进行的Java项目，用于创建逼真的Modbus从站模拟器。
springboot 集成 Modbus 和硬件设备通信
Is_cherishing的博客
12-27 1104
这些日子需要实现一个功能，springboot框架中集成Modbus，实现控制设备的状态，所以就学习Modbus协议的基础知识，通过网络资源研究了一天多，加上自己的理解及经验，完成了测试类的编写，以下简要说明记录两种实现方式。Modbus 协议中，线圈（Coils）和寄存器（Registers）是两种不同的数据类型，它们在功能和使用上有一些显著的区别和联系。
java modbus4j中文api_modbus4j使用（java）
weixin_42575109的博客
02-16 1747
java使用modbus4j示例如下，特别注意：如果想轮询去读数据，需要for循环调readHoldingRegistersTest(master,SLAVE_ADDRESS,0,100); 并且serialParameters.setStopBits(1); 修改为serialParameters.setStopBits(2);package com.test.modbus;import jav...
SpringBoot整合modbus 4j（Tcp）
程序员进阶之路
08-16 1916
【代码】SpringBoot整合modbus 4j（Tcp）
【在Spring Boot项目中接入Modbus协议】
L-Blog
03-03 1266
在Spring Boot项目中接入Modbus协议，可以通过使用第三方库（如jamod或modbus4j）来实现。以下是一个基本的步骤指南，帮助你在Spring Boot项目中集成Modbus。
springboot整合modbus4J（一）
weixin_44021888的博客
08-25 2651
springboot整合modbus4J（一）
springboot整合modbus4J（二）
weixin_44021888的博客
08-25 1662
springboot整合modbus4J（二）
springboot整合modbus实现通讯
weixin_47077809的博客
11-05 2105
springboot快速整合modbus通讯协议，快速的实现modbus通讯功能
SpringBoot基于modbus4j实现Modbus/TCP通讯
最新发布
loser.with.m的博客
04-28 814
Modbus是MODICON公司与1979年开发的一种通讯协议，是一种工业现场总线协议标准。1996年施耐德公司推出了基于以太网TCP/IP的Modbus协议------ModbusTCP。Modbus协议是一项应用层报文传输协议，包括ASCII、RTU、TCP三种报文类型，协议本身并没有定义物理层，只是定义了控制器能够认识和使用的消息结构，而不管他们是经过何种网络进行通信的。标准的Modbus协议物理层接口有RS232、RS422、RS485和以太网口。采用Master/Slave（主/从）方式通信。
Java整合springboot2.3+modbusTcp协议+netty高性能物联网服务源码
03-31
Java整合springboot2.3+modbusTcp协议+netty高性能物联网服务源码 1、Netty NIO high performance高性能. 2、Modbus Function sync/aync 同步/异步非阻塞。 3、Modbus IoT Data Connector Supports工业物联网平台IoT支持。 4、支持Modbus TCP\Modbus RTU protocol两种通信协议. 5、完全支持Modbus TCP 4种部署模式: TCP服务器master,TCP客户端slave,TCP服务器slave,TCP客户端master。 本人QQ412961810，有问题可以帮忙解答
ModbusTCP整合java springboot: 远程操控真机demo
01-19
写寄存器（每台内机占用 4 个寄存器） 1、开关设定 2、模式设定 3、温度设定 4、风速设定 读寄存器（每台内机占用 6 个寄存器） 1、开关查询 2、模式查询 3、温度查询 4、风速查询 5、室温查询 6、故障查询
modbusHb：基于SpringBoot实现的modbus心跳通信
02-04
基于Spring Boot实现的modbus心跳通信 基于Spring Boot实现的modbus定时tcp通信，支持线程池，可从数据库动态设置ip，端口号及执行周期（执行周期需遵循cron表达） 本项目使用Spring Data Jpa + MySQL，具体依赖见pom.xml modbus协议基于jlibmodbus实现，感谢 例子：
modbus4J文档
01-28
modbus4j文档，便于各位对modbus开发有需求的用户，文档类型为纯英文格式，中文文档我也没找着。
modbus4j文档（英文）
01-14
modbus4j是一个第三方的开源jar包，在此给出使用文档，中文的我也没有，慢慢看吧！
SpringBoot集成ModbusTCP
qq_48885166的博客
11-21 1508
【代码】SpringBoot集成ModbusTCP。
springboot中modbus使用
热门推荐
weixin_43069081的博客
05-09 1万+
modbus在springboot中的使用， 本人在用，复制即可用 pom.xml配置: <!-- 辅助modbus4j：repository id:ias-snapshots id:ias-releases 两个 --> <repositories> <repository> <releases> ...
springboot整合modbus4j
07-28
引用\[1\]中提到了使用Modbus4J来实现Spring Boot与ModbusTCP/RTU的集成。首先，你需要导入Modbus4J的依赖，可以通过Maven进行导入。然后，你需要添加一个名为Modbus4jUtils.java的工具类，其中包含一些字节转换的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值