java如何通過modbus4j實(shí)現(xiàn)modbus?TCP通訊

更新時(shí)間：2025年07月19日 08:40:05 作者：方漸鴻

Modbus協(xié)議包含RTU、ASCII、TCP三種類型,定義四個(gè)存儲(chǔ)區(qū)（輸出線圈、輸入線圈、輸出寄存器、輸入寄存器）及其地址范圍,支持讀寫功能,通過功能碼01-04操作,仿真軟件可模擬從站ID

Modbus通信協(xié)議

主要分為三個(gè)子協(xié)議：

RTU
ASCII
TCP

Modbus RTU:——傳輸?shù)氖亲止?jié)數(shù)組（bit[]）

通信：讀寫
輸出：可以讀寫
輸入：只能讀

存儲(chǔ)區(qū)：輸出線圈、輸入線圈、輸出寄存器、輸入寄存器

線圈：代表一個(gè)布爾量、最小單位是一個(gè)布爾（1或者0），

寄存器：一個(gè)寄存器代表16個(gè)最小單位，主要用于存儲(chǔ)數(shù)據(jù)

存儲(chǔ)區(qū)代號(hào)：

輸出線圈： 0（代號(hào)）

00001-09999（標(biāo)準(zhǔn)存儲(chǔ)區(qū)地址范圍）
000001-065536(擴(kuò)展存儲(chǔ)區(qū)地址范圍)

輸入線圈：1

10001-19999

輸出寄存器：4

40001-49999

輸入寄存器：3

30001-39999

存儲(chǔ)區(qū)范圍：5位和6位

5位：標(biāo)準(zhǔn)地址-Y XXXX
6位：擴(kuò)展地址-Y XXXXX

功能代碼：

驗(yàn)證4個(gè)常用功能碼，仿真軟件上面有F=01，F(xiàn)=02，F(xiàn)=03和F=04來(lái)顯示

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

測(cè)試使用Modbus Slave（下載）模擬

saveid：看資料"從站在modbus總線上可以有多個(gè)"，仿真軟件就能模擬一個(gè)從站，就是ID=1，當(dāng)然可以修改成ID=2
功能碼：4個(gè)功能碼，對(duì)應(yīng)寫4個(gè)方法，，仿真軟件上的F=1，或者F=2，3，4
addr：一開始看代碼4個(gè)方法addr都是從0開始，是否重復(fù)？答案是：4個(gè)功能碼表示4個(gè)區(qū)域或者設(shè)備，addr表示各自區(qū)域的地址編號(hào)。

Connection設(shè)置：設(shè)置連接參數(shù)

地址設(shè)置： F8 ，可以通過Setup或者右擊點(diǎn)位的

設(shè)置不同存儲(chǔ)區(qū)

讀取從站

代碼實(shí)現(xiàn)

1、依賴下載

阿里云不能直接下載

<!-- 若想引用modbus4j需要引入下列repository id:ias-snapshots id:ias-releases 兩個(gè) ，使用默認(rèn)倉(cāng)庫(kù)下載，不要使用阿里云倉(cāng)庫(kù)-->
    <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、測(cè)試讀取

讀取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 {
            // 設(shè)置主機(jī)TCP參數(shù)
            TcpParameters tcpParameters = new TcpParameters();

            // 設(shè)置TCP的ip地址
            InetAddress address = InetAddress.getByName("127.0.0.1");
            // TCP參數(shù)設(shè)置ip地址
            tcpParameters.setHost(address);

            // TCP設(shè)置長(zhǎng)連接
            tcpParameters.setKeepAlive(true);
            // TCP設(shè)置端口，這里設(shè)置是默認(rèn)端口502
            tcpParameters.setPort(Modbus.TCP_PORT);

            // 創(chuàng)建一個(gè)主機(jī)
            ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
            Modbus.setAutoIncrementTransactionId(true);

            int slaveId = 1;//從機(jī)地址
            int offset = 0;//寄存器讀取開始地址
            int quantity = 10;//讀取的寄存器數(shù)量

            try {
            if (!master.isConnected()){
                master.connect(); //開啟連接
            }
                // 讀取對(duì)應(yīng)從機(jī)的數(shù)據(jù)，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 協(xié)議
        // modbusFactory.createUdpMaster(params);//UDP 協(xié)議
        // modbusFactory.createAsciiMaster(wrapper);//ASCII 協(xié)議
//        ModbusMaster master = modbusFactory.crea
        ModbusMaster master = modbusFactory.createTcpMaster(params,false);
        master.init();
        return master;
    }

    /***
     *  讀取[01 Coil Status 0x]類型 開關(guān)數(shù)據(jù)
     * @author zhengfuping
     * @param slaveId 從站編號(hào)
     * @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]類型 開關(guān)數(shù)據(jù)
     *
     * @param slaveId 從站編號(hào)
     * @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]模擬量數(shù)據(jù)
     * @param slaveId
     * @param offset 位置
     * @param dataType 數(shù)據(jù)類型,來(lái)自com.serotonin.modbus4j.code.DataType
     */
    public static Number readHoldingRegister(int slaveId, int offset, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 03 Holding Register類型數(shù)據(jù)讀取
        BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
        Number value = getMaster().getValue(loc);
        return value;
    }

    /**
     * 讀取[04 Input Registers 3x]類型 模擬量數(shù)據(jù)
     */
    public static Number readInputRegisters(int slaveId, int offset, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 04 Input Registers類型數(shù)據(jù)讀取
        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測(cè)試
            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測(cè)試
            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測(cè)試
            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測(cè)試
            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();
        }
    }
}

讀取結(jié)果：

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)]寫一個(gè) 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();
        // 創(chuàng)建請(qǐng)求
        WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
        // 發(fā)送請(qǐng)求并獲取響應(yīng)對(duì)象
        WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
        if (response.isException()) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 寫[01 Coil Status(0x)] 寫多個(gè) function ID = 15
     * @param slaveId
     * @param startOffset  開始位置
     * @param bdata 寫入的數(shù)據(jù)
     * @return 是否寫入成功
     */
    public static boolean writeCoils(int slaveId, int startOffset, boolean[] bdata)
            throws ModbusTransportException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 創(chuàng)建請(qǐng)求
        WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, bdata);
        // 發(fā)送請(qǐng)求并獲取響應(yīng)對(duì)象
        WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
        if (response.isException()) {
            return false;
        } else {
            return true;
        }

    }

    /***
     * 寫[03 Holding Register(4x)] 寫一個(gè) 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();
        // 創(chuàng)建請(qǐng)求對(duì)象
        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)]寫多個(gè) function ID=16
     * @param slaveId
     * @param startOffset 起始位置偏移量值
     * @param sdata 寫入的數(shù)據(jù)
     */
    public static boolean writeRegisters(int slaveId, int startOffset, short[] sdata)
            throws ModbusTransportException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 創(chuàng)建請(qǐng)求對(duì)象
        WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, sdata);
        // 發(fā)送請(qǐng)求并獲取響應(yīng)對(duì)象
        ModbusResponse response = tcpMaster.send(request);
        if (response.isException()) {
            log.error(response.getExceptionMessage());
            return false;
        } else {
            return true;
        }
    }

    /**
     * 寫入數(shù)字類型的模擬量（如:寫入Float類型的模擬量、Double類型模擬量、整數(shù)類型Short、Integer、Long）
     *
     * @param slaveId
     * @param offset
     * @param value 寫入值,Number的子類,例如寫入Float浮點(diǎn)類型,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 {
//             測(cè)試01  單個(gè)寫入(0x)
			boolean t01 = writeCoil(1, 0, true);
			System.out.println("T01:" + t01);

//             測(cè)試02  批量寫入(0x)
			boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
			System.out.println("T02:" + t02);

//             測(cè)試03  單個(gè)寫入(4x)
			short v = -3;
			boolean t03 = writeRegister(1, 0, v);
			System.out.println("T03:" + t03);
//             測(cè)試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();
        }
    }
}