java modbus rtu通讯
本文章使用modbus4j和rxtxcomm进行modbus rtu通讯
串口通讯：rxtxcomm的使用：
下载地址：http://fizzed.com/oss/rxtx-for-java
rxtx解压包中的 rxtxParallel.dll，rxtxSerial.dll 这两个文件复制到 C:\Windows\System32 目录下
添加maven依赖
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/
org.bidib.jbidib.org.qbang.rxtx
rxtxcomm
2.2
com.infiniteautomation
modbus4j
3.0.4
Modbus4j工具类
package com.example.modbus_rtu;
import java.util.ArrayList;
import java.util.List;
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;
public class ModbusUtils {
/**
* 工厂。
*/
static ModbusFactory modbusFactory;
static {
if (modbusFactory == null) {
modbusFactory = new ModbusFactory();
}
}
/**
* 获取master
*
* @return
* @throws ModbusInitException
*/
public static ModbusMaster getMaster(String host, int port) throws ModbusInitException {
IpParameters params = new IpParameters();
params.setHost(host);
params.setPort(port);
//
// modbusFactory.createRtuMaster(wapper); //RTU 协议
// modbusFactory.createUdpMaster(params);//UDP 协议
// modbusFactory.createAsciiMaster(wrapper);//ASCII 协议
ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 协议
master.init();
return master;
}
public static ModbusMaster getRtuIpMaster(String host, int port) throws ModbusInitException {
IpParameters params = new IpParameters();
params.setHost(host);
params.setPort(port);
//这个属性确定了协议帧是否是通过tcp封装的RTU结构，采用modbus tcp/ip时，要设为false, 采用modbus rtu over tcp/ip时，要设为true
params.setEncapsulated(true);
ModbusMaster master = modbusFactory.createTcpMaster(params, false);
try {
//设置超时时间
master.setTimeout(1000);
//设置重连次数
master.setRetries(3);
//初始化
master.init();
} catch (ModbusInitException e) {
e.printStackTrace();
}
return master;
}
public static ModbusMaster getRtuComMaster(String com,int port) throws ModbusInitException {
//
// modbusFactory.createRtuMaster(wapper); //RTU 协议
// modbusFactory.createUdpMaster(params);//UDP 协议
// modbusFactory.createAsciiMaster(wrapper);//ASCII 协议
ModbusMaster master = modbusFactory.createRtuMaster(new SerialPortWrapperImpl(com,port));
master.setTimeout(2000);
master.init();
return master;
}
/**
* 读取[01 Coil Status 0x]类型 开关数据
*
* @param slaveId slaveId
* @param offset 位置
* @return 读取值
* @throws ModbusTransportException 异常
* @throws ErrorResponseException 异常
* @throws ModbusInitException 异常
*/
public static Boolean readCoilStatus(ModbusMaster master, int slaveId, int offset)
throws ModbusTransportException, ErrorResponseException, ModbusInitException {
// 01 Coil Status
BaseLocator loc = BaseLocator.coilStatus(slaveId, offset);
Boolean value = master.getValue(loc);
return value;
}
/**
* 读取[02 Input Status 1x]类型 开关数据
*
* @param slaveId
* @param offset
* @return
* @throws ModbusTransportException
* @throws ErrorResponseException
* @throws ModbusInitException
*/
public static Boolean readInputStatus(ModbusMaster master, int slaveId, int offset) throws ModbusTransportException, ErrorResponseException {
// 02 Input Status
BaseLocator loc = BaseLocator.inputStatus(slaveId, offset);
Boolean value = master.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(ModbusMaster master, int slaveId, int offset, int dataType)
throws ModbusTransportException, ErrorResponseException, ModbusInitException {
// 03 Holding Register类型数据读取
BaseLocator loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
Number value = master.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(ModbusMaster master, int slaveId, int offset, int dataType)
throws ModbusTransportException, ErrorResponseException, ModbusInitException {
// 04 Input Registers类型数据读取
BaseLocator loc = BaseLocator.inputRegister(slaveId, offset, dataType);
Number value = master.getValue(loc);
return value;
}
/**
* 批量读取使用方法
*
* @throws ModbusTransportException
* @throws ErrorResponseException
* @throws ModbusInitException
*/
public static List batchRead(ModbusMaster master, ArrayList data) throws ModbusTransportException, ErrorResponseException, ModbusInitException {
BatchRead batch = new BatchRead();
for (int i=0;i numbers = new ArrayList<>();
batch.setContiguousRequests(false);
BatchResults results = master.send(batch);
for (int i=0;i 写数据：
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.msg.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class Modbus4jWriteUtils {
static Log log = LogFactory.getLog(Modbus4jWriteUtils.class);
/**
* 工厂。
*/
static ModbusFactory modbusFactory;
static {
if (modbusFactory == null) {
modbusFactory = new ModbusFactory();
}
}
/**
* 写 [01 Coil Status(0x)]写一个 function ID = 5
*
* @param slaveId slave的ID
* @param writeOffset 位置
* @param writeValue 值
* @return 是否写入成功
* @throws ModbusTransportException
* @throws ModbusInitException
*/
public static boolean writeCoil(ModbusMaster master, int slaveId, int writeOffset, boolean writeValue)
throws ModbusTransportException, ModbusInitException {
// 获取master
ModbusMaster tcpMaster = master;
// 创建请求
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(ModbusMaster master, int slaveId, int startOffset, boolean[] bdata)
throws ModbusTransportException, ModbusInitException {
// 获取master
ModbusMaster tcpMaster = master;
// 创建请求
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(ModbusMaster master, int slaveId, int writeOffset, short writeValue)
throws ModbusTransportException, ModbusInitException {
// 获取master
ModbusMaster tcpMaster = master;
// 创建请求对象
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(ModbusMaster master, int slaveId, int startOffset, short[] sdata)
throws ModbusTransportException, ModbusInitException {
// 获取master
ModbusMaster tcpMaster = master;
// 创建请求对象
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
*/
}
SerialPortWrapper 实现类
package com.example.modbus_rtu;
import com.serotonin.modbus4j.serial.SerialPortWrapper;
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.UnsupportedCommOperationException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
public class SerialPortWrapperImpl implements SerialPortWrapper {
//枚举类型
Enumeration portList;
// 检测系统可用端口
private CommPortIdentifier portIdentifier;
// 端口
private SerialPort comPort;
//波特率
private int port;
//Com地址
private String com;
// 输入/输出流
private InputStream inputStream;
private OutputStream outputStream;
public SerialPortWrapperImpl(String com,int port){
this.com = com;
this.port = port;
}
@Override
public void close() throws Exception {
}
@Override
public void open() throws Exception {
//获得系统支持的所有端口（串口，并口）
portList = CommPortIdentifier.getPortIdentifiers();
while(portList.hasMoreElements()) {
portIdentifier = (CommPortIdentifier)portList.nextElement();
// CommPortIdentifier.PORT_SERIAL :串口
// CommPortIdentifier.PORT_PARALLEL :并口
// CommPortIdentifier.PORT_RS485 :RS485
// CommPortIdentifier.PORT_I2C :I2C
// CommPortIdentifier.PORT_RAW
if (portIdentifier.getPortType() == CommPortIdentifier.PORT_SERIAL) {
// System.out.println(portIdentifier.getName()); 获取串口名字
if (portIdentifier.getName().equals(this.com)) {
try {
// open:打开串口，第一个参数应用程序名称 字符串可随意填写，第二个参数阻塞时等待多少毫秒
comPort = (SerialPort)portIdentifier.open(this.com, 2000);
// 串口设置监听
// port.addEventListener(this);
// 设置可监听
comPort.notifyOnDataAvailable(true);
// 设置串口通信参数
// 波特率，数据位，停止位，校验方式
comPort.setSerialPortParams(port,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
outputStream = comPort.getOutputStream();
inputStream = comPort.getInputStream();
System.out.println("打开串口成功");
} catch (PortInUseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch (UnsupportedCommOperationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch (Exception e){
e.printStackTrace();
}
}
}
}
}
@Override
public InputStream getInputStream() {
return inputStream;
}
@Override
public OutputStream getOutputStream() {
return outputStream;
}
@Override
public int getBaudRate() {
return 0;
}
@Override
public int getFlowControlIn() {
return 0;
}
@Override
public int getFlowControlOut() {
return 0;
}
@Override
public int getDataBits() {
return 0;
}
@Override
public int getStopBits() {
return 0;
}
@Override
public int getParity() {
return 0;
}
}
测试类
public class Test {
public static void main(String[] args){
//modbus rtu
try {
ModbusMaster master = ModbusUtils.getRtuComMaster("COM4",9600);
while (true){
System.out.println(ModbusUtils.readHoldingRegister(master,1,14, DataType.FOUR_BYTE_FLOAT));
System.out.println(ModbusUtils.readHoldingRegister(master,1,16, DataType.FOUR_BYTE_FLOAT));
}
} catch (ModbusInitException e) {
e.printStackTrace();
} catch (ModbusTransportException e) {
e.printStackTrace();
} catch (ErrorResponseException e) {
e.printStackTrace();
}
}
}