Java实现ModbusTCP通信功能

一个项目，需要用Java实现使用ModbusTCP和硬件设备通信

视频地址：https://www.bilibili.com/video/BV1cz4y1R7cg

资料

代码下载

本文的代码和仿真软件：下载

官网资料

Modbus官网

Modbus协议

Modbus技术资源

MODBUS TCP / IP

关于Java的开源库

• 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用于通过串行端口进行通信。该库是一个经过积极测试和改进的项目。

博客资料

• ModbusTCP协议
• 基于TCP/IP协议的
• Modbusmodbus tcp通讯modbus4j使用说明-java编程
• modbus tcp 通讯modbus-master-tcp Java使用说明

Github资料

modbus4j

ModbusTCP协议

Modbus由MODICON公司于1979年开发，是一种工业现场总线协议标准。1996年施耐德公司推出基于以太网TCP/IP的Modbus协议：ModbusTCP。

Modbus协议是一项应用层报文传输协议，包括ASCII、RTU、TCP三种报文类型。

标准的Modbus协议物理层接口有RS232、RS422、RS485和以太网接口，采用master/slave方式通信。

个人感觉：

modbus协议也是对地址变量进行读取或者写入操作，变化的可能是地址变量的地址和数据类型。
这个功能码（指定要做什么，对4个不同modbus对象寄存器：是读啊，是写啊，还是对多个一起操作啊）

Modbus和RS485的关系：Modbus是协议，物理层接口有RS232、RS422、RS485和以太网接口几种

 

仿真软件

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

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

对应的代码要写4个方法

我要写一个Master(主站)，所以需要一个Slave(从站)

Modbus Slave下载

• 安装：一直下一步
• 激活码：5455415451475662（来源）
• 激活：Connection-->connect...（F3），输入激活码，下面截图没输入激活码，因为当时没找到激活码
• 操作：新建四个不同功能码的窗口，然后运行代码，修改仿真软件上的值。

代码参数的理解

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

选择TCP模式，端口是固定的502

地址类型

F8：

Slave Definition

功能码

操作：新建四个不同功能码的窗口，然后运行代码，修改仿真软件上的值。

数据类型

功能码01

功能码02

功能码03，选择Float类型

signed：有符号
unsigned：无符号
hex：十六进制
binary：二进制

big-endian：大端，将高序字节存储在起始地址（高位编址）
little-endian：小端，将低序字节存储在起始地址（低位编址）

swap：交换

双击第一个地址输入数据，会提示输入数据的类型，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.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实现
* 
* @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
源码地址：https://github.com/digitalpetri/modbus
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.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协议Java通讯读取例子
*
*
*/
public class ModbusMasterTCPDemo {

  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();
  }

  /**
   * 读取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;
  }

  /**
   * 读取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.readDouble();
          ReferenceCountUtil.release(readInputRegistersResponse);
      }
      return result;
  }

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

          // 执行操作

          // 读取开关量
          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 写入单个寄存器

类WriteSingleRegisterRequest

// 发送单个寄存器数据，一般是无符号16位值：比如10
master.sendRequest(new WriteSingleRegisterRequest(address, value), unitId);

0x10 Write Multiple Registers

功能码10 写入多个寄存器

写入多个寄存器

类WriteMultipleRegistersRequest

// float类型转字节数组
byte[] bytes = float2bytes(values);
// 转netty需要的字节类型
ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes);

// 发送多个寄存器数据，数据类型由quantity决定，2是float类型，4是double类型
master.sendRequest(new WriteMultipleRegistersRequest(address,quantity,byteBuf), unitId);

代码理解

slave：和上面的一样

输出信息

true
false
false
10.1
-5.6
9.2
6.00002
-90.122222

 

评价感受

• jlibmodbus：集成多个串口通信开源库，有意思
• modbus4j：很有名
• modbus-master-tcp：底层netty，支持异步
• Jamod：Github上安卓开发modbus通信用的多

到此这篇关于Java实现ModbusTCP通信的文章就介绍到这了,更多相关Java ModbusTCP通信内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.cnblogs.com/ioufev/p/10831289.html