1.写在前面
距离上一篇文章《使用Java实现串口通信》已经过去快两年的时间了，在此期间收到了很多读者的反馈，很高兴可以帮助到这么多人，根据收到的反馈，我对代码逻辑进行了优化整理，并增加了一些新功能，在此记录下，分享给大家。
先看下效果：
串口通信
2.环境搭建
本文的串口通信开发基于RXTX，所以需要引用一些RXTX的依赖包：
拷贝 RXTXcomm.jar 到 JAVA_HOME\jre\lib\ext目录中；
拷贝 rxtxSerial.dll 到 JAVA_HOME\jre\bin目录中；
拷贝 rxtxParallel.dll 到 JAVA_HOME\jre\bin目录中；
JAVA_HOME为jdk安装路径
注意：有同学遇到运行程序，报找不到main方法的错误，检查一下依赖包拷贝的路径是否正确，jdk安装后会生成两个jre目录，需要拷贝到jdk > jre目录下。
3.串口通信管理
SerialPortManager实现了对串口通信的管理，包括查找可用端口、打开|关闭串口、发送|接收数据。
package com.yang.serialport.manager;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import com.yang.serialport.utils.ArrayUtils;
import com.yang.serialport.utils.ShowUtils;
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
/**
* 串口管理
*
* @author yangle
*/
@SuppressWarnings("all")
public class SerialPortManager {
/**
* 查找所有可用端口
*
* @return 可用端口名称列表
*/
public static final ArrayList<String> findPorts() {
// 获得当前所有可用串口
Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
ArrayList<String> portNameList = new ArrayList<String>();
// 将可用串口名添加到List并返回该List
while (portList.hasMoreElements()) {
String portName = portList.nextElement().getName();
portNameList.add(portName);
}
return portNameList;
}
/**
* 打开串口
*
* @param portName
* 端口名称
* @param baudrate
* 波特率
* @return 串口对象
* @throws PortInUseException
* 串口已被占用
*/
public static final SerialPort openPort(String portName, int baudrate) throws PortInUseException {
try {
// 通过端口名识别端口
CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
// 打开端口，并给端口名字和一个timeout（打开操作的超时时间）
CommPort commPort = portIdentifier.open(portName, 2000);
// 判断是不是串口
if (commPort instanceof SerialPort) {
SerialPort serialPort = (SerialPort) commPort;
try {
// 设置一下串口的波特率等参数
// 数据位：8
// 停止位：1
// 校验位：None
serialPort.setSerialPortParams(baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e) {
e.printStackTrace();
}
return serialPort;
}
} catch (NoSuchPortException e1) {
e1.printStackTrace();
}
return null;
}
/**
* 关闭串口
*
* @param serialport
* 待关闭的串口对象
*/
public static void closePort(SerialPort serialPort) {
if (serialPort != null) {
serialPort.close();
}
}
/**
* 往串口发送数据
*
* @param serialPort
* 串口对象
* @param order
* 待发送数据
*/
public static void sendToPort(SerialPort serialPort, byte[] order) {
OutputStream out = null;
try {
out = serialPort.getOutputStream();
out.write(order);
out.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();
out = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 从串口读取数据
*
* @param serialPort
* 当前已建立连接的SerialPort对象
* @return 读取到的数据
*/
public static byte[] readFromPort(SerialPort serialPort) {
InputStream in = null;
byte[] bytes = {};
try {
in = serialPort.getInputStream();
// 缓冲区大小为一个字节
byte[] readBuffer = new byte[1];
int bytesNum = in.read(readBuffer);
while (bytesNum > 0) {
bytes = ArrayUtils.concat(bytes, readBuffer);
bytesNum = in.read(readBuffer);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (in != null) {
in.close();
in = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
return bytes;
}
/**
* 添加监听器
*
* @param port
* 串口对象
* @param listener
* 串口存在有效数据监听
*/
public static void addListener(SerialPort serialPort, DataAvailableListener listener) {
try {
// 给串口添加监听器
serialPort.addEventListener(new SerialPortListener(listener));
// 设置当有数据到达时唤醒监听接收线程
serialPort.notifyOnDataAvailable(true);
// 设置当通信中断时唤醒中断线程
serialPort.notifyOnBreakInterrupt(true);
} catch (TooManyListenersException e) {
e.printStackTrace();
}
}
/**
* 串口监听
*/
public static class SerialPortListener implements SerialPortEventListener {
private DataAvailableListener mDataAvailableListener;
public SerialPortListener(DataAvailableListener mDataAvailableListener) {
this.mDataAvailableListener = mDataAvailableListener;
}
public void serialEvent(SerialPortEvent serialPortEvent) {
switch (serialPortEvent.getEventType()) {
case SerialPortEvent.DATA_AVAILABLE: // 1.串口存在有效数据
if (mDataAvailableListener != null) {
mDataAvailableListener.dataAvailable();
}
break;
case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2.输出缓冲区已清空
break;
case SerialPortEvent.CTS: // 3.清除待发送数据
break;
case SerialPortEvent.DSR: // 4.待发送数据准备好了
break;
case SerialPortEvent.RI: // 5.振铃指示
break;
case SerialPortEvent.CD: // 6.载波检测
break;
case SerialPortEvent.OE: // 7.溢位（溢出）错误
break;
case SerialPortEvent.PE: // 8.奇偶校验错误
break;
case SerialPortEvent.FE: // 9.帧错误
break;
case SerialPortEvent.BI: // 10.通讯中断
ShowUtils.errorMessage("与串口设备通讯中断");
break;
default:
break;
}
}
}
/**
* 串口存在有效数据监听
*/
public interface DataAvailableListener {
/**
* 串口存在有效数据
*/
void dataAvailable();
}
}
主要看下readFromPort方法，上一版的readFromPort方法是通过InputStream中的available方法来判断当前缓冲区中有没有数据的，而available方法返回的是没有被阻断的字节数（已经被缓冲的内容），这就可能会导致接收到的数据不完整。
修改后的readFromPort方法中使用了read方法来判断当前缓冲区中有没有数据，然后把读取到的数据拼接到一起显示，方法中我把每次读取的大小设置成了1个字节，这个可以根据实际需求修改：
/**
* 从串口读取数据
*
* @param serialPort
* 当前已建立连接的SerialPort对象
* @return 读取到的数据
*/
public static byte[] readFromPort(SerialPort serialPort) {
InputStream in = null;
byte[] bytes = {};
try {
in = serialPort.getInputStream();
// 缓冲区大小为一个字节
byte[] readBuffer = new byte[1];
int bytesNum = in.read(readBuffer);
while (bytesNum > 0) {
bytes = ArrayUtils.concat(bytes, readBuffer);
bytesNum = in.read(readBuffer);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (in != null) {
in.close();
in = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
return bytes;
}
4.程序主窗口
package com.yang.serialport.ui;
import java.awt.Color;
import java.awt.GraphicsEnvironment;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import com.yang.serialport.manager.SerialPortManager;
import com.yang.serialport.utils.ByteUtils;
import com.yang.serialport.utils.ShowUtils;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
/**
* 主界面
*
* @author yangle
*/
@SuppressWarnings("all")
public class MainFrame extends JFrame {
// 程序界面宽度
public final int WIDTH = 530;
// 程序界面高度
public final int HEIGHT = 390;
// 数据显示区
private JTextArea mDataView = new JTextArea();
private JScrollPane mScrollDataView = new JScrollPane(mDataView);
// 串口设置面板
private JPanel mSerialPortPanel = new JPanel();
private JLabel mSerialPortLabel = new JLabel("串口");
private JLabel mBaudrateLabel = new JLabel("波特率");
private JComboBox mCommChoice = new JComboBox();
private JComboBox mBaudrateChoice = new JComboBox();
private ButtonGroup mDataChoice = new ButtonGroup();
private JRadioButton mDataASCIIChoice = new JRadioButton("ASCII", true);
private JRadioButton mDataHexChoice = new JRadioButton("Hex");
// 操作面板
private JPanel mOperatePanel = new JPanel();
private JTextArea mDataInput = new JTextArea();
private JButton mSerialPortOperate = new JButton("打开串口");
private JButton mSendData = new JButton("发送数据");
// 串口列表
private List<String> mCommList = null;
// 串口对象
private SerialPort mSerialport;
public MainFrame() {
initView();
initComponents();
actionListener();
initData();
}
/**
* 初始化窗口
*/
private void initView() {
// 关闭程序
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
// 禁止窗口最大化
setResizable(false);
// 设置程序窗口居中显示
Point p = GraphicsEnvironment.getLocalGraphicsEnvironment().getCenterPoint();
setBounds(p.x - WIDTH / 2, p.y - HEIGHT / 2, WIDTH, HEIGHT);
this.setLayout(null);
setTitle("串口通信");
}
/**
* 初始化控件
*/
private void initComponents() {
// 数据显示
mDataView.setFocusable(false);
mScrollDataView.setBounds(10, 10, 505, 200);
add(mScrollDataView);
// 串口设置
mSerialPortPanel.setBorder(BorderFactory.createTitledBorder("串口设置"));
mSerialPortPanel.setBounds(10, 220, 170, 130);
mSerialPortPanel.setLayout(null);
add(mSerialPortPanel);
mSerialPortLabel.setForeground(Color.gray);
mSerialPortLabel.setBounds(10, 25, 40, 20);
mSerialPortPanel.add(mSerialPortLabel);
mCommChoice.setFocusable(false);
mCommChoice.setBounds(60, 25, 100, 20);
mSerialPortPanel.add(mCommChoice);
mBaudrateLabel.setForeground(Color.gray);
mBaudrateLabel.setBounds(10, 60, 40, 20);
mSerialPortPanel.add(mBaudrateLabel);
mBaudrateChoice.setFocusable(false);
mBaudrateChoice.setBounds(60, 60, 100, 20);
mSerialPortPanel.add(mBaudrateChoice);
mDataASCIIChoice.setBounds(20, 95, 55, 20);
mDataHexChoice.setBounds(95, 95, 55, 20);
mDataChoice.add(mDataASCIIChoice);
mDataChoice.add(mDataHexChoice);
mSerialPortPanel.add(mDataASCIIChoice);
mSerialPortPanel.add(mDataHexChoice);
// 操作
mOperatePanel.setBorder(BorderFactory.createTitledBorder("操作"));
mOperatePanel.setBounds(200, 220, 315, 130);
mOperatePanel.setLayout(null);
add(mOperatePanel);
mDataInput.setBounds(25, 25, 265, 50);
mDataInput.setLineWrap(true);
mDataInput.setWrapStyleWord(true);
mOperatePanel.add(mDataInput);
mSerialPortOperate.setFocusable(false);
mSerialPortOperate.setBounds(45, 95, 90, 20);
mOperatePanel.add(mSerialPortOperate);
mSendData.setFocusable(false);
mSendData.setBounds(180, 95, 90, 20);
mOperatePanel.add(mSendData);
}
/**
* 初始化数据
*/
private void initData() {
mCommList = SerialPortManager.findPorts();
// 检查是否有可用串口，有则加入选项中
if (mCommList == null || mCommList.size() < 1) {
ShowUtils.warningMessage("没有搜索到有效串口！");
} else {
for (String s : mCommList) {
mCommChoice.addItem(s);
}
}
mBaudrateChoice.addItem("9600");
mBaudrateChoice.addItem("19200");
mBaudrateChoice.addItem("38400");
mBaudrateChoice.addItem("57600");
mBaudrateChoice.addItem("115200");
}
/**
* 按钮监听事件
*/
private void actionListener() {
// 串口
mCommChoice.addPopupMenuListener(new PopupMenuListener() {
@Override
public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
mCommList = SerialPortManager.findPorts();
// 检查是否有可用串口，有则加入选项中
if (mCommList == null || mCommList.size() < 1) {
ShowUtils.warningMessage("没有搜索到有效串口！");
} else {
int index = mCommChoice.getSelectedIndex();
mCommChoice.removeAllItems();
for (String s : mCommList) {
mCommChoice.addItem(s);
}
mCommChoice.setSelectedIndex(index);
}
}
@Override
public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
// NO OP
}
@Override
public void popupMenuCanceled(PopupMenuEvent e) {
// NO OP
}
});
// 打开|关闭串口
mSerialPortOperate.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if ("打开串口".equals(mSerialPortOperate.getText()) && mSerialport == null) {
openSerialPort(e);
} else {
closeSerialPort(e);
}
}
});
// 发送数据
mSendData.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
sendData(e);
}
});
}
/**
* 打开串口
*
* @param evt
* 点击事件
*/
private void openSerialPort(java.awt.event.ActionEvent evt) {
// 获取串口名称
String commName = (String) mCommChoice.getSelectedItem();
// 获取波特率，默认为9600
int baudrate = 9600;
String bps = (String) mBaudrateChoice.getSelectedItem();
baudrate = Integer.parseInt(bps);
// 检查串口名称是否获取正确
if (commName == null || commName.equals("")) {
ShowUtils.warningMessage("没有搜索到有效串口！");
} else {
try {
mSerialport = SerialPortManager.openPort(commName, baudrate);
if (mSerialport != null) {
mDataView.setText("串口已打开" + "\r\n");
mSerialPortOperate.setText("关闭串口");
}
} catch (PortInUseException e) {
ShowUtils.warningMessage("串口已被占用！");
}
}
// 添加串口监听
SerialPortManager.addListener(mSerialport, new SerialPortManager.DataAvailableListener() {
@Override
public void dataAvailable() {
byte[] data = null;
try {
if (mSerialport == null) {
ShowUtils.errorMessage("串口对象为空，监听失败！");
} else {
// 读取串口数据
data = SerialPortManager.readFromPort(mSerialport);
// 以字符串的形式接收数据
if (mDataASCIIChoice.isSelected()) {
mDataView.append(new String(data) + "\r\n");
}
// 以十六进制的形式接收数据
if (mDataHexChoice.isSelected()) {
mDataView.append(ByteUtils.byteArrayToHexString(data) + "\r\n");
}
}
} catch (Exception e) {
ShowUtils.errorMessage(e.toString());
// 发生读取错误时显示错误信息后退出系统
System.exit(0);
}
}
});
}
/**
* 关闭串口
*
* @param evt
* 点击事件
*/
private void closeSerialPort(java.awt.event.ActionEvent evt) {
SerialPortManager.closePort(mSerialport);
mDataView.setText("串口已关闭" + "\r\n");
mSerialPortOperate.setText("打开串口");
mSerialport = null;
}
/**
* 发送数据
*
* @param evt
* 点击事件
*/
private void sendData(java.awt.event.ActionEvent evt) {
// 待发送数据
String data = mDataInput.getText().toString();
if (mSerialport == null) {
ShowUtils.warningMessage("请先打开串口！");
return;
}
if ("".equals(data) || data == null) {
ShowUtils.warningMessage("请输入要发送的数据！");
return;
}
// 以字符串的形式发送数据
if (mDataASCIIChoice.isSelected()) {
SerialPortManager.sendToPort(mSerialport, data.getBytes());
}
// 以十六进制的形式发送数据
if (mDataHexChoice.isSelected()) {
SerialPortManager.sendToPort(mSerialport, ByteUtils.hexStr2Byte(data));
}
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new MainFrame().setVisible(true);
}
});
}
}
增加了数据格式设置功能（发送、接收），可选择ASCII（普通字符串）或Hex（十六进制），这也是反馈最多的问题。
当选择以十六进制的形式发送和接收数据时，增加了对奇数位数据的支持，比如输入1，会自动补齐为01发送。
5.FatJar打包
打包的时候遇到的问题，和串口通信无关，有的同学可能会遇到相同的问题，在这里说下，新装了一个Eclipse 4.7.3版本，发现本地安装FatJar的时候一直安装不上，网上查了下说FatJar不支持Eclipse 3.4以后的版本，可以通过下面的方法进行安装：
打开 Help -> Install New Software，在【Work with】选项中选择 The Eclipse Project Updates - http://download.eclipse.org/eclipse/updates/4.7，在下面的选项中勾选【Eclipse Tests, Tools，Examples, and Extras】下的【Eclipse 2.0 Style Plugin Support】，然后按照提示一直默认下一步，重启Eclipse：
Eclipse 2.0 Style Plugin Support
重启完成后，再次打开 Help -> Install New Software，在【Work with】选项中输入 fatjat - http://kurucz-grafika.de/fatjar，在下面的选项中勾选【FatJar】，然后按照提示一直默认下一步，重启Eclipse，在项目上右键就可以看到【Build Fat Jar】选项了：
FatJar
6.写在最后
本文Demo下载地址：https://github.com/alidili/SerialPortDemo
