一個項目，須要用Java實現使用ModbusTCP和硬件設備通訊php
資料
代碼下載html
- 本文的代碼和仿真軟件：藍奏雲下載
官網資料java
關於Java的開源庫git
- 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用於經過串行端口進行通訊。該庫是一個通過積極測試和改進的項目。
博客資料github
Github資料web
ModbusTCP協議
Modbus由MODICON公司於1979年開發，是一種工業現場總線協議標準。1996年施耐德公司推出基於以太網TCP/IP的Modbus協議：ModbusTCP。apache
Modbus協議是一項應用層報文傳輸協議，包括ASCII、RTU、TCP三種報文類型。編程
標準的Modbus協議物理層接口有RS23二、RS42二、RS485和以太網接口，採用master/slave方式通訊。app
我的感受：框架
modbus協議也是對
地址變量進行讀取或者寫入操做，變化的多是地址變量的地址和數據類型。 這個功能碼（指定要作什麼，指定存儲器，而後指定動做：是讀啊，是寫啊，仍是對多個一塊兒操做啊）Modbus和RS485的關係：Modbus是協議，物理層接口有RS23二、RS42二、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
特別有意思：經常使用的串口通訊庫都加進去了
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.jar
- commons-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對數據的寫入
類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 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.tcb.modbusmastertcp;
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通信讀取例子
*
* @author xqlee
*
*/
public class SimpleMasterExample {
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();
}
/**
* 讀取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.readFloat();
ReferenceCountUtil.release(readInputRegistersResponse);
}
return result;
}
/**
* 讀取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;
}
public static void main(String[] args) {
try {
// 初始化資源
initModbusTcpMaster();
// 執行操做
// 讀取模擬量
System.out.println(readHoldingRegisters(0, 4, 1));
System.out.println(readInputRegisters(0, 4, 1));
// 讀取開關量
System.out.println(readCoils(0, 1, 1));
System.out.println(readDiscreteInputs(0, 1, 1));
System.out.println(readDiscreteInputs(2, 1, 1));
// 釋放資源
release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
代碼理解
slave：和上面的同樣
輸出信息
2.5039635 1.5 true true true
評價感覺
- jlibmodbus：集成多個串口通訊開源庫，有意思
- modbus4j：頗有名
- modbus-master-tcp：底層netty，支持異步
- Jamod：Github上安卓開發modbus通訊用的多