【2023】java通过modbus4j实现modus TCP通讯

这篇具有很好参考价值的文章主要介绍了【2023】java通过modbus4j实现modus TCP通讯。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Modbus通信协议:

  • 主要分为三个子协议
    • RTU
    • ASCII
    • TCP

Modbus RTU:——传输的是字节数组(bit[])
通信:读写
输出:可以读写
输入:只能读

  • 存储区:输出线圈、输入线圈、输出寄存器、输入寄存器

    • 线圈:代表一个布尔量、最小单位是一个布尔(1或者0),
    • 寄存器:一个寄存器代表16个最小单位,主要用于存储数据
    • 存储区代号:
      • 输出线圈: 0(代号)
        • 00001-09999(标准存储区地址范围)
        • 000001-065536(扩展存储区地址范围)
      • 输入线圈:1
        • 10001-19999
      • 输出寄存器:4
        • 40001-49999
      • 输入寄存器:3
        • 30001-39999
  • 存储区范围:5位和6位

    • 5位:标准地址-Y XXXX
    • 6位:扩展地址-Y XXXXX

功能代码
modbus4j,IO通讯,java,tcp/ip,开发语言

验证4个常用功能码,仿真软件上面有F=01,F=02,F=03和F=04来显示

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

测试使用Modbus Slave(下载) 模拟
modbus4j,IO通讯,java,tcp/ip,开发语言

saveid:看资料"从站在modbus总线上可以有多个",仿真软件就能模拟一个从站,就是ID=1,当然可以修改成ID=2
功能码:4个功能码,对应写4个方法,,仿真软件上的F=1,或者F=2,3,4
addr:一开始看代码4个方法addr都是从0开始,是否重复?答案是:4个功能码表示4个区域或者设备,addr表示各自区域的地址编号。

  • Connection设置:设置连接参数

modbus4j,IO通讯,java,tcp/ip,开发语言

  • 地址设置: F8 ,可以通过Setup或者右击点位的
  • modbus4j,IO通讯,java,tcp/ip,开发语言

modbus4j,IO通讯,java,tcp/ip,开发语言

  • 设置不同存储区
    modbus4j,IO通讯,java,tcp/ip,开发语言
  • 读取从站

代码实现

1、依赖下载

阿里云不能直接下载
<!-- 若想引用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>
	
    <dependencies>
		 <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>
    </dependencies>

2、测试读取

  • 读取04(寄存器)
import com.intelligt.modbus.jlibmodbus.Modbus;
import com.intelligt.modbus.jlibmodbus.exception.ModbusIOException;
import com.intelligt.modbus.jlibmodbus.master.ModbusMaster;
import com.intelligt.modbus.jlibmodbus.master.ModbusMasterFactory;
import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestModbus {
    public static void main(String[] args) throws UnknownHostException {
            // 设置主机TCP参数
            TcpParameters tcpParameters = new TcpParameters();

            // 设置TCP的ip地址
            InetAddress address = InetAddress.getByName("127.0.0.1");
            // TCP参数设置ip地址
            tcpParameters.setHost(address);

            // TCP设置长连接
            tcpParameters.setKeepAlive(true);
            // TCP设置端口,这里设置是默认端口502
            tcpParameters.setPort(Modbus.TCP_PORT);

            // 创建一个主机
            ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
            Modbus.setAutoIncrementTransactionId(true);

            int slaveId = 1;//从机地址
            int offset = 0;//寄存器读取开始地址
            int quantity = 10;//读取的寄存器数量

            try {
            if (!master.isConnected()){
                master.connect(); //开启连接
            }
                // 读取对应从机的数据,readInputRegisters读取的写寄存器,功能码04
            int[] registerValues4 = master.readInputRegisters(slaveId,offset,quantity);

            for (int value : registerValues4){
                System.out.println("Address:"+offset++ +",Value:"+value);
            }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    master.disconnect();
                } catch (ModbusIOException e) {
                    e.printStackTrace();
                }
            }
    }
}

3、读取工具类

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;

public class Modbus4jReadUtils {

    static ModbusFactory modbusFactory;
    static {
        if (modbusFactory == null){
            modbusFactory = new ModbusFactory();
        }
    }
    /*** 
     * 初始化连接
     * @return ModbusMaster 
     */
    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.crea
        ModbusMaster master = modbusFactory.createTcpMaster(params,false);
        master.init();
        return master;
    }

    /***
     *  读取[01 Coil Status 0x]类型 开关数据
     * @author zhengfuping
     * @param slaveId 从站编号
     * @param offset 偏移位置
     * @return Boolean
     */
    public static Boolean readCoilStatus(int slaveId,int offset) throws ModbusInitException, ErrorResponseException, ModbusTransportException {
        BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId,offset);
        Boolean value = getMaster().getValue(loc);
        return value;
    }


    /**
     * 读取[02 Input Status 1x]类型 开关数据
     *
     * @param slaveId 从站编号
     * @param offset 偏移位
     * @return
     */
    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
     * @param offset 位置
     * @param dataType 数据类型,来自com.serotonin.modbus4j.code.DataType
     */
    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]类型 模拟量数据
     */
    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;
    }

//    批量读取
public static void batchRead(Integer count) throws ModbusInitException, ErrorResponseException, ModbusTransportException {
    BatchRead<Integer> batch = new BatchRead<Integer>();

    for (int i = 0; i <= count; i++) {
        batch.addLocator(i,BaseLocator.holdingRegister(1,i, DataType.TWO_BYTE_INT_SIGNED));
    }

    ModbusMaster master =getMaster();

    batch.setContiguousRequests(false);
    BatchResults<Integer> results = master.send(batch);
    for (int i = 0; i <= count; i++) {
        System.err.println(results.getValue(i));
    }
}

    public static void main(String[] args) {
        try {
            // 01测试
            Boolean v011 = readCoilStatus(1,1);
            Boolean v012 = readCoilStatus(1,2);
            Boolean v013 = readCoilStatus(1,3);

            System.out.println("v011:" + v011);
            System.out.println("v012:" + v012);
            System.out.println("v013:" + v013);
            // 02测试
            Boolean v021 = readInputStatus(1, 1);
            Boolean v022 = readInputStatus(1, 2);
            Boolean v023 = readInputStatus(1, 3);
            System.out.println("v021:" + v021);
            System.out.println("v022:" + v022);
            System.out.println("v023:" + v023);

            // 03测试
            Number v031 = readHoldingRegister(1, 1, DataType.TWO_BYTE_INT_SIGNED);//signed
            Number v032 = readHoldingRegister(1, 2, DataType.TWO_BYTE_INT_SIGNED);// 同上
            System.out.println("v031:" + v031);
            System.out.println("v032:" + v032);

            // 04测试
            Number v041 = readInputRegisters(1, 1, DataType.TWO_BYTE_INT_SIGNED);//
            Number v042 = readInputRegisters(1, 2, DataType.TWO_BYTE_INT_SIGNED);//
            System.out.println("v041:" + v041);
            System.out.println("v042:" + v042);

//            批量读取
            batchRead(9);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

读取结果:
modbus4j,IO通讯,java,tcp/ip,开发语言文章来源地址https://www.toymoban.com/news/detail-660966.html

4、写入工具类

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.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

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 值
     */
    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
     * @param startOffset  开始位置
     * @param bdata 写入的数据
     * @return 是否写入成功
     */
    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
     */
    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
     * @param startOffset 起始位置偏移量值
     * @param sdata 写入的数据
     */
    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
     */
    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 {
//             测试01  单个写入(0x)
			boolean t01 = writeCoil(1, 0, true);
			System.out.println("T01:" + t01);

//             测试02  批量写入(0x)
			boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
			System.out.println("T02:" + t02);

//             测试03  单个写入(4x)
			short v = -3;
			boolean t03 = writeRegister(1, 0, v);
			System.out.println("T03:" + t03);
//             测试04  批量写入(4x)
			boolean t04 = writeRegisters(1, 0, new short[] { -309, 390, 91 });
			System.out.println("t04:" + t04);
            //写模拟量
            writeHoldingRegister(1,8, 100, DataType.TWO_BYTE_INT_SIGNED);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

到了这里,关于【2023】java通过modbus4j实现modus TCP通讯的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java实现Modbus读写数据

    由于当时项目周期赶,引入了一个PLC4X组件,上手快。接下来就是使用这个组件遇到的一些问题: 关闭连接NioEventLoop没有释放导致oom 设计思想是一个设备一个连接,而不是一个网关一个连接 连接断开后客户端无从感知 前两个问题解决方案参考上篇文章,最后一个问题虽然可

    2024年02月09日
    浏览(41)
  • 通过exe4j将 java 项目(jar)打包成exe可执行文件(详细步骤)

    通过exe4j将 java 项目(jar)打包成exe可执行文件 文章目录 文章目录 一、下载安装 二、使用步骤 下载链接: ej-technologies - Java APM, Java Profiler, Java Installer Builder  安装只需一直下一步即可。 1.输入注册码“L-g782dn2d-1f1yqxx1rv1sqd”。 2.如下图: 3.如下图: 4.如下图: 5.如下图:

    2024年02月16日
    浏览(48)
  • Java实现使用jlibmodbus读取Modbus TCP数据

    提示:可以使用Modbus slave工具模拟Modbus数据站并添加一些数据。 1、pom引入依赖 2、创建modbus主机连接 3、通过连接获取功能码0x04与0x03的数据 4、根据具体业务情况,进行方法的调用与数据解析。在本人实际业务中,存在两个IP地址(实际中上文的主机连接,可以根据IP的不同

    2024年02月11日
    浏览(54)
  • modbus采集和 mqtt上报相结合,通过荔枝派(F1c100s芯片模块)实现数据采集连接阿里云物联网平台进行数据上报和下发功能。

    通过荔枝派(F1c100s芯片模块)搭载SDIO-wifi模块,写入了主函数程序。根据读取modbus模拟器的数据,反馈到阿里云物联网平台当中。图中左侧的阿里云物联网平台所显示的温度为66摄氏度,与modbus模拟器的数据是一样的,图片右侧是荔枝派(F1c100s芯片模块)的编程软件X-shell的

    2024年02月15日
    浏览(55)
  • 通过modbus tcp 和台达PLC通信测试记录

    安装台达梯形图软件 “WPLSoft” http://downloadcenter.delta-china.com.cn/DownloadCenter?v=1q=WPLsort_expr=cdatesort_dir=DESC 2.硬件连接 2.1 电脑网卡 连接PLC以太网, IP设为192.168.1.x网段,PLC默认IP为192.168.1.5. 2.2 PLC 供电24V, S/S输入公共端接GND,UP0/ZP0输出驱动电源的端口接GND / 24V 2.3 在 PLC X0输入触

    2024年02月08日
    浏览(49)
  • Python3通过串口服务器读取设备Modbus数据【modbus_rtu_over_tcp】

    工业采集设备支持ModbusRtu 协议,通讯端口为232串口 或485接口,上位机连接采集终端,不方便走线【串口线 、485总线】,利用现有网络,通过串口服务器进行连接。 实现方案: 1、虚拟串口,上位机通过串口直接采集数据, 缺点:需要安装、开启虚拟串口程序,增加不稳定因

    2024年02月11日
    浏览(60)
  • AWTK 开源串口屏开发(17) - 通过 MODBUS 访问数组数据

    在 AWTK 串口屏中,内置了 MODBUS Client Channel 的模型,不用编写代码即可实现在 ListView 中显示数组数据。 MODBUS 协议一次只能读取 125 个 WORD,AWTK-MODBUS Client Channel 支持长数据,自动分成多个请求访问。 不用编写代码,实现对远程设备上数组数据的显示。 从模板创建项目,将

    2024年04月28日
    浏览(29)
  • 华为OD机试 - 通过软盘拷贝文件 - 动态规划(Java 2023 B卷 200分)

    华为OD机试 2023B卷题库疯狂收录中,刷题 点这里 本专栏收录于

    2024年02月09日
    浏览(42)
  • 三天吃透Java面试八股文(2023最新整理),面试通过率高达90%

    什么样的求职者能够获得面试官的青睐?求职者需要准备哪些内容来面对形形色色的面试官?这两份资料是我在几十场面试中被面试官问到的问题, 比其他复制粘贴的面试题强一百倍 ,堪称 全网最强 (我不太喜欢“全网最强”这样的字眼,但确实做到了全网最强)。 写这

    2024年02月13日
    浏览(32)
  • 通过Python连接 modbus tcp 和台达PLC通信测试记录

    安装台达梯形图软件 “WPLSoft” http://downloadcenter.delta-china.com.cn/DownloadCenter?v=1q=WPLsort_expr=cdatesort_dir=DESC 2.硬件连接 2.1 电脑网卡 连接PLC以太网, IP设为192.168.1.x网段,PLC默认IP为192.168.1.5. 2.2 PLC 供电24V, S/S输入公共端接GND,UP0/ZP0输出驱动电源的端口接GND / 24V 2.3 在 PLC X0输入触

    2024年01月23日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包