使用Java串口通信


         很老套的代码,但是却费时很久,找到过很多参考代码,但是要不然和本身项目不太符合,要不然就运行不出来,报串口找不到的错误,也还因为jar包整了很久,去各种百度解决办法才真正实现使用java实现串口通信。

          1.  jar包的导入

                   1.1  如果你的电脑安装的是32位的JDK,那么有两种解决方案

                            A. 

[html] view plain copy
  1. 将文件comm.jar拷贝到%JAVA_HOME%\jre\lib\ext;    
  2. 文件javax.comm. properties拷贝到%JAVA_HOME%\jre\lib;     
  3. 文件win32comm.dll拷贝到%JAVA_HOME%\bin。    
  4. 注意%JAVA_HOME%是jdk的路径,而非jre。    

                            B. 使用Rxtx   jar包(32位)

                            下载地址:点击打开链接

                     1.2 如果你的电脑安装的是64位的JDK,那么只能使用Rxtx  jar包(64位)

                            下载地址:点击打开链接

          由于我写的项目是一个动态WEB项目,所以目前只实现了接收串口数据,在WEB页面操作后,再向硬件发送数据还未实现,后续还会更新。

          接收数据的实现思路如下:现在java程序中启动读串口数据的类,读出之后按解析保存至数据库中,WEB的显示后台则从数据库中取数据。

          首先是写好的串口工具类:

         

[html] view plain copy
  1. /**  
  2.  * 串口服务类,提供打开、关闭串口,读取、发送串口数据等服务(采用单例设计模式)  
  3.  * @author zhong  
  4.  *  
  5.  */  
  6. public class SerialTool {  
  7.       
  8.     private static SerialTool serialTool = null;  
  9.       
  10.     static {  
  11.         //在该类被ClassLoader加载时就初始化一个SerialTool对象  
  12.         if (serialTool == null) {  
  13.             serialTool = new SerialTool();  
  14.         }  
  15.     }  
  16.       
  17.     //私有化SerialTool类的构造方法,不允许其他类生成SerialTool对象  
  18.     private SerialTool() {}      
  19.       
  20.     /**  
  21.      * 获取提供服务的SerialTool对象  
  22.      * @return serialTool  
  23.      */  
  24.     public static SerialTool getSerialTool() {  
  25.         if (serialTool == null) {  
  26.             serialTool = new SerialTool();  
  27.         }  
  28.         return serialTool;  
  29.     }  
  30.   
  31.   
  32.     /**  
  33.      * 查找所有可用端口  
  34.      * @return 可用端口名称列表  
  35.      */  
  36.     @SuppressWarnings("unchecked")  
  37.     public static final ArrayList<String> findPort() {  
  38.   
  39.         //获得当前所有可用串口  
  40.         Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();      
  41.           
  42.         ArrayList<String> portNameList = new ArrayList<>();  
  43.   
  44.         //将可用串口名添加到List并返回该List  
  45.         while (portList.hasMoreElements()) {  
  46.             String portName = portList.nextElement().getName();  
  47.             portNameList.add(portName);  
  48.         }  
  49.         return portNameList;  
  50.     }  
  51.       
  52.     /**  
  53.      * 打开串口  
  54.      * @param portName 端口名称  
  55.      * @param baudrate 波特率  
  56.      * @return 串口对象  
  57.      * @throws SerialPortParameterFailure 设置串口参数失败  
  58.      * @throws NotASerialPort 端口指向设备不是串口类型  
  59.      * @throws NoSuchPort 没有该端口对应的串口设备  
  60.      * @throws PortInUse 端口已被占用  
  61.      */  
  62.     public static final SerialPort openPort(String portName, int baudrate) throws SerialPortParameterFailure, NotASerialPort, NoSuchPort, PortInUse {  
  63.   
  64.         try {  
  65.   
  66.             //通过端口名识别端口  
  67.             CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);  
  68.   
  69.             //打开端口,并给端口名字和一个timeout(打开操作的超时时间)  
  70.             CommPort commPort = portIdentifier.open(portName, 2000);  
  71.   
  72.             //判断是不是串口  
  73.             if (commPort instanceof SerialPort) {  
  74.                   
  75.                 SerialPort serialPort = (SerialPort) commPort;  
  76.                   
  77.                 try {                          
  78.                     //设置一下串口的波特率等参数  
  79.                     serialPort.setSerialPortParams(baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);                                
  80.                 } catch (UnsupportedCommOperationException e) {    
  81.                     throw new SerialPortParameterFailure();  
  82.                 }  
  83.                   
  84.                 System.out.println("Open " + portName + " sucessfully !");  
  85.                 return serialPort;  
  86.               
  87.             }          
  88.             else {  
  89.                 //不是串口  
  90.                 throw new NotASerialPort();  
  91.             }  
  92.         } catch (NoSuchPortException e1) {  
  93.           throw new NoSuchPort();  
  94.         } catch (PortInUseException e2) {  
  95.             throw new PortInUse();  
  96.         }  
  97.     }  
  98.       
  99.     /**  
  100.      * 关闭串口  
  101.      * @param serialport 待关闭的串口对象  
  102.      */  
  103.     public static void closePort(SerialPort serialPort) {  
  104.         if (serialPort != null) {  
  105.             serialPort.close();  
  106.             System.out.println("Close " + serialPort + " sucessfully !");  
  107.             serialPort = null;  
  108.         }  
  109.     }  
  110.       
  111.     /**  
  112.      * 往串口发送数据  
  113.      * @param serialPort 串口对象  
  114.      * @param order    待发送数据  
  115.      * @throws SendDataToSerialPortFailure 向串口发送数据失败  
  116.      * @throws SerialPortOutputStreamCloseFailure 关闭串口对象的输出流出错  
  117.      */  
  118.     public static void sendToPort(SerialPort serialPort, byte[] order) throws SendDataToSerialPortFailure, SerialPortOutputStreamCloseFailure {  
  119.   
  120.         OutputStream out = null;  
  121.           
  122.         try {  
  123.             out = serialPort.getOutputStream();  
  124.             out.write(order);  
  125.             out.flush();  
  126.               
  127.         } catch (IOException e) {  
  128.             throw new SendDataToSerialPortFailure();  
  129.         } finally {  
  130.             try {  
  131.                 if (out != null) {  
  132.                     out.close();  
  133.                     out = null;  
  134.                 }                  
  135.             } catch (IOException e) {  
  136.                 throw new SerialPortOutputStreamCloseFailure();  
  137.             }  
  138.         }  
  139.           
  140.     }  
  141.       
  142.     /**  
  143.      * 从串口读取数据  
  144.      * @param serialPort 当前已建立连接的SerialPort对象  
  145.      * @return 读取到的数据  
  146.      * @throws ReadDataFromSerialPortFailure 从串口读取数据时出错  
  147.      * @throws SerialPortInputStreamCloseFailure 关闭串口对象输入流出错  
  148.      */  
  149.     public static byte[] readFromPort(SerialPort serialPort) throws ReadDataFromSerialPortFailure, SerialPortInputStreamCloseFailure {  
  150.   
  151.         InputStream in = null;  
  152.         byte[] bytes = null;  
  153.   
  154.         try {  
  155.             in = serialPort.getInputStream();  
  156.             int bufflenth = in.available();        //获取buffer里的数据长度  
  157.               
  158.             while (bufflenth != 0) {                               
  159.                 bytes = new byte[bufflenth];    //初始化byte数组为buffer中数据的长度  
  160.                 in.read(bytes);  
  161.                 bufflenth = in.available();  
  162.             }   
  163.         } catch (IOException e) {  
  164.             throw new ReadDataFromSerialPortFailure();  
  165.         } finally {  
  166.             try {  
  167.                 if (in != null) {  
  168.                     in.close();  
  169.                     in = null;  
  170.                 }  
  171.             } catch(IOException e) {  
  172.                 throw new SerialPortInputStreamCloseFailure();  
  173.             }  
  174.         }  
  175.         return bytes;  
  176.     }  
  177.       
  178.     /**  
  179.      * 添加监听器  
  180.      * @param port     串口对象  
  181.      * @param listener 串口监听器  
  182.      * @throws TooManyListeners 监听类对象过多  
  183.      */  
  184.     public static void addListener(SerialPort port, SerialPortEventListener listener) throws TooManyListeners {  
  185.   
  186.         try {          
  187.             //给串口添加监听器  
  188.             port.addEventListener(listener);  
  189.             //设置当有数据到达时唤醒监听接收线程  
  190.             port.notifyOnDataAvailable(true);  
  191.             //设置当通信中断时唤醒中断线程  
  192.             port.notifyOnBreakInterrupt(true);  
  193.   
  194.         } catch (TooManyListenersException e) {  
  195.             throw new TooManyListeners();  
  196.         }  
  197.     }  
  198.       
  199.       
  200. }  

          写好之后,就是读串口类,要保存至数据库的话就是在读出数据后保存,此处无保存至数据库的代码:

         

[html] view plain copy
  1. public class EventListener implements SerialPortEventListener {  
  2.   
  3.      //1.定义变量  
  4.     SerialPort serialPort = null;  
  5.     InputStream inputStream = null;//输入流  
  6.     Thread readThread = null;  
  7.     //2.构造函数:  
  8.     //实现初始化动作:获取串口COM21、打开串口、获取串口输入流对象、为串口添加事件监听对象  
  9.       
  10.     public EventListener() throws NoSuchPortException, PortInUseException{  
  11.         try {  
  12.             //获取串口、打开窗串口、获取串口的输入流。  
  13.             serialPort = SerialTool.openPort("COM3", 115200);  
  14.             inputStream = serialPort.getInputStream();  
  15.             //向串口添加事件监听对象。  
  16.             serialPort.addEventListener(this);  
  17.             //设置当端口有可用数据时触发事件,此设置必不可少。  
  18.             serialPort.notifyOnDataAvailable(true);  
  19.         } catch (IOException e) {  
  20.             e.printStackTrace();  
  21.         } catch (TooManyListenersException e) {  
  22.             // TODO Auto-generated catch block  
  23.             e.printStackTrace();  
  24.         } catch (SerialPortParameterFailure e) {  
  25.             // TODO Auto-generated catch block  
  26.             e.printStackTrace();  
  27.         } catch (NotASerialPort e) {  
  28.             // TODO Auto-generated catch block  
  29.             e.printStackTrace();  
  30.         } catch (NoSuchPort e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         } catch (PortInUse e) {  
  34.             // TODO Auto-generated catch block  
  35.             e.printStackTrace();  
  36.         }finally {  
  37.         //  SerialTool.closePort(serialPort);  
  38.         }  
  39.     }  
  40.   
  41.     //重写继承的监听器方法  
  42.     @Override  
  43.     public void serialEvent(SerialPortEvent event) {  
  44.         //定义用于缓存读入数据的数组  
  45.         byte[] cache = new byte[1024];  
  46.         //记录已经到达串口COM21且未被读取的数据的字节(Byte)数。  
  47.         int availableBytes = 0;  
  48.   
  49.         //如果是数据可用的时间发送,则进行数据的读写  
  50.         if(event.getEventType() == SerialPortEvent.DATA_AVAILABLE){  
  51.             try {  
  52.                 availableBytes = inputStream.available();  
  53.                 while(availableBytes > 0){  
  54.                     inputStream.read(cache);  
  55.                     for(int i = 0; i < cache.length && i < availableBytes; i++){  
  56.                         //解码并输出数据  
  57.                         System.out.print((char)cache[i]);  
  58.                     }  
  59.                     availableBytes = inputStream.available();  
  60.                 }  
  61.                 System.out.println();  
  62.             } catch (IOException e) {  
  63.                 e.printStackTrace();  
  64.             }  
  65.         }  
  66.     }  
  67.   
  68.     public static void main(String[] args) throws NoSuchPortException, PortInUseException {  
  69.         new EventListener();  
  70.     }  
  71.       
  72. }  

再就是向串口发送数据:

[html] view plain copy
  1. public class Write {  
  2.     public static void main(String[] args) {  
  3.         SerialPort serialPort = null;                  //打开的端  
  4.         try {  
  5.             //打开串口  
  6.             serialPort = SerialTool.openPort("COM21", 9600);  
  7.             //数组“Hello World!”  
  8.             byte[] bs = new byte[]{'H','e','l','l','o',' ','W','o','r','l','d','!'};  
  9.             //写入数组  
  10.             SerialTool.sendToPort(serialPort, bs);  
  11.         } catch (SerialPortParameterFailure | NotASerialPort | NoSuchPort | PortInUse | SendDataToSerialPortFailure | SerialPortOutputStreamCloseFailure e) {  
  12.             // TODO Auto-generated catch block  
  13.             e.printStackTrace();  
  14.         }finally {  
  15.             //关闭串口  
  16.             SerialTool.closePort(serialPort);  
  17.         }  
  18.     }  
  19. }  
展开阅读全文

没有更多推荐了,返回首页