Java實(shí)現(xiàn)ModbusTCP通信功能

更新時(shí)間：2021年08月31日 16:53:44 作者：ioufev

使用ModbusTCP實(shí)現(xiàn)和硬件設(shè)備通信功能，本文通過實(shí)例圖文相結(jié)合給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友參考下吧

資料

代碼下載

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

官網(wǎng)資料

關(guān)于Java的開源庫

Jamod：Java Modbus實(shí)現(xiàn)：Java Modbus庫。該庫由Dieter Wimberger實(shí)施。
ModbusPal：ModbusPal是一個(gè)正在進(jìn)行的Java項(xiàng)目，用于創(chuàng)建逼真的Modbus從站模擬器。由于預(yù)定義的數(shù)學(xué)函數(shù)和/或Python腳本，寄存器值是動(dòng)態(tài)生成的。ModbusPal依賴于RxTx進(jìn)行串行通信，而Jython則依賴于腳本支持。
Modbus4J：Serotonin Software用Java編寫的Modbus協(xié)議的高性能且易于使用的實(shí)現(xiàn)。支持ASCII，RTU，TCP和UDP傳輸作為從站或主站，自動(dòng)請(qǐng)求分區(qū)，響應(yīng)數(shù)據(jù)類型解析和節(jié)點(diǎn)掃描。
JLibModbus：JLibModbus是java語言中Modbus協(xié)議的一種實(shí)現(xiàn)。jSSC和RXTX用于通過串行端口進(jìn)行通信。該庫是一個(gè)經(jīng)過積極測(cè)試和改進(jìn)的項(xiàng)目。

博客資料

ModbusTCP協(xié)議
基于TCP/IP協(xié)議的
M odbus modbus tcp通訊 modbus4j使用說明-java編程
modbus tcp 通訊modbus-master-tcp Java使用說明

Github資料

modbus4j

ModbusTCP協(xié)議

Modbus由MODICON公司于1979年開發(fā)，是一種工業(yè)現(xiàn)場(chǎng)總線協(xié)議標(biāo)準(zhǔn)。1996年施耐德公司推出基于以太網(wǎng)TCP/IP的Modbus協(xié)議：ModbusTCP。

Modbus協(xié)議是一項(xiàng)應(yīng)用層報(bào)文傳輸協(xié)議，包括ASCII、RTU、TCP三種報(bào)文類型。

標(biāo)準(zhǔn)的Modbus協(xié)議物理層接口有RS232、RS422、RS485和以太網(wǎng)接口，采用master/slave方式通信。

個(gè)人感覺：

modbus協(xié)議也是對(duì)地址變量進(jìn)行讀取或者寫入操作，變化的可能是地址變量的地址和數(shù)據(jù)類型。
這個(gè)功能碼（指定要做什么，對(duì)4個(gè)不同modbus對(duì)象寄存器：是讀啊，是寫啊，還是對(duì)多個(gè)一起操作?。?/p>

Modbus和RS485的關(guān)系：Modbus是協(xié)議，物理層接口有RS232、RS422、RS485和以太網(wǎng)接口幾種

仿真軟件

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

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

對(duì)應(yīng)的代碼要寫4個(gè)方法

我要寫一個(gè)Master(主站)，所以需要一個(gè)Slave(從站)

Modbus Slave下載

安裝：一直下一步
激活碼：5455415451475662（來源）
激活：Connection-->connect...（F3），輸入激活碼，下面截圖沒輸入激活碼，因?yàn)楫?dāng)時(shí)沒找到激活碼
操作：新建四個(gè)不同功能碼的窗口，然后運(yùn)行代碼，修改仿真軟件上的值。

代碼參數(shù)的理解

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)。

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

地址類型

F8：

Slave Definition

功能碼

操作：新建四個(gè)不同功能碼的窗口，然后運(yùn)行代碼，修改仿真軟件上的值。

數(shù)據(jù)類型

功能碼01

功能碼02

功能碼03，選擇Float類型

signed：有符號(hào)
unsigned：無符號(hào)
hex：十六進(jìn)制
binary：二進(jìn)制

big-endian：大端，將高序字節(jié)存儲(chǔ)在起始地址（高位編址）
little-endian：小端，將低序字節(jié)存儲(chǔ)在起始地址（低位編址）

swap：交換

雙擊第一個(gè)地址輸入數(shù)據(jù)，會(huì)提示輸入數(shù)據(jù)的類型，32位數(shù)據(jù)占2個(gè)地址，所以下一個(gè)地址是--

功能碼04

使用jlibmodbus

參考：Java實(shí)現(xiàn)ModBus的poll端（主機(jī)master端，查詢和接受數(shù)據(jù)）
源碼1：https://sourceforge.net/projects/jlibmodbus/
源碼2：https://github.com/kochedykov/jlibmodbus

特別有意思：常用的串口通信庫都加進(jìn)去了

maven依賴

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

測(cè)試功能碼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 {
			// 設(shè)置主機(jī)TCP參數(shù)
			TcpParameters tcpParameters = new TcpParameters();
 
			// 設(shè)置TCP的ip地址
			InetAddress adress = InetAddress.getByName("127.0.0.1");
 
			// TCP參數(shù)設(shè)置ip地址
			// tcpParameters.setHost(InetAddress.getLocalHost());
			tcpParameters.setHost(adress);
 
			// TCP設(shè)置長連接
			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[] registerValues = master.readInputRegisters(slaveId, offset, quantity);
 
				// 控制臺(tái)輸出
				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();
		}
	}
}

打印到控制臺(tái)的信息

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
有個(gè)坑：Maven配的阿里云倉庫，下載不下來，注釋掉阿里云倉庫使用默認(rèn)倉庫才能下載好。

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 兩個(gè) ，使用默認(rèn)倉庫下載，不要使用阿里云倉庫-->
    <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實(shí)現(xiàn)modbus協(xié)議通訊

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

modbus4j.jarcommons-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實(shí)現(xiàn)
 * 
 * @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 協(xié)議
		// modbusFactory.createUdpMaster(params);//UDP 協(xié)議
		// modbusFactory.createAsciiMaster(wrapper);//ASCII 協(xié)議
		ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 協(xié)議
		master.init();

		return master;
	}

	/**
	 * 讀取[01 Coil Status 0x]類型 開關(guān)數(shù)據(jù)
	 * 
	 * @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]類型 開關(guān)數(shù)據(jù)
	 * 
	 * @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]模擬量數(shù)據(jù)
	 * 
	 * @param slaveId
	 *            slave Id
	 * @param offset
	 *            位置
	 * @param dataType
	 *            數(shù)據(jù)類型,來自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類型數(shù)據(jù)讀取
		BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
		Number value = getMaster().getValue(loc);
		return value;
	}

	/**
	 * 讀取[04 Input Registers 3x]類型 模擬量數(shù)據(jù)
	 * 
	 * @param slaveId
	 *            slaveId
	 * @param offset
	 *            位置
	 * @param dataType
	 *            數(shù)據(jù)類型,來自com.serotonin.modbus4j.code.DataType
	 * @return 返回結(jié)果
	 * @throws ModbusTransportException
	 *             異常
	 * @throws ErrorResponseException
	 *             異常
	 * @throws ModbusInitException
	 *             異常
	 */
	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;
	}

	/**
	 * 批量讀取使用方法
	 * 
	 * @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));
	}

	/**
	 * 測(cè)試
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			// 01測(cè)試
			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測(cè)試
			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測(cè)試
			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測(cè)試
			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配置

操作：新建四個(gè)不同功能碼的窗口，然后運(yùn)行代碼，修改仿真軟件上的值。

輸出信息

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對(duì)數(shù)據(jù)的寫入

原文鏈接：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寫入數(shù)據(jù)
 * 
 * @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)]寫一個(gè) 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();
		// 創(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
	 *            slaveId
	 * @param startOffset
	 *            開始位置
	 * @param bdata
	 *            寫入的數(shù)據(jù)
	 * @return 是否寫入成功
	 * @throws ModbusTransportException
	 * @throws ModbusInitException
	 */
	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
	 * @return
	 * @throws ModbusTransportException
	 * @throws ModbusInitException
	 */
	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
	 *            modbus的slaveID
	 * @param startOffset
	 *            起始位置偏移量值
	 * @param sdata
	 *            寫入的數(shù)據(jù)
	 * @return 返回是否寫入成功
	 * @throws ModbusTransportException
	 * @throws ModbusInitException
	 */
	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 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
			// 測(cè)試01
//			boolean t01 = writeCoil(1, 0, true);
//			System.out.println("T01:" + t01);

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

			// 測(cè)試03
//			short v = -3;
//			boolean t03 = writeRegister(1, 0, v);
//			System.out.println("T03:" + t03);
			// 測(cè)試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
源碼地址：https://github.com/digitalpetri/modbus
modbus tcp通訊Java的方案之前已經(jīng)講解過一種,modbus4j實(shí)現(xiàn)Java語言的modbus tcp協(xié)議通訊。從上一個(gè)方案中我們不難發(fā)現(xiàn)modbus4j的通訊實(shí)現(xiàn)方式是同步的。
實(shí)際應(yīng)用中可能會(huì)讀取大量的數(shù)據(jù)。同步處理對(duì)于應(yīng)用的響應(yīng)還是不太友好的。
本博客主要講解另外一種Java語言的modbux tcp通訊方案。那就是modbus-master-tcp。

maven依賴

pom.xml注意,需要將java的編譯版本指定到1.8.因?yàn)橹挥?.8以后才支持lambda表達(dá)式。

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

觀察可以發(fā)現(xiàn),modbus-master-tcp項(xiàng)目的底層是基于netty框架開發(fā)。天然的支持異步處理。在性能方面有很好的提升。

編寫modbus tcp讀取案例

類SimpleMasterExample

package com.ioufev;

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協(xié)議Java通訊讀取例子
 *
 *
 */
public class ModbusMasterTCPDemo {

    static ModbusTcpMaster master;

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

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

    /**
     * 讀取Coils開關(guān)量
     *
     * @param address
     *            寄存器開始地址
     * @param quantity
     *            數(shù)量
     * @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();// 工具類做的同步返回.實(shí)際使用推薦結(jié)合業(yè)務(wù)進(jìn)行異步處理
        if (readCoilsResponse != null) {
            ByteBuf buf = readCoilsResponse.getCoilStatus();
            result = buf.readBoolean();
            ReferenceCountUtil.release(readCoilsResponse);
        }
        return result;
    }

    /**
     * 讀取readDiscreteInputs開關(guān)量
     *
     * @param address
     *            寄存器開始地址
     * @param quantity
     *            數(shù)量
     * @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();// 工具類做的同步返回.實(shí)際使用推薦結(jié)合業(yè)務(wù)進(jìn)行異步處理
        if (discreteInputsResponse != null) {
            ByteBuf buf = discreteInputsResponse.getInputStatus();
            result = buf.readBoolean();
            ReferenceCountUtil.release(discreteInputsResponse);
        }
        return result;
    }

    /**
     * 讀取HoldingRegister數(shù)據(jù)
     *
     * @param address
     *            寄存器地址
     * @param quantity
     *            寄存器數(shù)量
     * @param unitId
     *            id
     * @return 讀取結(jié)果
     * @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();// 工具類做的同步返回.實(shí)際使用推薦結(jié)合業(yè)務(wù)進(jìn)行異步處理
        if (readHoldingRegistersResponse != null) {
            ByteBuf buf = readHoldingRegistersResponse.getRegisters();
            result = buf.readFloat();
            ReferenceCountUtil.release(readHoldingRegistersResponse);
        }
        return result;
    }

    /**
     * 讀取InputRegisters模擬量數(shù)據(jù)
     *
     * @param address
     *            寄存器開始地址
     * @param quantity
     *            數(shù)量
     * @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();// 工具類做的同步返回.實(shí)際使用推薦結(jié)合業(yè)務(wù)進(jìn)行異步處理
        if (readInputRegistersResponse != null) {
            ByteBuf buf = readInputRegistersResponse.getRegisters();
            result = buf.readDouble();
            ReferenceCountUtil.release(readInputRegistersResponse);
        }
        return result;
    }

    public static void main(String[] args) {
        try {
            // 初始化資源
            initModbusTcpMaster();

            // 執(zhí)行操作

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

            // 讀取模擬量
            System.out.println(readHoldingRegisters(0, 2, 1));
            System.out.println(readHoldingRegisters(2, 2, 1));
            System.out.println(readHoldingRegisters(4, 2, 1));
            System.out.println(readInputRegisters(2, 4, 1));
            System.out.println(readInputRegisters(6, 4, 1));

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

編寫modbus tcp寫入案例

0x06 Write Single Register

功能碼06 寫入單個(gè)寄存器

類WriteSingleRegisterRequest

// 發(fā)送單個(gè)寄存器數(shù)據(jù)，一般是無符號(hào)16位值：比如10
master.sendRequest(new WriteSingleRegisterRequest(address, value), unitId);

0x10 Write Multiple Registers

功能碼10 寫入多個(gè)寄存器

寫入多個(gè)寄存器

類WriteMultipleRegistersRequest

// float類型轉(zhuǎn)字節(jié)數(shù)組
byte[] bytes = float2bytes(values);
// 轉(zhuǎn)netty需要的字節(jié)類型
ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes);

// 發(fā)送多個(gè)寄存器數(shù)據(jù)，數(shù)據(jù)類型由quantity決定，2是float類型，4是double類型
master.sendRequest(new WriteMultipleRegistersRequest(address,quantity,byteBuf), unitId);

代碼理解