9号彩票

技术支持Support
联系我们Contact
搜索Search
你的位置:首页 > 技术支持

java串口通信详解

2015-1-16 14:51:20点击:

序言

说到开源,恐怕很少有人不挑大指称赞。学生通过开源代码学到了知识,程序员通过开源类库获得了别人的成功经验及能够按时完成手头的工程,商家通过开源软件赚到了钱……,总之是皆大欢喜。然而开源软件或类库的首要缺点就是大多缺乏详细的说明文档和使用的例子,或者就是软件代码随便你用,就是文档,例子和后期服务收钱。这也难怪,毕竟就像某个著名NBA球员说的那样:“我还要养家,所以千万美元以下的合同别找我谈,否则我宁可待业”。是啊,支持开源的人也要养家,收点钱也不过分。要想既不花钱又学到知识就只能借助网络和了,我只是想抛砖引玉,为开源事业做出点微薄共献,能为你的工程解决哪怕一个小问题,也就足够了。

虽然我的这个系列介绍的东西不是什么Web框架,也不是什么开源服务器,但是我相信,作为一个程序员,什么样的问题都会遇到。有时候越是简单的问题反而越棘手;越是小的地方就越是找不到称手的家伙。只要你不是整天只与“架构”、“构件”、“框架”打交道的话,相信我所说的东西你一定会用到。


1     串口通信简介... 1

1.1      常见的Java串口包... 1

1.2      串口包的安装(Windows下)... 1

2     串口API概览... 2

2.1      javax.comm.CommPort2

2.2      javax.comm.CommPortIdentifier3

2.3      javax.comm.SerialPort3

2.4      串口API实例... 3

2.4.1       列举出本机所有可用串口... 3

2.4.2       串口参数的配置... 4

2.4.3       串口的读写... 4

3     串口通信的通用模式及其问题... 5

3.1      事件监听模型... 5

3.2      串口读数据的线程模型... 6

3.3      第三种方法... 7

4     结束语... 9


1     串口通信简介

嵌入式系统或传感器网络的很多应用和测试都需要通过PC机与嵌入式设备或传感器节点进行通信。其中,最常用的接口就是RS-232串口和并口(鉴于USB接口的复杂性以及不需要很大的数据传输量,USB接口用在这里还是显得过于奢侈,况且目前除了SUN有一个支持USB的包之外,我还没有看到其他直接支持USB的Java类库)。SUN的CommAPI分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。RS-232-C(又称EIA RS-232-C,以下简称RS232)是在1970年由美国电子工业协会(EIA)联合贝尔系统、调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。RS232是一个全双工的通讯协议,它可以同时进行数据接收和发送的工作。

1.1 常见的Java串口包

目前,常见的Java串口包有SUN在1998年发布的串口通信API:comm2.0.jar(Windows下)、comm3.0.jar(Linux/Solaris);IBM的串口通信API以及一个开源的实现。鉴于在Windows下SUN的API比较常用以及IBM的实现和SUN的在API层面都是一样的,那个开源的实现又不像两家大厂的产品那样让人放心,这里就只介绍SUN的串口通信API在Windows平台下的使用。

1.2 串口包的安装(Windows下)

到SUN的网站下载javacomm20-win32.zip,包含的东西如下所示:


按照其使用说明(Readme.html)的说法,要想使用串口包进行串口通信,除了设置好环境变量之外,还要将win32com.dll复制到<JDK>\bin目录下;将comm.jar复制到<JDK>\lib;把javax.comm.properties也同样拷贝到<JDK>\lib目录下。然而在真正运行使用串口包的时候,仅作这些是不够的。因为通常当运行“java MyApp”的时候,是由JRE下的虚拟机启动MyApp的。而我们只复制上述文件到JDK相应目录下,所以应用程序将会提示找不到串口。解决这个问题的方法很简单,我们只须将上面提到的文件放到JRE相应的目录下就可以了。

值得注意的是,在网络应用程序中使用串口API的时候,还会遇到其他更复杂问题。有兴趣的话,你可以查看CSDN社区中“关于网页上Appletjavacomm20读取客户端串口的问题”的帖子。

2     串口API概览

2.1      javax.comm.CommPort

这是用于描述一个被底层系统支持的端口的抽象类。它包含一些高层的IO控制方法,这些方法对于所有不同的通讯端口来说是通用的。SerialPort 和ParallelPort都是它的子类,前者用于控制串行端口而后者用于控这并口,二者对于各自底层的物理端口都有不同的控制方法。这里我们只关心SerialPort。

2.2      javax.comm.CommPortIdentifier

这个类主要用于对串口进行管理和设置,是对串口进行访问控制的核心类。主要包括以下方法

l         确定是否有可用的通信端口

l         为IO操作打开通信端口

l         决定端口的所有权

l         处理端口所有权的争用

l         管理端口所有权变化引发的事件(Event)

2.3        javax.comm.SerialPort

这个类用于描述一个RS-232串行通信端口的底层接口,它定义了串口通信所需的最小功能集。通过它,用户可以直接对串口进行读、写及设置工作。

2.4 串口API实例

大段的文字怎么也不如一个小例子来的清晰,下面我们就一起看一下串口包自带的例子---SerialDemo中的一小段代码来加深对串口API核心类的使用方法的认识。

2.4.1   列举出本机所有可用串口

void listPortChoices() {

            CommPortIdentifier portId;

            Enumeration en = CommPortIdentifier.getPortIdentifiers();

            // iterate through the ports.

            while (en.hasMoreElements()) {

                portId = (CommPortIdentifier) en.nextElement();

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

                    System.out.println(portId.getName());

                }

            }

            portChoice.select(parameters.getPortName());

        }

以上代码可以列举出当前系统所有可用的串口名称,我的机器上输出的结果是COM1和COM3。

2.4.2   串口参数的配置

串口一般有如下参数可以在该串口打开以前配置进行配置:

包括波特率,输入/输出流控制,数据位数,停止位和齐偶校验。

SerialPort sPort;

try {

            sPort.setSerialPortParams(BaudRate,Databits,Stopbits,Parity);

                     //设置输入/输出控制流

                     sPort.setFlowControlMode(FlowControlIn | FlowControlOut);

        } catch (UnsupportedCommOperationException e) {}

2.4.3   串口的读写

对串口读写之前需要先打开一个串口:

CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier(PortName);

try {

            SerialPort  sPort = (SerialPort) portId.open("串口所有者名称", 超时等待时间);

        } catch (PortInUseException e) {//如果端口被占用就抛出这个异常

            throw new SerialConnectionException(e.getMessage());

        }

//用于对串口写数据

OutputStream os = new BufferedOutputStream(sPort.getOutputStream());

os.write(int data);

//用于从串口读数据

InputStream is = new BufferedInputStream(sPort.getInputStream());

int receivedData = is.read();

读出来的是int型,你可以把它转换成需要的其他类型。

这里要注意的是,由于Java语言没有无符号类型,即所有的类型都是带符号的,在由byte到int的时候应该尤其注意。因为如果byte的最高位是1,则转成int类型时将用1来占位。这样,原本是10000000的byte类型的数变成int型就成了1111111110000000,这是很严重的问题,应该注意避免。

3     串口通信的通用模式及其问题

终于唠叨完我最讨厌的基础知识了,下面开始我们本次的重点--串口应用的研究。由于向串口写数据很简单,所以这里我们只关注于从串口读数据的情况。通常,串口通信应用程序有两种模式,一种是实现SerialPortEventListener接口,监听各种串口事件并作相应处理;另一种就是建立一个独立的接收线程专门负责数据的接收。由于这两种方法在某些情况下存在很严重的问题(至于什么问题这里先卖个关子J),所以我的实现是采用第三种方法来解决这个问题。

3.1 事件监听模型

现在我们来看看事件监听模型是如何运作的

l        首先需要在你的端口控制类(例如SManager)加上“implements SerialPortEventListener”

l        在初始化时加入如下代码:

try {

            SerialPort sPort.addEventListener(SManager);

        } catch (TooManyListenersException e) {

            sPort.close();

            throw new SerialConnectionException("too many listeners added");

        }

        sPort.notifyOnDataAvailable(true);

l        覆写public void serialEvent(SerialPortEvent e)方法,在其中对如下事件进行判断:

BI -通讯中断.

  CD -载波检测.

  CTS -清除发送.

  DATA_AVAILABLE -有数据到达.

  DSR -数据设备准备好.

  FE -帧错误.

  OE -溢位错误.

  OUTPUT_BUFFER_EMPTY -输出缓冲区已清空.

  PE -奇偶校验错.

RI - 振铃指示.

一般最常用的就是DATA_AVAILABLE--串口有数据到达事件。也就是说当串口有数据到达时,你可以在serialEvent中接收并处理所收到的数据。然而在我的实践中,遇到了一个十分严重的问题。

首先描述一下我的实验:我的应用程序需要接收传感器节点从串口发回的查询数据,并将结果以图标的形式显示出来。串口设定的波特率是115200,川口每隔128毫秒返回一组数据(大约是30字节左右),周期(即持续时间)为31秒。实测的时候在一个周期内应该返回4900多个字节,而用事件监听模型我最多只能收到不到1500字节,不知道这些字节都跑哪里去了,也不清楚到底丢失的是那部分数据。值得注意的是,这是我将serialEvent()中所有处理代码都注掉,只剩下打印代码所得的结果。数据丢失的如此严重是我所不能忍受的,于是我决定采用其他方法。

3.2 串口读数据的线程模型

这个模型顾名思义,就是将接收数据的操作写成一个线程的形式:

public void startReadingDataThread() {

        Thread readDataProcess = new Thread(new Runnable() {

            public void run() {

                            while (newData != -1) {

                    try {

                                          newData = is.read();

                        System.out.println(newData);

                                          //其他的处理过程

                                          ……….

                                   } catch (IOException ex) {

                        System.err.println(ex);

                        return;

                    }

                     }

              readDataProcess.start();

}

在我的应用程序中,我将收到的数据打包放到一个缓存中,然后启动另一个线程从缓存中获取并处理数据。两个线程以生产者—消费者模式协同工作,数据的流向如下图所示:

 

这样,我就圆满解决了丢数据问题。然而,没高兴多久我就又发现了一个同样严重的问题:虽然这回不再丢数据了,可是原本一个周期(31秒)之后,传感器节电已经停止传送数据了,但我的串口线程依然在努力的执行读串口操作,在控制台也可以看见收到的数据仍在不断的打印。原来,由于传感器节点发送的数据过快,而我的接收线程处理不过来,所以InputStream就先把已到达却还没处理的字节缓存起来,于是就导致了明明传感器节点已经不再发数据了,而控制台却还能看见数据不断打印这一奇怪的现象。唯一值得庆幸的是最后收到数据确实是4900左右字节,没出现丢失现象。然而当处理完最后一个数据的时候已经快1分半钟了,这个时间远远大于节点运行周期。这一延迟对于一个实时的显示系统来说简直是灾难!

后来我想,是不是由于两个线程之间的同步和通信导致了数据接收缓慢呢?于是我在接收线程的代码中去掉了所有处理代码,仅保留打印收到数据的语句,结果依然如故。看来并不是线程间的通信阻碍了数据的接收速度,而是用线程模型导致了对于发送端数据发送速率过快的情况下的数据接收延迟。这里申明一点,就是对于数据发送速率不是如此快的情况下前面者两种模型应该还是好用的,只是特殊情况还是应该特殊处理。

3.3 第三种方法

痛苦了许久(Boss天天催我L)之后,偶然的机会,我听说TinyOS中(又是开源的)有一部分是和我的应用程序类似的串口通信部分,于是我下载了它的1.x版的Java代码部分,参考了它的处理方法。解决问题的方法说穿了其实很简单,就是从根源入手。根源不就是接收线程导致的吗,那好,我就干脆取消接收线程和作为中介的共享缓存,而直接在处理线程中调用串口读数据的方法来解决问题(什么,为什么不把处理线程也一并取消?----都取消应用程序界面不就锁死了吗?所以必须保留)于是程序变成了这样:

public byte[] getPack(){

       while (true) {

                       // PacketLength为数据包长度

                    byte[] msgPack = new byte[PacketLength];

                    for(int i = 0; i < PacketLength; i++){

                        if( (newData = is.read()) != -1){

                            msgPack[i] = (byte) newData;

                            System.out.println(msgPack[i]);

                        }

                    }

                    return msgPack;

                            }

}

在处理线程中调用这个方法返回所需要的数据序列并处理之,这样不但没有丢失数据的现象行出现,也没有数据接收延迟了。这里唯一需要注意的就是当串口停止发送数据或没有数据的时候is.read()一直都返回-1,如果一旦在开始接收数据的时候发现-1就不要理它,继续接收,直到收到真正的数据为止。


4     结束语

本文介绍了串口通信的基本知识,以及常用的几种模式。通过实践,提出了一些问题,并在最后加以解决。值得注意的是对于第一种方法,我曾将传感器发送的时间由128毫秒增加到512毫秒,仍然有很严重的数据丢失现象发生,所以如果你的应用程序需要很精密的结果,传输数据的速率又很快的话,就最好不要用第一种方法。对于第二种方法,由于是线程导致的问题,所以对于不同的机器应该会有不同的表现,对于那些处理多线程比较好的机器来说,应该会好一些。但是我的机器是Inter 奔四3.0双核CPU+512DDR内存,这样都延迟这么厉害,还得多强的CPU才行啊?所以对于数据量比较大的传输来说,还是用第三种方法吧。不过这个世界问题是很多的,而且未知的问题比已知的问题多的多,说不定还有什么其他问题存在,欢迎你通过下面的联系方式和我一起研究。 

关于java使用javacomm20-win32实践总结
        由于这几天要通过java调用通过串口或并口连接的硬件资源,所以我就要用到和底层的硬件进行通讯。通过RS-232的通讯协议,了解电脑和外设是怎样进行通讯的。在应用中我们也可以通过JNI来实现(详情请见http://hgq0011.javaeye.com/blog/31508),这样的话,就必须知道更多的知识。由于java已经提供我们一个javacomm20-win32通用的API我们还是实行“拿来主义”吧。我就把整个应用的过程详细的说一下,希望给需要的人一点帮助。
       我们经过串口和外设通讯,下面我就以串口为例进行解说。
       1)我们要准备相应的设备。

             电脑,外设,通过数据线把他们连接起来。
         2)检验外设到底是用的那个COM口和电脑通讯的.

              也就是说,他们有没有真确的连接上。我们可以通过下载串口通讯口测试软件,我用的是"SuperCommTool.exe"的绿色软件,进行测试的。这软件很适应,如果选中的某个COM已经被使用了,它会给你一个相应的提示(端口以被占用)。如果你不知道到底是使用的那个端口,那么你可以通过superCommTool软件一个一个的试,如果正常的话,那么你可以看到有数据显示在数据接收窗口。也许,有些主板的串口坏了,那么你就要买一个转接卡,通过PCI插口转接。
           3)察看外设使用说明书知道外设的相关参数.

                比如,波特率,数据位,停止位,校验位,等等。只有正确参数,才能显示正确的数据。当然,你可以在通讯测试软件上调试这些参数的。比如:波特率 = 2400,数据位 = 8,停止位 = 2 ,校验位 = 1。
            4)准备开发环境。

                 最基本的JDK了,你可以使用自己钟爱的IDE,帮助你开发。IDE可能自带了JDK,那么 你要把相应的javaComm20-win32放到运行时使用的JDK中。 下载JAVAcomm20-win32。
            5)了解javaComm20-win32。

                 你必须把win32com.dll复制到java.home/bin下;把javax.comm.properties复制到java.home/lib下;把comm.jar添加到你classPath下。前面两个都是非常重要的。
                  下面说明用到的几个类:
                         javax.comm.CommPortIdentifier 

                         通讯端口管理器,CommPortIdentifier是控制访问到通讯端口的中 心类。它包括的方法有:
                       a. 通过驱动决定通讯端口是可用的。
                        b. 打开通讯端口为了I/O操作。
                        c. 决定端口的拥有者。
                        d. 解析端口拥有者的争夺。
                        e. 管理事件显示在端口拥有者的中的状态改变。
                       一个应用程序首先使用CommPortIdentifier中的方法,通过相关的驱动去获取那些通讯端口是可用的  并且选择一个端口便于开始。然后它使用方法在其它类中想      CommPort,ParallelPort和SerialPort通过  这个端口进行通讯。
                         javax.comm.SerialPort 

                                一个RS-232串口通讯端口。SerialPort 描述底层的接口到一个串口通讯端口
 变得有效的通过底层的系统。SerialPort定义最小的必需的功能便于串口通讯端口。 

                         javax.comm.SerialPortEventListener 串行端口事件传播。
                         javax.comm.CommDriver

            6)代码的编写。

                  a. 获取SerialPort sPort对象的两种方法。
                  1)                      2)

java 代码

1.    System.loadLibrary("win32com");   

2.     javax.comm.CommDriver driver = null;   

3.     String driverName = "com.sun.comm.Win32Driver";   

4.     SerialPort sPort = (SerialPort) driver.getCommPort("COM4", ommPortIdentifier.PORT_SERIAL);  

 

java 代码

1.    CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM4");   

2.    SerialPort sPort = (SerialPort)portId.open("shipment",1000);      

                     以上两种方法都可以。不过一般都会采用第二种。方法说明我们获取了对串行端口(COM4),可以和它进行通讯了。
                    b. 设置串行端口通讯参数。

java 代码

1.    sPort.setSerialPortParams(2400,SerialPort.DATABITS_8,SerialPort.STOPBITS_2,SerialPort.PARITY_NONE);  

                          c. 获取输入(出)流。

java 代码

1.    InputStream is = sPort.getInputStream();//从外设获取数据   

2.    OutputStream os = sPort.getOutputStream();//发送命令到外设  

                          d.通过监听器就可以得到数据了。

java 代码

1.    //Set notifyOnDataAvailable to true to allow event driven input.   

2.                sPort.notifyOnDataAvailable(true);   

3.      

4.                 // Set notifyOnBreakInterrup to allow event driven break handling.   

5.                sPort.notifyOnBreakInterrupt(true);   

6.      

7.                 // Set receive timeout to allow breaking out of polling loop during  input handling.   

8.                sPort.enableReceiveTimeout(30);   

9.                StringBuffer linkWgt = new StringBuffer();//存放获取的数据   

10.             sPort.addEventListener(    

11.                 new SerialPortEventListener(){   

12.                     public void serialEvent(SerialPortEvent e){   

13.                         int newData = 0;   

14.                         // Determine type of event.   

15.                         switch (e.getEventType()) {   

16.                         // Read data until -1 is returned. If \r is received substitute   

17.                             // \n for correct newline handling.   

18.                             case SerialPortEvent.DATA_AVAILABLE:   

19.                                 while (newData != -1) {   

20.                                     try {   

21.                                         newData = is.read();   

22.                                         if (newData == -1) {   

23.                                             break;   

24.                                         }   

25.                                         if ('\r' == (char)newData) {   

26.                                         } else {   

27.                                             linkWgt.append((char)newData);   

28.                                         }   

29.                                     } catch (IOException ex) {   

30.                                         System.err.println(ex);   

31.                                         return;   

32.                                     }   

33.                                 }   

34.   

35.                             // Append received data to messageAreaIn.   

36.                                

37.                              try{   

38.                                 System.out.println("linkWgt ---------|||||          "+Double.valueOf(linkWgt.toString()));   

39.                                    

40.                              }catch(Exception ew){   

41.                                 ew.printStackTrace();   

42.                              }finally{   

43.                                 try{   

44.                                     //用完了,记得关闭端口。   

45.                                     is.close();   

46.                                     sPort.close();   

47.                                 }catch(Exception c){   

48.                                     c.printStackTrace();   

49.                                 }   

50.                              }   

51.                             break;   

52.                             // If break event append BREAK RECEIVED message.   

53.                             case SerialPortEvent.BI:   

54.                                 System.out.println("\n--- BREAK RECEIVED ---\n");   

55.                         }   

56.                     }   

57.   

58.                 }   

59.             );  

                7)常见的异常

                     a. javax.comm.NoSuchPortException   这个说明你的javax.comm.properties没有放到正确的位置。               

                          如果有什么不正确的地方,欢迎批评指正,谢谢!

Java串行端口通讯技术 

了解串行通讯

    串行通讯协议有很多种,像RS232,RS485,RS422,甚至现今流行的USB等都是串行通讯协议。而串行通讯技术的应用无处不在。可能大家见的最多就是电脑的串口与Modem的通讯。记得在PC机刚开始在中国流行起来时(大约是在90年代前五年),那时甚至有人用一条串行线进行两台电脑之间的数据共享。除了这些,手机,PDA,USB鼠标、键盘等等都是以串行通讯的方式与电脑连接。而笔者工作性质的关系,所接触到的就更多了,像多串口卡,各种种类的具有串口通讯接口的检测与测量仪器,串口通讯的网络设备等。

    虽然串行通讯有很多种,但笔者所知的在整个电子通讯产品方面,以RS232的通讯方式最为多见。虽然USB接口的电子产品也是层出不穷,但了解一下Java在串行通讯方面的技术还有有必要的,说不定有哪位读者还想用此技术写一个PDA与电脑之间数据共享的程序呢。

    本文主要以RS232为主来讲解JAVA的串行通讯技术。

RS232通讯基础

    RS-232-C(又称 EIA RS-232-C,以下简称RS232)是在1970年由美国电子工业协会(EIA)联合贝尔系统、调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。RS232是一个全双工的通讯协议,它可以同时进行数据接收和发送的工作。RS232的端口通常有两种:9针(DB9)和25针(DB25)。

DB9和DB25的常用针脚定义

 9针串口(DB9

25针串口(DB25

针号

功能说明

缩写

针号

功能说明

缩写

1

数据载波检测

DCD

8

数据载波检测

DCD

2

接收数据

RXD

3

接收数据

RXD

3

发送数据

TXD

2

发送数据

TXD

4

数据终端准备

DTR

20

数据终端准备

DTR

5

信号地

GND

7

信号地

GND

6

数据设备准备好

DSR

6

 

数据准备好

DSR

7

请求发送

RTS

4

请求发送

RTS

8

清除发送

CTS

5

清除发送

CTS

9

振铃指示

RI

22

振铃指示

RI

常见的边线方式

常见的通讯方式是三线式,这种方式是将两个RS232设备的发送端(TXD)和接收端(RXD)及接地端(GND)互相连接,也是许多读者所知道的连接方式:

(9针)

2(RXD)

---------

3(TXD

3(TXD)

---------

2(TXD)

5(GND)

---------

5(GND)

(25针)

2(RXD)

---------

3(TXD

3(TXD)

---------

2(RXD)

7(GND)

---------

7(GND)

    这种方式分别将两端的RS232接口的2--3,3---2,5(7)---5(7)针脚连接起来。其中2是数据接收线(RXD),3是数据发送线(TXD),5(7)是接地(RND)。如果有一台式PC,和一部NoteBook电脑,就可以用这种方式连线了。用三线式可以将大多数的RS232设备连接起来。但如果你认死了2--3,3--2,5(7)--5(7)对接这个理,会发现在连某些RS232设备时并不奏效。这是因为有些设备在电路内部已将2和3线调换过来了,你只要2,3,5(7)针一一对应就行了。

小技巧:如何辨别TXDRXD端口?
    搞电子的人手边应该常备一个电表,用来测测电压,电阻什么的会很有用。你只要分别测一下RS232端口的2--53--5针脚之间的电压,通常TXD针脚与GND之间会有3~15V左右的负电压,表示它是TXD针脚。

  安装Java Communications API   

    Sun的J2SE中并没有直接提供以上提到的任何一种串行通讯协议的开发包,而是以独立的jar包形式发布在java.sun.com网站上(从这里)----即comm.jar,称之为Javatm Communications API,它是J2SE的标准扩展。comm.jar并不是最近才有,早在1998年时,sun就已经发布了这个开发包。comm.jar分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。目前sun发布的comm.jar只有Windows和Solaris平台两个版本,如果你需要Linux平台下的,可以在http://www.geeksville.com/~kevinh/linuxcomm.html找到。

    在使用comm.jar之前,必须知道如何安装它。这也是困扰许多初学java RS232通讯者的一个难题。如果我们电脑上安装了JDK, 它将同时为我们安装一份JRE(Java Runtime Entironment),通常我们运行程序时都是以JRE来运行的。所以以下的安装适用于JRE。如果你是用JDK来运行程序的,请将相应的改成。

    下载了comm.jar开发包后,与之一起的还有两个重要的文件,win32com.dll和javax.comm.properties。 comm.jar提供了通讯用的java API,而win32com.dll提供了供comm.jar调用的本地驱动接口。而javax.comm.properties是这个驱动的类配置文件。首先将comm.jar复制到\lib\ext目录。再将win21com.dll复制到你的RS232应用程序运行的目录,即user.dir。然后将javax.comm.properties复制到\lib目录。

通讯前的准备

    如果你手头上没有现成的提供了标准RS232串口的设备,你可以将自己的电脑模拟成两台不同的串口设备。通常电脑主机后面的面板提供了两个9针的串口,请将这两个串口的2,3,5脚按前面介绍的方法连接。电子市场都有现成的连接头卖,请不要买那种封装的严严实实的接头,而要买用螺丝封装可以拆开的连接头,这样可以方便自己根据需要连接各个针脚。

Comm API基础

    我无意于在此详细描述Comm API每个类和接口的用法,但我会介绍Comm API的类结构和几个重要的API用法。

    所有的comm API位于javax.comm包下面。从Comm API的javadoc来看,它介绍给我们的只有区区以下13个类或接口:

javax.comm.CommDriver 
javax.comm.CommPort 
javax.comm.ParallelPort 
javax.comm.SerialPort 
javax.comm.CommPortIdentifier 
javax.comm.CommPortOwnershipListener
javax.comm.ParallelPortEvent 
javax.comm.SerialPortEvent 
javax.comm.ParallelPortEventListener (extends java.util.EventListener) 
javax.comm.SerialPortEventListener (extends java.util.EventListener) 
javax.comm.NoSuchPortException 
javax.comm.PortInUseException 
javax.comm.UnsupportedCommOperationException 

    下面讲解一下几个主要类或接口。

    1.枚举出系统所有的RS232端口

    在开始使用RS232端口通讯之前,我们想知道系统有哪些端口是可用的,以下代码列出系统中所有可用的RS232端口:

Enumeration en = CommPortIdentifier.getPortIdentifiers();
CommPortIdentifier portId;
while (en.hasMoreElements()) 
{
    portId = (CommPortIdentifier) en.nextElement();
    /*
如果端口类型是串口,则打印出其端口信息*/
    if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) 
    {
        System.out.println(portId.getName());
    }
}
在我的电脑上以上程序输出以下结果:
COM1
COM2

    CommPortIdentifier类的getPortIdentifiers方法可以找到系统所有的串口,每个串口对应一个CommPortIdentifier类的实例。

    2.打开端口

    如果你使用端口,必须先打开它。

    try{
    CommPort serialPort = portId.open("My App", 60);
    /* 从端口中读取数据*/
    InputStream input = serialPort.getInputStream();
    input.read(...);  
    /* 往端口中写数据*/
    OutputStream output = serialPort.getOutputStream();
    output.write(...)
    ...
    }catch(PortInUseException ex)
    { ... }

    通过CommPortIdentifier的open方法可以返回一个CommPort对象。open方法有两个参数,第一个是String,通常设置为你的应用程序的名字。第二个参数是时间,即开启端口超时的毫秒数。当端口被另外的应用程序占用时,将抛出PortInUseException异常。

    在这里CommPortIdentifier类和CommPort类有什么区别呢?其实它们两者是一一对应的关系。CommPortIdentifier主要负责端口的初始化和开启,以及管理它们的占有权。而CommPort则是跟实际的输入和输出功能有关的。通过CommPort的getInputStream()可以取得端口的输入流,它是java.io.InputStream接口的一个实例。我们可以用标准的InputStream的操作接口来读取流中的数据,就像通过FileInputSteam读取文件的内容一样。相应的,CommPort的getOutputStream可以获得端口的输出流,这样就可以往串口输出数据了。

    3. 关闭端口

    使用完的端口,必须记得将其关闭,这样可以让其它的程序有机会使用它,不然其它程序使用该端口时可能会抛出端口正在使用中的错误。很奇怪的是,CommPortIdentifier类只提供了开启端口的方法,而要关闭端口,则要调用CommPort类的close()方法。

通讯方式

    CommPort的输入流的读取方式与文件的输入流有些不一样,那就是你可能永远不知这个InputStream何时结束,除非对方的OutputStream向你发送了一个特定数据表示发送结束,你收到这个特定字符后,再行关闭你的InputStream。而comm.jar提供了两种灵活的方式让你读取数据。

    1. 轮询方式(Polling)

    举个例子,你同GF相约一起出门去看电影,但你的GF好打扮,这一打扮可能就是半小时甚至一小时以上。这时你就耐不住了,每两分钟就催问一次“好了没?”,如此这样,直到你的GF说OK了才算完。这个就叫轮询(Polling)。

    在程序中,轮询通常设计成一个封闭的循环,当满足某个条件时即结束循环。刚才那个例子中,你的GF说“OK了!”,这个就是结束你轮询的条件。在单线程的程序中,当循环一直执行某项任务而又无法预知它何时结束时,此时你的程序看起来可能就像死机一样。在VB程序中,这个问题可以用在循环结构中插入一个doEvent语句来解决。而Java中,最好的方式是使用线程,就像以下代码片断一样。

    public TestPort extend Thread
    {
        ...
        InputStream input = serialPort.getInputStream();
        StringBuffer buf = new StringBuffer();
        boolean stopped = false;
        ...
        public void run()
        {
            try {
                while( !stopped )
        int ch = input.read();
                if ( ch=='q' || ch=='Q' )
                {
                    /* 结束读取,关闭端口...*/
                    stopped = true;
                    ...
                }
                else
                {
                    buf.append((char)ch);
                    ...
                }
            }catch (InterruptedException e) { }
        }

    }

    2. 监听方式(listening)

   Comm API支持标准的Java Bean型的事件模型。也就是说,你可以使用类似AddXXXListener这样的方法为一个串口注册自己的监听器,以监听方式进行数据读取。

     如要对端口监听,你必须先取得CommPortIdentifier类的一个实例,
      CommPort serialPort = portId.open("My App", 60);

    从而取得SerialPort,再调用它的addEventListener方法为它添加监听器,
    serialPort.addEventListener(new MyPortListener());

    SerialPort的监听器必须继承于SerialPortEventListener接口。当有任何SerialPort的事件发生时,将自动调用监听器中的serialEvent方法。Serial Event有以下几种类型:

BI - 通讯中断.
CD -
载波检测.
CTS -
清除发送.
DATA_AVAILABLE -
有数据到达.
DSR -
数据设备准备好.
FE -
帧错误.
OE -
溢位错误.
OUTPUT_BUFFER_EMPTY -
输出缓冲区已清空.
PE -
奇偶校验错.
RI -
 振铃指示.

下面是一个监听器的示例,
public void MyPortListener implements SerialPortEventListener
{  

 

    这个监听器只是简单打印每个发生的事件名称。而对于大多数应用程序来说,通常关心是DATA_AVAILABLE事件,当数据从外部设备传送到端口上来时将触发此事件。此时就可以使用前面提到过的方法,serialPort.getInputStream()来从InputStream中读取数据了。

完整的程序

    为节省篇幅,本文只提供了一些代码片断来帮助读者来理解Comm API的用法。你可以从Comm API的开发包中取得完整的可运行的演示程序。请先下载了comm API的开发包,解压之后有一个名为Sample的目录,里面有几个演示程序,分别是:

1) BlackBox: ASerialPortBlackBox application.

2) ParallelBlackBox: AParallelPortBlackBox application

3) SerialDemo: A simpler SerialPort sample application

4) Simple: A very simple comm application

5) NullDriver: A template for driver writers. Can be used as the starting point
to write a driver for the Comm API.

6) porting: A template CommPortIdentifier java file for people interested
in porting the Comm API to a new platform.

其中,第1),3),4)是关于rs232通讯的演示程序。而其它的,2)是并行端口的演示程序。5)和6)是开发自己的端口驱动程序的模板程序,有兴趣的读者可以自行研究。

 public void serialEvent(SerialPortEvent evt)
{
   switch (evt.getEventType())
    {
      case SerialPortEvent.CTS :
            System.out.println("CTS event occured.");
            break;
      case SerialPortEvent.CD :
            System.out.println("CD event occured.");
            break;
      case SerialPortEvent.BI :
            System.out.println("BI event occured.");
            break;
      case SerialPortEvent.DSR :
            System.out.println("DSR event occured.");
            break;
      case SerialPortEvent.FE :
            System.out.println("FE event occured.");
            break;
      case SerialPortEvent.OE :
            System.out.println("OE event occured.");
            break;
      case SerialPortEvent.PE :
            System.out.println("PE event occured.");
            break;
      case SerialPortEvent.RI :
            System.out.println("RI event occured.");
            break;
      case SerialPortEvent.OUTPUT_BUFFER_EMPTY :
            System.out.println("OUTPUT_BUFFER_EMPTY event occured.");
            break;
      case SerialPortEvent.DATA_AVAILABLE :
            System.out.println("DATA_AVAILABLE event occured.");
      int ch;
      StringBuffer buf = new StringBuffer();
       InputStream input = serialPort.getInputStream
      try {
      while ( (ch=input.read()) > 0) {
        buf.append((char)ch);      
      }
          System.out.print(buf);
      } catch (IOException e) {}
      break;

    }
}

java串口编程

1. SerialBean
SerialBean是本类库与其他应用程序的接口。该类库中定义了SerialBean的构造方法以及初始化串口,从串口读取数据,往串口写入数据以及关闭串口的函数。具体介绍如下:

public SerialBean(int PortID)
本函数构造一个指向特定串口的SerialBean,该串口由参数PortID所指定。PortID = 1 表示COM1,PortID = 2 表示COM2,由此类推。

public int Initialize()
本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1,否则返回-1。初始化的结果是该串口被SerialBean独占性使用,其参数被设置为9600, N, 8, 1。如果串口被成功初始化,则打开一个进程读取从串口传入的数据并将其保存在缓冲区中。

public String ReadPort(int Length)
本函数从串口(缓冲区)中读取指定长度的一个字符串。参数Length指定所返回字符串的长度。

public void WritePort(String Msg)
本函数向串口发送一个字符串。参数Msg是需要发送的字符串。

public void ClosePort()
本函数停止串口检测进程并关闭串口。
package serial;
 import java.io.*;
 import java.util.*;
 import javax.comm.*;
 /**
  *
  * This bean provides some basic functions to implement full dulplex
  * information exchange through the srial port.
  *
  */
 public class SerialBean
 {
   static String PortName;
   CommPortIdentifier portId;
   SerialPort serialPort;
   static OutputStream out;
   static InputStream  in;
   SerialBuffer SB;
   ReadSerial   RT;
     /**
      *
      * Constructor
      *
      * @param PortID the ID of the serial to be used. 1 for COM1,
      * 2 for COM2, etc.
      *
      */
     public SerialBean(int PortID)
     {
       PortName = "COM" + PortID;
     }
     /**
      *
      * This function initialize the serial port for communication. It startss a
      * thread which consistently monitors the serial port. Any signal capturred
      * from the serial port is stored into a buffer area.
      *
      */
     public int Initialize()
     {
       int InitSuccess = 1;
       int InitFail    = -1;
     try
     {
       portId = CommPortIdentifier.getPortIdentifier(PortName);
       try
       {
         serialPort = (SerialPort)
         portId.open("Serial_Communication", 2000);
       } catch (PortInUseException e)
       {
         return InitFail;
       }
       //Use InputStream in to read from the serial port, and OutputStream
       //out to write to the serial port.
       try
       {
         in  = serialPort.getInputStream();
         out = serialPort.getOutputStream();
       } catch (IOException e)
       {
         return InitFail;
       }
       //Initialize the communication parameters to 9600, 8, 1, none.
       try
       {
          serialPort.setSerialPortParams(9600,
               SerialPort.DATABITS_8,
               SerialPort.STOPBITS_1,
               SerialPort.PARITY_NONE);
       } catch (UnsupportedCommOperationException e)
       {
         return InitFail;
       }
     } catch (NoSuchPortException e)
     {
       return InitFail;
     }
     // when successfully open the serial port,  create a new serial buffer,
     // then create a thread that consistently accepts incoming signals from
     // the serial port. Incoming signals are stored in the serial buffer.
     SB = new SerialBuffer();
     RT = new ReadSerial(SB, in);
     RT.start();
     // return success information
     return InitSuccess;
     }
     /**
      *
      * This function returns a string with a certain length from the incomin
      * messages.
      *
      * @param Length The length of the string to be returned.
      *
      */
     public String ReadPort(int Length)
     {
       String Msg;
       Msg = SB.GetMsg(Length);
       return Msg;
     }
     /**
      *
      * This function sends a message through the serial port.
      *
      * @param Msg The string to be sent.
      *
      */
     public void WritePort(String Msg)
     {
       int c;
       try
       {
         for (int i = 0; i < Msg.length(); i++)
           out.write(Msg.charAt(i));
       } catch (IOException e)  {}
     }
     /**
      *
      * This function closes the serial port in use.
      *
      */
     public void ClosePort()
     {
       RT.stop();
       serialPort.close();
     }
 }

2. SerialBuffer

SerialBuffer是本类库中所定义的串口缓冲区,它定义了往该缓冲区中写入数据和从该缓冲区中读取数据所需要的函数。

public synchronized String GetMsg(int Length)
本函数从串口(缓冲区)中读取指定长度的一个字符串。参数Length指定所返回字符串的长度。

public synchronized void PutChar(int c)
本函数望串口缓冲区中写入一个字符,参数c 是需要写入的字符。

在往缓冲区写入数据或者是从缓冲区读取数据的时候,必须保证数据的同步,因此GetMsg和PutChar函数均被声明为synchronized并在具体实现中采取措施实现的数据的同步。
package serial;
 /**
  *
  * This class implements the buffer area to store incoming data from the serial
  * port.
  *
  */
 public class SerialBuffer
 {
   private String Content = "";
   private String CurrentMsg, TempContent;
   private boolean available = false;
   private int LengthNeeded = 1;
     /**
      *
      * This function returns a string with a certain length from the incomin
      * messages.
      *
      * @param Length The length of the string to be returned.
      *
      */
   public synchronized String GetMsg(int Length)
   {
     LengthNeeded = Length;
     notifyAll();
     if (LengthNeeded > Content.length())
     {
       available = false;
       while (available == false)
       {
         try
         {
           wait();
         } catch (InterruptedException e) { }
       }
     }
     CurrentMsg  = Content.substring(0, LengthNeeded);
     TempContent = Content.substring(LengthNeeded);
     Content = TempContent;
     LengthNeeded = 1;
     notifyAll();
     return CurrentMsg;
   }
     /**
      *
      * This function stores a character captured from the serial port to the
      * buffer area.
      *
      * @param t The char value of the character to be stored.
      *
      */
   public synchronized void PutChar(int c)
   {
     Character d = new Character((char) c);
     Content = Content.concat(d.toString());
     if (LengthNeeded < Content.length())
     {
       available = true;
     }
     notifyAll();
   }
 }
   3. ReadSerial
ReadSerial是一个进程,它不断的从指定的串口读取数据并将其存放到缓冲区中。

public ReadSerial(SerialBuffer SB, InputStream Port)
本函数构造一个ReadSerial进程,参数SB指定存放传入数据的缓冲区,参数Port指定从串口所接收的数据流。

public void run()
ReadSerial进程的主函数,它不断的从指定的串口读取数据并将其存放到缓冲区中。
package serial;
 import java.io.*;
 /**
  *
  * This class reads message from the specific serial port and save
  * the message to the serial buffer.
  *
  */
 public class ReadSerial extends Thread
 {
   private SerialBuffer ComBuffer;
   private InputStream ComPort;
     /**
      *
      * Constructor
      *
      * @param SB The buffer to save the incoming messages.
      * @param Port The InputStream from the specific serial port.
      *
      */
   public ReadSerial(SerialBuffer SB, InputStream Port)
   {
     ComBuffer = SB;
     ComPort = Port;
   }
   public void run()
   {
     int c;
     try
     {
       while (true)
       {
         c = ComPort.read();
         ComBuffer.PutChar(c);
       }
     } catch (IOException e) {}
   }
 }
4. SerialExample
SerialExample是本类库所提供的一个例程。它所实现的功能是打开串口COM1,
对其进行初始化,从串口读取信息对其进行处理后将处理结果发送到串口。
import serial.*;
 import java.io.*;
 /**
  *
  * This is an example of how to use the SerialBean. It opens COM1 and reads
  * six messages with different length form the serial port.
  *
  */
 class SerialExample
 {
   public static void main(String[] args)
   {
     //TO DO: Add your JAVA codes here
     SerialBean SB = new SerialBean(1);
     String Msg;
     SB.Initialize();
     for (int i = 5; i <= 10; i++)
     {
       Msg = SB.ReadPort(i);
       SB.WritePort("Reply: " + Msg);
     }
     SB.ClosePort();
   }
 }
 本类库中使用了Java Communication API (javax.comm)。这是一个Java扩展类库,
并不包括在标准的Java SDK当中。如果你尚未安装这个扩展类库的话,你应该从
Sun公司的Java站点下载这个类库并将其安装在你的系统上。在所下载的包里面包括
一个安装说明,如果你没有正确安装这个类库及其运行环境的话,运行这个程序的时候
你会找不到串口。
正确安装Java Communication API并将上述程序编译通过以后,
你可以按如下方法测试这个程序。如果你只有一台机器,你可以利用一条
RS-232电缆将COM1和COM2连接起来,在COM1上运行SerialExample,
在COM2上运行Windows提供的超级终端程序。如果你有两台机器的话,
你可以利用一条RS-232电缆将两台机器的COM1(或者是COM2)连接起来,在一端运行例程,
另外一端运行Windows提供的超级终端程序。如果有必要的话,可以对SerialExample中
所声明的串口进行相应改动。
本程序在Windows 2000 + Java SDK 1.3环境下编译通过并成功运行。

 

java 串口通信

2007-05-11 11:50

/******************************************
*
 程序文件名称:SendComm.java
*
功能:从串行口COM1中发送数据
******************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.comm.*;

class S_Frame extends Frame implements Runnable,ActionListener
{
/*
检测系统中可用的通讯端口类 */
static CommPortIdentifier portId;
/*Enumeration
为枚举型类,util */
static Enumeration portList;
OutputStream outputStream;
/*RS-232
的串行口 */
SerialPort serialPort;
Thread readThread;
Panel p=new Panel();
TextField in_message=new TextField("
打开COM1,波特率9600,数据位8,停止位1.");
TextArea out_message=new TextArea();
Button btnOpen=new Button("
打开串口, 发送数据");
Button btnClose=new Button("
关闭串口, 停止发送数据");
byte data[]=new byte[10240];
/*
设置判断要是否关闭串口的标志*/
boolean mark;

/*
安排窗体*/
S_Frame()
{ super("
串口发送数据");
setSize(200,200);
setVisible(true);
add(out_message,"Center");
add(p,"North");
p.add(btnOpen);
p.add(btnClose);
add(in_message,"South");
btnOpen.addActionListener(this);
btnClose.addActionListener(this);
} //R_Frame() end

/*
点击按扭打开串口.*/
public void actionPerformed(ActionEvent event) {
if (event.getSource()==btnClose){
serialPort.close(); //
关闭串口
mark=true; //
用于中止线程的run()方法
in_message.setText("
串口COM1已经关闭,停止发送数据.");
}
else { mark=false;
/*
从文本区按字节读取数据*/
data=out_message.getText().getBytes();
/*
打开串口*/
start();
in_message.setText("
串口COM1已经打开,正在每2秒钟发送一次数据.....");
}
} //actionPerformed() end

/*
打开串口,并调用线程发送数据*/
public void start(){
/*
获取系统中所有的通讯端口 */
portList=CommPortIdentifier.getPortIdentifiers();
/*
用循环结构找出串口 */
while (portList.hasMoreElements()){
/*
强制转换为通讯端口类型*/
portId=(CommPortIdentifier)portList.nextElement();
if(portId.getPortType() == CommPortIdentifier.PORT_SERIAL){
if (portId.getName().equals("COM1")) {
/*
打开串口 */
try {
serialPort = (SerialPort) portId.open("ReadComm", 2000);
}
catch (PortInUseException e) { }
/*
设置串口输出流*/
try {
outputStream = serialPort.getOutputStream();
}
catch (IOException e) {}
} //if end
} //if end
} //while end
/*
调用线程发送数据*/
try{
readThread = new Thread(this);
//
线程负责每发送一次数据,休眠2秒钟
readThread.start();
}
catch (Exception e) { }
} //start() end

/*
发送数据,休眠2秒钟后重发*/
public void run() {
/*
设置串口通讯参数*/
try {
serialPort.setSerialPortParams(9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
}
catch (UnsupportedCommOperationException e) { }
/*
发送数据流(将数组data[]中的数据发送出去)*/
try {
outputStream.write(data);
}
catch (IOException e) { }
/*
发送数据后休眠2秒钟,然后再重发*/
try { Thread.sleep(2000);
if (mark)
{return; //
结束run方法,导致线程死亡
}
start();
}
catch (InterruptedException e) { }
} //run() end
} //
S_Frame end

public class SendComm
{public static void main(String args[])
{ S_Frame S_win=new S_Frame();
S_win.addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e)
{System.exit(0); }
});
S_win.pack();
}
}





/******************************************
*
 程序文件名称:ReadComm.java
*
功能:从串行口COM1中接收数据
******************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.comm.*;

class R_Frame extends Frame implements Runnable,ActionListener,SerialPortEventListener
{
/*
检测系统中可用的通讯端口类 */
static CommPortIdentifier portId;
/* Enumeration
为枚举型类,java.util */
static Enumeration portList;
InputStream inputStream;
/*
声明RS-232串行端口的成员变量 */
SerialPort serialPort;
Thread readThread;
String str="";
TextField out_message=new TextField("
上面文本框显示接收到的数据");
TextArea in_message=new TextArea();
Button btnOpen=new Button("
打开串口");

/*
建立窗体*/
R_Frame()
{
super("
串口接收数据");
setSize(200,200);
setVisible(true);
btnOpen.addActionListener(this);
add(out_message,"South");
add(in_message,"Center");
add(btnOpen,"North");
} //R_Frame() end

/*
点击按扭所触发的事件:打开串口,并监听串口. */
public void actionPerformed(ActionEvent event)
{
/*
获取系统中所有的通讯端口 */
portList=CommPortIdentifier.getPortIdentifiers();
/*
用循环结构找出串口 */
while (portList.hasMoreElements()){
/*
强制转换为通讯端口类型*/
portId=(CommPortIdentifier)portList.nextElement();
if(portId.getPortType() == CommPortIdentifier.PORT_SERIAL){
if (portId.getName().equals("COM1")) {
try {
serialPort = (SerialPort) portId.open("ReadComm", 2000);
out_message.setText("
已打开端口COM1 ,正在接收数据..... ");
}
catch (PortInUseException e) { }

/*
设置串口监听器*/
try {
serialPort.addEventListener(this);
}
catch (TooManyListenersException e) { }
/*
侦听到串口有数据,触发串口事件*/
serialPort.notifyOnDataAvailable(true);
} //if end
} //if end
} //while end
readThread = new Thread(this);
readThread.start(); //
线程负责每接收一次数据休眠20秒钟
} //actionPerformed() end

/*
接收数据后休眠20秒钟*/
public void run() {
try {
Thread.sleep(20000);
}
catch (InterruptedException e) { }
} //run() end

/*
串口监听器触发的事件,设置串口通讯参数,读取数据并写到文本区中*/
public void serialEvent(SerialPortEvent event) {
/*
设置串口通讯参数:波特率、数据位、停止位、奇偶校验*/
try {
serialPort.setSerialPortParams(9600,
  SerialPort.DATABITS_8,
  SerialPort.STOPBITS_1,
  SerialPort.PARITY_NONE);
}
catch (UnsupportedCommOperationException e) {
   }
byte[] readBuffer = new byte[20];
try {
inputStream = serialPort.getInputStream();
}
catch (IOException e) {}
try {
   /* 从线路上读取数据流 */
while (inputStream.available() > 0) {
int numBytes = inputStream.read(readBuffer);
} //while end
str=new String(readBuffer);
/*
接收到的数据存放到文本区中*/
in_message.append(str+"\n");
}
catch (IOException e) { }
} //serialEvent() end
} //
R_Frame end

public class ReadComm
{
public static void main(String args[])
{
/*
实例化接收串口数据的窗体类 */
R_Frame R_win=new R_Frame();
/*
定义窗体适配器的关闭按钮功能 */
R_win.addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e)
{System.exit(0); }
});
R_win.pack();
}
}

 

友情链接:欢乐彩票  永利彩票  9号彩票  欢乐彩票  9号彩票  

免责声明: 本站资料及图片来源互联网文章,本网不承担任何由内容信息所引起的争议和法律责任。所有作品版权归原创作者所有,与本站立场无关,如用户分享不慎侵犯了您的权益,请联系我们告知,我们将做删除处理!