Java實現Modbus RTU通訊

最近花了好長時間去研究~上代碼

package test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.TooManyListenersException;

import com.serotonin.io.serial.SerialPortException;

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;

public class SerialPortUtils implements SerialPortEventListener {
    // 檢測系統中可用的通訊端口類
    private CommPortIdentifier commPortId;
    // 枚舉類型
    private Enumeration<CommPortIdentifier> portList;
    // RS232串口
    private SerialPort serialPort;
    // 輸入流
    private InputStream inputStream;
    // 輸出流
    private OutputStream outputStream;
    // 保存串口返回信息
    private String data;
    // 保存串口返回信息十六進制
    private String dataHex;

    /**
     * 初始化串口
     *
     * @throws
     * @author LinWenLi
     * @date 2018年7月21日下午3:44:16
     * @Description: TODO
     * @param: paramConfig 存放串口連接必要參數的對象（會在下方給出類代碼）
     * @return: void
     */
    @SuppressWarnings("unchecked")
    public void init() throws SerialPortException {
        // 獲取系統中所有的通訊端口
        portList = CommPortIdentifier.getPortIdentifiers();
        // 記錄是否含有指定串口
        boolean isExsist = false;
        // 循環通訊端口
        while (portList.hasMoreElements()) {
            commPortId = portList.nextElement();
            // 判斷是否是串口
            if (commPortId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                // 比較串口名稱是否是指定串口
                if ("COM7".equals(commPortId.getName())) {
                    // 串口存在
                    isExsist = true;
                    // 打開串口
                    try {
                        // open:（應用程序名【隨意命名】，阻塞時等待的毫秒數）
                        serialPort = (SerialPort) commPortId.open(Object.class.getSimpleName(), 2000);
                        // 設置串口監聽
                        serialPort.addEventListener(this);
                        // 設置串口數據時間有效(可監聽)
                        serialPort.notifyOnDataAvailable(true);
                        // 設置串口通訊參數:波特率，數據位，停止位,校驗方式
                        serialPort.setSerialPortParams(9600, 8,
                                1, 0);
                    } catch (PortInUseException e) {
                        throw new SerialPortException("端口被占用");
                    } catch (TooManyListenersException e) {
                        throw new SerialPortException("監聽器過多");
                    } catch (UnsupportedCommOperationException e) {
                        throw new SerialPortException("不支持的COMM端口操作異常");
                    }
                    // 結束循環
                    break;
                }
            }
        }
        // 若不存在該串口則拋出異常
        if (!isExsist) {
            throw new SerialPortException("不存在該串口！");
        }
    }

    /**
     * 實現接口SerialPortEventListener中的方法 讀取從串口中接收的數據
     */
    @Override
    public void serialEvent(SerialPortEvent event) {
    }


    /**
     * 讀取串口返回信息
     *
     * @author LinWenLi
     * @date 2018年7月21日下午3:43:04
     * @return: void
     */
    public void readCommPort() throws SerialPortException {
    }

    /**
     * 發送信息到串口
     *
     * @throws
     * @author LinWenLi
     * @date 2018年7月21日下午3:45:22
     * @param: data
     * @return: void
     */
    public void sendComm(String data) throws SerialPortException {
        byte[] writerBuffer = null;
        try {
//            writerBuffer = hexToByteArray(data);
            writerBuffer = data.getBytes(StandardCharsets.UTF_8);
        } catch (NumberFormatException e) {
            throw new SerialPortException("命令格式錯誤！");
        }
        try {
            outputStream = serialPort.getOutputStream();
            outputStream.write(writerBuffer);
            outputStream.flush();
        } catch (NullPointerException e) {
            throw new SerialPortException("找不到串口。");
        } catch (IOException e) {
            throw new SerialPortException("發送信息到串口時發生IO異常");
        }
    }

    /**
     * 關閉串口
     *
     * @throws
     * @author LinWenLi
     * @date 2018年7月21日下午3:45:43
     * @Description: 關閉串口
     * @param:
     * @return: void
     */
    public void closeSerialPort() throws SerialPortException {
        if (serialPort != null) {
            serialPort.notifyOnDataAvailable(false);
            serialPort.removeEventListener();
            if (inputStream != null) {
                try {
                    inputStream.close();
                    inputStream = null;
                } catch (IOException e) {
                    throw new SerialPortException("關閉輸入流時發生IO異常");
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                    outputStream = null;
                } catch (IOException e) {
                    throw new SerialPortException("關閉輸出流時發生IO異常");
                }
            }
            serialPort.close();
            serialPort = null;
        }
    }

    /**
     * 十六進制串口返回值獲取
     */
    public String getDataHex() {
        String result = dataHex;
        // 置空執行結果
        dataHex = null;
        // 返回執行結果
        return result;
    }

    /**
     * 串口返回值獲取
     */
    public String getData() {
        String result = data;
        // 置空執行結果
        data = null;
        // 返回執行結果
        return result;
    }

    /**
     * Hex字符串轉byte
     *
     * @param inHex 待轉換的Hex字符串
     * @return 轉換后的byte
     */
    public static byte hexToByte(String inHex) {
        return (byte) Integer.parseInt(inHex, 16);
    }

    /**
     * hex字符串轉byte數組
     *
     * @param inHex 待轉換的Hex字符串
     * @return 轉換后的byte數組結果
     */
    public static byte[] hexToByteArray(String inHex) {
        int hexlen = inHex.length();
        byte[] result;
        if (hexlen % 2 == 1) {
            // 奇數
            hexlen++;
            result = new byte[(hexlen / 2)];
            inHex = "0" + inHex;
        } else {
            // 偶數
            result = new byte[(hexlen / 2)];
        }
        int j = 0;
        for (int i = 0; i < hexlen; i += 2) {
            result[j] = hexToByte(inHex.substring(i, i + 2));
            j++;
        }
        return result;
    }

    /**
     * 數組轉換成十六進制字符串
     *
     * @param bArray
     * @return HexString
     */
    public static final String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
    
    /**
     * 打卡串口
     * @param portName 串口名
     * @param baudRate 波特率
     * @param dataBits 數據位
     * @param stopBits 停止位
     * @param parity 校驗位
     * @return 串口對象
     */
    public static SerialPort open(String portName, Integer baudRate, Integer dataBits,
                                  Integer stopBits, Integer parity) {
        SerialPort result = null;
        try {
            // 通過端口名識別端口
            CommPortIdentifier identifier = CommPortIdentifier.getPortIdentifier(portName);
            // 打開端口，並給端口名字和一個timeout（打開操作的超時時間）
            if(identifier.isCurrentlyOwned()) {
                return null;
            }
            CommPort commPort = identifier.open(portName, 2000);
            // 判斷是不是串口
            if (commPort instanceof SerialPort) {
                result = (SerialPort) commPort;
                // 設置一下串口的波特率等參數
                result.setSerialPortParams(baudRate, dataBits, stopBits, parity);
            }else{
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    
    /**
     * 關閉串口
     * @param serialPort
     */
    public static void close(SerialPort serialPort) {
        if (serialPort != null) {
            serialPort.close();
        }
    }
    
}

package modbus_rtu;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.serotonin.modbus4j.serial.SerialPortWrapper;

import gnu.io.SerialPort;
import test.SerialPortUtils;

/**
 * 自定義串口封裝
 *
 * @author wusq
 * @date 2021/1/3
 */
public class SerialPortWrapperImpl implements SerialPortWrapper {

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    /**
     * 串口對象
     */
    private SerialPort serialPort;

    /**
     * 串口
     */
    private String port;

    /**
     * 波特率
     */
    private Integer baudRate;

    /**
     * 數據位的位數，RTU是8位，ASCII是7位
     */
    private Integer dataBits;

    /**
     * 停止位的位數，如果無奇偶校驗為2，有奇偶校驗為1
     */
    private Integer stopBits;

    /**
     * 奇偶校驗位，無校驗是0，奇校驗是1，偶校驗是2
     */
    private Integer parity;

    /**
     * 硬件之間輸入流應答控制
     */
    private Integer flowControlIn;

    /**
     * 硬件之間輸出流應答控制
     */
    private Integer flowControlOut;

    public SerialPortWrapperImpl() {
        super();
    }

    public SerialPortWrapperImpl(String port, int baudRate, int dataBits, int stopBits, int parity,
                                 int flowControlIn, int flowControlOut) {
        this.port = port;
        this.baudRate = baudRate;
        this.dataBits = dataBits;
        this.stopBits = stopBits;
        this.parity = parity;
        this.flowControlIn = flowControlIn;
        this.flowControlOut = flowControlOut;
    }

    @Override
    public void close() throws Exception {
        SerialPortUtils.close(serialPort);
    }

    @Override
    public void open() throws Exception {
        serialPort = SerialPortUtils.open(port, baudRate, dataBits, stopBits, parity);
    }

    @Override
    public InputStream getInputStream() {
        InputStream in = null;
        try {
            in = serialPort.getInputStream();
        } catch (IOException e) {
            log.error("獲取串口輸入流錯誤", e);
        }

        return in;
    }

    @Override
    public OutputStream getOutputStream() {
        OutputStream out = null;
        try {
            out = serialPort.getOutputStream();
        } catch (IOException e) {
            log.error("獲取串口輸出流錯誤", e);
        }

        return out;
    }

    @Override
    public int getBaudRate() {
        return this.baudRate;
    }

    @Override
    public int getDataBits() {
        return this.dataBits;
    }

    @Override
    public int getStopBits() {
        return this.stopBits;
    }

    @Override
    public int getParity() {
        return this.parity;
    }

    public int getFlowControlIn() {
        return this.flowControlIn;
    }

    public int getFlowControlOut() {
        return this.flowControlOut;
    }

    public SerialPort getSerialPort() {
        return serialPort;
    }

    public void setSerialPort(SerialPort serialPort) {
        this.serialPort = serialPort;
    }

    public String getPort() {
        return port;
    }

    public void setPort(String port) {
        this.port = port;
    }

    public void setBaudRate(Integer baudRate) {
        this.baudRate = baudRate;
    }

    public void setDataBits(Integer dataBits) {
        this.dataBits = dataBits;
    }

    public void setStopBits(Integer stopBits) {
        this.stopBits = stopBits;
    }

    public void setParity(Integer parity) {
        this.parity = parity;
    }

    public void setFlowControlIn(Integer flowControlIn) {
        this.flowControlIn = flowControlIn;
    }

    public void setFlowControlOut(Integer flowControlOut) {
        this.flowControlOut = flowControlOut;
    }
}

package modbus_rtu;

import javax.annotation.Resource;


import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersRequest;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersResponse;
import com.serotonin.modbus4j.msg.WriteRegisterRequest;
import com.serotonin.modbus4j.msg.WriteRegisterResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;
import com.serotonin.modbus4j.msg.WriteRegistersResponse;
import com.serotonin.modbus4j.sero.util.queue.ByteQueue;

public class ModbusRtuMaster {
    // 檢測系統中可用的通訊端口類
    private static SerialPortWrapperImpl wrapper;
    
    private static ModbusMaster master;
    
    private static ModbusFactory modbusFactory;
    
    
    //private static ModbusRtuMaster modbusRtuMaster;
    
    public ModbusRtuMaster() {
        
    }
    
    /*
     * public static synchronized ModbusRtuMaster getInstance() { if(modbusRtuMaster
     * == null) { modbusRtuMaster = new ModbusRtuMaster(); } return modbusRtuMaster;
     * }
     */
    /**
     * 端口是否在使用
     * @param serialNumber
     * @return
     */
    public boolean inUse(String serialNumber) {
        boolean bl = false;
        if(this.wrapper == null) {
            return bl;
        }
        if(this.wrapper.getPort() !=null && this.wrapper.getPort().equalsIgnoreCase(serialNumber)) {
            bl = master.isInitialized();
        }
        return bl;
    }
    
    public  void createRtuMaster(String serialNumber,int baudRate,int dataBit,int stopBit,int checkoutBit) throws Exception{//relayParamConfig.getSerialNumber(), relayParamConfig.getBaudRate(),
        //relayParamConfig.getDataBit(),relayParamConfig.getStopBit(), relayParamConfig.getCheckoutBit()
        // 設置串口參數，串口是COM1，波特率是9600
        wrapper = new SerialPortWrapperImpl(serialNumber, baudRate,
                dataBit,stopBit, checkoutBit,0,0);//SerialPort.PARITY_NONE
        modbusFactory = new ModbusFactory();
//        System.out.println("relayParamConfig.getSerialNumber()->"+relayParamConfig.getSerialNumber());
        master = modbusFactory.createRtuMaster(wrapper);
        master.init();
        // 從站設備ID是1
//        int slaveId = 1;

        // 讀取保持寄存器
//        readHoldingRegisters(master, slaveId, 0, 3);
        // 將地址為0的保持寄存器數據修改為0
//        writeRegister(master, slaveId, offset, value);
        // 再讀取保持寄存器
//        readHoldingRegisters(master, slaveId, 0, 3);
//        short[] s = {00};
//        controlRelay(master, slaveId, 0, s);
//        RtuMasterTest.writeRegistersTest(master, slaveId, 0, s);
    }
    
    /*
     * public void init(RelayParamConfig relayParamConfig) throws Exception {
     * this.relayParamConfig = relayParamConfig;
     * if(!this.inUse(relayParamConfig.getSerialNumber())) { this.createRtuMaster();
     * } }
     */
    
    public void closeRtuMaster() throws Exception{
        wrapper.close();
    }
    
    public void controlRelay(int slaveId, int offset, int value) throws Exception{
        writeRegister(master, slaveId, offset, value);
//        this.closeRtuMaster();
    }
//    int slaveId = 1;

    // 讀取保持寄存器
//    readHoldingRegisters(master, slaveId, 0, 3);
    // 將地址為0的保持寄存器數據修改為0
//    writeRegister(master, slaveId, offset, value);

    private void readHoldingRegisters(ModbusMaster master, int slaveId, int start, int len) throws Exception{
        ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(slaveId, start, len);
        ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master.send(request);
        if (response.isException()){
            System.out.println("讀取保持寄存器錯誤，錯誤信息是" + response.getExceptionMessage());
        }else {
//            System.out.println("讀取保持寄存器=" + Arrays.toString(response.getShortData()));
        }
    }

    private void writeRegister(ModbusMaster master, int slaveId, int offset, int value) throws Exception{
        WriteRegisterRequest request = new WriteRegisterRequest(slaveId, offset, value);
        ByteQueue queue = new ByteQueue();

        WriteRegisterResponse response = (WriteRegisterResponse) master.send(request);
        if (response.isException()){
            System.out.println("寫保持寄存器錯誤，錯誤信息是" + response.getExceptionMessage());
        }else{
            System.out.println("指令發送成功!");
        }
    }

    public void writeRegistersTest(ModbusMaster master, int slaveId, int start, short[] values) {
        try {
            WriteRegistersRequest request = new WriteRegistersRequest(slaveId, start, values);
            System.out.println("request:"+request);
            System.out.println("FunctionCode:"+request.getFunctionCode());
            System.out.println("SlaveId:"+request.getSlaveId());
            WriteRegistersResponse response = (WriteRegistersResponse) master.send(request);

            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else {
                System.out.println("Success");
            }
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        ModbusRtuMaster rmt = new ModbusRtuMaster();
        try {
            rmt.createRtuMaster("COM7",9600,8,1,0);
            rmt.controlRelay(1,1,0);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

上述程序所需關鍵包我上傳到了百度雲盤

鏈接：https://pan.baidu.com/s/1JaZaNcnQu1fp7DBIuowazg

提取碼：us3z