Implementierung und Debugging der Kommunikation zwischen Java-Programm und serieller Schnittstelle

Das Folgende ist eine Einführung in das neueste Projekt des Herausgebers, das die Implementierung und das Debuggen des Kommunikationsteils der seriellen Schnittstelle umfasst.

Prinzip der seriellen Kommunikation

Serielle Kommunikation bezieht sich auf das Senden und Empfangen von Bytes in Bits durch die serielle Schnittstelle. Obwohl langsamer als die Byte-für-Byte-Parallelkommunikation, kann ein serieller Port Daten auf einem Kabel senden und gleichzeitig Daten auf einem anderen Kabel empfangen.

Der serielle Port ist ein sehr verbreitetes Gerätekommunikationsprotokoll auf Computern (nicht zu verwechseln mit Universal SerialBus oder USB)

Typischerweise wird der serielle Port für die Übertragung von ASCII-Codezeichen verwendet. Die Kommunikation erfolgt über 3 Drähte: (1) Masse, (2) Senden, (3) Empfangen. Da die serielle Kommunikation asynchron ist, kann ein Port Daten auf einer Leitung senden und gleichzeitig Daten auf einer anderen Leitung empfangen. Die anderen Leitungen dienen dem Handshaking, sind aber nicht erforderlich. Die wichtigsten Parameter für die serielle Kommunikation sind Bitrate, Datenbits, Stoppbits und Parität. Damit zwei Ports kommunizieren können, müssen diese Parameter übereinstimmen

RS-232 (ANSI/EIA-232-Standard) ist ein serieller Verbindungsstandard auf IBM-PCs und kompatiblen Geräten, RS-422 (EIA RS-422-AStandard) ist der serielle Anschluss-Verbindungsstandard für Macintosh-Computer von Apple. RS-485 (EIA-485-Standard) ist eine Verbesserung von RS-422.

Schließen Sie die Vorbereitungsarbeiten ab, die für die serielle Kommunikation und das Debuggen auf einem Computer erforderlich sind.

Da es auf Laptops oder Desktops grundsätzlich keine gekoppelten seriellen Anschlüsse gibt, die wir zum Debuggen verwenden könnten, müssen wir die virtuelle Version herunterladen Serielle Port-Software zur Implementierung des Debuggings serieller Ports.

Laden Sie die Software für die virtuelle serielle Schnittstelle herunter: http://pan.baidu.com/s/1hqhGDbI (die hier bereitgestellte ist relativ einfach zu verwenden). Nachdem der Download und die Installation abgeschlossen sind, sollten Sie es nicht überstürzen. Kopieren Sie die Datei vspdctl.dll in das Installationsverzeichnis, z. B.: Mein Verzeichnis ist –>D:SoftWareInstallVirtual Serial Port Driver 7.2 Datei herunterladen und erfolgreich aktivieren.

Öffnen Sie die Software, um virtuelle serielle Ports hinzuzufügen. Sie werden normalerweise paarweise hinzugefügt (COM3, COM4 hinzufügen), wie in der Abbildung gezeigt:

Nachdem Wenn das Hinzufügen abgeschlossen ist, gehen Sie zu „Überprüfen“ im Geräte-Manager und finden Sie zwei weitere virtuelle serielle Ports, wie gezeigt:

Laden Sie die Debugging-Software für serielle Ports herunter http://pan.baidu .com/s/1c0AVaXq hier verfügbar Es handelt sich um eine ältere Debugging-Software, die jedoch immer noch relativ einfach zu verwenden ist. Entpacken Sie es einfach und klicken Sie, um es zu öffnen.

Sie können zunächst direkt zwei Debugging-Fenster öffnen, die zur Darstellung der seriellen Schnittstellen COM3 bzw. COM4 dienen. Die Parameter der beiden seriellen Ports müssen gleich eingestellt sein, um Daten normal senden und empfangen zu können. (Wenn beim Debuggen Daten normal gesendet und empfangen werden können, können Sie einen Debugger deaktivieren und stattdessen ein Java-Programm verwenden), wie in der Abbildung gezeigt:

Schreiben von Java-Programmcode

Dieser Teil wird unser Fokus sein. Um mit der seriellen Schnittstelle zu kommunizieren, müssen wir zuerst das Paket RXTXcomm.jar zum Projekt hinzufügen (legen Sie es im lib-Verzeichnis im Projekt ab und fügen Sie es dem Build-Pfad hinzu) (win64 -bit-Download-Adresse: http://pan.baidu.com/s/1o6zLmTc); Darüber hinaus müssen Sie die dekomprimierten Dateien rxtxParallel.dll und rxtxSerial.dll im Verzeichnis %JAVA_HOME%/jre/bin ablegen Das Paket kann normal geladen und aufgerufen werden.

Programmcode-Analyse:

package comm;

import java.io.*;
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import gnu.io.*;

public class ContinueRead extends Thread implements SerialPortEventListener { // SerialPortEventListener
    // 监听器,我的理解是独立开辟一个线程监听串口数据
    static CommPortIdentifier portId; // 串口通信管理类
    static Enumeration<?> portList; // 有效连接上的端口的枚举
    InputStream inputStream; // 从串口来的输入流
    static OutputStream outputStream;// 向串口输出的流
    static SerialPort serialPort; // 串口的引用
    // 堵塞队列用来存放读到的数据
    private BlockingQueue<String> msgQueue = new LinkedBlockingQueue<String>();

    @Override
    /**
     * SerialPort EventListene 的方法,持续监听端口上是否有数据流
     */
    public void serialEvent(SerialPortEvent event) {//

        switch (event.getEventType()) {
        case SerialPortEvent.BI:
        case SerialPortEvent.OE:
        case SerialPortEvent.FE:
        case SerialPortEvent.PE:
        case SerialPortEvent.CD:
        case SerialPortEvent.CTS:
        case SerialPortEvent.DSR:
        case SerialPortEvent.RI:
        case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
            break;
        case SerialPortEvent.DATA_AVAILABLE:// 当有可用数据时读取数据
            byte[] readBuffer = new byte[20];
            try {
                int numBytes = -1;
                while (inputStream.available() > 0) {
                    numBytes = inputStream.read(readBuffer);

                    if (numBytes > 0) {
                        msgQueue.add(new Date() + "真实收到的数据为：-----"
                                + new String(readBuffer));
                        readBuffer = new byte[20];// 重新构造缓冲对象，否则有可能会影响接下来接收的数据
                    } else {
                        msgQueue.add("额------没有读到数据");
                    }
                }
            } catch (IOException e) {
            }
            break;
        }
    }

    /**
     * 
     * 通过程序打开COM4串口，设置监听器以及相关的参数
     * 
     * @return 返回1 表示端口打开成功，返回 0表示端口打开失败
     */
    public int startComPort() {
        // 通过串口通信管理类获得当前连接上的串口列表
        portList = CommPortIdentifier.getPortIdentifiers();

        while (portList.hasMoreElements()) {

            // 获取相应串口对象
            portId = (CommPortIdentifier) portList.nextElement();

            System.out.println("设备类型：--->" + portId.getPortType());
            System.out.println("设备名称：---->" + portId.getName());
            // 判断端口类型是否为串口
            if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                // 判断如果COM4串口存在，就打开该串口
                if (portId.getName().equals("COM4")) {
                    try {
                        // 打开串口名字为COM_4(名字任意),延迟为2毫秒
                        serialPort = (SerialPort) portId.open("COM_4", 2000);

                    } catch (PortInUseException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 设置当前串口的输入输出流
                    try {
                        inputStream = serialPort.getInputStream();
                        outputStream = serialPort.getOutputStream();
                    } catch (IOException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 给当前串口添加一个监听器
                    try {
                        serialPort.addEventListener(this);
                    } catch (TooManyListenersException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 设置监听器生效，即：当有数据时通知
                    serialPort.notifyOnDataAvailable(true);

                    // 设置串口的一些读写参数
                    try {
                        // 比特率、数据位、停止位、奇偶校验位
                        serialPort.setSerialPortParams(9600,
                                SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
                                SerialPort.PARITY_NONE);
                    } catch (UnsupportedCommOperationException e) {
                        e.printStackTrace();
                        return 0;
                    }

                    return 1;
                }
            }
        }
        return 0;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            System.out.println("--------------任务处理线程运行了--------------");
            while (true) {
                // 如果堵塞队列中存在数据就将其输出
                if (msgQueue.size() > 0) {
                    System.out.println(msgQueue.take());
                }
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ContinueRead cRead = new ContinueRead();
        int i = cRead.startComPort();
        if (i == 1) {
            // 启动线程来处理收到的数据
            cRead.start();
            try {
                String st = "哈哈----你好";
                System.out.println("发出字节数：" + st.getBytes("gbk").length);
                outputStream.write(st.getBytes("gbk"), 0,
                        st.getBytes("gbk").length);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } else {
            return;
        }
    }
}

Java-Programm und Kommunikations-Debugging für serielle Schnittstellen

Screenshot zum Programm-Debugging:

Zusammenfassung

Serielle Kommunikation wird vielerorts eingesetzt, insbesondere in der Embedded-Entwicklung, SMS-Modulentwicklung und kundenspezifischer Software für verschiedene Hardwareprodukte. Unter diesen ist das am häufigsten verwendete Kommunikationsprotokoll das RS-232-Kommunikationsprotokoll. Wenn Sie ein echter Meister der seriellen Kommunikationsentwicklung werden möchten, müssen Sie das serielle Kommunikationsprotokoll vollständig verstehen (ich bin noch ein Anfänger ... hoffe ich). ein Experte kann Hilfestellung geben).

Ein weiterer Schwerpunkt der seriellen Kommunikation besteht darin, die Art der Daten zu bestimmen und nach dem Empfang gültige Daten zu extrahieren. Diese müssen gemäß dem entsprechenden Protokoll codiert werden.

Weitere Artikel zur Kommunikationsimplementierung und zum Debuggen zwischen Java-Programmen und seriellen Schnittstellen finden Sie auf der chinesischen PHP-Website!