Java使用开源Rxtx实现串口通讯(串口开发)

http://blog.csdn.net/xiezhiyong3621/article/details/8092150


简单实例下载:http://download.csdn.net/detail/xiezhiyong3621/7186795

Rxtx开源包下载地址:http://users.frii.com/jarvi/rxtx/download.html

http://rxtx.qbang.org/wiki/index.php/Download
使用方法:
windows平台:
1、把rxtxParallel.dll、rxtxSerial.dll拷贝到:C:\WINDOWS\system32下。
2、如果是在开发的时候(JDK),需要把RXTXcomm.jar、rxtxParallel.dll、rxtxSerial.dll拷贝到..\jre...\lib\ext下;如:D:\Program Files\Java\jre1.6.0_02\lib\ext
3、而且需要把项目1.右键->2.Preperties(首选项)->3.Java Build Path->4.Libraries->5.展开RXTXcomm.jar->6.Native library location:(None)->7.浏览External Folder(选择至该项目的lib文件夹,如:E:/Item/MyItem/WebRoot/WEB-INF/lib).
[java] view plain copy print ?
  1. import gnu.io.*;  
  2. import java.io.*;   
  3. import java.util.*;   
  4. import com.call.dao.*;  
  5.    
  6.  public class SerialReader extends Observable implements Runnable,SerialPortEventListener  
  7.     {  
  8.     static CommPortIdentifier portId;  
  9.     int delayRead = 100;  
  10.     int numBytes; // buffer中的实际数据字节数  
  11.     private static byte[] readBuffer = new byte[1024]; // 4k的buffer空间,缓存串口读入的数据  
  12.     static Enumeration portList;  
  13.     InputStream inputStream;  
  14.     OutputStream outputStream;  
  15.     static SerialPort serialPort;  
  16.     HashMap serialParams;  
  17.     Thread readThread;//本来是static类型的  
  18.     //端口是否打开了  
  19.     boolean isOpen = false;  
  20.     // 端口读入数据事件触发后,等待n毫秒后再读取,以便让数据一次性读完  
  21.     public static final String PARAMS_DELAY = "delay read"// 延时等待端口数据准备的时间  
  22.     public static final String PARAMS_TIMEOUT = "timeout"// 超时时间  
  23.     public static final String PARAMS_PORT = "port name"// 端口名称  
  24.     public static final String PARAMS_DATABITS = "data bits"// 数据位  
  25.     public static final String PARAMS_STOPBITS = "stop bits"// 停止位  
  26.     public static final String PARAMS_PARITY = "parity"// 奇偶校验  
  27.     public static final String PARAMS_RATE = "rate"// 波特率  
  28.   
  29.     public boolean isOpen(){  
  30.         return isOpen;  
  31.     }  
  32.     /** 
  33.      * 初始化端口操作的参数. 
  34.      * @throws SerialPortException  
  35.      *  
  36.      * @see 
  37.      */  
  38.     public SerialReader()  
  39.     {  
  40.         isOpen = false;  
  41.     }  
  42.   
  43.     public void open(HashMap params)   
  44.     {   
  45.         serialParams = params;  
  46.         if(isOpen){  
  47.             close();  
  48.         }  
  49.         try  
  50.         {  
  51.             // 参数初始化  
  52.             int timeout = Integer.parseInt( serialParams.get( PARAMS_TIMEOUT )  
  53.                 .toString() );  
  54.             int rate = Integer.parseInt( serialParams.get( PARAMS_RATE )  
  55.                 .toString() );  
  56.             int dataBits = Integer.parseInt( serialParams.get( PARAMS_DATABITS )  
  57.                 .toString() );  
  58.             int stopBits = Integer.parseInt( serialParams.get( PARAMS_STOPBITS )  
  59.                 .toString() );  
  60.             int parity = Integer.parseInt( serialParams.get( PARAMS_PARITY )  
  61.                 .toString() );  
  62.             delayRead = Integer.parseInt( serialParams.get( PARAMS_DELAY )  
  63.                 .toString() );  
  64.             String port = serialParams.get( PARAMS_PORT ).toString();  
  65.             // 打开端口  
  66.             portId = CommPortIdentifier.getPortIdentifier( port );  
  67.             serialPort = ( SerialPort ) portId.open( "SerialReader", timeout );  
  68.             inputStream = serialPort.getInputStream();  
  69.             serialPort.addEventListener( this );  
  70.             serialPort.notifyOnDataAvailable( true );  
  71.             serialPort.setSerialPortParams( rate, dataBits, stopBits, parity );  
  72.               
  73.             isOpen = true;  
  74.         }  
  75.         catch ( PortInUseException e )  
  76.         {  
  77.            // 端口"+serialParams.get( PARAMS_PORT ).toString()+"已经被占用";  
  78.         }  
  79.         catch ( TooManyListenersException e )  
  80.         {  
  81.            //"端口"+serialParams.get( PARAMS_PORT ).toString()+"监听者过多";  
  82.         }  
  83.         catch ( UnsupportedCommOperationException e )  
  84.         {  
  85.            //"端口操作命令不支持";  
  86.         }  
  87.         catch ( NoSuchPortException e )  
  88.         {  
  89.           //"端口"+serialParams.get( PARAMS_PORT ).toString()+"不存在";  
  90.         }  
  91.         catch ( IOException e )  
  92.         {  
  93.            //"打开端口"+serialParams.get( PARAMS_PORT ).toString()+"失败";  
  94.         }  
  95.         serialParams.clear();  
  96.         Thread readThread = new Thread( this );  
  97.         readThread.start();  
  98.     }  
  99.   
  100.        
  101.     public void run()  
  102.     {  
  103.         try  
  104.         {  
  105.             Thread.sleep(50);  
  106.         }  
  107.         catch ( InterruptedException e )  
  108.         {  
  109.         }  
  110.     }   
  111.     public void start(){  
  112.       try {    
  113.         outputStream = serialPort.getOutputStream();  
  114.          }   
  115.     catch (IOException e) {}  
  116.     try{   
  117.         readThread = new Thread(this);  
  118.         readThread.start();  
  119.     }   
  120.     catch (Exception e) {  }  
  121.    }  //start() end  
  122.   
  123.   
  124.    public void run(String message) {  
  125.     try {   
  126.         Thread.sleep(4);   
  127.            }   
  128.      catch (InterruptedException e) {  }   
  129.      try {  
  130.          if(message!=null&&message.length()!=0)  
  131.          {     
  132.              System.out.println("run message:"+message);  
  133.             outputStream.write(message.getBytes());  
  134.          }  
  135.     } catch (IOException e) {}  
  136.    }   
  137.       
  138.   
  139.     public void close()   
  140.     {   
  141.         if (isOpen)  
  142.         {  
  143.             try  
  144.             {  
  145.                 serialPort.notifyOnDataAvailable(false);  
  146.                 serialPort.removeEventListener();  
  147.                 inputStream.close();  
  148.                 serialPort.close();  
  149.                 isOpen = false;  
  150.             } catch (IOException ex)  
  151.             {  
  152.             //"关闭串口失败";  
  153.             }  
  154.         }  
  155.     }  
  156.       
  157.     public void serialEvent( SerialPortEvent event )  
  158.     {  
  159.         try  
  160.         {  
  161.             Thread.sleep( delayRead );  
  162.         }  
  163.         catch ( InterruptedException e )  
  164.         {  
  165.             e.printStackTrace();  
  166.         }  
  167.         switch ( event.getEventType() )  
  168.         {  
  169.             case SerialPortEvent.BI: // 10  
  170.             case SerialPortEvent.OE: // 7  
  171.             case SerialPortEvent.FE: // 9  
  172.             case SerialPortEvent.PE: // 8  
  173.             case SerialPortEvent.CD: // 6  
  174.             case SerialPortEvent.CTS: // 3  
  175.             case SerialPortEvent.DSR: // 4  
  176.             case SerialPortEvent.RI: // 5  
  177.             case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2  
  178.                 break;  
  179.             case SerialPortEvent.DATA_AVAILABLE: // 1  
  180.                 try  
  181.                 {  
  182.                     // 多次读取,将所有数据读入  
  183.                      while (inputStream.available() > 0) {  
  184.                      numBytes = inputStream.read(readBuffer);  
  185.                      }  
  186.                        
  187.                      //打印接收到的字节数据的ASCII码  
  188.                      for(int i=0;i<numBytes;i++){  
  189.                         // System.out.println("msg[" + numBytes + "]: [" +readBuffer[i] + "]:"+(char)readBuffer[i]);  
  190.                      }  
  191. //                    numBytes = inputStream.read( readBuffer );  
  192.                     changeMessage( readBuffer, numBytes );  
  193.                 }  
  194.                 catch ( IOException e )  
  195.                 {  
  196.                     e.printStackTrace();  
  197.                 }  
  198.                 break;  
  199.         }  
  200.     }  
  201.   
  202.     // 通过observer pattern将收到的数据发送给observer  
  203.     // 将buffer中的空字节删除后再发送更新消息,通知观察者  
  204.     public void changeMessage( byte[] message, int length )  
  205.     {  
  206.         setChanged();  
  207.         byte[] temp = new byte[length];  
  208.         System.arraycopy( message, 0, temp, 0, length );  
  209.         notifyObservers( temp );  
  210.     }  
  211.   
  212.     static void listPorts()  
  213.     {  
  214.         Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();  
  215.         while ( portEnum.hasMoreElements() )  
  216.         {  
  217.             CommPortIdentifier portIdentifier = ( CommPortIdentifier ) portEnum  
  218.                 .nextElement();  
  219.               
  220.         }  
  221.     }  
  222.       
  223.       
  224.     public void openSerialPort(String message)  
  225.     {  
  226.         HashMap<String, Comparable> params = new HashMap<String, Comparable>();   
  227.         otherDAO odao=new otherDAO();  
  228.         String port=odao.selectNumberById(15);  
  229.         String rate = "9600";  
  230.         String dataBit = ""+SerialPort.DATABITS_8;  
  231.         String stopBit = ""+SerialPort.STOPBITS_1;  
  232.         String parity = ""+SerialPort.PARITY_NONE;      
  233.         int parityInt = SerialPort.PARITY_NONE;   
  234.         params.put( SerialReader.PARAMS_PORT, port ); // 端口名称  
  235.         params.put( SerialReader.PARAMS_RATE, rate ); // 波特率  
  236.         params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 数据位  
  237.         params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止位  
  238.         params.put( SerialReader.PARAMS_PARITY, parityInt ); // 无奇偶校验  
  239.         params.put( SerialReader.PARAMS_TIMEOUT, 100 ); // 设备超时时间 1秒  
  240.         params.put( SerialReader.PARAMS_DELAY, 100 ); // 端口数据准备时间 1秒  
  241.         try {  
  242.             open(params);//打开串口  
  243.             LoginFrame cf=new LoginFrame();  
  244.             addObserver(cf);  
  245.             if(message!=null&&message.length()!=0)  
  246.              {  
  247.                 String str="";  
  248.                 for(int i=0;i<10;i++)  
  249.                 {  
  250.                     str+=message;  
  251.                 }  
  252.                  start();   
  253.                  run(str);    
  254.              }   
  255.         } catch (Exception e) {   
  256.         }  
  257.     }  
  258.   
  259.     static String getPortTypeName( int portType )  
  260.     {  
  261.         switch ( portType )  
  262.         {  
  263.             case CommPortIdentifier.PORT_I2C:  
  264.                 return "I2C";  
  265.             case CommPortIdentifier.PORT_PARALLEL:  
  266.                 return "Parallel";  
  267.             case CommPortIdentifier.PORT_RAW:  
  268.                 return "Raw";  
  269.             case CommPortIdentifier.PORT_RS485:  
  270.                 return "RS485";  
  271.             case CommPortIdentifier.PORT_SERIAL:  
  272.                 return "Serial";  
  273.             default:  
  274.                 return "unknown type";  
  275.         }  
  276.     }  
  277.   
  278.        
  279.     public  HashSet<CommPortIdentifier> getAvailableSerialPorts()//本来static  
  280.     {  
  281.         HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();  
  282.         Enumeration thePorts = CommPortIdentifier.getPortIdentifiers();  
  283.         while ( thePorts.hasMoreElements() )  
  284.         {  
  285.             CommPortIdentifier com = ( CommPortIdentifier ) thePorts  
  286.                 .nextElement();  
  287.             switch ( com.getPortType() )  
  288.             {  
  289.                 case CommPortIdentifier.PORT_SERIAL:  
  290.                     try  
  291.                     {  
  292.                         CommPort thePort = com.open( "CommUtil"50 );  
  293.                         thePort.close();  
  294.                         h.add( com );  
  295.                     }  
  296.                     catch ( PortInUseException e )  
  297.                     {  
  298.                         System.out.println( "Port, " + com.getName()  
  299.                             + ", is in use." );  
  300.                     }  
  301.                     catch ( Exception e )  
  302.                     {  
  303.                         System.out.println( "Failed to open port "  
  304.                             + com.getName() + e );  
  305.                     }  
  306.             }  
  307.         }  
  308.         return h;  
  309.     }  
  310. }  
  311.   
  312. //ASCII表  
  313. //-------------------------------------------------------------  
  314. //                 ASCII Characters                              
  315. //                              
  316. //Dec   Hex       Char    Code   Dec   Hex  Char  
  317. //                              
  318. //0     0         NUL            64    40    @  
  319. //1     1         SOH            65    41    A  
  320. //2     2         STX            66    42    B  
  321. //3     3         ETX            67    43    C  
  322. //4     4         EOT            68    44    D  
  323. //5     5         ENQ            69    45    E  
  324. //6     6         ACK            70    46    F  
  325. //7     7         BEL            71    47    G  
  326. //8     8         BS             72    48    H  
  327. //9     9         HT             73    49    I  
  328. //10    0A        LF             74    4A    J  
  329. //11    0B        VT             75    4B    K  
  330. //12    0C        FF             76    4C    L  
  331. //13    0D        CR             77    4D    M  
  332. //14    0E        SO             78    4E    N  
  333. //15    0F        SI             79    4F    O  
  334. //16    10        SLE            80    50    P  
  335. //17    11        CS1            81    51    Q  
  336. //18    12        DC2            82    52    R  
  337. //19    13        DC3            83    53    S  
  338. //20    14        DC4            84    54    T  
  339. //21    15        NAK            85    55    U  
  340. //22    16        SYN            86    56    V  
  341. //23    17        ETB            87    57    W  
  342. //24    18        CAN            88    58    X  
  343. //25    19        EM             89    59    Y  
  344. //26    1A        SIB            90    5A    Z  
  345. //27    1B        ESC            91    5B    [  
  346. //                               92    5C     \  
  347. //28    1C        FS             93    5D    ]  
  348. //29    1D        GS             94    5E    ^  
  349. //30    1E        RS             95    5F    _  
  350. //31    1F        US             96    60    `  
  351. //32    20    (space)            97    61    a  
  352. //33    21        !              98    62    b  
  353. //34    22        "      
  354. //                               99    63    c  
  355. //35    23        #              100    64    d  
  356. //36    24        $                      
  357. //37    25        %              101    65    e  
  358. //38    26        &              102    66    f  
  359. //39    27        '              103    67    g  
  360. //40    28        (              104    68    h  
  361. //41    29        )              105    69    i  
  362. //42    2A        *              106    6A    j  
  363. //43    2B        +              107    6B    k  
  364. //44    2C        ,              108    6C    l  
  365. //45    2D        -              109    6D    m  
  366. //46    2E        .              110    6E    n  
  367. //47    2F        /              111    6F    o  
  368. //48    30        0              112    70    p  
  369. //49    31        1              113    72    q  
  370. //50    32        2              114    72    r  
  371. //51    33        3              115    73    s  
  372. //52    34        4              116    74    t  
  373. //53    35        5              117    75    u  
  374. //54    36        6              118    76    v  
  375. //55    37        7              119    77    w  
  376. //56    38        8              120    78    x  
  377. //57    39        9              121    79    y  
  378. //58    3A        :              122    7A    z  
  379. //59    3B        ;              123    7B    {  
  380. //60    3C        <              124    7C    |  
  381. //61    3D        =              125    7D    }  
  382. //62    3E        >              126    7E    ~  
  383. //63    3F        ?              127    7F     

简单实例下载:http://download.csdn.net/detail/xiezhiyong3621/7186795


你可能感兴趣的:(Java使用开源Rxtx实现串口通讯(串口开发))