*Java串口通信详解
序言
说到开源，恐怕很少有人不挑大指称赞。学生通过开源代码学到了知识，程序员通过开源类库获得了别人的成功经验及能够按时完成手头的工程，商家通过开源软件赚到了钱……，总之是皆大欢喜。然而开源软件或类库的首要缺点就是大多缺乏详细的说明文档和使用的例子，或者就是软件代码随便你用，就是文档，例子和后期服务收钱。这也难怪，毕竟就像某个著名NBA 球员说的那样：“我还要养家，所以千万美元以下的合同别找我谈，否则我宁可待业”。是啊，支持开源的人也要养家，收点钱也不过分。要想既不花钱又学到知识就只能借助网络和了，我只是想抛砖引玉，为开源事业做出点微薄共献，能为你的工程解决哪怕一个小问题，也就足够了。
虽然我的这个系列介绍的东西不是什么Web框架，也不是什么开源服务器，但是我相信，作为一个程序员，什么样的问题都会遇到。有时候越是简单的问题反而越棘手；越是小的地方就越是找不到称手的家伙。只要你不是整天只与“架构”、“构件”、“框架”打交道的话，相信我所说的东西你一定会用到。
1串口通信简介
1.1常见的Java串口包
1.2串口包的安装（Windows下）
2串口API概览
https://www.doczj.com/doc/6616609563.html,mPort
https://www.doczj.com/doc/6616609563.html,mPortIdentifier
https://www.doczj.com/doc/6616609563.html,m.SerialPort
2.4串口API实例
2.4.1列举出本机所有可用串口
2.4.2串口参数的配置
2.4.3串口的读写
3串口通信的通用模式及其问题
3.1事件监听模型
3.2串口读数据的线程模型
3.3第三种方法
4结束语
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复制到
值得注意的是，在网络应用程序中使用串口API的时候，还会遇到其他更复杂问题。有兴趣的话，你可以查看CSDN社区中“关于网页上Applet用javacomm20读取客户端串口的问题”的帖子。
2串口API概览
https://www.doczj.com/doc/6616609563.html,mPort
这是用于描述一个被底层系统支持的端口的抽象类。它包含一些高层的IO控制方法，这些方法对于所有不同的通讯端口来说是通用的。SerialPort 和ParallelPort都是它的子类，前者用于控制串行端口而后者用于控这并口，二者对于各自底层的物理端口都有不同的控制方法。这里我们只关心SerialPort。
https://www.doczj.com/doc/6616609563.html,mPortIdentifier
这个类主要用于对串口进行管理和设置，是对串口进行访问控制的核心类。主要包括以下方法l确定是否有可用的通信端口
l为IO操作打开通信端口
l决定端口的所有权
l处理端口所有权的争用
l管理端口所有权变化引发的事件（Event）
https://www.doczj.com/doc/6616609563.html,m.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来实现（详情请见https://www.doczj.com/doc/6616609563.html,/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下；把https://www.doczj.com/doc/6616609563.html,m.properties复制到java.home/lib下；把comm.jar添加到你classPath下。前面两个都是非常重要的。
下面说明用到的几个类：
https://www.doczj.com/doc/6616609563.html,mPortIdentifier
通讯端口管理器，CommPortIdentifier是控制访问到通讯端口的中心类。它包括的方法有：
a. 通过驱动决定通讯端口是可用的。
b. 打开通讯端口为了I/O操作。
c. 决定端口的拥有者。
d. 解析端口拥有者的争夺。
e. 管理事件显示在端口拥有者的中的状态改变。
一个应用程序首先使用CommPortIdentifier中的方法，通过相关的驱动去获取那些通讯端口是可用的并且选择一个端口便于开始。然后它使用方法在其它类中
想CommPort,ParallelPort和SerialPort通过这个端口进行通讯。
https://www.doczj.com/doc/6616609563.html,m.SerialPort
一个RS-232串口通讯端口。SerialPort 描述底层的接口到一个串口通讯端口
变得有效的通过底层的系统。SerialPort定义最小的必需的功能便于串口通讯端口。
https://www.doczj.com/doc/6616609563.html,m.SerialPortEventListener 串行端口事件传播。
https://www.doczj.com/doc/6616609563.html,mDriver
6）代码的编写。
a. 获取SerialPort sPort对象的两种方法。
1）2）
java 代码
1.System.loadLibrary("win32com");
2. https://www.doczj.com/doc/6616609563.html,mDriver driver = null;
3. String driverName = "https://www.doczj.com/doc/6616609563.html,m.Win32Dri
ver";
4. SerialPort sPort = (SerialPort) driver.getCommP
ort("COM4", ommPortIdentifier.PORT_SERIAL);
java 代码
https://www.doczj.com/doc/6616609563.html,mPortIdentifier portId = CommPortIdentifier
.getPortIdentifier("COM4");
2.SerialPort sPort = (SerialPort)portId.open("ship
ment",1000);
以上两种方法都可以。不过一般都会采用第二种。方法说明我们获取了对串行端口(COM4),可以和它进行通讯了。
b. 设置串行端口通讯参数。
java 代码
1.sPort.setSerialPortParams(2400,SerialPort.DATA
BITS_8,SerialPort.STOPBITS_2,SerialPort.PARIT
Y_NONE);
c. 获取输入（出）流。
java 代码
1.InputStream is = sPort.getInputStream();//从外
设获取数据
2.OutputStream os = sPort.getOutputStream();//
发送命令到外设
d.通过监听器就可以得到数据了。
java 代码
1.//Set notifyOnDataAvailable to true to allow eve
nt driven input.
2. sPort.notifyOnDataAvailable(true);
3.
4. // Set notifyOnBreakInterrup to allow e
vent 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(SerialPortE
vent e){
13. int newData = 0;
14. // Determine type of event.
15. switch (e.getEventType()) {
16. // Read data until -1 is returne
d. If \r is received substitute
17. // \n for correct newline han
dling.
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)new
Data) {
26. } else {
27. linkWgt.append((
char)newData);
28. }
29. } catch (IOException e
x) {
30. System.err.println(e
x);
31. return;
32. }
33. }
34.
35. // Append received data to
messageAreaIn.
36.
37. try{
38. System.out.println("linkW
gt ---------||||| "+Double.valueOf(linkWg t.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 BR
EAK RECEIVED message.
53. case SerialPortEvent.BI:
54. System.out.println("\n---
BREAK RECEIVED ---\n");
55. }
56. }
57.
58. }
59. );
7）常见的异常
a. https://www.doczj.com/doc/6616609563.html,m.NoSuchPortException 这个说明你的https://www.doczj.com/doc/6616609563.html,m.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的常用针脚定义
常见的边线方式
常见的通讯方式是三线式，这种方式是将两个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)针一一对应就行了。
安装Java Communications API
Sun的J2SE中并没有直接提供以上提到的任何一种串行通讯协议的开发包，而是以独立的jar包形式发布在https://www.doczj.com/doc/6616609563.html,网站上(从这里下载)----即comm.jar，称之为Java tm Communications API，它是J2SE的标准扩展。comm.jar并不是最近才有，早在1998年时，sun就已经发布了这个开发包。comm.jar分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。目前sun发布的comm.jar只有Windows和Solaris平台两个版本，如果你需要Linux平台下的，可以在
https://www.doczj.com/doc/6616609563.html,/~kevinh/linuxcomm.html找到。
在使用comm.jar之前，必须知道如何安装它。这也是困扰许多初学java RS232通讯者的一个难题。如果我们电脑上安装了JDK, 它将同时为我们安装一份JRE(Java Runtime Entironment)，通常我们运行程序时都是以JRE来运行的。所以以下的安装适用于JRE。如果你是用JDK来运行程序的，请将相应的改成。
下载了comm.jar开发包后，与之一起的还有两个重要的文件，win32com.dll和https://www.doczj.com/doc/6616609563.html,m.properties。comm.jar提供了通讯用的java API，而win32com.dll提供了供comm.jar调用的本地驱动接口。而https://www.doczj.com/doc/6616609563.html,m.properties是这个驱动的类配置文件。首先将comm.jar复制到\lib\ext目录。再将win21com.dll复制到你的RS232应用程序运行的目录，即user.dir。然后将https://www.doczj.com/doc/6616609563.html,m.properties复制到\lib目录。
通讯前的准备
如果你手头上没有现成的提供了标准RS232串口的设备，你可以将自己的电脑模拟成两台不同的串口设备。通常电脑主机后面的面板提供了两个9针的串口，请将这两个串口的2,3,5脚按前面介绍的方法连接。电子市场都有现成的连接头卖，请不要买那种封装的严严实实的接头，而要买用螺丝封装可以拆开的连接头，这样可以方便自己根据需要连接各个针脚。
Comm API基础
我无意于在此详细描述Comm API每个类和接口的用法，但我会介绍Comm API的类结构和几个重要的API用法。
所有的comm API位于https://www.doczj.com/doc/6616609563.html,m包下面。从Comm API的javadoc来看，它介绍给我们的只有区区以下13个类或接口：
https://www.doczj.com/doc/6616609563.html,mDriver
https://www.doczj.com/doc/6616609563.html,mPort
https://www.doczj.com/doc/6616609563.html,m.ParallelPort
https://www.doczj.com/doc/6616609563.html,m.SerialPort
https://www.doczj.com/doc/6616609563.html,mPortIdentifier
https://www.doczj.com/doc/6616609563.html,mPortOwnershipListener
https://www.doczj.com/doc/6616609563.html,m.ParallelPortEvent
https://www.doczj.com/doc/6616609563.html,m.SerialPortEvent
https://www.doczj.com/doc/6616609563.html,m.ParallelPortEventListener (extends java.util.EventListener)
https://www.doczj.com/doc/6616609563.html,m.SerialPortEventListener (extends java.util.EventListener)
https://www.doczj.com/doc/6616609563.html,m.NoSuchPortException
https://www.doczj.com/doc/6616609563.html,m.PortInUseException
https://www.doczj.com/doc/6616609563.html,m.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: A Serial Port BlackBox application.
2) ParallelBlackBox: A Parallel Port BlackBox 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 https://www.doczj.com/doc/6616609563.html,m.*;
/**
*
* 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);
{
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)
java调用coms端口串口通信的方法。 首先需要下到串口驱动。javacomm20-win32.zip 去sun的主页应该有下的。 在这个驱动中有comm.jar，https://www.doczj.com/doc/6616609563.html,m.properties，win32com.dll 这么3个重要的文件。 1、首先配置驱动，把https://www.doczj.com/doc/6616609563.html,m.properties，win32com.dll拷贝到你的jdk 中 具体位置为C:\Program Files\Java\jdk1.6.0_06\bin 然后配置windows系统环境变量，在path中加入C:\Program Files\Java\jdk1.6.0_06\bin; 打开你的java工程，配置user library,并导入comm.jar包。 2、现在就可以开始写代码了。串口读写代码如下 CommPortIdentifier portID = CommPortIdentifier.getPortIdentifier(com);//1，先拿到Identifier //其中com是String类型的，传入的是串口名com="COM1"; SerialPort port = (SerialPort)portID.open("MyComm", 100000000);//2,打开串口 //"MyComm"是串口名，100000000是串口过期时间（ms）。 port.setSerialPortParams(rate, databits,stopbit, parity);//3，设置串口属性 //rate 波特率（默认9600），databits载波位（默认8），stopbit停止位（默认1），parity校验位（默认0无校验） port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);//4（可选）设置数据流控制模式，默认为无 port.close();//关闭串口 3、串口读入写出流。
Java的串口通信程序 首先需要到到sun主页下载串口通信的包，因为一般的jrd中不含有这个包的，有点补丁的意思。（CSDN上也有）。解压缩，为了使Java Communications API能够正确的与Windows系统交互，需要几个小的技巧。下面是三个很重要的文件，你可以从Sun的网站上下载得到 comm.jar win32com.dll javaxm.properties 对于JVM来说，要正确的识别串口，将这几个文件放在系统中合适的位置使很重要的。 comm..jar应该放在以下目录中 %JAVA_HOME%/lib %JAVA_HOME%/jre/lib/ext win32com.dll应该放在以下目录中 %windir%system32 javax.properties应该放在以下目录中 %JAVA_HOME%/lib
%JAVA_HOME%/jre/lib 你可以通过编译和运行Sun的例程来验证串口是否可以使用了。 JBuilder中安装安装Java Communication API （以下在JBuilder 2006中测试通过） 如果你使用JBuilder，那么还需要为JBuilder配置API。 一般来说，根据你的JBuilder配置，你也许需要将win32com.dll和javax.properties安装到相应的目录中，可以参照上述的目录。例如，如果你使用JBuilder附带的JVM的话，你也许需要将win32com.dll和javax.properties放到C:\Borland\JBuilder2006\jdk1.5的相应位置。 我使用的是JCreator，在打开Configure，然后点击option，选中jdk profile然后双击选中的jdk文件，选择edit，在弹出的窗口中选择串口通信包所在的文件（.jar文件），这样配置就算完成了。 以下分别是接收和发送程序，CSDN上搜的，省的自己写了：发送程序： import java.awt.*; import java.awt.event.*; import java.io.*; import java.util.*;
java串口通讯程序 1、下载java Communications api开发包。| 是Sun公司提供的，用于开发平台独立的通讯应用程序的扩展API。 2、将拷贝入C:\j2sdk1.4.2_04\bin 3、将拷贝入C:\j2sdk1.4.2_04\jre\lib\ext 4、将拷贝入C:\j2sdk1.4.2_04\jre\lib 5、编译文件 import .*; import .*; import .*; public class CommTest{ public static void main(String[] args){ SerialPort serialPort=null; DataOutputStream doutput=null; InputStream inputStream; CommPortIdentifier portId=null; String messageString="hello \n"; try{ portId=("COM1"); }catch(NoSuchPortException ne) { "ne"); (); } try{ serialPort=(SerialPort) ("TestComm", 5); OutputStream output = (); doutput=new DataOutputStream(output); inputStream = (); }catch(PortInUseException ex) { "ex"); (); }catch(IOException ie) { "ie"); (); //(); } try { (9600, , , ; } catch (UnsupportedCommOperationException e) {} } try { ()); } catch (IOException e) {}
Java串口通信编程指南
1. 概述 在java中，利用Java Communication包可以操作串口，但官方的包在3.0之后就只支持Linux和Solaris平台了，Windows平台的只支持到98年出的2.0版本，不过在XP下还能使用。另外，也可以用开源的Rxtx实现串口通信，这里仅以Java Communication包，在Windows 平台实现串口通信进行说明。 2. 前期准备 2.1. 下载Java Communication包 ?下载地址如下：https://www.doczj.com/doc/6616609563.html,/Jolt/javacomm20-win32.zip。 ?如果是非Windows平台，请到Sun网站选择其他版本下载。地址如下： https://www.doczj.com/doc/6616609563.html,/download/products.xml?id=43208d3d 2.2. 配置 ?解压缩javacomm20-win32.zip ?把win32com.dll拷贝到{JAVA_HOME}\jre\bin ?把comm.jar拷贝到{JAVA_HOME}\jre\lib\ext ?把https://www.doczj.com/doc/6616609563.html,m.properties拷贝到{JAVA_HOME}\jre\lib ?set CLASSPATH={JAVA_HOME}\jre \lib\ext \comm.jar;%classpath%
3. 实现过程 主要步骤包括： ?获得串口标识 ?打开串口 ?设置串行端口通讯参数 ?获取输入（出）流 ?进行读写操作 3.1. 获得串口标识 指定串口的端口号，生成串口的标识类的实例。 https://www.doczj.com/doc/6616609563.html,mPortIdentifier是通讯端口管理器，控制访问到通讯端口的中心类。一个应用程序首先使用CommPortIdentifier中的方法，通过相关的驱动去获取那些通讯端口是可用的并且选择一个端口便于开始。它包括如下功能： a. 通过驱动决定通讯端口是可用的。 b. 打开通讯端口为了I/O操作。 c. 决定端口的拥有者。 d. 解析端口拥有者的争夺。 e. 管理事件显示在端口拥有者的中的状态改变。 示例代码如下： 代码: 3.2. 打开串口 示例代码如下： 代码:
Java串口通信详解 序言 说到开源，恐怕很少有人不挑大指称赞。学生通过开源代码学到了知识，程序员通过开源类库获得了别人的成功经验及能够按时完成手头的工程，商家通过开源软件赚到了钱……，总之是皆大欢喜。然而开源软件或类库的首要缺点就是大多缺乏详细的说明文档和使用的例子，或者就是软件代码随便你用，就是文档，例子和后期服务收钱。这也难怪，毕竟就像某个著名NBA 球员说的那样：“我还要养家，所以千万美元以下的合同别找我谈，否则我宁可待业”。是啊，支持开源的人也要养家，收点钱也不过分。要想既不花钱又学到知识就只能借助网络和了，我只是想抛砖引玉，为开源事业做出点微薄共献，能为你的工程解决哪怕一个小问题，也就足够了。 虽然我的这个系列介绍的东西不是什么Web框架，也不是什么开源服务器，但是我相信，作为一个程序员，什么样的问题都会遇到。有时候越是简单的问题反而越棘手；越是小的地方就越是找不到称手的家伙。只要你不是整天只与“架构”、“构件”、“框架”打交道的话，相信我所说的东西你一定会用到。 1串口通信简介 1.1常见的Java串口包 1.2串口包的安装（Windows下） 2串口API概览 https://www.doczj.com/doc/6616609563.html,mPort https://www.doczj.com/doc/6616609563.html,mPortIdentifier https://www.doczj.com/doc/6616609563.html,m.SerialPort 2.4串口API实例 2.4.1列举出本机所有可用串口 2.4.2串口参数的配置 2.4.3串口的读写 3串口通信的通用模式及其问题 3.1事件监听模型 3.2串口读数据的线程模型 3.3第三种方法 4结束语 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，包含的东西如下所示：
Java串口通信编程指导 Java串口通信编程
概述 在java中，利用Java Communication包能够操作串口，但官方的包在3.0之后就只支持Linux和Solaris平台了，Windows平台的只支持到98年出的2.0版本，只是在XP下还能使用。另外，也能够用开源的Rxtx实现串口通信，那个地点仅以Java Communication包，在Windows平台实现串口通信进行讲明。 前期预备 下载Java Communication包 下载地址如下：https://www.doczj.com/doc/6616609563.html,/Jolt/javacomm20-win32.zip。 配置 解压缩javacomm20-win32.zip 把win32com.dll拷贝到{JA V A_HOME}\jre\bin 把comm.jar拷贝到{JA V A_HOME}\jre\lib\ext set CLASSPATH={JA V A_HOME}\jre \lib\ext \comm.jar;%classpath%
实现过程 要紧步骤包括： 获得串口标识 打开串口 设置串行端口通讯参数 猎取输入（出）流 进行读写操作 获得串口标识 指定串口的端口号，生成串口的标识类的实例。 a. 通过驱动决定通讯端口是可用的。 b. 打开通讯端口为了I/O操作。 c. 决定端口的拥有者。 d. 解析端口拥有者的争夺。 e. 治理事件显示在端口拥有者的中的状态改变。示例代码如下： 代码: 打开串口 示例代码如下： 代码:
5000（毫秒）是超时时刻。 设置串行端口通讯参数 设置串口传输的波特率、数据位、停止位、奇偶校验等参数。 示例代码如下： 代码: try { // 通信条件の設定 // 通信速度 9600 baud // データビット 8bit // ストップビット 1bit // パリティなし // フローコントロールの設定 // 無制御を使用 port.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE); } catch (UnsupportedCommOperationException ex) { ex.printStackTrace(); System.exit(1); } 猎取输入（出）流 利用getInputStream()以及getOutputStream()从每个串口产生对应的输入输出流对象。 示例代码如下： 代码:
一个通过java串口通信控制LED显示数据的实例 在很多应用程序中都需要用到pc机与外部设备如：嵌入式系统、传感器、开关 设备等进行数据通讯。其中，最常用的接口就是RS-232串口和并口。SUN的 CommAPI分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。 至于java串口通讯的配置以及通讯模式在sun的demo以及网上都有很多具体的 实例。 下面是我在开发一个叫号功能模块时通过串口通信来控制LED显示的实例，由于 第一次进行相关的开发，看似一个非常简单的功能在实际开发中却遇到了一些问 题，希望本人的解决方式能够对大家有所帮助，也希望大家能够提出更好的解决 方式。 先看一下LED显示屏厂商提供的通讯协议： ---遥控单双色、单双行、混合屏 一、每一次对任一特定地址发送信息由内码帧(7f/7e)，数码帧 (6f/6e)，定时帧(5f)，时间帧(4f)中的一种或多种构成，结束 时发送一结束帧。 二、帧结构：每帧由84字节构成。 1、内码帧：一幕由一起始帧和零或多个中间帧组成，一次 发送可有多幕。 1）起始帧：地址（1字节）＋帧控制7F（1字节） ＋幕号（1字节）+COMMAND（8字节） +内码/ASCII（73字节） 2）中间帧：地址（1字节）＋帧控制7E（1字节）＋ 幕号（1字节）+COMMAND（8字节）+内码/ASCII （73字节） 3）COMMAND： 前4字节未定义，后4字节依次为动画（0～4），移入及移出（各16种），速度（0～255），追加 （D3连续、D2停止、D0闪烁、D4时间、D6暂停、 D7动画） 4）内码/ASCII结构： a、内码4字节，依次为控制字节（D7宽体/正常体、D4绿色、D5红色、D3粗体、D2细体反白、D1 粗体反白、D0细体），内码高位，内码低位，未用 b、ASCII2字节，依次为控制字节（D7宽体/正常体、D5绿色、D4红色、D3粗体、D2细体反白、D1粗体 反白、D0细体），ASCII码 2、数码帧：由一起始帧和零或多中间帧组成。 1）起始帧：地址（1字节）＋帧控制6F（1字节）＋ 数据（82字节）
通过comm.jar等配置 如果用applet应用程序的话，下面这个函数是可以取到串口的，但是如果通过web应用程序（或者通过jsp调用）却取不到串口，而且也不会抛出异常，感觉很奇怪，特来请教！ CommPortIdentifier.getPortIdentifiers(); 同时目标机器的java运行环境也需要把w32comm.dll, comm.jar xxx.proper等放到相应的目录 就是用ibm的包而不用sun的comm包： ibm-javacomm-win32-x86.zip 只需要把comm驱动包这个类的装载更新一下即 https://www.doczj.com/doc/6616609563.html,/serialcomm.htm 利用Java实现串口全双工通讯 一个嵌入式系统通常需要通过串口与其主控系统进行全双工通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统。本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程。 本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java(用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序)。另外本类库还提供了一个例程SerialExample.java 作为示范。在下面的内容中将逐一对这几个部分进行详细介绍。 1. SerialBean SerialBean是本类库与其他应用程序的接口。该类库中定义了SerialBean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数。具体介绍如下： 本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定。PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推。 本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1，否则返回-1。初始化的结果是该串口被SerialBean独占性使用，其参数被设置为9600, N, 8, 1。如果串口被成功初始化，则打开一个进程读取从串口传入的数据并将其保存在缓冲区中。
小技巧：如何辨别TXD和RXD端口？ 搞电子的人手边应该常备一个电表，用来测测电压，电阻什么的会很有用。你只要分别测一下RS232端口的2--5或3--5针脚之间的电压，通常TXD针脚与GND之间会有 3~15V左右的负电压，表示它是TXD针脚。 安装JavaCommunicationsAPI Sun的J2SE中并没有直接提供以上提到的任何一种串行通讯协议的开发包，而是以独立的jar包形式发布在https://www.doczj.com/doc/6616609563.html,网站上(从这里下载)----即comm.jar，称之为Javatm CommunicationsAPI，它是J2SE的标准扩展。comm.jar并不是最近才有，早在1998年时，sun就已经发布了这个开发包。comm.jar分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。目前sun发布的comm.jar只有Windows和Solaris平台两个版本，如果你需要Linux平台下的，可以在 https://www.doczj.com/doc/6616609563.html,/~kevinh/linuxcomm.html找到。 在使用comm.jar之前，必须知道如何安装它。这也是困扰许多初学javaRS232通讯者的一个难题。如果我们电脑上安装了JDK,它将同时为我们安装一份JRE(Java RuntimeEntironment)，通常我们运行程序时都是以JRE来运行的。所以以下的安装适用于JRE。如果你是用JDK来运行程序的，请将相应的改成。 下载了comm.jar开发包后，与之一起的还有两个重要的文件，win32com.dll和https://www.doczj.com/doc/6616609563.html,m.properties。comm.jar提供了通讯用的javaAPI，而win32com.dll提供了供comm.jar调用的本地驱动接口。而https://www.doczj.com/doc/6616609563.html,m.properties是这个驱动的类配置文件。首先将comm.jar复制到\lib\ext目录。再将win21com.dll复制到你的RS232应用程序运行的目录，即user.dir。然后将https://www.doczj.com/doc/6616609563.html,m.properties复制到\lib目录。 通讯前的准备 如果你手头上没有现成的提供了标准RS232串口的设备，你可以将自己的电脑模拟成两台不同的串口设备。通常电脑主机后面的面板提供了两个9针的串口，请将这两个串口的2,3,5脚按前面介绍的方法连接。电子市场都有现成的连接头卖，请不要买那种封装的严严实实的接头，而要买用螺丝封装可以拆开的连接头，这样可以方便自己根据需要连接各 个针脚。 Comm API基础 我无意于在此详细描述Comm API每个类和接口的用法，但我会介绍CommAPI的 类结构和几个重要的API用法。 所有的comm API位于https://www.doczj.com/doc/6616609563.html,m包下面。从CommAPI的javadoc来看，它 介绍给我们的只有区区以下13个类或接口： https://www.doczj.com/doc/6616609563.html,mDriver https://www.doczj.com/doc/6616609563.html,mPort https://www.doczj.com/doc/6616609563.html,m.ParallelPort
java串口通信API说明 java串口通信 Java提供了 CommunicationAPI(包含于https://www.doczj.com/doc/6616609563.html,m包中)用于通过与机器无关的方式，控制各种外部设备。Communications API，是标准的Java的扩展部分，它在JavaAPI中是没有附带的。因此，必须先在SUN公司网站的Java站点(https://www.doczj.com/doc/6616609563.html,)上下载这个扩展类库。 1.1Communications API 简介 Communications API 的核心是抽象的CommPort类及其两个子类：SerialPort类和ParallePort类。其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。CommPort类还提供了常规的通信模式和方法，例如:getInputStream( )方法和getOutputStream( )方法，专用于与端口上的设备进行通信。 然而，这些类的构造方法都被有意的设置为非公有的(non-public)。所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表；再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open( )方法，这样，就能得到一个CommPort对象。当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备。该子类可以是SerialPort类和ParallePort类中的一个。下面将分别对CommPort类，CommPortIdentifier类，串口类SerialPort进行详细的介绍。
这是用Java编写的实现串口通信的程序源代码。至于支持串口通信的comm.jar 包，请各位从sun或别的网站处下载！这里只提供源码让大家参考。 gui.java算是一个框架；panel.java是面板，相当于前台；SerialCommunication.java是一个JavaBean，相当于后台。面板视图如下： 从串口中读入信息的机制如下：后台监测到有信息读入到缓存，就读取之，用一个字符串变量储存，并置“有新信息读入”的标识（相当于一个开关）为真。面板有一个计时器监听器，用轮询的方式查询后台的“有新信息读入”的标识是否为真，若为真则马上读入到前台，显示到文本框上，并置“有新信息读入”的标识为假（顺手关门）。 gui.java: import java.awt.*; import javax.swing.*; public class gui { public static void main(String[] args) { JFrame frame=new JFrame("密谈"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.getContentPane().add(new panel()); frame.pack(); frame.setVisible(true);
frame.setResizable(false); } } panel.java： import java.awt.*; import java.awt.event.*; import javax.swing.*; public class panel extends JPanel { String SB; JTextArea show; JTextField text; JButton submit,connect,stop; SerialCommunication port; Timer timer; JPanel write; JPanel read; public panel() { SB=new String(""); port=new SerialCommunication(1); timer=new Timer(100,new timeListener()); show=new JTextArea(20,25); show.setLineWrap(true); show.setAutoscrolls(true); text=new JTextField("",25); submit=new JButton("提交"); connect=new JButton("连接"); stop=new JButton("断开"); write=new JPanel(); read=new JPanel(); setLayout(new BoxLayout(this,BoxLayout.Y_AXIS)); submit.addActionListener(new submitListener()); connect.addActionListener(new connectListener()); stop.addActionListener(new stopListener()); write.setPreferredSize(new Dimension(300,70)); write.add(text); write.add(connect); write.add(submit); write.add(stop); write.setBackground(Color.CYAN);
java 串口通讯实例（转） 2010-01-28 12:33 java串口通讯 最近在搞C的串口通讯，C里面没有线程的概念，所以C对串口的读写只能在一个进程里面，这样 如果串口的缓存有问题，就会导致报告丢失（正好是我们遇到的），我们来看看支持线程的java是如何来解决这个问题的。 本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程。 本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java (用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序)。另外本类库还提供了一个例程SerialExample.java 作为示范。在下面的内容中将逐一对这几个部分进行详细介绍。 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() 本函数停止串口检测进程并关闭串口。 SerialBean的源代码如下： package serial; import java.io.*; import java.util.*; import https://www.doczj.com/doc/6616609563.html,m.*; /** *
java串口API java串口API Java提供了CommunicationAPI(包含于https://www.doczj.com/doc/6616609563.html,m包中)用于通过与机器无关的方式，控制各种外部设备。Communications API，是标准的Java的扩展部分，它在JavaAPI中是没有附带的。因此，必须先在SUN公司网站的Java站点(https://www.doczj.com/doc/6616609563.html,)上下载这个扩展类库。 1.1Communications API简介 Communications API的核心是抽象的CommPort类及其两个子类：SerialPort类和ParallePort类。其中，SerialPort类是用于串口通信的类，ParallePort类是用于并行口通信的类。CommPort类还提供了常规的通信模式和方法，例如:getInputStream()方法和getOutputStream()方法，专用于与端口上的设备进行通信。 然而，这些类的构造方法都被有意的设置为非公有的(non-public)。所以，不能直接构造对象，而是先通过静态的CommPortIdentifer.getPortIdentifiers()获得端口列表；再从这个端口列表中选择所需要的端口，并调用CommPortIdentifer对象的Open()方法，这样，就能得到一个CommPort对象。当然，还要将这个CommPort对象的类型转换为某个非抽象的子类，表明是特定的通讯设备。该子类可以是SerialPort类和ParallePort类中的一个。下面将分别对CommPort类，CommPortIdentifier类，串口类SerialPort进行详细的介绍。 1.2CommPortIdentifier类 CommPortIdentifier类的方法如下： 方法说明 addPortName(String,int,CommDriver)添加端口名到端口列表里addPortOwnershipListener(CommPortOwnershipListener)添加端口拥有的监听器removePortOwnershipListener(CommPortOwnershipListener)移除端口拥有的监听器getCurrentOwner()得到当前占有端口的对象或应用程序 getName()得到端口名称 getPortIdentifier(CommPort)得到参数打开的端口的CommPortIdentifier类型对象getPortIdentifier(String)得到以参数命名的端口的CommPortIdentifier类型对象getPortIdentifiers()得到系统中的端口列表 getPortType()得到端口的类型 isCurrentlyOwned()判断当前端口是否被占用 open(FileDescriptor)用文件描述的类型打开端口 open(String,int)打开端口,两个参数：程序名称,延迟时间(毫秒数) 1.3SerialPort类 SerialPort关于串口参数的静态成员变量 成员变量说明成员变量说明成员变量说明 DATABITS_5数据位为5STOPBITS_2停止位为2PARITY_ODD奇检验
Win32 串口编程（一）(2009-08-16 16:28:13) 标签：串口重叠i/o 分类：Windows 翻译自：ms-help://MS.MSDNQTR.v80.chs/MS.MSDN.v80/MS.WIN32COM.v10.en/dnfiles/html/msdn_s erial.htm 老外写的文章，虽比较全面，但很啰嗦，不如看各个函数的文档来得快。为方便以后查阅，列出本文涉及的主要函数如下： CreateFile、ReadFile、WriteFile、GetOverlappedResult、WaitForSingleObject SetCommMask、WaitCommEvent ClearCommError、GetCommModemStatus、EscapeCommFunction GetCommState、BuildCommDCB、SetCommState、SetCommTimeouts 此外，新浪的博客系统限制文章最大长度为40000字节，只好把这篇文章分成几部分了。 0 简介 本文仅关注在Windows NT和95间兼容的API。Windows 95支持Telephony API(TAPI)，但Windows NT 3.x不支持TAPI，所以本文不讨论它。 本文的示例程序MTTTY(Multithreaded TTY)使用了三个线程：一个进行内存管理的界面线程；控制所有写入操作的写入者线程；读取数据和处理端口状态改变的读取/状态线程。示例采用了一些不同的堆来进行内存管理；还大量使用了同步方法来进行线程间通信。 1 打开端口 使用CreateFile函数打开端口。打开端口时有两种方法：重叠的和非重叠的。下列代码片段以重叠方式打开端口： HANDLE hComm; hComm = CreateFile( gszPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0); if (hComm == INV ALID_HANDLE_V ALUE) // error opening port; abort Win32 串口编程（二）(2009-08-16 16:39:32) 标签：串口重叠i/o it 分类：Windows 3 串口状态 有两种获取通信端口状态的方法。第一种方法是设置事件掩码，当指定事件发生时应用程序会收到通知。SetCommMask函数用于设置事件掩码，WaitCommEvent用于等待指定的事件发生。它们与16位Windows中的SetCommEventMask和EnableCommNotification类似，只是它们不发送WM_COMMNOTIFY消息。第二种方法是不时地调用另一些状态函数来获取通信端口的状态。当然，轮询是低效的，不建议使用。 3.1 通信事件 通信事件在使用通信端口时可能随时发生。接收通信事件需要两个步骤： 用SetCommMask设定需要接收通知的事件
java 串口通讯程序 1、下载java Communications api 开发包。| https://www.doczj.com/doc/6616609563.html,m是Sun公司提供的，用于开发平台独立的通讯应用程序的扩展 API 。 2、将win32com.dll 拷贝入C:\j2sdk1.4.2_04\bin 3、将comm.jar 拷贝入C:\j2sdk1.4.2_04\jre\lib\ext 4、将https://www.doczj.com/doc/6616609563.html,m.properties 拷贝入C:\j2sdk1.4.2_04\jre\lib 5、编译CommTest.java 文件 import java.io.*; import java.util.*; import https://www.doczj.com/doc/6616609563.html,m.*; public class CommTest{ public static void main(String[] args){ SerialPort serialPort=null; DataOutputStream doutput=null; InputStream inputStream; CommPortIdentifier portId=null; String messageString="hello \n"; try{ portId=CommPortIdentifier.getPortIdentifier("COM1"); }catch(NoSuchPortException ne) { System.out.println("ne"); ne.printStackTrace(); } try{ serialPort=(SerialPort) portId.open("TestComm", 5); OutputStream output = serialPort.getOutputStream(); doutput=new DataOutputStream(output); inputStream = serialPort.getInputStream(); }catch(PortInUseException ex) { System.out.println("ex"); ex.printStackTrace(); }catch(IOException ie) { System.out.println("ie"); ie.printStackTrace(); //serialPort.close(); } try { serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); } catch (UnsupportedCommOperationException e) {} } try { doutput.write(messageString.getBytes()); } catch (lOException e) {} } 6、串口打开后，用InputStream和DataOutputStream读写就可以了。 7、由于串口为共享资源，所以在设计程序时应采用单例模式。 8、A PI 在https://www.doczj.com/doc/6616609563.html,m下有13个类和接口，分别是
利用java实现串口全双工通讯 (投稿) qingye jiang (john) smth id: qyjohn e-mail : qjiang@https://www.doczj.com/doc/6616609563.html, 一个嵌入式系统通常需要通过串口与其主控系统进行全双工通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统。本文介绍了一个简单的通过串口实现全双工通讯的java类库，该类库大大的简化了对串口进行操作的过程。 本类库主要包括：serialbean.java (与其他应用程序的接口), serialbuffer.java (用来保存从串口所接收数据的缓冲区), readserial.java (从串口读取数据的程序)。另外本类库还提供了一个例程serialexample.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() 本函数停止串口检测进程并关闭串口。
Java串口通信 1.Java串口通信实现 在Java中，利用Java Communication API可以操作计算机的串口，Jar包的名称为comm.jar，但是这个包只合适于Windows平台的操作系统，其它的操作系统需要其它的Jar包。Comm.jar包由Sun公司发布，分别提供了对常用的RS232串行端口和IEEE1284并行端口通信的支持。Java Communication API和环境变量配置所需要的文件我已经打包后放在同文档的目录下，名称为：javacomm20-win32.zip。 1.1.通信前的准备工作 在实现与计算机串口通信之前，需要对Java作一些相应的环境变量配置，配置步骤很简单，只需三步即可完成。 win32com.dll拷贝到{JAVA_HOME}\jre\bin 把comm.jar拷贝到{JAVA_HOME}\jre\lib 把https://www.doczj.com/doc/6616609563.html,m.properties拷贝到{JA V A_HOME}\jre\lib 说明：为什么这些文件都是放到jre路径下呢？这是因为通常运行“Java MyApp” 的时候，都是由JRE下的虚拟机启动的。只有放在“这里”，虚拟机才能顺利的找到相应的文件，不然可能会提示找不到串口的错误信息。 1.2.Java Communication API的大概认识 这里没有详细描述CommAPI每个类和接口的用法，只介绍案例代码中有用到的主要类和接口的用法，这也是CommAPI最基础的类结构。下面截图是CommAPI的所有类：
https://www.doczj.com/doc/6616609563.html,mPort 这是用于描述被底层系统支持的端口的抽象类，通常常用的端口有串口和并口，该抽象类包含了IO的控制方法，这些方法对于所有不同的通信端口来说都是通用的。 SerialPort和ParallelPort是它的两个子类，分别表示串口和并口。两都对于各自底层的物理端口有着不同的控制方法。这里暂时只关注SerialPort类。 https://www.doczj.com/doc/6616609563.html,mPortIdentifier 这个类主要用于对串口进行管理和设置，是对串口进行访问控制的核心类。常用的方法有： ◆确定是否有可用的通信端口 ◆为IO操作打开通信端口 ◆决定端口的所有权 ◆处理端口所有权的争用 ◆管理端口通信引发的事件(Event) https://www.doczj.com/doc/6616609563.html,m.SerialPort 这个类描述了RS-232串口通信端口的底层类，它定义了串口通信所需要的基本功能。例如，通过它，用户可以直接对串口进行读、写及参数设置的工作。一个SerialPort 对象对应着一个端口。 1.3.串口通信的实现过程 串口通信的主要步骤包括： ◆获得串口标识 ◆打开串口 ◆设置串行端口通讯参数 ◆获取输入（出）流 ◆进行读写操作