Java實現ModbusTCP通訊

時間 2019-11-08

標籤 java 實現 modbustcp 通訊欄目 Java 简体版

原文原文鏈接

一個項目，須要用Java實現使用ModbusTCP和硬件設備通訊php

資料

代碼下載html

本文的代碼和仿真軟件：藍奏雲下載

官網資料java

Modbus官網

Modbus協議

Modbus技術資源

MODBUS TCP / IP

關於Java的開源庫git

Jamod：Java Modbus實現：Java Modbus庫。該庫由Dieter Wimberger實施。

ModbusPal：ModbusPal是一個正在進行的Java項目，用於建立逼真的Modbus從站模擬器。因爲預約義的數學函數和/或Python腳本，寄存器值是動態生成的。ModbusPal依賴於RxTx進行串行通訊，而Jython則依賴於腳本支持。

Modbus4J：Serotonin Software用Java編寫的Modbus協議的高性能且易於使用的實現。支持ASCII，RTU，TCP和UDP傳輸做爲從站或主站，自動請求分區，響應數據類型解析和節點掃描。

JLibModbus：JLibModbus是java語言中Modbus協議的一種實現。jSSC和RXTX用於經過串行端口進行通訊。該庫是一個通過積極測試和改進的項目。

博客資料github

ModbusTCP協議

基於TCP/IP協議的Modbus

modbus tcp通信modbus4j使用說明-java編程

modbus tcp 通信modbus-master-tcp Java使用說明

Github資料web

modbus4j

ModbusTCP協議

Modbus由MODICON公司於1979年開發，是一種工業現場總線協議標準。1996年施耐德公司推出基於以太網TCP/IP的Modbus協議：ModbusTCP。apache

Modbus協議是一項應用層報文傳輸協議，包括ASCII、RTU、TCP三種報文類型。編程

標準的Modbus協議物理層接口有RS23二、RS42二、RS485和以太網接口，採用master/slave方式通訊。app

我的感受：框架

modbus協議也是對地址變量進行讀取或者寫入操做，變化的多是地址變量的地址和數據類型。
這個功能碼（指定要作什麼，指定存儲器，而後指定動做：是讀啊，是寫啊，仍是對多個一塊兒操做啊）

Modbus和RS485的關係：Modbus是協議，物理層接口有RS23二、RS42二、RS485和以太網接口幾種

仿真軟件

驗證4個經常使用功能碼，仿真軟件上面有F=01，F=02，F=03和F=04來顯示

0x01：讀線圈
0x02：讀離散量輸入
0x03：讀保持寄存器
0x04：讀輸入寄存器

對應的代碼要寫4個方法

我要寫一個Master(主站)，因此須要一個Slave(從站)

Modbus Slave下載

安裝：一直下一步

激活碼：5455415451475662（來源）

激活：Connection-->connect...（F3），輸入激活碼，下面截圖沒輸入激活碼，由於當時沒找到激活碼

選擇TCP模式，端口是固定的502

地址類型

F8：

Slave Definition

功能碼

數據類型

功能碼01

功能碼02

功能碼03，選擇Float類型

雙擊第一個地址輸入數據，會提示輸入數據的類型，32位數據佔2個地址，因此下一個地址是--

功能碼04

使用jlibmodbus

參考：Java實現ModBus的poll端（主機master端，查詢和接受數據）

源碼1：https://sourceforge.net/projects/jlibmodbus/

源碼2：https://github.com/kochedykov/jlibmodbus

特別有意思：經常使用的串口通訊庫都加進去了

maven依賴

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

測試功能碼04

package com.tcb.jlibmodbus;

import java.net.InetAddress;

import com.intelligt.modbus.jlibmodbus.Modbus;
import com.intelligt.modbus.jlibmodbus.exception.ModbusIOException;
import com.intelligt.modbus.jlibmodbus.exception.ModbusNumberException;
import com.intelligt.modbus.jlibmodbus.exception.ModbusProtocolException;
import com.intelligt.modbus.jlibmodbus.master.ModbusMaster;
import com.intelligt.modbus.jlibmodbus.master.ModbusMasterFactory;
import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;


/**
 * Hello world!
 *
 */
public class App {
    public static void main(String[] args) {
        try {
            // 設置主機TCP參數
            TcpParameters tcpParameters = new TcpParameters();
 
            // 設置TCP的ip地址
            InetAddress adress = InetAddress.getByName("127.0.0.1");
 
            // TCP參數設置ip地址
            // tcpParameters.setHost(InetAddress.getLocalHost());
            tcpParameters.setHost(adress);
 
            // 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[] registerValues = master.readInputRegisters(slaveId, offset, quantity);
 
                // 控制檯輸出
                for (int value : registerValues) {
                    System.out.println("Address: " + offset++ + ", Value: " + value);
                }
 
            } catch (ModbusProtocolException e) {
                e.printStackTrace();
            } catch (ModbusNumberException e) {
                e.printStackTrace();
            } catch (ModbusIOException e) {
                e.printStackTrace();
            } finally {
                try {
                    master.disconnect();
                } catch (ModbusIOException e) {
                    e.printStackTrace();
                }
            }
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印到控制檯的信息

Address: 0, Value: 88
Address: 1, Value: 66
Address: 2, Value: 8
Address: 3, Value: 6
Address: 4, Value: 32727
Address: 5, Value: 32808
Address: 6, Value: 0
Address: 7, Value: 3
Address: 8, Value: 2
Address: 9, Value: 1

使用modbus4j

maven依賴

官方說明：https://github.com/infiniteautomation/modbus4j

有個坑：Maven配的阿里雲倉庫，下載不下來，註釋掉阿里雲倉庫使用默認倉庫才能下載好。

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tcb</groupId>
  <artifactId>modbus</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>modbus</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  
  <!-- 若想引用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>

</project>

Java實現modbus協議通信

原文連接：http://www.leftso.com/blog/83.html
核心依賴:

modbus4j.jar

commons-lang3-3.0.jar

Modbus4jUtils類

package com.tcb.modbus;

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實現
 * 
 * @author lxq
 * @dependencies modbus4j-3.0.3.jar
 * @website https://github.com/infiniteautomation/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();
        }
    }
}

代碼理解

slave配置

輸出信息

v011:true
v012:false
v013:true
v021:true
v022:false
v023:true
v031:7.5
v032:10.5
v041:1.5
v042:3.0
7.5
true

Java經過modbus4j對數據的寫入

原文連接：http://www.leftso.com/blog/83.html

類Modbus4jWriteUtils.java

package com.tcb.modbus;

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寫入數據
 * 
 * @author xq
 *
 */
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 registerCount
     *            ,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();
        }

    }

}

代碼理解

使用modbus-master-tcp

原文連接：http://www.leftso.com/blog/310.html
modbus tcp通信Java的方案以前已經講解過一種,modbus4j實現Java語言的modbus tcp協議通信。從上一個方案中咱們不難發現modbus4j的通信實現方式是同步的。
實際應用中可能會讀取大量的數據。同步處理對於應用的響應仍是不太友好的。
本博客主要講解另一種Java語言的modbux tcp通信方案。那就是modbus-master-tcp。

maven依賴

pom.xml注意,須要將java的編譯版本指定到1.8.由於只有1.8之後才支持lambda表達式。

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

觀察能夠發現,modbus-master-tcp項目的底層是基於netty框架開發。自然的支持異步處理。在性能方面有很好的提高。

編寫modbus tcp讀取案例

類SimpleMasterExample

package com.tcb.modbusmastertcp;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import com.digitalpetri.modbus.codec.Modbus;
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;

/***
 * modbus TCP協議Java通信讀取例子
 * 
 * @author xqlee
 *
 */
public class SimpleMasterExample {

    static ModbusTcpMaster master;

    /**
     * 獲取TCP協議的Master
     * 
     * @return
     */
    public static void initModbusTcpMaster() {
        if (master == null) {
            // 建立配置
            ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("localhost").setPort(502).build();
            master = new ModbusTcpMaster(config);
        }
    }

    /***
     * 釋放資源
     */
    public static void release() {
        if (master != null) {
            master.disconnect();
        }
        Modbus.releaseSharedResources();
    }

    /**
     * 讀取HoldingRegister數據
     * 
     * @param address
     *            寄存器地址
     * @param quantity
     *            寄存器數量
     * @param unitId
     *            id
     * @return 讀取結果
     * @throws InterruptedException
     *             異常
     * @throws ExecutionException
     *             異常
     */
    public static Number readHoldingRegisters(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        Number result = null;
        CompletableFuture<ReadHoldingRegistersResponse> future = master
                .sendRequest(new ReadHoldingRegistersRequest(address, quantity), unitId);
        ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();// 工具類作的同步返回.實際使用推薦結合業務進行異步處理
        if (readHoldingRegistersResponse != null) {
            ByteBuf buf = readHoldingRegistersResponse.getRegisters();
            result = buf.readFloat();
            ReferenceCountUtil.release(readHoldingRegistersResponse);
        }
        return result;
    }

    /**
     * 讀取InputRegisters模擬量數據
     * 
     * @param address
     *            寄存器開始地址
     * @param quantity
     *            數量
     * @param unitId
     *            ID
     * @return 讀取值
     * @throws InterruptedException
     *             異常
     * @throws ExecutionException
     *             異常
     */
    public static Number readInputRegisters(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        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;
    }

    /**
     * 讀取Coils開關量
     * 
     * @param address
     *            寄存器開始地址
     * @param quantity
     *            數量
     * @param unitId
     *            ID
     * @return 讀取值
     * @throws InterruptedException
     *             異常
     * @throws ExecutionException
     *             異常
     */
    public static Boolean readCoils(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        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;
    }

    /**
     * 讀取readDiscreteInputs開關量
     * 
     * @param address
     *            寄存器開始地址
     * @param quantity
     *            數量
     * @param unitId
     *            ID
     * @return 讀取值
     * @throws InterruptedException
     *             異常
     * @throws ExecutionException
     *             異常
     */
    public static Boolean readDiscreteInputs(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        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 static void main(String[] args) {
        try {
            // 初始化資源
            initModbusTcpMaster();
            // 執行操做
            // 讀取模擬量
            System.out.println(readHoldingRegisters(0, 4, 1));
            System.out.println(readInputRegisters(0, 4, 1));

            // 讀取開關量
            System.out.println(readCoils(0, 1, 1));
            System.out.println(readDiscreteInputs(0, 1, 1));
            System.out.println(readDiscreteInputs(2, 1, 1));

            // 釋放資源
            release();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代碼理解

slave：和上面的同樣

輸出信息