Java实现ModbusTCP通信

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

资料

代码下载

• 本文的代码和仿真软件：蓝奏云下载

官网资料

• 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协议的Modbus
• modbus 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协议也是对地址变量进行读取或者写入操作，变化的可能是地址变量的地址和数据类型。 这个功能码（指定要做什么，指定存储器，然后指定动作：是读啊，是写啊，还是对多个一起操作啊）

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依赖

1<dependency>
2<groupId>com.intelligt.modbus</groupId>
3<artifactId>jlibmodbus</artifactId>
4<version>1.2.9.7</version>
5</dependency>

测试功能码04

1package com.tcb.jlibmodbus;
2
3import java.net.InetAddress;
4
5import com.intelligt.modbus.jlibmodbus.Modbus;
6import com.intelligt.modbus.jlibmodbus.exception.ModbusIOException;
7import com.intelligt.modbus.jlibmodbus.exception.ModbusNumberException;
8import com.intelligt.modbus.jlibmodbus.exception.ModbusProtocolException;
9import com.intelligt.modbus.jlibmodbus.master.ModbusMaster;
10import com.intelligt.modbus.jlibmodbus.master.ModbusMasterFactory;
11import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;
12
13
14/**
15 * Hello world!
16 *
17 */
18public class App {
19	public static void main(String[] args) {
20		try {
21			// 设置主机TCP参数
22			TcpParameters tcpParameters = new TcpParameters();
23 
24			// 设置TCP的ip地址
25			InetAddress adress = InetAddress.getByName("127.0.0.1");
26 
27			// TCP参数设置ip地址
28			// tcpParameters.setHost(InetAddress.getLocalHost());
29			tcpParameters.setHost(adress);
30 
31			// TCP设置长连接
32			tcpParameters.setKeepAlive(true);
33			// TCP设置端口，这里设置是默认端口502
34			tcpParameters.setPort(Modbus.TCP_PORT);
35 
36			// 创建一个主机
37			ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
38			Modbus.setAutoIncrementTransactionId(true);
39 
40			int slaveId = 1;//从机地址
41			int offset = 0;//寄存器读取开始地址
42			int quantity = 10;//读取的寄存器数量
43 
44 
45			try {
46				if (!master.isConnected()) {
47					master.connect();// 开启连接
48				}
49 
50				// 读取对应从机的数据，readInputRegisters读取的写寄存器，功能码04
51				int[] registerValues = master.readInputRegisters(slaveId, offset, quantity);
52 
53				// 控制台输出
54				for (int value : registerValues) {
55					System.out.println("Address: " + offset++ + ", Value: " + value);
56				}
57 
58			} catch (ModbusProtocolException e) {
59				e.printStackTrace();
60			} catch (ModbusNumberException e) {
61				e.printStackTrace();
62			} catch (ModbusIOException e) {
63				e.printStackTrace();
64			} finally {
65				try {
66					master.disconnect();
67				} catch (ModbusIOException e) {
68					e.printStackTrace();
69				}
70			}
71		} catch (RuntimeException e) {
72			throw e;
73		} catch (Exception e) {
74			e.printStackTrace();
75		}
76	}
77}

打印到控制台的信息

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

使用modbus4j

maven依赖

• 官方说明：https://github.com/infiniteautomation/modbus4j
• 有个坑：Maven配的阿里云仓库，下载不下来，注释掉阿里云仓库使用默认仓库才能下载好。

pom.xml

1<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3  <modelVersion>4.0.0</modelVersion>
4
5  <groupId>com.tcb</groupId>
6  <artifactId>modbus</artifactId>
7  <version>0.0.1-SNAPSHOT</version>
8  <packaging>jar</packaging>
9
10  <name>modbus</name>
11  <url>http://maven.apache.org</url>
12
13  <properties>
14    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15  </properties>
16  
17  <!-- 若想引用modbus4j需要引入下列repository id:ias-snapshots id:ias-releases 两个 ，使用默认仓库下载，不要使用阿里云仓库-->
18    <repositories>
19	    <repository>
20	        <releases>
21	            <enabled>false</enabled>
22	        </releases>
23	        <snapshots>
24	            <enabled>true</enabled>
25	        </snapshots>
26	        <id>ias-snapshots</id>
27	        <name>Infinite Automation Snapshot Repository</name>
28	        <url>https://maven.mangoautomation.net/repository/ias-snapshot/</url>
29	    </repository>
30	    <repository>
31	        <releases>
32	            <enabled>true</enabled>
33	        </releases>
34	        <snapshots>
35	            <enabled>false</enabled>
36	        </snapshots>
37	        <id>ias-releases</id>
38	        <name>Infinite Automation Release Repository</name>
39	        <url>https://maven.mangoautomation.net/repository/ias-release/</url>
40	    </repository>
41	</repositories>
42	
43    <dependencies>
44		 <dependency>
45		    <groupId>junit</groupId>
46		    <artifactId>junit</artifactId>
47		    <version>4.13-beta-3</version>
48		    <scope>test</scope>
49		</dependency>
50		<dependency>
51		    <groupId>com.infiniteautomation</groupId>
52		    <artifactId>modbus4j</artifactId>
53		    <version>3.0.3</version>
54		</dependency>
55		
56		<dependency>
57		    <groupId>org.apache.commons</groupId>
58		    <artifactId>commons-lang3</artifactId>
59		    <version>3.9</version>
60		</dependency>
61    </dependencies>
62
63</project>
64

Java实现modbus协议通讯

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

• modbus4j.jar
• commons-lang3-3.0.jar

Modbus4jUtils类

1package com.tcb.modbus;
2
3import com.serotonin.modbus4j.BatchRead;
4import com.serotonin.modbus4j.BatchResults;
5import com.serotonin.modbus4j.ModbusFactory;
6import com.serotonin.modbus4j.ModbusMaster;
7import com.serotonin.modbus4j.code.DataType;
8import com.serotonin.modbus4j.exception.ErrorResponseException;
9import com.serotonin.modbus4j.exception.ModbusInitException;
10import com.serotonin.modbus4j.exception.ModbusTransportException;
11import com.serotonin.modbus4j.ip.IpParameters;
12import com.serotonin.modbus4j.locator.BaseLocator;
13
14/**
15 * modbus通讯工具类,采用modbus4j实现
16 * 
17 * @author lxq
18 * @dependencies modbus4j-3.0.3.jar
19 * @website https://github.com/infiniteautomation/modbus4j
20 */
21public class Modbus4jUtils {
22	/**
23	 * 工厂。
24	 */
25	static ModbusFactory modbusFactory;
26	static {
27		if (modbusFactory == null) {
28			modbusFactory = new ModbusFactory();
29		}
30	}
31
32	/**
33	 * 获取master
34	 * 
35	 * @return
36	 * @throws ModbusInitException
37	 */
38	public static ModbusMaster getMaster() throws ModbusInitException {
39		IpParameters params = new IpParameters();
40		params.setHost("localhost");
41		params.setPort(502);
42		//
43		// modbusFactory.createRtuMaster(wapper); //RTU 协议
44		// modbusFactory.createUdpMaster(params);//UDP 协议
45		// modbusFactory.createAsciiMaster(wrapper);//ASCII 协议
46		ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 协议
47		master.init();
48
49		return master;
50	}
51
52	/**
53	 * 读取[01 Coil Status 0x]类型 开关数据
54	 * 
55	 * @param slaveId
56	 *            slaveId
57	 * @param offset
58	 *            位置
59	 * @return 读取值
60	 * @throws ModbusTransportException
61	 *             异常
62	 * @throws ErrorResponseException
63	 *             异常
64	 * @throws ModbusInitException
65	 *             异常
66	 */
67	public static Boolean readCoilStatus(int slaveId, int offset)
68			throws ModbusTransportException, ErrorResponseException, ModbusInitException {
69		// 01 Coil Status
70		BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
71		Boolean value = getMaster().getValue(loc);
72		return value;
73	}
74
75	/**
76	 * 读取[02 Input Status 1x]类型 开关数据
77	 * 
78	 * @param slaveId
79	 * @param offset
80	 * @return
81	 * @throws ModbusTransportException
82	 * @throws ErrorResponseException
83	 * @throws ModbusInitException
84	 */
85	public static Boolean readInputStatus(int slaveId, int offset)
86			throws ModbusTransportException, ErrorResponseException, ModbusInitException {
87		// 02 Input Status
88		BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
89		Boolean value = getMaster().getValue(loc);
90		return value;
91	}
92
93	/**
94	 * 读取[03 Holding Register类型 2x]模拟量数据
95	 * 
96	 * @param slaveId
97	 *            slave Id
98	 * @param offset
99	 *            位置
100	 * @param dataType
101	 *            数据类型,来自com.serotonin.modbus4j.code.DataType
102	 * @return
103	 * @throws ModbusTransportException
104	 *             异常
105	 * @throws ErrorResponseException
106	 *             异常
107	 * @throws ModbusInitException
108	 *             异常
109	 */
110	public static Number readHoldingRegister(int slaveId, int offset, int dataType)
111			throws ModbusTransportException, ErrorResponseException, ModbusInitException {
112		// 03 Holding Register类型数据读取
113		BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
114		Number value = getMaster().getValue(loc);
115		return value;
116	}
117
118	/**
119	 * 读取[04 Input Registers 3x]类型 模拟量数据
120	 * 
121	 * @param slaveId
122	 *            slaveId
123	 * @param offset
124	 *            位置
125	 * @param dataType
126	 *            数据类型,来自com.serotonin.modbus4j.code.DataType
127	 * @return 返回结果
128	 * @throws ModbusTransportException
129	 *             异常
130	 * @throws ErrorResponseException
131	 *             异常
132	 * @throws ModbusInitException
133	 *             异常
134	 */
135	public static Number readInputRegisters(int slaveId, int offset, int dataType)
136			throws ModbusTransportException, ErrorResponseException, ModbusInitException {
137		// 04 Input Registers类型数据读取
138		BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
139		Number value = getMaster().getValue(loc);
140		return value;
141	}
142
143	/**
144	 * 批量读取使用方法
145	 * 
146	 * @throws ModbusTransportException
147	 * @throws ErrorResponseException
148	 * @throws ModbusInitException
149	 */
150	public static void batchRead() throws ModbusTransportException, ErrorResponseException, ModbusInitException {
151
152		BatchRead<Integer> batch = new BatchRead<Integer>();
153
154		batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.FOUR_BYTE_FLOAT));
155		batch.addLocator(1, BaseLocator.inputStatus(1, 0));
156
157		ModbusMaster master = getMaster();
158
159		batch.setContiguousRequests(false);
160		BatchResults<Integer> results = master.send(batch);
161		System.out.println(results.getValue(0));
162		System.out.println(results.getValue(1));
163	}
164
165	/**
166	 * 测试
167	 * 
168	 * @param args
169	 */
170	public static void main(String[] args) {
171		try {
172			// 01测试
173			Boolean v011 = readCoilStatus(1, 0);
174			Boolean v012 = readCoilStatus(1, 1);
175			Boolean v013 = readCoilStatus(1, 6);
176			System.out.println("v011:" + v011);
177			System.out.println("v012:" + v012);
178			System.out.println("v013:" + v013);
179			// 02测试
180			Boolean v021 = readInputStatus(1, 0);
181			Boolean v022 = readInputStatus(1, 1);
182			Boolean v023 = readInputStatus(1, 2);
183			System.out.println("v021:" + v021);
184			System.out.println("v022:" + v022);
185			System.out.println("v023:" + v023);
186
187			// 03测试
188			Number v031 = readHoldingRegister(1, 1, DataType.FOUR_BYTE_FLOAT);// 注意,float
189			Number v032 = readHoldingRegister(1, 3, DataType.FOUR_BYTE_FLOAT);// 同上
190			System.out.println("v031:" + v031);
191			System.out.println("v032:" + v032);
192
193			// 04测试
194			Number v041 = readInputRegisters(1, 0, DataType.FOUR_BYTE_FLOAT);//
195			Number v042 = readInputRegisters(1, 2, DataType.FOUR_BYTE_FLOAT);//
196			System.out.println("v041:" + v041);
197			System.out.println("v042:" + v042);
198			// 批量读取
199			batchRead();
200
201		} catch (Exception e) {
202			e.printStackTrace();
203		}
204	}
205}

代码理解

slave配置

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

输出信息

1v011:true
2v012:false
3v013:true
4v021:true
5v022:false
6v023:true
7v031:7.5
8v032:10.5
9v041:1.5
10v042:3.0
117.5
12true

Java通过modbus4j对数据的写入

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

类Modbus4jWriteUtils.java

1package com.tcb.modbus;
2
3import org.apache.commons.logging.Log;
4import org.apache.commons.logging.LogFactory;
5
6import com.serotonin.modbus4j.ModbusFactory;
7import com.serotonin.modbus4j.ModbusMaster;
8import com.serotonin.modbus4j.code.DataType;
9import com.serotonin.modbus4j.exception.ErrorResponseException;
10import com.serotonin.modbus4j.exception.ModbusInitException;
11import com.serotonin.modbus4j.exception.ModbusTransportException;
12import com.serotonin.modbus4j.ip.IpParameters;
13import com.serotonin.modbus4j.locator.BaseLocator;
14import com.serotonin.modbus4j.msg.ModbusResponse;
15import com.serotonin.modbus4j.msg.WriteCoilRequest;
16import com.serotonin.modbus4j.msg.WriteCoilResponse;
17import com.serotonin.modbus4j.msg.WriteCoilsRequest;
18import com.serotonin.modbus4j.msg.WriteCoilsResponse;
19import com.serotonin.modbus4j.msg.WriteRegisterRequest;
20import com.serotonin.modbus4j.msg.WriteRegisterResponse;
21import com.serotonin.modbus4j.msg.WriteRegistersRequest;
22
23/**
24 * modbus4j写入数据
25 * 
26 * @author xq
27 *
28 */
29public class Modbus4jWriteUtils {
30	static Log log = LogFactory.getLog(Modbus4jWriteUtils.class);
31	/**
32	 * 工厂。
33	 */
34	static ModbusFactory modbusFactory;
35	static {
36		if (modbusFactory == null) {
37			modbusFactory = new ModbusFactory();
38		}
39	}
40
41	/**
42	 * 获取tcpMaster
43	 * 
44	 * @return
45	 * @throws ModbusInitException
46	 */
47	public static ModbusMaster getMaster() throws ModbusInitException {
48		IpParameters params = new IpParameters();
49		params.setHost("localhost");
50		params.setPort(502);
51
52		ModbusMaster tcpMaster = modbusFactory.createTcpMaster(params, false);
53		tcpMaster.init();
54
55		return tcpMaster;
56	}
57
58	/**
59	 * 写 [01 Coil Status(0x)]写一个 function ID = 5
60	 * 
61	 * @param slaveId
62	 *            slave的ID
63	 * @param writeOffset
64	 *            位置
65	 * @param writeValue
66	 *            值
67	 * @return 是否写入成功
68	 * @throws ModbusTransportException
69	 * @throws ModbusInitException
70	 */
71	public static boolean writeCoil(int slaveId, int writeOffset, boolean writeValue)
72			throws ModbusTransportException, ModbusInitException {
73		// 获取master
74		ModbusMaster tcpMaster = getMaster();
75		// 创建请求
76		WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
77		// 发送请求并获取响应对象
78		WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
79		if (response.isException()) {
80			return false;
81		} else {
82			return true;
83		}
84	}
85
86	/**
87	 * 写[01 Coil Status(0x)] 写多个 function ID = 15
88	 * 
89	 * @param slaveId
90	 *            slaveId
91	 * @param startOffset
92	 *            开始位置
93	 * @param bdata
94	 *            写入的数据
95	 * @return 是否写入成功
96	 * @throws ModbusTransportException
97	 * @throws ModbusInitException
98	 */
99	public static boolean writeCoils(int slaveId, int startOffset, boolean[] bdata)
100			throws ModbusTransportException, ModbusInitException {
101		// 获取master
102		ModbusMaster tcpMaster = getMaster();
103		// 创建请求
104		WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, bdata);
105		// 发送请求并获取响应对象
106		WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
107		if (response.isException()) {
108			return false;
109		} else {
110			return true;
111		}
112
113	}
114
115	/***
116	 * 写[03 Holding Register(4x)] 写一个 function ID = 6
117	 * 
118	 * @param slaveId
119	 * @param writeOffset
120	 * @param writeValue
121	 * @return
122	 * @throws ModbusTransportException
123	 * @throws ModbusInitException
124	 */
125	public static boolean writeRegister(int slaveId, int writeOffset, short writeValue)
126			throws ModbusTransportException, ModbusInitException {
127		// 获取master
128		ModbusMaster tcpMaster = getMaster();
129		// 创建请求对象
130		WriteRegisterRequest request = new WriteRegisterRequest(slaveId, writeOffset, writeValue);
131		WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.send(request);
132		if (response.isException()) {
133			log.error(response.getExceptionMessage());
134			return false;
135		} else {
136			return true;
137		}
138
139	}
140
141	/**
142	 * 
143	 * 写入[03 Holding Register(4x)]写多个 function ID=16
144	 * 
145	 * @param slaveId
146	 *            modbus的slaveID
147	 * @param startOffset
148	 *            起始位置偏移量值
149	 * @param sdata
150	 *            写入的数据
151	 * @return 返回是否写入成功
152	 * @throws ModbusTransportException
153	 * @throws ModbusInitException
154	 */
155	public static boolean writeRegisters(int slaveId, int startOffset, short[] sdata)
156			throws ModbusTransportException, ModbusInitException {
157		// 获取master
158		ModbusMaster tcpMaster = getMaster();
159		// 创建请求对象
160		WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, sdata);
161		// 发送请求并获取响应对象
162		ModbusResponse response = tcpMaster.send(request);
163		if (response.isException()) {
164			log.error(response.getExceptionMessage());
165			return false;
166		} else {
167			return true;
168		}
169	}
170
171	/**
172	 * 写入数字类型的模拟量（如:写入Float类型的模拟量、Double类型模拟量、整数类型Short、Integer、Long）
173	 * 
174	 * @param slaveId
175	 * @param offset
176	 * @param value
177	 *            写入值,Number的子类,例如写入Float浮点类型,Double双精度类型,以及整型short,int,long
178	 * @param registerCount
179	 *            ,com.serotonin.modbus4j.code.DataType
180	 * @throws ModbusTransportException
181	 * @throws ErrorResponseException
182	 * @throws ModbusInitException
183	 */
184	public static void writeHoldingRegister(int slaveId, int offset, Number value, int dataType)
185			throws ModbusTransportException, ErrorResponseException, ModbusInitException {
186		// 获取master
187		ModbusMaster tcpMaster = getMaster();
188		// 类型
189		BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
190		tcpMaster.setValue(locator, value);
191	}
192
193	public static void main(String[] args) {
194		try {
195			//@formatter:off
196			// 测试01
197//			boolean t01 = writeCoil(1, 0, true);
198//			System.out.println("T01:" + t01);
199
200			// 测试02
201//			boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
202//			System.out.println("T02:" + t02);
203
204			// 测试03
205//			short v = -3;
206//			boolean t03 = writeRegister(1, 0, v);
207//			System.out.println("T03:" + t03);
208			// 测试04
209//			boolean t04 = writeRegisters(1, 0, new short[] { -3, 3, 9 });
210//			System.out.println("t04:" + t04);
211			//写模拟量
212			writeHoldingRegister(1,0, 10.1f, DataType.FOUR_BYTE_FLOAT);
213			
214			//@formatter:on
215		} catch (Exception e) {
216			e.printStackTrace();
217		}
218
219	}
220
221}

代码理解

使用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表达式。

1	<dependency>
2		<groupId>com.digitalpetri.modbus</groupId>
3		<artifactId>modbus-master-tcp</artifactId>
4		<version>1.1.0</version>
5	</dependency>

观察可以发现,modbus-master-tcp项目的底层是基于netty框架开发。天然的支持异步处理。在性能方面有很好的提升。

编写modbus tcp读取案例

类SimpleMasterExample

1package com.tcb.modbusmastertcp;
2
3import java.util.concurrent.CompletableFuture;
4import java.util.concurrent.ExecutionException;
5
6import com.digitalpetri.modbus.codec.Modbus;
7import com.digitalpetri.modbus.master.ModbusTcpMaster;
8import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
9import com.digitalpetri.modbus.requests.ReadCoilsRequest;
10import com.digitalpetri.modbus.requests.ReadDiscreteInputsRequest;
11import com.digitalpetri.modbus.requests.ReadHoldingRegistersRequest;
12import com.digitalpetri.modbus.requests.ReadInputRegistersRequest;
13import com.digitalpetri.modbus.responses.ReadCoilsResponse;
14import com.digitalpetri.modbus.responses.ReadDiscreteInputsResponse;
15import com.digitalpetri.modbus.responses.ReadHoldingRegistersResponse;
16import com.digitalpetri.modbus.responses.ReadInputRegistersResponse;
17
18import io.netty.buffer.ByteBuf;
19import io.netty.util.ReferenceCountUtil;
20
21/***
22 * modbus TCP协议Java通讯读取例子
23 * 
24 * @author xqlee
25 *
26 */
27public class SimpleMasterExample {
28
29	static ModbusTcpMaster master;
30
31	/**
32	 * 获取TCP协议的Master
33	 * 
34	 * @return
35	 */
36	public static void initModbusTcpMaster() {
37		if (master == null) {
38			// 创建配置
39			ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("localhost").setPort(502).build();
40			master = new ModbusTcpMaster(config);
41		}
42	}
43
44	/***
45	 * 释放资源
46	 */
47	public static void release() {
48		if (master != null) {
49			master.disconnect();
50		}
51		Modbus.releaseSharedResources();
52	}
53
54	/**
55	 * 读取HoldingRegister数据
56	 * 
57	 * @param address
58	 *            寄存器地址
59	 * @param quantity
60	 *            寄存器数量
61	 * @param unitId
62	 *            id
63	 * @return 读取结果
64	 * @throws InterruptedException
65	 *             异常
66	 * @throws ExecutionException
67	 *             异常
68	 */
69	public static Number readHoldingRegisters(int address, int quantity, int unitId)
70			throws InterruptedException, ExecutionException {
71		Number result = null;
72		CompletableFuture<ReadHoldingRegistersResponse> future = master
73				.sendRequest(new ReadHoldingRegistersRequest(address, quantity), unitId);
74		ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
75		if (readHoldingRegistersResponse != null) {
76			ByteBuf buf = readHoldingRegistersResponse.getRegisters();
77			result = buf.readFloat();
78			ReferenceCountUtil.release(readHoldingRegistersResponse);
79		}
80		return result;
81	}
82
83	/**
84	 * 读取InputRegisters模拟量数据
85	 * 
86	 * @param address
87	 *            寄存器开始地址
88	 * @param quantity
89	 *            数量
90	 * @param unitId
91	 *            ID
92	 * @return 读取值
93	 * @throws InterruptedException
94	 *             异常
95	 * @throws ExecutionException
96	 *             异常
97	 */
98	public static Number readInputRegisters(int address, int quantity, int unitId)
99			throws InterruptedException, ExecutionException {
100		Number result = null;
101		CompletableFuture<ReadInputRegistersResponse> future = master
102				.sendRequest(new ReadInputRegistersRequest(address, quantity), unitId);
103		ReadInputRegistersResponse readInputRegistersResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
104		if (readInputRegistersResponse != null) {
105			ByteBuf buf = readInputRegistersResponse.getRegisters();
106			result = buf.readFloat();
107			ReferenceCountUtil.release(readInputRegistersResponse);
108		}
109		return result;
110	}
111
112	/**
113	 * 读取Coils开关量
114	 * 
115	 * @param address
116	 *            寄存器开始地址
117	 * @param quantity
118	 *            数量
119	 * @param unitId
120	 *            ID
121	 * @return 读取值
122	 * @throws InterruptedException
123	 *             异常
124	 * @throws ExecutionException
125	 *             异常
126	 */
127	public static Boolean readCoils(int address, int quantity, int unitId)
128			throws InterruptedException, ExecutionException {
129		Boolean result = null;
130		CompletableFuture<ReadCoilsResponse> future = master.sendRequest(new ReadCoilsRequest(address, quantity),
131				unitId);
132		ReadCoilsResponse readCoilsResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
133		if (readCoilsResponse != null) {
134			ByteBuf buf = readCoilsResponse.getCoilStatus();
135			result = buf.readBoolean();
136			ReferenceCountUtil.release(readCoilsResponse);
137		}
138		return result;
139	}
140
141	/**
142	 * 读取readDiscreteInputs开关量
143	 * 
144	 * @param address
145	 *            寄存器开始地址
146	 * @param quantity
147	 *            数量
148	 * @param unitId
149	 *            ID
150	 * @return 读取值
151	 * @throws InterruptedException
152	 *             异常
153	 * @throws ExecutionException
154	 *             异常
155	 */
156	public static Boolean readDiscreteInputs(int address, int quantity, int unitId)
157			throws InterruptedException, ExecutionException {
158		Boolean result = null;
159		CompletableFuture<ReadDiscreteInputsResponse> future = master
160				.sendRequest(new ReadDiscreteInputsRequest(address, quantity), unitId);
161		ReadDiscreteInputsResponse discreteInputsResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
162		if (discreteInputsResponse != null) {
163			ByteBuf buf = discreteInputsResponse.getInputStatus();
164			result = buf.readBoolean();
165			ReferenceCountUtil.release(discreteInputsResponse);
166		}
167		return result;
168	}
169
170	public static void main(String[] args) {
171		try {
172			// 初始化资源
173			initModbusTcpMaster();
174			// 执行操作
175			// 读取模拟量
176			System.out.println(readHoldingRegisters(0, 4, 1));
177			System.out.println(readInputRegisters(0, 4, 1));
178
179			// 读取开关量
180			System.out.println(readCoils(0, 1, 1));
181			System.out.println(readDiscreteInputs(0, 1, 1));
182			System.out.println(readDiscreteInputs(2, 1, 1));
183
184			// 释放资源
185			release();
186		} catch (Exception e) {
187			e.printStackTrace();
188		}
189	}
190}

代码理解

slave：和上面的一样

输出信息

12.5039635
21.5
3true
4true
5true

评价感受

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