文章目录

一、Java 串口通信部署
二、Java 串口通信报错
- 1. JDK 有关错误
- 2. dll 有关错误

一、Java 串口通信部署

准备

uartassist5.0.3 串口调试助手。
vspd(Configure Virtual Serial Port Driver) 虚拟串口驱动，收钱，破解。
mfz-rxtx-2.2-20081207-win-x64.zip [点击进入下载](

RXTX for Java

)

部署

1. 配置 Java 环境

将
mfz-rxtx-2.2-20081207-win-x64
包下的
rxtxParallel.dll 和 rxtxSerial.dll
复制到
D:\InstallDirectory\jdk1.8\bin
目录下(即，将两个 dll 复制到 JDK 的 bin 目录下)。

2. 新建项目，引入依赖。

如果新建的是 maven 项目则复制如下的依赖链接到 pom 文件中

<!-- https://mvnrepository.com/artifact/org.bidib.jbidib.org.qbang.rxtx/rxtxcomm -->
<dependency>
    <groupId>org.bidib.jbidib.org.qbang.rxtx</groupId>
    <artifactId>rxtxcomm</artifactId>
    <version>2.2</version>
</dependency>

如果是普通项目则将
mfz-rxtx-2.2-20081207-win-x64
包下的
RXTXcomm.jar
手动添加到项目依赖中。

3. 代码（网上荡的）

package com.example.iobox.serialPortComm;

import gnu.io.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class MinGeSerialTest extends Thread implements SerialPortEventListener{


    private static final Logger logger = LoggerFactory.getLogger(MinGeSerialTest.class);

    // 通讯端口管理，控制对通信端口的访问的中心类
    static CommPortIdentifier portManager;
    // 有效连接上的端口的枚举
    static Enumeration<?> portList;
    // 串口输入流引用
    static InputStream inputStream;
    // 串口输出流引用
    static OutputStream outputStream;
    // 串口对象引用
    static SerialPort serialPort;
    // 堵塞队列：用来存放串口发送到服务端的数据
    private BlockingQueue<String> msgQueue = new LinkedBlockingQueue();
    // 线程控制标识
    private boolean flag = true;

    public void serialEvent(SerialPortEvent event) {
        switch (event.getEventType()) {
            /*
             *  SerialPortEvent.BI:/*Break interrupt,通讯中断
             *  SerialPortEvent.OE:/*Overrun error，溢位错误
             *  SerialPortEvent.FE:/*Framing error，传帧错误
             *  SerialPortEvent.PE:/*Parity error，校验错误
             *  SerialPortEvent.CD:/*Carrier detect，载波检测
             *  SerialPortEvent.CTS:/*Clear to send，清除发送
             *  SerialPortEvent.DSR:/*Data set ready，数据设备就绪
             *  SerialPortEvent.RI:/*Ring indicator，响铃指示
             *  SerialPortEvent.OUTPUT_BUFFER_EMPTY:/*Output buffer is empty，输出缓冲区清空
             */
            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[0];
                try {
                    readBuffer = new byte[inputStream.available()];
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    // 存储待接收读取字节数大小
                    int numBytes = 0;
                    while (inputStream.available() > 0) {
                        numBytes = inputStream.read(readBuffer);
                        if (numBytes > 0) {
                            msgQueue.add(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                                    .format(new Date()) + " 收到的串口发送数据为："+ new String(readBuffer));
                            // 数据接收缓冲容器清空初始化
                            readBuffer = new byte[0];
                        }
                    }
                } catch (IOException e) {
                    logger.error("IO异常", e);
                }
                break;
        }
    }

    public int init() {
        // 通过串口通信管理类获得当前连接上的端口列表
        //（获取一个枚举对象，该 CommPortIdentifier 对象包含系统中每个端口的对象集[串口、并口]）
        portList = CommPortIdentifier.getPortIdentifiers();
        while (portList.hasMoreElements()) {
            // 获取相应串口对象
            portManager = (CommPortIdentifier) portList.nextElement();
            /*
             *  判断端口类型是否为串口
             *  PORT_SERIAL = 1; 【串口】
             *  PORT_PARALLEL = 2; 【并口】
             *  PORT_I2C = 3; 【I2C】
             *  PORT_RS485 = 4; 【RS485】
             *  PORT_RAW = 5; 【RAW】
             */
            if (portManager.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                logger.info("串口设备名称：" + portManager.getName());
                // 判断模拟 COM1 串口存在，就打开该串口
                if (portManager.getName().equals("COM1")) {
                    logger.info("测试串口设备名称：" + portManager.getName());
                    try {
                        if (serialPort==null) {
                            // 打开串口，设置名字为COM_1(自定义),延迟阻塞时等待3000毫秒（赋值给预设的串口引用）
                            serialPort = (SerialPort)portManager.open("COM1", 3000);
                            logger.info("串口设备 COM1 已打开");
                        }
                    } catch (PortInUseException e) {
                        logger.error("串口使用异常", e);
                        return 0;
                    }
                    // 在串口引用不为空时进行下述操作
                    if (serialPort!=null) {
                        // 1. 设置串口的输入输出流引用
                        try {
                            inputStream = serialPort.getInputStream();
                            outputStream = serialPort.getOutputStream();
                        } catch (IOException e) {
                            logger.error("串口输入输出IO异常", e);
                            return 0;
                        }
                        // 2. 设置串口监听器
                        try {
                            serialPort.addEventListener(this);
                        } catch (TooManyListenersException e) {
                            logger.error("串口监听器添加异常", e);
                            return 0;
                        }
                        // 设置监听器在有数据时通知生效
                        serialPort.notifyOnDataAvailable(true);

                        // 3. 设置串口相关读写参数
                        try {
                            // 比特率、数据位、停止位、校验位
                            serialPort.setSerialPortParams(115200,
                                    SerialPort.DATABITS_8,
                                    SerialPort.STOPBITS_1,
                                    SerialPort.PARITY_NONE);
                        } catch (UnsupportedCommOperationException e) {
                            logger.error("串口设置操作异常", e);
                            return 0;
                        }
                        return 1;
                    }
                    return 0;
                }
            }
        }
        return 0;
    }

    @Override
    public void run() {
        try {
            logger.info("串口线程已运行");
            while (flag) {
                // 如果堵塞队列中存在数据就将其输出
                if (msgQueue.size() > 0) {
                    // take() 取走BlockingQueue里排在首位的对象
                    // 若BlockingQueue为空，阻断进入等待状态直到Blocking有新的对象被加入为止
                    String msg = msgQueue.take();
                    logger.info(msg);
                    //echo数据
                    sendToPort(serialPort, msg.getBytes());
                }
            }
        } catch (InterruptedException e) {
            logger.error("线程执行异常", e);
        }
    }

    public void stopGetDataBySerialPort() {
        this.flag = false;
    }

    /**
     * 往串口发送数据
     *
     * @param serialPort 串口对象
     * @param data       待发送数据
     */
    public static void sendToPort(SerialPort serialPort, byte[] data) {
        OutputStream out = null;
        try {
            out = serialPort.getOutputStream();
            out.write(data);
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("hello world");
        MinGeSerialTest handle = new MinGeSerialTest();
        int i = handle.init();
        if (i == 1) {
            // 线程启动
            handle.start();
        }
    }

}

运行

运行 vspd ，设置串口：

在这里插入图片描述

115200:波特率

N:无校验位

8:8 个数据位

1:1 个停止位

运行 Java 程序：

hello world
WARNING:  RXTX Version mismatch
  Jar version = RXTX-2.2 (CVS snapshot 2011.02.03, modified by CMU CREATE Lab, http://code.google.com/p/create-lab-commons/)
  native lib Version = RXTX-2.2-20081207 Cloudhopper Build rxtx.cloudhopper.net
15:22:02.303 [main] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 串口设备名称：COM1
15:22:02.306 [main] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 测试串口设备名称：COM1
15:22:02.397 [main] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 串口设备 COM1 已打开
15:22:02.397 [Thread-0] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 串口线程已运行
/** 分割分割
   * 上面的表示 Java 程序同串口链接成功。
   *
   * 下面打印的消息表示：串口调试助手通过 COM 口发送过来的消息，Java 程序接收到消息并打印（消息乱码是因为没有对消息处理）。
   */
15:22:10.122 [Thread-0] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 2022-09-09 15:22:10 收到的串口发送数据为：�
15:22:11.792 [Thread-0] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 2022-09-09 15:22:11 收到的串口发送数据为：�
15:22:12.752 [Thread-0] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 2022-09-09 15:22:12 收到的串口发送数据为：�
16:05:41.502 [Thread-0] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 2022-09-09 16:05:41 收到的串口发送数据为：�
16:05:42.389 [Thread-0] INFO com.example.iobox.serialPortComm.MinGeSerialTest - 2022-09-09 16:05:42 收到的串口发送数据为：�

运行串口调试助手：

二、Java 串口通信报错

1. JDK 有关错误

程序启动失败，报错内容如下：

#
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x0000000180004465, pid=25348, tid=19380
#
# JRE version: OpenJDK Runtime Environment (11.0.7) (build 11.0.7+0-Cloud-Compiler-JDK-V100R002C00SPC010B001)
# Java VM: OpenJDK 64-Bit Server VM (11.0.7+0-Cloud-Compiler-JDK-V100R002C00SPC010B001, mixed mode, tiered, compressed oops, g1 gc, windows-amd64)
# Problematic frame:
# C  [rxtxSerial.dll+0x4465]
#
# No core dump will be written. Minidumps are not enabled by default on client versions of Windows
#
# An error report file with more information is saved as:
# D:\0906JavaModbus\javaTest\IoBOX\hs_err_pid25348.log
#
# If you would like to submit a bug report, please visit:
#   http://bugreport.java.com/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#

Process finished with exit code 1

百度而来的解决方案有以下几种：

在 idea 安装目录下的 idea64.exe.vmoptions 中添加
-XX:+CreateMinidumpOnCrash
；结果：失败。

如何找到 idea64.exe.vmoptions ：

右击 idea -> 属性 -> 复制所在目录，进入 bin 目录下即可找到。
-XX:+CreateMinidumpOnCrash 的作用是：

HotSpot VM 在非 server 版的 Windows上选择默认不写出 minidump。让 HotSpot VM在client版Windows上写出minidump，这样 HotSpot VM 在 crash 时就会调用 Windows 的 MiniDumpWriteDump() 函数写出 minidump 。

修改虚拟机选项；结果：失败。

// 注：从网上找到这条解决方案没起作用，又百度了好多相似的得知 exclude 后面跟的路径指的是是从运行时报错的日志文件中找到的报错的类，然后忽略掉对这个类文件的编译。然而我的报错日志并没有关于类的信息。
-XX:CompileCommand=exclude,org/hibernate/cfg/annotations/SimpleValueBinder，setType

JDK 版本从 11 降为 1.8

；结果：成功。百度说是 JDK 本身的一个 BUG，深究不懂…

2. dll 有关错误

报错内容如下：

Exception in thread "main" java.lang.UnsatisfiedLinkError: no rxtxSerial in java.library.path
 at java.lang.ClassLoader.loadLibrary(Unknown Source)
 at java.lang.Runtime.loadLibrary0(Unknown Source)
 at java.lang.System.loadLibrary(Unknown Source)
 at gnu.io.CommPortIdentifier.<clinit>(CommPortIdentifier.java:83)
 at com.three.rxtx.SimpleRead.main(SimpleRead.java:86)

原因：

mfz-rxtx-2.2-20081207-win-x64
包下的
rxtxParallel.dll 和 rxtxSerial.dll
复制到
D:\InstallDirectory\jdk1.8\bin
目录下,可能是复制目录出错，或者文件复制不对。

原文链接：https://blog.csdn.net/weixin_44276313/article/details/126784894