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），输入激活码，下面截图没输入激活码，因为当时没找到激活码

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

地址类型

F8：

Slave Definition

功能码

数据类型

功能码01

---

功能码02

---

功能码03，选择Float类型

双击第一个地址输入数据，会提示输入数据的类型，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();

        <span class="hljs-comment">// 设置TCP的ip地址</span>
        InetAddress adress = InetAddress.getByName(<span class="hljs-string">"127.0.0.1"</span>);

        <span class="hljs-comment">// TCP参数设置ip地址</span>
        <span class="hljs-comment">// tcpParameters.setHost(InetAddress.getLocalHost());</span>
        tcpParameters.setHost(adress);

        <span class="hljs-comment">// TCP设置长连接</span>
        tcpParameters.setKeepAlive(<span class="hljs-keyword">true</span>);
        <span class="hljs-comment">// TCP设置端口，这里设置是默认端口502</span>
        tcpParameters.setPort(Modbus.TCP_PORT);

        <span class="hljs-comment">// 创建一个主机</span>
        ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
        Modbus.setAutoIncrementTransactionId(<span class="hljs-keyword">true</span>);

        <span class="hljs-keyword">int</span> slaveId = <span class="hljs-number">1</span>;<span class="hljs-comment">//从机地址</span>
        <span class="hljs-keyword">int</span> offset = <span class="hljs-number">0</span>;<span class="hljs-comment">//寄存器读取开始地址</span>
        <span class="hljs-keyword">int</span> quantity = <span class="hljs-number">10</span>;<span class="hljs-comment">//读取的寄存器数量</span>


        <span class="hljs-keyword">try</span> {
            <span class="hljs-keyword">if</span> (!master.isConnected()) {
                master.connect();<span class="hljs-comment">// 开启连接</span>
            }

            <span class="hljs-comment">// 读取对应从机的数据，readInputRegisters读取的写寄存器，功能码04</span>
            <span class="hljs-keyword">int</span>[] registerValues = master.readInputRegisters(slaveId, offset, quantity);

            <span class="hljs-comment">// 控制台输出</span>
            <span class="hljs-keyword">for</span> (<span class="hljs-keyword">int</span> value : registerValues) {
                System.out.println(<span class="hljs-string">"Address: "</span> + offset++ + <span class="hljs-string">", Value: "</span> + value);
            }

        } <span class="hljs-keyword">catch</span> (ModbusProtocolException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (ModbusNumberException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (ModbusIOException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">finally</span> {
            <span class="hljs-keyword">try</span> {
                master.disconnect();
            } <span class="hljs-keyword">catch</span> (ModbusIOException e) {
                e.printStackTrace();
            }
        }
    } <span class="hljs-keyword">catch</span> (RuntimeException e) {
        <span class="hljs-keyword">throw</span> e;
    } <span class="hljs-keyword">catch</span> (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>

<span class="hljs-tag">&lt;<span class="hljs-name">dependencies</span>&gt;</span>
     <span class="hljs-tag">&lt;<span class="hljs-name">dependency</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">groupId</span>&gt;</span>junit<span class="hljs-tag">&lt;/<span class="hljs-name">groupId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">artifactId</span>&gt;</span>junit<span class="hljs-tag">&lt;/<span class="hljs-name">artifactId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">version</span>&gt;</span>4.13-beta-3<span class="hljs-tag">&lt;/<span class="hljs-name">version</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">scope</span>&gt;</span>test<span class="hljs-tag">&lt;/<span class="hljs-name">scope</span>&gt;</span>
    <span class="hljs-tag">&lt;/<span class="hljs-name">dependency</span>&gt;</span>
    <span class="hljs-tag">&lt;<span class="hljs-name">dependency</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">groupId</span>&gt;</span>com.infiniteautomation<span class="hljs-tag">&lt;/<span class="hljs-name">groupId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">artifactId</span>&gt;</span>modbus4j<span class="hljs-tag">&lt;/<span class="hljs-name">artifactId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">version</span>&gt;</span>3.0.3<span class="hljs-tag">&lt;/<span class="hljs-name">version</span>&gt;</span>
    <span class="hljs-tag">&lt;/<span class="hljs-name">dependency</span>&gt;</span>
    
    <span class="hljs-tag">&lt;<span class="hljs-name">dependency</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">groupId</span>&gt;</span>org.apache.commons<span class="hljs-tag">&lt;/<span class="hljs-name">groupId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">artifactId</span>&gt;</span>commons-lang3<span class="hljs-tag">&lt;/<span class="hljs-name">artifactId</span>&gt;</span>
        <span class="hljs-tag">&lt;<span class="hljs-name">version</span>&gt;</span>3.9<span class="hljs-tag">&lt;/<span class="hljs-name">version</span>&gt;</span>
    <span class="hljs-tag">&lt;/<span class="hljs-name">dependency</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">dependencies</span>&gt;</span>

</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);

     <span class="hljs-comment">// 03测试</span>
     Number v031 = readHoldingRegister(<span class="hljs-number">1</span>, <span class="hljs-number">1</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">// 注意,float</span>
     Number v032 = readHoldingRegister(<span class="hljs-number">1</span>, <span class="hljs-number">3</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">// 同上</span>
     System.out.println(<span class="hljs-string">"v031:"</span> + v031);
     System.out.println(<span class="hljs-string">"v032:"</span> + v032);
    
     <span class="hljs-comment">// 04测试</span>
     Number v041 = readInputRegisters(<span class="hljs-number">1</span>, <span class="hljs-number">0</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">//</span>
     Number v042 = readInputRegisters(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, DataType.FOUR_BYTE_FLOAT);<span class="hljs-comment">//</span>
     System.out.println(<span class="hljs-string">"v041:"</span> + v041);
     System.out.println(<span class="hljs-string">"v042:"</span> + v042);
     <span class="hljs-comment">// 批量读取</span>
     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();
}
}

<span class="hljs-comment">/**
 * 获取tcpMaster
 * 
 * <span class="hljs-doctag">@return</span>
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> ModbusMaster <span class="hljs-title">getMaster</span><span class="hljs-params">()</span> <span class="hljs-keyword">throws</span> ModbusInitException </span>{
    IpParameters params = <span class="hljs-keyword">new</span> IpParameters();
    params.setHost(<span class="hljs-string">"localhost"</span>);
    params.setPort(<span class="hljs-number">502</span>);

    ModbusMaster tcpMaster = modbusFactory.createTcpMaster(params, <span class="hljs-keyword">false</span>);
    tcpMaster.init();

    <span class="hljs-keyword">return</span> tcpMaster;
}

<span class="hljs-comment">/**
 * 写 [01 Coil Status(0x)]写一个 function ID = 5
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 *            slave的ID
 * <span class="hljs-doctag">@param</span> writeOffset
 *            位置
 * <span class="hljs-doctag">@param</span> writeValue
 *            值
 * <span class="hljs-doctag">@return</span> 是否写入成功
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeCoil</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> writeOffset, <span class="hljs-keyword">boolean</span> writeValue)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 获取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 创建请求</span>
    WriteCoilRequest request = <span class="hljs-keyword">new</span> WriteCoilRequest(slaveId, writeOffset, writeValue);
    <span class="hljs-comment">// 发送请求并获取响应对象</span>
    WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }
}

<span class="hljs-comment">/**
 * 写[01 Coil Status(0x)] 写多个 function ID = 15
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 *            slaveId
 * <span class="hljs-doctag">@param</span> startOffset
 *            开始位置
 * <span class="hljs-doctag">@param</span> bdata
 *            写入的数据
 * <span class="hljs-doctag">@return</span> 是否写入成功
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeCoils</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> startOffset, <span class="hljs-keyword">boolean</span>[] bdata)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 获取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 创建请求</span>
    WriteCoilsRequest request = <span class="hljs-keyword">new</span> WriteCoilsRequest(slaveId, startOffset, bdata);
    <span class="hljs-comment">// 发送请求并获取响应对象</span>
    WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }

}

<span class="hljs-comment">/***
 * 写[03 Holding Register(4x)] 写一个 function ID = 6
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 * <span class="hljs-doctag">@param</span> writeOffset
 * <span class="hljs-doctag">@param</span> writeValue
 * <span class="hljs-doctag">@return</span>
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeRegister</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> writeOffset, <span class="hljs-keyword">short</span> writeValue)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 获取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 创建请求对象</span>
    WriteRegisterRequest request = <span class="hljs-keyword">new</span> WriteRegisterRequest(slaveId, writeOffset, writeValue);
    WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        log.error(response.getExceptionMessage());
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }

}

<span class="hljs-comment">/**
 * 
 * 写入[03 Holding Register(4x)]写多个 function ID=16
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 *            modbus的slaveID
 * <span class="hljs-doctag">@param</span> startOffset
 *            起始位置偏移量值
 * <span class="hljs-doctag">@param</span> sdata
 *            写入的数据
 * <span class="hljs-doctag">@return</span> 返回是否写入成功
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">boolean</span> <span class="hljs-title">writeRegisters</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> startOffset, <span class="hljs-keyword">short</span>[] sdata)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ModbusInitException </span>{
    <span class="hljs-comment">// 获取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 创建请求对象</span>
    WriteRegistersRequest request = <span class="hljs-keyword">new</span> WriteRegistersRequest(slaveId, startOffset, sdata);
    <span class="hljs-comment">// 发送请求并获取响应对象</span>
    ModbusResponse response = tcpMaster.send(request);
    <span class="hljs-keyword">if</span> (response.isException()) {
        log.error(response.getExceptionMessage());
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">false</span>;
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">true</span>;
    }
}

<span class="hljs-comment">/**
 * 写入数字类型的模拟量（如:写入Float类型的模拟量、Double类型模拟量、整数类型Short、Integer、Long）
 * 
 * <span class="hljs-doctag">@param</span> slaveId
 * <span class="hljs-doctag">@param</span> offset
 * <span class="hljs-doctag">@param</span> value
 *            写入值,Number的子类,例如写入Float浮点类型,Double双精度类型,以及整型short,int,long
 * <span class="hljs-doctag">@param</span> registerCount
 *            ,com.serotonin.modbus4j.code.DataType
 * <span class="hljs-doctag">@throws</span> ModbusTransportException
 * <span class="hljs-doctag">@throws</span> ErrorResponseException
 * <span class="hljs-doctag">@throws</span> ModbusInitException
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">writeHoldingRegister</span><span class="hljs-params">(<span class="hljs-keyword">int</span> slaveId, <span class="hljs-keyword">int</span> offset, Number value, <span class="hljs-keyword">int</span> dataType)</span>
        <span class="hljs-keyword">throws</span> ModbusTransportException, ErrorResponseException, ModbusInitException </span>{
    <span class="hljs-comment">// 获取master</span>
    ModbusMaster tcpMaster = getMaster();
    <span class="hljs-comment">// 类型</span>
    BaseLocator&lt;Number&gt; locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
    tcpMaster.setValue(locator, value);
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-comment">//@formatter:off</span>
        <span class="hljs-comment">// 测试01</span>

// boolean t01 = writeCoil(1, 0, true);
// System.out.println(“T01:” + t01);

        <span class="hljs-comment">// 测试02</span>

// boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
// System.out.println(“T02:” + t02);

        <span class="hljs-comment">// 测试03</span>

// 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);

        <span class="hljs-comment">//@formatter:on</span>
    } <span class="hljs-keyword">catch</span> (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 {

<span class="hljs-keyword">static</span> ModbusTcpMaster master;

<span class="hljs-comment">/**
 * 获取TCP协议的Master
 * 
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">initModbusTcpMaster</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">if</span> (master == <span class="hljs-keyword">null</span>) {
        <span class="hljs-comment">// 创建配置</span>
        ModbusTcpMasterConfig config = <span class="hljs-keyword">new</span> ModbusTcpMasterConfig.Builder(<span class="hljs-string">"localhost"</span>).setPort(<span class="hljs-number">502</span>).build();
        master = <span class="hljs-keyword">new</span> ModbusTcpMaster(config);
    }
}

<span class="hljs-comment">/***
 * 释放资源
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">release</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">if</span> (master != <span class="hljs-keyword">null</span>) {
        master.disconnect();
    }
    Modbus.releaseSharedResources();
}

<span class="hljs-comment">/**
 * 读取HoldingRegister数据
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器地址
 * <span class="hljs-doctag">@param</span> quantity
 *            寄存器数量
 * <span class="hljs-doctag">@param</span> unitId
 *            id
 * <span class="hljs-doctag">@return</span> 读取结果
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             异常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             异常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Number <span class="hljs-title">readHoldingRegisters</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Number result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadHoldingRegistersResponse&gt; future = master
            .sendRequest(<span class="hljs-keyword">new</span> ReadHoldingRegistersRequest(address, quantity), unitId);
    ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();<span class="hljs-comment">// 工具类做的同步返回.实际使用推荐结合业务进行异步处理</span>
    <span class="hljs-keyword">if</span> (readHoldingRegistersResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = readHoldingRegistersResponse.getRegisters();
        result = buf.readFloat();
        ReferenceCountUtil.release(readHoldingRegistersResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * 读取InputRegisters模拟量数据
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器开始地址
 * <span class="hljs-doctag">@param</span> quantity
 *            数量
 * <span class="hljs-doctag">@param</span> unitId
 *            ID
 * <span class="hljs-doctag">@return</span> 读取值
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             异常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             异常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Number <span class="hljs-title">readInputRegisters</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Number result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadInputRegistersResponse&gt; future = master
            .sendRequest(<span class="hljs-keyword">new</span> ReadInputRegistersRequest(address, quantity), unitId);
    ReadInputRegistersResponse readInputRegistersResponse = future.get();<span class="hljs-comment">// 工具类做的同步返回.实际使用推荐结合业务进行异步处理</span>
    <span class="hljs-keyword">if</span> (readInputRegistersResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = readInputRegistersResponse.getRegisters();
        result = buf.readFloat();
        ReferenceCountUtil.release(readInputRegistersResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * 读取Coils开关量
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器开始地址
 * <span class="hljs-doctag">@param</span> quantity
 *            数量
 * <span class="hljs-doctag">@param</span> unitId
 *            ID
 * <span class="hljs-doctag">@return</span> 读取值
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             异常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             异常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Boolean <span class="hljs-title">readCoils</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Boolean result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadCoilsResponse&gt; future = master.sendRequest(<span class="hljs-keyword">new</span> ReadCoilsRequest(address, quantity),
            unitId);
    ReadCoilsResponse readCoilsResponse = future.get();<span class="hljs-comment">// 工具类做的同步返回.实际使用推荐结合业务进行异步处理</span>
    <span class="hljs-keyword">if</span> (readCoilsResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = readCoilsResponse.getCoilStatus();
        result = buf.readBoolean();
        ReferenceCountUtil.release(readCoilsResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * 读取readDiscreteInputs开关量
 * 
 * <span class="hljs-doctag">@param</span> address
 *            寄存器开始地址
 * <span class="hljs-doctag">@param</span> quantity
 *            数量
 * <span class="hljs-doctag">@param</span> unitId
 *            ID
 * <span class="hljs-doctag">@return</span> 读取值
 * <span class="hljs-doctag">@throws</span> InterruptedException
 *             异常
 * <span class="hljs-doctag">@throws</span> ExecutionException
 *             异常
 */</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> Boolean <span class="hljs-title">readDiscreteInputs</span><span class="hljs-params">(<span class="hljs-keyword">int</span> address, <span class="hljs-keyword">int</span> quantity, <span class="hljs-keyword">int</span> unitId)</span>
        <span class="hljs-keyword">throws</span> InterruptedException, ExecutionException </span>{
    Boolean result = <span class="hljs-keyword">null</span>;
    CompletableFuture&lt;ReadDiscreteInputsResponse&gt; future = master
            .sendRequest(<span class="hljs-keyword">new</span> ReadDiscreteInputsRequest(address, quantity), unitId);
    ReadDiscreteInputsResponse discreteInputsResponse = future.get();<span class="hljs-comment">// 工具类做的同步返回.实际使用推荐结合业务进行异步处理</span>
    <span class="hljs-keyword">if</span> (discreteInputsResponse != <span class="hljs-keyword">null</span>) {
        ByteBuf buf = discreteInputsResponse.getInputStatus();
        result = buf.readBoolean();
        ReferenceCountUtil.release(discreteInputsResponse);
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-comment">// 初始化资源</span>
        initModbusTcpMaster();
        <span class="hljs-comment">// 执行操作</span>
        <span class="hljs-comment">// 读取模拟量</span>
        System.out.println(readHoldingRegisters(<span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">1</span>));
        System.out.println(readInputRegisters(<span class="hljs-number">0</span>, <span class="hljs-number">4</span>, <span class="hljs-number">1</span>));

        <span class="hljs-comment">// 读取开关量</span>
        System.out.println(readCoils(<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>));
        System.out.println(readDiscreteInputs(<span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>));
        System.out.println(readDiscreteInputs(<span class="hljs-number">2</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>));

        <span class="hljs-comment">// 释放资源</span>
        release();
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    }
}

}

代码理解

slave：和上面的一样

输出信息

2.5039635
1.5
true
true
true

评价感受

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