java - 我无法通过 modbus 与数据记录器通信

Question

我正在尝试像这样连接数据记录器:

我可以通过串行发送问题，串行只不过是一个字节数组。问题是我无法得到答案。我知道数据记录器以 9600 波特率进行通信。我尝试连接示波器以查看是否是程序或硬件问题，但示波器似乎向我发送了答案，但我无法接收。这说明问题肯定出在软件上。下面我在示波器中展示答案

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;

public class SerialRead implements SerialPortEventListener
{

    private SerialPort serialPort;
    private static String st;
    private String PORT_ID;
    private static SerialRead mInstance = null;
    private InputStream input;
    private OutputStream output;
    private static final int TIME_OUT = 2000;

    //TODO: inserisci il baud per la velocità di acquisizione
    private static final int DATA_RATE = 9600;


    public static SerialRead getInstance()
    {
        if (mInstance == null) {
            mInstance = new SerialRead();
        }

        return mInstance;
    }

    /**
     * setto il valore della PORT_ID e vado a restituire l'istanza della classe
     * @param PORT_ID
     * @return
     */
    public SerialRead setPORT_ID(String PORT_ID) {
        this.PORT_ID = PORT_ID;

        if (PORT_ID == null){
            throw new NullPointerException("Devi dare un valore alla porta");
        }

        return this;
    }


    private SerialRead() {
        //costruttore interno
        initialize();
        close();
    }


    /**
     * metodo che va a settare i parametri per l'inizializzazione della porta seriale ed
     * per la comunicazione seriale per gestire sucessivamente la richiesta con un
     * InputStream e OutputSteam
     * @return
     */
    public SerialRead initialize() {
        CommPortIdentifier portId = null;
        Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
        // iterate through, looking for the port
        while (portEnum.hasMoreElements()) {
            CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
            if (currPortId.getName().equals(PORT_ID)) {
                portId = currPortId;
                System.out.println("-Porta connessa da " + SerialRead.class.getSimpleName());
                break;
            }
        }

        try {
            serialPort = (SerialPort) portId.open(PORT_ID, TIME_OUT);
            // set port parameters
            serialPort.setSerialPortParams(DATA_RATE,
                    SerialPort.DATABITS_8,
                    SerialPort.STOPBITS_1,
                    SerialPort.PARITY_NONE);
            input = serialPort.getInputStream();
            output = serialPort.getOutputStream();
            // add event listeners
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
        } catch (Exception e) {
        }

        return this;
    }

    /**
     * chiude la porta seriale così da liberare la comunicazione per la scrittura o la lettura
     * questo perchè è monodirezionale
     */
    private synchronized void close() {
        if (serialPort != null) {
            serialPort.removeEventListener();
            serialPort.close();
        }
    }

    /**
     * Richiamo il metodo definito all'interno dell'interfaccia implementata SerialPortEventListener
     * Creo un thread continuo per la lettura dei dati che andrà a terminare alla lettura di un dato specifico
     * Andremo a leggere i dati solamente nel caso in cui siano disponibili
     * @param oEvent
     */

    @Override
    public synchronized void serialEvent(final SerialPortEvent oEvent) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
                    try {
                        int available = input.available();
                        byte[] chunk = new byte[available];
                        //System.out.println(chunk);
                        input.read(chunk, 0, available);
                        st = new String(chunk);
                        System.out.print(st);
                        /*try{ //impostato per risparmiare prestazioni e eseguire il ciclo meno spesso
                            Thread.sleep(5000);
                        } catch(InterruptedException ex) {
                            Thread.currentThread().interrupt();
                        }*/
                    }
                    catch (IOException e) {
                        System.out.println("IO Error Occurred: " + e.toString());
                    }
                }
            }
        }).start();
    }

}

SerialWriter.java

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;

public class SerialWriter
{

    /**
     * inizializzazione porte e strumenti per la scrittura della seriale
     */
    private SerialPort serialPort;
    private String PORT_ID;
    private static SerialWriter mInstance = null;
    private CommPortIdentifier portId = null;
    private InputStream input;
    private OutputStream output;
    private static final int TIME_OUT = 2000;

    //TODO: inserisci il baud per la velocità di acquisizione
    private static final int DATA_RATE = 9600;

    private SerialWriter() {
        //costruttore interno
        close();
    }


    public static SerialWriter getInstance() {
        if (mInstance == null) {
            mInstance = new SerialWriter();
        }
        return mInstance;
    }

    /**
     * setto il valore della PORT_ID e vado a restituire l'istanza della classe
     * @param PORT_ID
     * @return
     */
    public SerialWriter setPORT_ID(String PORT_ID) {
        this.PORT_ID = PORT_ID;

        if (PORT_ID == null){
            throw new NullPointerException("Devi dare un valore alla porta");
        }
        return this;
    }


    /**
     * metodo che va a settare i parametri per l'inizializzazione della porta seriale ed
     * per la comunicazione seriale per gestire sucessivamente la richiesta con un
     * InputStream e OutputSteam
     * @return
     */
    public SerialWriter initialize() {
        Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
        // iterate through, looking for the port
        while (portEnum.hasMoreElements()) {
            CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
            //for (String portName : PORT_NAMES) {
                if (currPortId.getName().equals(PORT_ID)) {
                    portId = currPortId;
                    System.out.println("-Porta connessa da " + SerialWriter.class.getSimpleName());
                    break;
                }
           //}
        }
        if (portId == null) {
            System.out.println("scanner is not connected !");
        }
        try {
            serialPort = (SerialPort) portId.open(PORT_ID, TIME_OUT);
            // set port parameters
            serialPort.setSerialPortParams(DATA_RATE,
                    SerialPort.DATABITS_8,
                    SerialPort.STOPBITS_1,
                    SerialPort.PARITY_NONE);
            input = serialPort.getInputStream();
            output = serialPort.getOutputStream();
            serialPort.notifyOnDataAvailable(true);

        } catch (Exception e) {
        }
        return this;
    }

    /**
     * chiude la porta seriale così da liberare la comunicazione per la scrittura o la lettura
     * questo perchè è monodirezionale
     */
    private synchronized void close() {
        if (serialPort != null) {
            serialPort.removeEventListener();
            serialPort.close();
            System.out.println("-Porta chiusa da " + SerialWriter.class.getSimpleName());
        }
    }

    /**
     * metodo create per inviare una serie ("infinita") di messaggi tramite il parametro varags(un array di elementi)
     * @param messagge
     */
    public void sendData(String... messagge) {

        if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {

            OutputStream outstream = null;
            try {
                outstream = serialPort.getOutputStream();
                for (String currentMessage: messagge) {
                    //TODO: da cancellare- solo per debugging 1-2 riga
                    System.out.println(currentMessage);
                    outstream.write("\n".getBytes());
                    outstream.write(currentMessage.getBytes());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        close();
    }


    public synchronized void sendData(byte... messagge) {

        if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {

            OutputStream outstream = null;
            try {
                outstream = serialPort.getOutputStream();
                /*for (byte currentMessage: messagge) {
                    //TODO: da cancellare- solo per debugging 1-2 riga
                    System.out.println(currentMessage);
                    //outstream.write("\n".getBytes());
                    outstream.write(currentMessage);
                    outstream.flush();
                }*/

                outstream.write(messagge);
                //outstream.flush();

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        close();
    }


    public void sendData(char... messagge) {

        if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {

            OutputStream outstream = null;
            try {
                outstream = serialPort.getOutputStream();
                for (char currentMessage: messagge) {
                    //TODO: da cancellare- solo per debugging 1-2 riga
                    System.out.println(Integer.toBinaryString(currentMessage));
                    //outstream.write("\n".getBytes());
                    outstream.write(String.valueOf(currentMessage).getBytes());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        close();
    }

}

以及主要 Activity :

public class SerialeEsegui
{
    public static void main(String args[]) {
        String PORT_ID = "COM4";
        SerialRead.getInstance().setPORT_ID(PORT_ID).initialize();
}

Answer 1

在您的代码中没有发送请求，因此我假设该设备正在自行传输。 Modbus 协议(protocol)比标准串行通信复杂得多。人们通常需要构建诸如协议(protocol)栈之类的东西才能接收消息。我们使用 Modbus 做了很多工作，并且使用 SuperCom 库 ( adontec.com ) 来完成此操作。它还提供了一个名为 RS_RXMODBUS 的函数，可以接收原始 Modbus 数据。不幸的是，这个库不是免费的，但工作非常可靠。