java串口的监听
源博客： http://blog.csdn.net/u013363811/article/details/44225303
Java对串口编程的API包
目前比较常见的针对Java的串口包有3个来源：一是1998年SUN发布的串口通信API：comm2.0.jar（Windows环境下）和comm3.0.jar（Linux/Solaris环境下）；二是IBM的串口通信API；三是一些开源的API。本文介绍的是在Windows环境下使用java语言对串口进行编程，所以选取SUN的官方API（comm2.0.jar）。comm2.0.jar和comm3.0.jar的下载地址如下：
comm2.0.jar：http://pan.baidu.com/s/1pJKBOcN
comm3.0.jar：http://pan.baidu.com/s/1o6wrpwA
对串口编程的环境搭建
软件环境搭建
在本文写作时，本人所使用的软件开发环境为：Windows7，Jdk1.6.0_10，Eclipse3.4.1。Java对串口编程的环境搭建分为以下步骤：
1.下载并安装jdk，本人jdk的根目录是“D:\ProgramFiles\Java\jdk1.6.0_10”，在接下来的文章中路径“D:\ProgramFiles\Java\jdk1.6.0_10”将使用“%JAVA_HOME%”来代替；
2.下载comm2.0.jar（下载链接见上文）并将串口编程必须的3个文件拷贝到jdk对应的文件夹中：
2.1.将win32com.dll文件拷贝到“%JAVA_HOME%\bin”以及“%JAVA_HOME%\jre\bin”目录下
2.2 将comm.jar文件拷贝到“%JAVA_HOME%\lib”以及“%JAVA_HOME%\jre\lib\ext”目录下
2.3 将javax.comm.properties文件拷贝到“%JAVA_HOME%\lib”以及“%JAVA_HOME%\jre\lib”下
3 新建工程并将comm.jar添加到工程文件中：
3.1 新建java工程serialPortProgramming，并将该工程的运行时环境（JRE）指定为步骤1中新安装的jdk。
3.2 在工程中新建“lib”文件夹，并将comm.jar文件拷贝到该文件夹下，右键点击该文件选择【Build Path】—【Add to Build Path】。
“硬件” 环境准备
Java对串口编程，首先设备上需要有串口（这不废话吗），但如今的大多数电脑主板上并不带串口，所以本人用Virtual Serial Port Driver软件虚拟出一对串口COM11和COM21，以方便文章的写作和实验的进行。
下载Virtual Serial Port Driver7.1（http://pan.baidu.com/s/1qW6wCsW）并安装，使用压缩包中的“vspdctl.dll”文件替换软件安装根目录中的“vspdctl.dll”文件即可完成破解。安装Virtual Serial Port Driver之后用该软件创建一对端口（COM11和COM21），在此创建的一对串口将在之后的实验中再次使用到。因为串口COM11和COM21是通过软件虚拟的、相互连接的一对串口，所以从COM11发送的数据COM21会接收到，反之亦然。
当然如果自己的设备上有串口的话也可以不用创建虚拟串口，只需要将一个串口的数据发送引脚（引脚3，如图 2所示）和另一个串口的数据接收引脚（引脚2）使用一根铜线链接即可实现数据的收发。如果设备上只有一个串口，要实现串口数据的收发，可以将串口的引脚2和引脚3使用铜线相连接，这样从本串口发送的数据就会通过本串口接收到。
实例一：获取本地串口并实现打开与关闭
在上文创建好的工程中新建包“com.serialPort.writer”并新建类OpenerAndCloser，该类实现串口的获取、打开与关闭。
OpenerAndCloser.java
package com.serialPort.writer;
import java.util.Enumeration;
import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
import javax.comm.UnsupportedCommOperationException;
/**
* 该类实现3个功能
* 1.列举出本地所有的串口;
* 2.打开所有串口(但是未向串口中写数据);
* 3.关闭打开的串口。
*/
public class OpenerAndCloser {
public static void main(String[] args){
//1.获取本地所有的端口并输出其名称：
//1.1.用于标识端口的变量
CommPortIdentifier portIdentifier = null;
//1.2.记录所有端口的变量
Enumeration allPorts
= CommPortIdentifier.getPortIdentifiers();
//1.3.输出每一个端口
while(allPorts.hasMoreElements()){
portIdentifier
= (CommPortIdentifier) allPorts.nextElement();
System.out.println("串口：" + portIdentifier.getName());
}
//2.打开COM11和COM21端口
//2.1.获取两个端口
CommPortIdentifier com11 = null;
CommPortIdentifier com21 = null;
try {
com11 = CommPortIdentifier.getPortIdentifier("COM11");
com21 = CommPortIdentifier.getPortIdentifier("COM21");
} catch (NoSuchPortException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//2.2.打开两个端口，但是什么都没干
SerialPort serialCom11 = null;
SerialPort serialCom21 = null;
try {
//open方法的第1个参数表示串口被打开后的所有者名称，
//第2个参数表示如果串口被占用的时候本程序的最长等待时间，以毫秒为单位。
serialCom11
= (SerialPort)com11.open("OpenerAndCloser", 1000);
serialCom21
= (SerialPort)com21.open("OpenerAndCloser", 1000);
} catch (PortInUseException e) {
//要打开的端口被占用时抛出该异常
e.printStackTrace();
}
//2.3.设置两个端口的参数
try {
serialCom11.setSerialPortParams(
9600, //波特率
SerialPort.DATABITS_8,//数据位数
SerialPort.STOPBITS_1,//停止位
SerialPort.PARITY_NONE//奇偶位
);
serialCom21.setSerialPortParams(
9600, //波特率
SerialPort.DATABITS_8,//数据位数
SerialPort.STOPBITS_1,//停止位
SerialPort.PARITY_NONE//奇偶位
);
} catch (UnsupportedCommOperationException e) {
e.printStackTrace();
}
//3.关闭COM11和COM21端口
//关闭端口的方法在SerialPort类中
serialCom11.close();
serialCom21.close();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
在以上的代码中，有两个较为重要的类，在此做以说明，它们是类CommPortIdentifier和类SerialPort。这两个类都来自于comm.jar，CommPortIdentifier类代表本地串口，可以通过该类的静态方法getPortIdentifier或getPortIdentifiers获取本地的串口，该类的实例方法open用于打开串口。SerialPort类同样代表本地串口，不过其代表的是打开的串口，可以通过该类的实例方法close关闭已经打开的串口，也可以通过该类的实例方法获取串口的输入输出流，实现往串口数据的读写操作。
执行Com11Writer类的main方法，就会发现控制台输出了本地机器的所有串口（包括虚拟串口和物理串口）。
实例二：串口数据的读写
向串口写数据
在包“com.serialPort.writer”下新建Com11Writer类，该类实现往COM11写入数据“Hello World!”的功能，向串口COM11写入的数据会发送到与其相连的另一个串口COM21，并被COM21所接收，从串口接收数据的方式将在下文讲到，以下是Com11Writer的源代码：
Com11Writer.java
package com.serialPort.writer;
import java.io.IOException;
import java.io.OutputStream;
import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
/**
* Com11Writer类的功能是向COM11串口发送字符串“Hello World!”
*/
public class Com11Writer {
public static void main(String[] args) {
//1.定义变量
CommPortIdentifier com11 = null;//用于记录本地串口
SerialPort serialCom11 = null;//用于标识打开的串口
try {
//2.获取COM11口
com11 = CommPortIdentifier.getPortIdentifier("COM11");
//3.打开COM11
serialCom11 = (SerialPort) com11.open("Com11Writer", 1000);
//4.往串口写数据（使用串口对应的输出流对象）
//4.1.获取串口的输出流对象
OutputStream outputStream = serialCom11.getOutputStream();
//4.2.通过串口的输出流向串口写数据“Hello World!”：
//使用输出流往串口写数据的时候必须将数据转换为byte数组格式或int格式，
//当另一个串口接收到数据之后再根据双方约定的规则，对数据进行解码。
outputStream.write(new byte[]{'H','e','l','l','o',
' ','W','o','r','l','d','!'});
outputStream.flush();
//4.3.关闭输出流
outputStream.close();
//5.关闭串口
serialCom11.close();
} catch (NoSuchPortException e) {
//找不到串口的情况下抛出该异常
e.printStackTrace();
} catch (PortInUseException e) {
//如果因为端口被占用而导致打开失败，则抛出该异常
e.printStackTrace();
} catch (IOException e) {
//如果获取输出流失败，则抛出该异常
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
从串口读数据
从串口COM11发送的数据最终将到达与其连通的串口COM21，如果COM21处于可用状态，则到达的数据将被缓存，等待程序的读取。从串口读入数据有多种模式，本文将介绍“轮询模式”和事件监听模式。
“轮询模式”是指程序（线程）每隔固定的时间就对串口进行一次扫描，如果扫描发现串口中有可用数据，则进行读取。Com21PollingListener类使用“事件监听模式”读取串口COM21接收到的数据：
Com21PollingListener.java
package com.serialPort.listener;
import java.io.IOException;
import java.io.InputStream;
import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
/**
* Com21PollingListener类使用“轮训”的方法监听串口COM21，
* 并通过COM21的输入流对象来获取该端口接收到的数据（在本文中数据来自串口COM11）。
*/
public class Com21PollingListener {
public static void main(String[] args){
//1.定义变量
CommPortIdentifier com21 = null;//未打卡的端口
SerialPort serialCom21 = null;//打开的端口
InputStream inputStream = null;//端口输入流
try{
//2.获取并打开串口COM21
com21 = CommPortIdentifier.getPortIdentifier("COM21");
serialCom21 = (SerialPort) com21.open("Com21Listener", 1000);
//3.获取串口的输入流对象
inputStream = serialCom21.getInputStream();
//4.从串口读入数据
//定义用于缓存读入数据的数组
byte[] cache = new byte[1024];
//记录已经到达串口COM21且未被读取的数据的字节（Byte）数。
int availableBytes = 0;
//无限循环，每隔20毫秒对串口COM21进行一次扫描，检查是否有数据到达
while(true){
//获取串口COM21收到的可用字节数
availableBytes = inputStream.available();
//如果可用字节数大于零则开始循环并获取数据
while(availableBytes > 0){
//从串口的输入流对象中读入数据并将数据存放到缓存数组中
inputStream.read(cache);
//将获取到的数据进行转码并输出
for(int j = 0;j < cache.length && j < availableBytes; j++){
//因为COM11口发送的是使用byte数组表示的字符串，
//所以在此将接收到的每个字节的数据都强制装换为char对象即可，
//这是一个简单的编码转换，读者可以根据需要进行更加复杂的编码转换。
System.out.print((char)cache[j]);
}
System.out.println();
//更新循环条件
availableBytes = inputStream.available();
}
//让线程睡眠20毫秒
Thread.sleep(20);
}
}catch(InterruptedException e){
e.printStackTrace();
}catch (NoSuchPortException e) {
//找不到串口的情况下抛出该异常
e.printStackTrace();
} catch (PortInUseException e) {
//如果因为端口被占用而导致打开失败，则抛出该异常
e.printStackTrace();
} catch (IOException e) {
//如果获取输出流失败，则抛出该异常
e.printStackTrace();
}
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
“事件监听模式”是为串口注册一个事件监听类，当有数据到达串口的时候就会触发事件，在事件的响应方法中读取串口接收到的数据。Com21EventListener类使用“事件监听模式”读取串口COM21接收到的数据：
Com21EventListener.java
package com.serialPort.listener;
import java.io.IOException;
import java.io.InputStream;
import java.util.TooManyListenersException;
import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
/**
* Com21EventListener类使用“事件监听模式”监听串口COM21，
* 并通过COM21的输入流对象来获取该端口接收到的数据（在本文中数据来自串口COM11）。
* 使用“事件监听模式”监听串口，必须字定义一个事件监听类，该类实现SerialPortEventListener
* 接口并重写serialEvent方法，在serialEvent方法中编写监听逻辑。
*/
public class Com21EventListener implements SerialPortEventListener {
//1.定义变量
CommPortIdentifier com21 = null;//未打卡的端口
SerialPort serialCom21 = null;//打开的端口
InputStream inputStream = null;//输入流
//2.构造函数：
//实现初始化动作：获取串口COM21、打开串口、获取串口输入流对象、为串口添加事件监听对象
public Com21EventListener(){
try {
//获取串口、打开窗串口、获取串口的输入流。
com21 = CommPortIdentifier.getPortIdentifier("COM21");
serialCom21 = (SerialPort) com21.open("Com21EventListener", 1000);
inputStream = serialCom21.getInputStream();
//向串口添加事件监听对象。
serialCom21.addEventListener(this);
//设置当端口有可用数据时触发事件，此设置必不可少。
serialCom21.notifyOnDataAvailable(true);
} catch (NoSuchPortException e) {
e.printStackTrace();
} catch (PortInUseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (TooManyListenersException e) {
e.printStackTrace();
}
}
//重写继承的监听器方法
@Override
public void serialEvent(SerialPortEvent event) {
//定义用于缓存读入数据的数组
byte[] cache = new byte[1024];
//记录已经到达串口COM21且未被读取的数据的字节（Byte）数。
int availableBytes = 0;
//如果是数据可用的时间发送，则进行数据的读写
if(event.getEventType() == SerialPortEvent.DATA_AVAILABLE){
try {
availableBytes = inputStream.available();
while(availableBytes > 0){
inputStream.read(cache);
for(int i = 0; i < cache.length && i < availableBytes; i++){
//解码并输出数据
System.out.print((char)cache[i]);
}
availableBytes = inputStream.available();
}
System.out.println();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//在main方法中创建类的实例
public static void main(String[] args) {
new Com21EventListener();
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
读写程序的联合运行
串口能接收到数据的前提是该串口处于打开（可用）状态，如果串口处于关闭状态，那么发送到该串口的数据就会丢失。所以在实验的过程中，如果使用铜线连接同一个串口的引脚2和引脚3，一定要注意的是千万不能在向串口发送完数据之后关闭该串口，然后再次打开串口去读取数据，一定要让串口始终处于打开状态直到程序运行结束。
基于以上的说明，在本文所涉及到的实例中，首先运行Com21PollingListener类（或Com21EventListener类）中的main方法打开端口监听程序，然后再运行Com11Writer类的main方法通过COM11向COM21发送数据，这样程序就能从COM21读取数据。
参考与鸣谢
在本文写作的过程中参考了很多网络资源，其中参考了如下几篇文章，在此对所有作者的无私奉献表示衷心的感谢。
http://blog.csdn.net/luoduyu/article/details/2182321
http://www.cnblogs.com/dyufei/archive/2010/09/19/2573913.html
http://www.cnblogs.com/dyufei/archive/2010/09/19/2573912.html
http://www.cnblogs.com/dyufei/archive/2010/09/19/2573911.html
本文实例的源工程文件可以从以下链接获取：http://pan.baidu.com/s/1qW0Xc3E