【IntelliJ IDEA 2019.2】java读取发送pc串口数据

缺乏、安全感 2021-09-21 01:00 475阅读 0赞

# 1.先加好三个包。 #

[http://download.csdn.net/download/baidu\_30541191/9383178][http_download.csdn.net_download_baidu_30541191_9383178]

**注意：可以先不放这3个包，等到编译运行出错后，再根据提示放到相应目录即可。**

下载解决后得到3个包

![20191223114759557.png][]

rxtxParallel.dll  
rxtxSerial.dll  
放到可被搜索的目录下，例如：

![2019122317024370.png][]

RXTXcomm.jar （这一步可以省掉）  
放到C:\\Program Files\\Java\\jre1.8.0\_202\\lib\\ext

# 2.建一个测试工程 #

a.先建立一个普通的默认工程。

b.新建一个lib文件夹，放入RXTXcomm.jar，工程目录里就会自动出现该文件，再右键选择“add as library”

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3podW9odWkzMDczMTc2ODQ_size_16_color_FFFFFF_t_70][]

就会变成

![2019122316310059.png][]

根据上图，把库加入到代码里,

import gnu.io.*;

然后就可以使用库里的方法或函数了。

## 问题1：没有主清单属性 ##

![20191223163706617.png][]

解决方法：那是因为误操作，点成了![20191223165608467.png][]， 点运行工程即可，不能运行jar包。

## 问题2：包路径没加对 ##

![20191223165957842.png][]

解决方法：那就把那两个dll文件找到提示的目录之一即可。

![2019122317024370.png][]

## 问题3：加错32位的dll. ##

![20191223170441246.png][]

解决方法：下载64位的dll.

## 测试代码如下： ##

import javax.print.DocFlavor;
    import java.util.ArrayList;
    
    import java.io.*;
    import java.util.*;
    import gnu.io.*;
    
    public class Test {
        public static void main(String[] args) {
            System.out.printf("*****************\n");
            for (String tmp:FindPort()){
                System.out.println(tmp);
            }
            System.out.printf("----- End -----\n");
        }
    
        public static final ArrayList<String> FindPort(){
            Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();//获得所有串口
            ArrayList<String> PortNameList = new ArrayList<>();
            //串口名字添加到List并返回
            while (portList.hasMoreElements()) {
                String portName = portList.nextElement().getName();
                PortNameList.add(portName);
            }
            return PortNameList;
        }
    }

## 运行结果如下： ##

可以显示当前可用的串口。

![20191223170703610.png][]

# 3.写完整工程 #

网上找的，一放进去就可以编译运行的很精简到只有两个文件的例程：

《java串口通讯传输信息+串口助手模拟》[https://download.csdn.net/download/qq\_38150996/9856447][https_download.csdn.net_download_qq_38150996_9856447]

下载下来就可以编译进行，还带UI的工程：

《JAVA串口调试助手RXTX 源码》[https://download.csdn.net/download/u010050187/7390833][https_download.csdn.net_download_u010050187_7390833]

自已写的代码见附录，可惜，无论是自已写的，还是网上找的，都会遇到以下问题：

问题点：

#
    # A fatal error has been detected by the Java Runtime Environment:
    #
    #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x0000000180005b00, pid=8432, tid=12608
    #
    # JRE version: Java(TM) SE Runtime Environment (13.0.1+9) (build 13.0.1+9)
    # Java VM: Java HotSpot(TM) 64-Bit Server VM (13.0.1+9, mixed mode, sharing, tiered, compressed oops, g1 gc, windows-amd64)
    # Problematic frame:
    # C  [rxtxSerial.dll+0x5b00]

解决方法：推测是dll文件出问题了。有点遗憾，最后还是没调通，不过，由于很少有人用JAVA来调串口工具，所以，这个DLL库估计很久没人维护了，在我的win10-64bit电脑上运行失败，也在情理之中。

# 附录1：自已写的代码 #

Test.java

import java.awt.*;
    import java.io.*;
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    import gnu.io.*;
    
    //public class SerialPortDao implements Runnable, SerialPortEventListener {
    public class Test {
        private static boolean isOpen=false;
        static Set<CommPortIdentifier> portList=new HashSet<CommPortIdentifier>();
        final static String appName="MyApp";
        private static InputStream is;
        private static OutputStream os;
        private static SerialPort serialPort;
        static byte[] readBuffer=new byte[1024];
    
        public static void main(String[] args) {
            System.out.printf("*****************\n");
    
            Set<CommPortIdentifier> ListTmp = getPortList();
            for (CommPortIdentifier portIp:ListTmp) {
                String strPort = portIp.getName();
                System.out.println(strPort);
                if (strPort.equals("COM10")) {
                    if (openSerialPort(portIp, 1000)) {
                        System.out.printf("Opend %s Success.\n", strPort);
                        while (true) {
                            sendMessage("ATZ\r");
                            delay_ms(1000);
                            //uartReceiveDatafromSingleChipMachine(serialPort);
                            //serialEvent(serialPort);
    
                            try {
                                //获取data buffer数据长度
                                int bufferLength = is.available();
                               // System.out.println(bufferLength);
                                if (bufferLength > 0) {
                                    is.read();
                                   // delay_ms(100);
                                }
                            } catch (Exception e){
    
                            }
    
                        }
                    } else {
                        System.out.printf("Error: Opend %s Failed!!!\n", strPort);
                    }
                }
            }
    
            System.out.printf("----- End -----\n");
        }
    
        public static void delay_ms(int nms){
            try {
                Robot r = new Robot();
                r.delay(nms);
            } catch (Exception e) {
            }
        }
    
        public static Set<CommPortIdentifier> getPortList(){
            /*不带参数的getPortIdentifiers方法获得一个枚举对象，该对象又包含了系统中管理每个端口的CommPortIdentifier对象。
             * 注意这里的端口不仅仅是指串口，也包括并口。
             * 这个方法还可以带参数。
             * getPortIdentifiers(CommPort)获得与已经被应用程序打开的端口相对应的CommPortIdentifier对象。
             * getPortIdentifier(String portName)获取指定端口名（比如“COM1”）的CommPortIdentifier对象。
             */
            Enumeration tempPortList=CommPortIdentifier.getPortIdentifiers(); //枚举类
            while(tempPortList.hasMoreElements()){
                //在这里可以调用getPortType方法返回端口类型，串口为CommPortIdentifier.PORT_SERIAL
                CommPortIdentifier portIp = (CommPortIdentifier) tempPortList.nextElement();
                portList.add(portIp);
            }
            return portList;
        }
    
        public static boolean openSerialPort(CommPortIdentifier portIp,int delay){
            try {
                serialPort=(SerialPort) portIp.open(appName, delay);
                /* open方法打开通讯端口，获得一个CommPort对象。它使程序独占端口。
                 * 如果端口正被其他应用程序占用，将使用 CommPortOwnershipListener事件机制，传递一个PORT_OWNERSHIP_REQUESTED事件。
                 * 每个端口都关联一个 InputStream 和一个OutputStream。
                 * 如果端口是用open方法打开的，那么任何的getInputStream都将返回相同的数据流对象，除非有close 被调用。
                 * 有两个参数，第一个为应用程序名；第二个参数是在端口打开时阻塞等待的毫秒数。
                 */
            } catch (PortInUseException e) {
                return false;
            }
            try {
                is=serialPort.getInputStream();/*获取端口的输入流对象*/
                os=serialPort.getOutputStream();/*获取端口的输出流对象*/
            } catch (IOException e) {
                return false;
            }
            //try {
                //serialPort.addEventListener(this);/*注册一个SerialPortEventListener事件来监听串口事件*/
            //} catch (TooManyListenersException e) {
            //    return false;
           // }
            serialPort.notifyOnDataAvailable(true);/*数据可用*/
            try {
                /*设置串口初始化参数，依次是波特率，数据位，停止位和校验*/
                serialPort.setSerialPortParams(38400, SerialPort.DATABITS_8,SerialPort.STOPBITS_1 , SerialPort.PARITY_NONE);
            } catch (UnsupportedCommOperationException e) {
                return false;
            }
            return true;
        }
    
        public static boolean closeSerialPort(){
            if(isOpen){
                try {
                    is.close();
                    os.close();
                    serialPort.notifyOnDataAvailable(false);
                    serialPort.removeEventListener();
                    serialPort.close();
                    isOpen = false;
                } catch (IOException e) {
                    return false;
                }
            }
            return true;
        }
    
        public static boolean sendMessage(String message){
            try {
                System.out.println(message);
                os.write(message.getBytes());
            } catch (IOException e) {
                return false;
            }
            return true;
        }
    
        /**
         * 从串口读取数据
         * @param serialPort 当前已建立连接的SerialPort对象
         * @return 读取到的数据
         * @throws ReadDataFromSerialPortFailure 从串口读取数据时出错
         * @throws SerialPortInputStreamCloseFailure 关闭串口对象输入流出错
         */
        public static byte[] readFromPort(SerialPort serialPort) {
    
            InputStream in = null;
            byte[] bytes = null;
    
            try {
    
                in = serialPort.getInputStream();
                int bufflenth = in.available();        //获取buffer里的数据长度
    
                while (bufflenth != 0) {
                    bytes = new byte[bufflenth];    //初始化byte数组为buffer中数据的长度
                    in.read(bytes);
                    bufflenth = in.available();
                }
            } catch (IOException e) {
                //throw new ReadDataFromSerialPortFailure();
            } finally {
                try {
                    if (in != null) {
                        in.close();
                        in = null;
                    }
                } catch(IOException e) {
                    //throw new SerialPortInputStreamCloseFailure();
                }
    
            }
    
            return bytes;
    
        }
    
        public void serialEvent(SerialPortEvent event) {
            /*
             * 此处省略一下事件，可酌情添加
             *  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，输出缓冲区清空
             */
            System.out.println("eve");
            if(event.getEventType()==SerialPortEvent.DATA_AVAILABLE){
                /*Data available at the serial port，端口有可用数据。读到缓冲数组，输出到终端*/
                try {
                    while(is.available()>0){
                        is.read(readBuffer);//收到的数据再此，可视情况处理
                        System.out.println(readBuffer);
                    }
                    //SPCommandDao.startDoMessage(new String (readBuffer));//这一句是我的自定义类，处理接受到的信息，可删除
                } catch (IOException e) {
                }
            }
        }
    
        /*
         * 上位机接收数据
         * 串口对象seriesPort
         * 接收数据buffer
         * 返回一个byte数组
         */
        public  static  byte[] uartReceiveDatafromSingleChipMachine(SerialPort serialPort)
        {
            byte[] receiveDataPackage=null;
            InputStream in=null;
            try
            {
                in=serialPort.getInputStream();
                //获取data buffer数据长度
                int bufferLength=in.available();
                System.out.println(bufferLength);
                //while(bufferLength!=0)
                if (bufferLength > 0)
                {
                    //receiveDataPackage=new byte[bufferLength];
              //      in.read();
             //       in.read(receiveDataPackage);
             //       bufferLength=in.available();
    
    
    
                }
            }
            catch (IOException e)
            {
               // e.printStackTrace();
            }
            return receiveDataPackage;
        }
    
        public static void run() {
            try {
                Thread.sleep(50);//每次收发数据完毕后线程暂停50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }

[http_download.csdn.net_download_baidu_30541191_9383178]: http://download.csdn.net/download/baidu_30541191/9383178
[20191223114759557.png]: /images/20210920/38782c57a5194f3986cdf8140a768908.png
[2019122317024370.png]: /images/20210920/74b1824d98294b24978ebc978c1ffb4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3podW9odWkzMDczMTc2ODQ_size_16_color_FFFFFF_t_70]: /images/20210920/2482b9c04c59487da4277067d7c580b9.png
[2019122316310059.png]: /images/20210920/c92601c0173645a8b6682c203a0263f7.png
[20191223163706617.png]: /images/20210920/32c1216d9eca41178d48550f36a6f43a.png
[20191223165608467.png]: /images/20210920/d77b8874387d4b538c7eb52df8663aad.png
[20191223165957842.png]: /images/20210920/f6c6ef79641e4814b9af424f3dce0c1c.png
[20191223170441246.png]: /images/20210920/218ae8d5dc9a4f67935acab933b491d7.png
[20191223170703610.png]: /images/20210920/150dd1088deb42b89b06f7e6cb34c735.png
[https_download.csdn.net_download_qq_38150996_9856447]: https://download.csdn.net/download/qq_38150996/9856447
[https_download.csdn.net_download_u010050187_7390833]: https://download.csdn.net/download/u010050187/7390833