使用Java实现串口通信(二)

作者: 容华谢后 | 来源:发表于2018-06-06 07:32 被阅读198次

    1.写在前面

    距离上一篇文章《使用Java实现串口通信》已经过去快两年的时间了,在此期间收到了很多读者的反馈,很高兴可以帮助到这么多人,根据收到的反馈,我对代码逻辑进行了优化整理,并增加了一些新功能,在此记录下,分享给大家。

    先看下效果:

    串口通信

    2.环境搭建

    本文的串口通信开发基于RXTX,所以需要引用一些RXTX的依赖包:

    RXTX 依赖包下载地址,内含32位与64位版本

    • 拷贝 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

    相关文章

      网友评论

        本文标题:使用Java实现串口通信(二)

        本文链接:https://www.haomeiwen.com/subject/aptmsftx.html