Java实现ModbusTCP通信

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

1
package com.tcb.jlibmodbus;
2

3
import java.net.InetAddress;
4

5
import com.intelligt.modbus.jlibmodbus.Modbus;
6
import com.intelligt.modbus.jlibmodbus.exception.ModbusIOException;
7
import com.intelligt.modbus.jlibmodbus.exception.ModbusNumberException;
8
import com.intelligt.modbus.jlibmodbus.exception.ModbusProtocolException;
9
import com.intelligt.modbus.jlibmodbus.master.ModbusMaster;
10
import com.intelligt.modbus.jlibmodbus.master.ModbusMasterFactory;
11
import com.intelligt.modbus.jlibmodbus.tcp.TcpParameters;
12

13
/**
14
 * Hello world!
15
 *
16
 */
17
public class App {
18
  public static void main(String[] args) {
19
    try {
20
      // 设置主机TCP参数
21
      TcpParameters tcpParameters = new TcpParameters();
22

23
      // 设置TCP的ip地址
24
      InetAddress adress = InetAddress.getByName("127.0.0.1");
25

26
      // TCP参数设置ip地址
27
      // tcpParameters.setHost(InetAddress.getLocalHost());
28
      tcpParameters.setHost(adress);
29

30
      // TCP设置长连接
31
      tcpParameters.setKeepAlive(true);
32
      // TCP设置端口，这里设置是默认端口502
33
      tcpParameters.setPort(Modbus.TCP_PORT);
34

35
      // 创建一个主机
36
      ModbusMaster master = ModbusMasterFactory.createModbusMasterTCP(tcpParameters);
37
      Modbus.setAutoIncrementTransactionId(true);
38

39
      int slaveId = 1;//从机地址
40
      int offset = 0;//寄存器读取开始地址
41
      int quantity = 10;//读取的寄存器数量
42

43

44
      try {
45
        if (!master.isConnected()) {
46
          master.connect();// 开启连接
47
        }
48

49
        // 读取对应从机的数据，readInputRegisters读取的写寄存器，功能码04
50
        int[] registerValues = master.readInputRegisters(slaveId, offset, quantity);
51

52
        // 控制台输出
53
        for (int value : registerValues) {
54
          System.out.println("Address: " + offset++ + ", Value: " + value);
55
        }
56

57
      } catch (ModbusProtocolException e) {
58
        e.printStackTrace();
59
      } catch (ModbusNumberException e) {
60
        e.printStackTrace();
61
      } catch (ModbusIOException e) {
62
        e.printStackTrace();
63
      } finally {
64
        try {
65
          master.disconnect();
66
        } catch (ModbusIOException e) {
67
          e.printStackTrace();
68
        }
69
      }
70
    } catch (RuntimeException e) {
71
      throw e;
72
    } catch (Exception e) {
73
      e.printStackTrace();
74
    }
75
  }
76
}

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

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>

1
package com.tcb.modbus;
2

3
import com.serotonin.modbus4j.BatchRead;
4
import com.serotonin.modbus4j.BatchResults;
5
import com.serotonin.modbus4j.ModbusFactory;
6
import com.serotonin.modbus4j.ModbusMaster;
7
import com.serotonin.modbus4j.code.DataType;
8
import com.serotonin.modbus4j.exception.ErrorResponseException;
9
import com.serotonin.modbus4j.exception.ModbusInitException;
10
import com.serotonin.modbus4j.exception.ModbusTransportException;
11
import com.serotonin.modbus4j.ip.IpParameters;
12
import 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
 */
21
public 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(params); //RTU 协议
44
    // modbusFactory.createUdpMaster(params);//UDP 协议
45
    // modbusFactory.createAsciiMaster(params);//ASCII 协议
46

47
        // 采用 Modbus RTU over TCP/IP，第二个参数为 true，即 modbusFactory.createTcpMaster(params, true)
48
    ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 协议
49
    master.init();
50

51
    return master;
52
  }
53

54
  /**
55
   * 读取[01 Coil Status 0x]类型 开关数据
56
   *
57
   * @param slaveId
58
   *            slaveId
59
   * @param offset
60
   *            位置
61
   * @return 读取值
62
   * @throws ModbusTransportException
63
   *             异常
64
   * @throws ErrorResponseException
65
   *             异常
66
   * @throws ModbusInitException
67
   *             异常
68
   */
69
  public static Boolean readCoilStatus(int slaveId, int offset)
70
      throws ModbusTransportException, ErrorResponseException, ModbusInitException {
71
    // 01 Coil Status
72
    BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
73
    Boolean value = getMaster().getValue(loc);
74
    return value;
75
  }
76

77
  /**
78
   * 读取[02 Input Status 1x]类型 开关数据
79
   *
80
   * @param slaveId
81
   * @param offset
82
   * @return
83
   * @throws ModbusTransportException
84
   * @throws ErrorResponseException
85
   * @throws ModbusInitException
86
   */
87
  public static Boolean readInputStatus(int slaveId, int offset)
88
      throws ModbusTransportException, ErrorResponseException, ModbusInitException {
89
    // 02 Input Status
90
    BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
91
    Boolean value = getMaster().getValue(loc);
92
    return value;
93
  }
94

95
  /**
96
   * 读取[03 Holding Register类型 2x]模拟量数据
97
   *
98
   * @param slaveId
99
   *            slave Id
100
   * @param offset
101
   *            位置
102
   * @param dataType
103
   *            数据类型,来自com.serotonin.modbus4j.code.DataType
104
   * @return
105
   * @throws ModbusTransportException
106
   *             异常
107
   * @throws ErrorResponseException
108
   *             异常
109
   * @throws ModbusInitException
110
   *             异常
111
   */
112
  public static Number readHoldingRegister(int slaveId, int offset, int dataType)
113
      throws ModbusTransportException, ErrorResponseException, ModbusInitException {
114
    // 03 Holding Register类型数据读取
115
    BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
116
    Number value = getMaster().getValue(loc);
117
    return value;
118
  }
119

120
  /**
121
   * 读取[04 Input Registers 3x]类型 模拟量数据
122
   *
123
   * @param slaveId
124
   *            slaveId
125
   * @param offset
126
   *            位置
127
   * @param dataType
128
   *            数据类型,来自com.serotonin.modbus4j.code.DataType
129
   * @return 返回结果
130
   * @throws ModbusTransportException
131
   *             异常
132
   * @throws ErrorResponseException
133
   *             异常
134
   * @throws ModbusInitException
135
   *             异常
136
   */
137
  public static Number readInputRegisters(int slaveId, int offset, int dataType)
138
      throws ModbusTransportException, ErrorResponseException, ModbusInitException {
139
    // 04 Input Registers类型数据读取
140
    BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
141
    Number value = getMaster().getValue(loc);
142
    return value;
143
  }
144

145
  /**
146
   * 批量读取使用方法
147
   *
148
   * @throws ModbusTransportException
149
   * @throws ErrorResponseException
150
   * @throws ModbusInitException
151
   */
152
  public static void batchRead() throws ModbusTransportException, ErrorResponseException, ModbusInitException {
153

154
    BatchRead<Integer> batch = new BatchRead<Integer>();
155

156
    batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.FOUR_BYTE_FLOAT));
157
    batch.addLocator(1, BaseLocator.inputStatus(1, 0));
158

159
    ModbusMaster master = getMaster();
160

161
    batch.setContiguousRequests(false);
162
    BatchResults<Integer> results = master.send(batch);
163
    System.out.println(results.getValue(0));
164
    System.out.println(results.getValue(1));
165
  }
166

167
  /**
168
   * 测试
169
   *
170
   * @param args
171
   */
172
  public static void main(String[] args) {
173
    try {
174
      // 01测试
175
      Boolean v011 = readCoilStatus(1, 0);
176
      Boolean v012 = readCoilStatus(1, 1);
177
      Boolean v013 = readCoilStatus(1, 6);
178
      System.out.println("v011:" + v011);
179
      System.out.println("v012:" + v012);
180
      System.out.println("v013:" + v013);
181
      // 02测试
182
      Boolean v021 = readInputStatus(1, 0);
183
      Boolean v022 = readInputStatus(1, 1);
184
      Boolean v023 = readInputStatus(1, 2);
185
      System.out.println("v021:" + v021);
186
      System.out.println("v022:" + v022);
187
      System.out.println("v023:" + v023);
188

189
      // 03测试
190
      Number v031 = readHoldingRegister(1, 1, DataType.FOUR_BYTE_FLOAT);// 注意,float
191
      Number v032 = readHoldingRegister(1, 3, DataType.FOUR_BYTE_FLOAT);// 同上
192
      System.out.println("v031:" + v031);
193
      System.out.println("v032:" + v032);
194

195
      // 04测试
196
      Number v041 = readInputRegisters(1, 0, DataType.FOUR_BYTE_FLOAT);//
197
      Number v042 = readInputRegisters(1, 2, DataType.FOUR_BYTE_FLOAT);//
198
      System.out.println("v041:" + v041);
199
      System.out.println("v042:" + v042);
200
      // 批量读取
201
      batchRead();
202

203
    } catch (Exception e) {
204
      e.printStackTrace();
205
    }
206
  }
207
}

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

1
package com.tcb.modbus;
2

3
import org.apache.commons.logging.Log;
4
import org.apache.commons.logging.LogFactory;
5

6
import com.serotonin.modbus4j.ModbusFactory;
7
import com.serotonin.modbus4j.ModbusMaster;
8
import com.serotonin.modbus4j.code.DataType;
9
import com.serotonin.modbus4j.exception.ErrorResponseException;
10
import com.serotonin.modbus4j.exception.ModbusInitException;
11
import com.serotonin.modbus4j.exception.ModbusTransportException;
12
import com.serotonin.modbus4j.ip.IpParameters;
13
import com.serotonin.modbus4j.locator.BaseLocator;
14
import com.serotonin.modbus4j.msg.ModbusResponse;
15
import com.serotonin.modbus4j.msg.WriteCoilRequest;
16
import com.serotonin.modbus4j.msg.WriteCoilResponse;
17
import com.serotonin.modbus4j.msg.WriteCoilsRequest;
18
import com.serotonin.modbus4j.msg.WriteCoilsResponse;
19
import com.serotonin.modbus4j.msg.WriteRegisterRequest;
20
import com.serotonin.modbus4j.msg.WriteRegisterResponse;
21
import com.serotonin.modbus4j.msg.WriteRegistersRequest;
22

23
/**
24
 * modbus4j写入数据
25
 *
26
 * @author xq
27
 *
28
 */
29
public 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
}

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

1
package com.ioufev;
2

3
import java.util.concurrent.CompletableFuture;
4
import java.util.concurrent.ExecutionException;
5

6
import com.digitalpetri.modbus.codec.Modbus;
7
import com.digitalpetri.modbus.master.ModbusTcpMaster;
8
import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
9
import com.digitalpetri.modbus.requests.ReadCoilsRequest;
10
import com.digitalpetri.modbus.requests.ReadDiscreteInputsRequest;
11
import com.digitalpetri.modbus.requests.ReadHoldingRegistersRequest;
12
import com.digitalpetri.modbus.requests.ReadInputRegistersRequest;
13
import com.digitalpetri.modbus.responses.ReadCoilsResponse;
14
import com.digitalpetri.modbus.responses.ReadDiscreteInputsResponse;
15
import com.digitalpetri.modbus.responses.ReadHoldingRegistersResponse;
16
import com.digitalpetri.modbus.responses.ReadInputRegistersResponse;
17

18
import io.netty.buffer.ByteBuf;
19
import io.netty.util.ReferenceCountUtil;
20

21
/***
22
 * modbus TCP协议Java通讯读取例子
23
 *
24
 *
25
 */
26
public class ModbusMasterTCPDemo {
27

28
    static ModbusTcpMaster master;
29

30
    /**
31
     * 获取TCP协议的Master
32
     *
33
     * @return
34
     */
35
    public static void initModbusTcpMaster() {
36
        if (master == null) {
37
            // 创建配置
38
            ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("localhost").setPort(502).build();
39
            master = new ModbusTcpMaster(config);
40
        }
41
    }
42

43
    /***
44
     * 释放资源
45
     */
46
    public static void release() {
47
        if (master != null) {
48
            master.disconnect();
49
        }
50
        Modbus.releaseSharedResources();
51
    }
52

53
    /**
54
     * 读取Coils开关量
55
     *
56
     * @param address
57
     *            寄存器开始地址
58
     * @param quantity
59
     *            数量
60
     * @param unitId
61
     *            ID
62
     * @return 读取值
63
     * @throws InterruptedException
64
     *             异常
65
     * @throws ExecutionException
66
     *             异常
67
     */
68
    public static Boolean readCoils(int address, int quantity, int unitId)
69
            throws InterruptedException, ExecutionException {
70
        Boolean result = null;
71
        CompletableFuture<ReadCoilsResponse> future = master.sendRequest(new ReadCoilsRequest(address, quantity),
72
                unitId);
73
        ReadCoilsResponse readCoilsResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
74
        if (readCoilsResponse != null) {
75
            ByteBuf buf = readCoilsResponse.getCoilStatus();
76
            result = buf.readBoolean();
77
            ReferenceCountUtil.release(readCoilsResponse);
78
        }
79
        return result;
80
    }
81

82
    /**
83
     * 读取readDiscreteInputs开关量
84
     *
85
     * @param address
86
     *            寄存器开始地址
87
     * @param quantity
88
     *            数量
89
     * @param unitId
90
     *            ID
91
     * @return 读取值
92
     * @throws InterruptedException
93
     *             异常
94
     * @throws ExecutionException
95
     *             异常
96
     */
97
    public static Boolean readDiscreteInputs(int address, int quantity, int unitId)
98
            throws InterruptedException, ExecutionException {
99
        Boolean result = null;
100
        CompletableFuture<ReadDiscreteInputsResponse> future = master
101
                .sendRequest(new ReadDiscreteInputsRequest(address, quantity), unitId);
102
        ReadDiscreteInputsResponse discreteInputsResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
103
        if (discreteInputsResponse != null) {
104
            ByteBuf buf = discreteInputsResponse.getInputStatus();
105
            result = buf.readBoolean();
106
            ReferenceCountUtil.release(discreteInputsResponse);
107
        }
108
        return result;
109
    }
110

111
    /**
112
     * 读取HoldingRegister数据
113
     *
114
     * @param address
115
     *            寄存器地址
116
     * @param quantity
117
     *            寄存器数量
118
     * @param unitId
119
     *            id
120
     * @return 读取结果
121
     * @throws InterruptedException
122
     *             异常
123
     * @throws ExecutionException
124
     *             异常
125
     */
126
    public static Number readHoldingRegisters(int address, int quantity, int unitId)
127
            throws InterruptedException, ExecutionException {
128
        Number result = null;
129
        CompletableFuture<ReadHoldingRegistersResponse> future = master
130
                .sendRequest(new ReadHoldingRegistersRequest(address, quantity), unitId);
131
        ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
132
        if (readHoldingRegistersResponse != null) {
133
            ByteBuf buf = readHoldingRegistersResponse.getRegisters();
134
            result = buf.readFloat();
135
            ReferenceCountUtil.release(readHoldingRegistersResponse);
136
        }
137
        return result;
138
    }
139

140
    /**
141
     * 读取InputRegisters模拟量数据
142
     *
143
     * @param address
144
     *            寄存器开始地址
145
     * @param quantity
146
     *            数量
147
     * @param unitId
148
     *            ID
149
     * @return 读取值
150
     * @throws InterruptedException
151
     *             异常
152
     * @throws ExecutionException
153
     *             异常
154
     */
155
    public static Number readInputRegisters(int address, int quantity, int unitId)
156
            throws InterruptedException, ExecutionException {
157
        Number result = null;
158
        CompletableFuture<ReadInputRegistersResponse> future = master
159
                .sendRequest(new ReadInputRegistersRequest(address, quantity), unitId);
160
        ReadInputRegistersResponse readInputRegistersResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
161
        if (readInputRegistersResponse != null) {
162
            ByteBuf buf = readInputRegistersResponse.getRegisters();
163
            result = buf.readDouble();
164
            ReferenceCountUtil.release(readInputRegistersResponse);
165
        }
166
        return result;
167
    }
168

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

174
            // 执行操作
175

176
            // 读取开关量
177
            System.out.println(readCoils(0, 1, 1));
178
            System.out.println(readDiscreteInputs(0, 1, 1));
179
            System.out.println(readDiscreteInputs(1, 1, 1));
180

181
            // 读取模拟量
182
            System.out.println(readHoldingRegisters(0, 2, 1));
183
            System.out.println(readHoldingRegisters(2, 2, 1));
184
            System.out.println(readHoldingRegisters(4, 2, 1));
185
            System.out.println(readInputRegisters(2, 4, 1));
186
            System.out.println(readInputRegisters(6, 4, 1));
187

188
            // 释放资源
189
            release();
190
        } catch (Exception e) {
191
            e.printStackTrace();
192
        }
193
    }
194
}