Java实现ModbusTCP通信功能-eolink官网

Java实现ModbusTCP通信功能

目录资料关于java的开源库ModbusTCP协议仿真软件使用jlibmodbus使用modbus-master-tcpmaven依赖编写modbus tcp写入案例评价感受

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

视频地址：https://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依赖

com.intelligt.modbus

jlibmodbus

1.2.9.7

测试功能码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

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

4.0.0

com.tcb

modbus

0.0.1-SNAPSHOT

jar

modbus

http://maven.apache.org

UTF-8

false

true

ias-snapshots

Infinite Automation Snapshot Repository

https://maven.mangoautomation.net/repository/ias-snapshot/

true

false

ias-releases

Infinite Automation Release Repository

https://maven.mangoautomation.net/repository/ias-release/

junit

4.13-beta-3

test

com.infiniteautomation

modbus4j

3.0.3

org.apache.commons

commons-lang3

3.9

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

4.0.0

com.tcb

modbus

0.0.1-SNAPSHOT

jar

modbus

http://maven.apache.org

UTF-8

false

true

ias-snapshots

Infinite Automation Snapshot Repository

https://maven.mangoautomation.net/repository/ias-snapshot/

true

false

ias-releases

Infinite Automation Release Repository

https://maven.mangoautomation.net/repository/ias-release/

junit

4.13-beta-3

test

com.infiniteautomation

modbus4j

3.0.3

org.apache.commons

commons-lang3

3.9

Java实现modbus协议通讯

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 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 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 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 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 batch = new BatchRead();

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 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测试

Boolehttp://an 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对数据的写入

类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 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

maven依赖

pom.xml注意,需要将java的编译版本指定到1.8.因为只有1.8以后才支持lambda表达式。

com.digitalpetri.modbus

modbus-master-tcp

1.1.0

观察可以发现,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 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 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 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 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

10.1

-5.6

9.2

6.00002

-90.122222

评价感受

jlibmodbus：集成多个串口通信开源库，有意思

modbus4j：很有名

modbus-master-tcp：底层netty，支持异步

Jamod：Github上安卓开发modbus通信用的多

Flask接口签名sign原理与实例代码浅析

914 2022-10-01

Java实现ModbusTCP通信功能

多平台统一管理软件接口，如何实现多平台统一管理软件接口

Flask接口签名sign原理与实例代码浅析

java中的接口是类吗

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！