2. 程式人生 > >64位電腦通過串列埠傳送資料到硬體

64位電腦通過串列埠傳送資料到硬體

阿新 • • 發佈：2019-01-16

首先下載：RXTX的包，（僅64位有效）Rxtx開源包下載地址：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).

[html] view plain copy print?
  1. package comme64;  
  2. import gnu.io.*;  
  3. import java.io.*;   
  4. import java.util.*;    
  5. public class SerialReader extends Observable implements Runnable,SerialPortEventListener  
  6.     {  
  7.     static CommPortIdentifier portId;  
  8.     int delayRead = 100;  
  9.     int numBytes; //   
  10.     private static byte[] readBuffer
     = new byte[1024]; //  
  11.     static Enumeration portList;  
  12.     InputStream inputStream;  
  13.     OutputStream outputStream;  
  14.     static SerialPort serialPort;  
  15.     HashMap serialParams;  
  16.     Thread readThread;  
  17.     boolean isOpen = false;  
  18.     public static final String PARAMS_DELAY = "delay read"; //   
  19.     public static final String PARAMS_TIMEOUT
     = "timeout"; // 超時時間  
  20.     public static final String PARAMS_PORT = "port name"; // 埠名稱  
  21.     public static final String PARAMS_DATABITS = "data bits"; //  
  22.     public static final String PARAMS_STOPBITS = "stop bits"; //  
  23.     public static final String PARAMS_PARITY = "parity"; // 奇偶校驗  
  24.     public static final String PARAMS_RATE = "rate"; //   
  25.     public boolean isOpen(){  
  26.     <span style="white-space:pre">  </span>return isOpen;  
  27.     }  
  28.     /**  
  29.      * 初始化埠操作的引數.  
  30.      * @throws SerialPortException   
  31.      *   
  32.      * @see  
  33.      */  
  34.     public SerialReader()  
  35.     {  
  36.     <span style="white-space:pre">  </span>isOpen = false;  
  37.     }  
  38.     public void open(HashMap params)  
  39.     {   
  40.     <span style="white-space:pre">  </span>serialParams = params;  
  41.     <span style="white-space:pre">  </span>if(isOpen){  
  42.     <span style="white-space:pre">      </span>close();  
  43.     <span style="white-space:pre">  </span>}  
  44.         try  
  45.         {  
  46.             // 引數初始  
  47.             int timeout = Integer.parseInt( serialParams.get( PARAMS_TIMEOUT )  
  48.                 .toString() );  
  49.             int rate = Integer.parseInt( serialParams.get( PARAMS_RATE )  
  50.                 .toString() );  
  51.             int dataBits = Integer.parseInt( serialParams.get( PARAMS_DATABITS )  
  52.                 .toString() );  
  53.             int stopBits = Integer.parseInt( serialParams.get( PARAMS_STOPBITS )  
  54.                 .toString() );  
  55.             int parity = Integer.parseInt( serialParams.get( PARAMS_PARITY )  
  56.                 .toString() );  
  57.             delayRead = Integer.parseInt( serialParams.get( PARAMS_DELAY )  
  58.                 .toString() );  
  59.             String port = serialParams.get( PARAMS_PORT ).toString();  
  60.             // 開啟埠  
  61.             portId = CommPortIdentifier.getPortIdentifier( port );  
  62.             serialPort = ( SerialPort ) portId.open( "SerialReader", timeout );  
  63.             inputStream = serialPort.getInputStream();  
  64.             serialPort.addEventListener( this );  
  65.             serialPort.notifyOnDataAvailable( true );  
  66.             serialPort.setSerialPortParams( rate, dataBits, stopBits, parity );  
  67.             isOpen = true;  
  68.         }  
  69.         catch ( PortInUseException e )  
  70.         {  
  71.            // 埠"+serialParams.get( PARAMS_PORT ).toString()+"已經被佔�?;  
  72.         }  
  73.         catch ( TooManyListenersException e )  
  74.         {  
  75.            //"埠"+serialParams.get( PARAMS_PORT ).toString()+"監聽者過�?;  
  76.         }  
  77.         catch ( UnsupportedCommOperationException e )  
  78.         {  
  79.            //"埠操作命令不支�?;  
  80.         }  
  81.         catch ( NoSuchPortException e )  
  82.         {  
  83.           //"埠"+serialParams.get( PARAMS_PORT ).toString()+"不存�?;  
  84.         }  
  85.         catch ( IOException e )  
  86.         {  
  87.            //"開啟埠"+serialParams.get( PARAMS_PORT ).toString()+"失敗";  
  88.         }  
  89.         serialParams.clear();  
  90.         Thread readThread = new Thread( this );  
  91.         readThread.start();  
  92.     }  
  93.     public void run()  
  94.     {  
  95.         try  
  96.         {  
  97.             Thread.sleep(50);  
  98.         }  
  99.         catch ( InterruptedException e )  
  100.         {  
  101.         }  
  102.     }   
  103.     public void start(){  
  104.   try {    
  105.  outputStream = serialPort.getOutputStream();  
  106.     }   
  107.  catch (IOException e) {}  
  108.   try{   
  109.     readThread = new Thread(this);  
  110.     </span>readThread.start();  
  111.     </span>}   
  112.     </span>catch (Exception e) {  }  
  113.    }  //start() end  
  114.    public void run(String message) {  
  115.    try {   
  116.    Thread.sleep(4);   
  117.            }   
  118.    catch (InterruptedException e) {  }   
  119.  try {  
  120.  if(message!=null&&message.length()!=0)  
  121.     {   
  122.  System.out.println("run message:"+message);  
  123.          outputStream.write(message.getBytes());    
  124.  }  
  125. } catch (IOException e) {}  
  126.    }   
  127.     public void close()   
  128.     {   
  129.         if (isOpen)  
  130.         {  
  131.             try  
  132.             {  
  133.             <span style="white-space:pre">  </span>serialPort.notifyOnDataAvailable(false);  
  134.             <span style="white-space:pre">  </span>serialPort.removeEventListener();  
  135.                 inputStream.close();  
  136.                 serialPort.close();  
  137.                 isOpen = false;  
  138.             } catch (IOException ex)  
  139.             {  
  140.             //"關閉串列埠失敗";  
  141.             }  
  142.         }  
  143.     }  
  144.     public void serialEvent( SerialPortEvent event )  
  145.     {  
  146.         try  
  147.         {  
  148.             Thread.sleep( delayRead );  
  149.         }  
  150.         catch ( InterruptedException e )  
  151.         {  
  152.             e.printStackTrace();  
  153.         }  
  154.         switch ( event.getEventType() )  
  155.         {  
  156.             case SerialPortEvent.BI: // 10  
  157.             case SerialPortEvent.OE: // 7  
  158.             case SerialPortEvent.FE: // 9  
  159.             case SerialPortEvent.PE: // 8  
  160.             case SerialPortEvent.CD: // 6  
  161.             case SerialPortEvent.CTS: // 3  
  162.             case SerialPortEvent.DSR: // 4  
  163.             case SerialPortEvent.RI: // 5  
  164.             case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2  
  165.                 break;  
  166.             case SerialPortEvent.DATA_AVAILABLE: // 1  
  167.                 try  
  168.                 {  
  169.                     // 多次讀取,將所有資料讀�?  
  170.                      while (inputStream.available() > 0) {  
  171.                      numBytes = inputStream.read(readBuffer);  
  172.                      }  
  173.                      //列印接收到的位元組資料的ASCII�?  
  174.                      for(int i=0;i<numBytes;i++){  
  175.                     <span style="white-space:pre">  </span>// System.out.println("msg[" + numBytes + "]: [" +readBuffer[i] + "]:"+(char)readBuffer[i]);  
  176.                      }  
  177. //                    numBytes = inputStream.read( readBuffer );  
  178.                     changeMessage( readBuffer, numBytes );  
  179.                 }  
  180.                 catch ( IOException e )  
  181.                 {  
  182.                     e.printStackTrace();  
  183.                 }  
  184.                 break;  
  185.         }  
  186.     }  
  187.     // 通過observer pattern將收到的資料發�?給observer  
  188.     // 將buffer中的空位元組刪除後再發送更新消�?通知觀察�?  
  189.     public void changeMessage( byte[] message, int length )  
  190.     {  
  191.         setChanged();  
  192.         byte[] temp = new byte[length];  
  193.         System.arraycopy( message, 0, temp, 0, length );  
  194.         notifyObservers( temp );  
  195.     }  
  196.     static void listPorts()  
  197.     {  
  198.         Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();  
  199.         while ( portEnum.hasMoreElements() )  
  200.         {  
  201.             CommPortIdentifier portIdentifier = ( CommPortIdentifier ) portEnum  
  202.                 .nextElement();  
  203.         }  
  204.     }  
  205.     public void openSerialPort(String message)  
  206.     {  
  207.         HashMap<String, Comparable> params = new HashMap<String, Comparable>();    
  208.         String port="COM1";  
  209.         String rate = "9600";  
  210.         String dataBit = ""+SerialPort.DATABITS_8;  
  211.         String stopBit = ""+SerialPort.STOPBITS_1;  
  212.         String parity = ""+SerialPort.PARITY_NONE;      
  213.         int parityInt = SerialPort.PARITY_NONE;   
  214.         params.put( SerialReader.PARAMS_PORT, port ); // 埠名稱  
  215.         params.put( SerialReader.PARAMS_RATE, rate ); // 波特�?  
  216.         params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 資料�?  
  217.         params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止�?  
  218.         params.put( SerialReader.PARAMS_PARITY, parityInt ); // 無奇偶校�?  
  219.         params.put( SerialReader.PARAMS_TIMEOUT, 100 ); // 裝置超時時間 1�?  
  220.         params.put( SerialReader.PARAMS_DELAY, 100 ); // 埠資料準備時間 1�?  
  221.         try {  
  222. open(params);//開啟串列埠  
  223. //LoginFrame cf=new LoginFrame();  
  224. //addObserver(cf);  
  225. //也可以像上面�?��通過LoginFrame來繫結串列埠的通訊輸出.  
  226. if(message!=null&&message.length()!=0)  
  227.  {  
  228. String str="";  
  229. for(int i=0;i<10;i++)  
  230. {  
  231. str+=message;  
  232. }  
  233.  start();   
  234.     run(str);    
  235.  }   
  236. } catch (Exception e) {   
  237. }  
  238.     }  
  239.     static String getPortTypeName( int portType )  
  240.     {  
  241.         switch ( portType )  
  242.         {  
  243.             case CommPortIdentifier.PORT_I2C:  
  244.                 return "I2C";  
  245.             case CommPortIdentifier.PORT_PARALLEL:  
  246.                 return "Parallel";  
  247.             case CommPortIdentifier.PORT_RAW:  
  248.                 return "Raw";  
  249.             case CommPortIdentifier.PORT_RS485:  
  250.                 return "RS485";  
  251.             case CommPortIdentifier.PORT_SERIAL:  
  252.                 return "Serial";  
  253.             default:  
  254.                 return "unknown type";  
  255.         }  
  256.     }  
  257.     public  HashSet<CommPortIdentifier> getAvailableSerialPorts()//本來static  
  258.     {  
  259.         HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();  
  260.         Enumeration thePorts = CommPortIdentifier.getPortIdentifiers();  
  261.         while ( thePorts.hasMoreElements() )  
  262.         {  
  263.             CommPortIdentifier com = ( CommPortIdentifier ) thePorts  
  264.                 .nextElement();  
  265.             switch ( com.getPortType() )  
  266.             {  
  267.                 case CommPortIdentifier.PORT_SERIAL:  
  268.                     try  
  269.                     {  
  270.                         CommPort thePort = com.open( "CommUtil", 50 );  
  271.                         thePort.close();  
  272.                         h.add( com );  
  273.                     }  
  274.                     catch ( PortInUseException e )  
  275.                     {  
  276.                         System.out.println( "Port, " + com.getName()  
  277.                             + ", is in use." );  
  278.                     }  
  279.                     catch ( Exception e )  
  280.                     {  
  281.                         System.out.println( "Failed to open port "  
  282.                             + com.getName() + e );  
  283.                     }  
  284.             }  
  285.         }  
  286.         return h;  
  287.     }  
  288. }  
package comme64;
import gnu.io.*;
import java.io.*; 
import java.util.*;  
 
 
public class SerialReader extends Observable implements Runnable,SerialPortEventListener
    {
    static CommPortIdentifier portId;
    int delayRead = 100;
    int numBytes; // 
    private static byte[] readBuffer = new byte[1024]; //
    static Enumeration portList;
    InputStream inputStream;
    OutputStream outputStream;
    static SerialPort serialPort;
    HashMap serialParams;
    Thread readThread;
   
    boolean isOpen = false;
   
    public static final String PARAMS_DELAY = "delay read"; // 
    public static final String PARAMS_TIMEOUT = "timeout"; // 超時時間
    public static final String PARAMS_PORT = "port name"; // 埠名稱
    public static final String PARAMS_DATABITS = "data bits"; //
    public static final String PARAMS_STOPBITS = "stop bits"; //
    public static final String PARAMS_PARITY = "parity"; // 奇偶校驗
    public static final String PARAMS_RATE = "rate"; // 


    public boolean isOpen(){
    <span style="white-space:pre">	</span>return isOpen;
    }
    /**
     * 初始化埠操作的引數.
     * @throws SerialPortException 
     * 
     * @see
     */
    public SerialReader()
    {
    <span style="white-space:pre">	</span>isOpen = false;
    }


    public void open(HashMap params)
    { 
    <span style="white-space:pre">	</span>serialParams = params;
    <span style="white-space:pre">	</span>if(isOpen){
    <span style="white-space:pre">		</span>close();
    <span style="white-space:pre">	</span>}
        try
        {
            // 引數初始
            int timeout = Integer.parseInt( serialParams.get( PARAMS_TIMEOUT )
                .toString() );
            int rate = Integer.parseInt( serialParams.get( PARAMS_RATE )
                .toString() );
            int dataBits = Integer.parseInt( serialParams.get( PARAMS_DATABITS )
                .toString() );
            int stopBits = Integer.parseInt( serialParams.get( PARAMS_STOPBITS )
                .toString() );
            int parity = Integer.parseInt( serialParams.get( PARAMS_PARITY )
                .toString() );
            delayRead = Integer.parseInt( serialParams.get( PARAMS_DELAY )
                .toString() );
            String port = serialParams.get( PARAMS_PORT ).toString();
            // 開啟埠
            portId = CommPortIdentifier.getPortIdentifier( port );
            serialPort = ( SerialPort ) portId.open( "SerialReader", timeout );
            inputStream = serialPort.getInputStream();
            serialPort.addEventListener( this );
            serialPort.notifyOnDataAvailable( true );
            serialPort.setSerialPortParams( rate, dataBits, stopBits, parity );
            isOpen = true;
        }
        catch ( PortInUseException e )
        {
           // 埠"+serialParams.get( PARAMS_PORT ).toString()+"已經被佔�?;
        }
        catch ( TooManyListenersException e )
        {
           //"埠"+serialParams.get( PARAMS_PORT ).toString()+"監聽者過�?;
        }
        catch ( UnsupportedCommOperationException e )
        {
           //"埠操作命令不支�?;
        }
        catch ( NoSuchPortException e )
        {
          //"埠"+serialParams.get( PARAMS_PORT ).toString()+"不存�?;
        }
        catch ( IOException e )
        {
           //"開啟埠"+serialParams.get( PARAMS_PORT ).toString()+"失敗";
        }
        serialParams.clear();
        Thread readThread = new Thread( this );
        readThread.start();
    }


     
    public void run()
    {
        try
        {
            Thread.sleep(50);
        }
        catch ( InterruptedException e )
        {
        }
    } 
    public void start(){
  try {  
 outputStream = serialPort.getOutputStream();
    } 
 catch (IOException e) {}
  try{ 
    readThread = new Thread(this);
	</span>readThread.start();
	</span>} 
	</span>catch (Exception e) {  }
   }  //start() end




   public void run(String message) {
   try { 
   Thread.sleep(4); 
           } 
   catch (InterruptedException e) {  } 
 try {
 if(message!=null&&message.length()!=0)
    { 
 System.out.println("run message:"+message);
         outputStream.write(message.getBytes());  
 }
} catch (IOException e) {}
   } 
    


    public void close() 
    { 
        if (isOpen)
        {
            try
            {
            <span style="white-space:pre">	</span>serialPort.notifyOnDataAvailable(false);
            <span style="white-space:pre">	</span>serialPort.removeEventListener();
                inputStream.close();
                serialPort.close();
                isOpen = false;
            } catch (IOException ex)
            {
            //"關閉串列埠失敗";
            }
        }
    }
    
    public void serialEvent( SerialPortEvent event )
    {
        try
        {
            Thread.sleep( delayRead );
        }
        catch ( InterruptedException e )
        {
            e.printStackTrace();
        }
        switch ( event.getEventType() )
        {
            case SerialPortEvent.BI: // 10
            case SerialPortEvent.OE: // 7
            case SerialPortEvent.FE: // 9
            case SerialPortEvent.PE: // 8
            case SerialPortEvent.CD: // 6
            case SerialPortEvent.CTS: // 3
            case SerialPortEvent.DSR: // 4
            case SerialPortEvent.RI: // 5
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2
                break;
            case SerialPortEvent.DATA_AVAILABLE: // 1
                try
                {
                    // 多次讀取,將所有資料讀�?
                     while (inputStream.available() > 0) {
                     numBytes = inputStream.read(readBuffer);
                     }
                     
                     //列印接收到的位元組資料的ASCII�?
                     for(int i=0;i<numBytes;i++){
                    <span style="white-space:pre">	</span>// System.out.println("msg[" + numBytes + "]: [" +readBuffer[i] + "]:"+(char)readBuffer[i]);
                     }
//                    numBytes = inputStream.read( readBuffer );
                    changeMessage( readBuffer, numBytes );
                }
                catch ( IOException e )
                {
                    e.printStackTrace();
                }
                break;
        }
    }


    // 通過observer pattern將收到的資料發�?給observer
    // 將buffer中的空位元組刪除後再發送更新消�?通知觀察�?
    public void changeMessage( byte[] message, int length )
    {
        setChanged();
        byte[] temp = new byte[length];
        System.arraycopy( message, 0, temp, 0, length );
        notifyObservers( temp );
    }


    static void listPorts()
    {
        Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
        while ( portEnum.hasMoreElements() )
        {
            CommPortIdentifier portIdentifier = ( CommPortIdentifier ) portEnum
                .nextElement();
            
        }
    }
    
    
    public void openSerialPort(String message)
    {
        HashMap<String, Comparable> params = new HashMap<String, Comparable>();  
        String port="COM1";
        String rate = "9600";
        String dataBit = ""+SerialPort.DATABITS_8;
        String stopBit = ""+SerialPort.STOPBITS_1;
        String parity = ""+SerialPort.PARITY_NONE;    
        int parityInt = SerialPort.PARITY_NONE; 
        params.put( SerialReader.PARAMS_PORT, port ); // 埠名稱
        params.put( SerialReader.PARAMS_RATE, rate ); // 波特�?
        params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 資料�?
        params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止�?
        params.put( SerialReader.PARAMS_PARITY, parityInt ); // 無奇偶校�?
        params.put( SerialReader.PARAMS_TIMEOUT, 100 ); // 裝置超時時間 1�?
        params.put( SerialReader.PARAMS_DELAY, 100 ); // 埠資料準備時間 1�?
        try {
open(params);//開啟串列埠
//LoginFrame cf=new LoginFrame();
//addObserver(cf);
//也可以像上面�?��通過LoginFrame來繫結串列埠的通訊輸出.
if(message!=null&&message.length()!=0)
 {
String str="";
for(int i=0;i<10;i++)
{
str+=message;
}
 start(); 
    run(str);  
 } 
} catch (Exception e) { 
}
    }


    static String getPortTypeName( int portType )
    {
        switch ( portType )
        {
            case CommPortIdentifier.PORT_I2C:
                return "I2C";
            case CommPortIdentifier.PORT_PARALLEL:
                return "Parallel";
            case CommPortIdentifier.PORT_RAW:
                return "Raw";
            case CommPortIdentifier.PORT_RS485:
                return "RS485";
            case CommPortIdentifier.PORT_SERIAL:
                return "Serial";
            default:
                return "unknown type";
        }
    }


     
    public  HashSet<CommPortIdentifier> getAvailableSerialPorts()//本來static
    {
        HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();
        Enumeration thePorts = CommPortIdentifier.getPortIdentifiers();
        while ( thePorts.hasMoreElements() )
        {
            CommPortIdentifier com = ( CommPortIdentifier ) thePorts
                .nextElement();
            switch ( com.getPortType() )
            {
                case CommPortIdentifier.PORT_SERIAL:
                    try
                    {
                        CommPort thePort = com.open( "CommUtil", 50 );
                        thePort.close();
                        h.add( com );
                    }
                    catch ( PortInUseException e )
                    {
                        System.out.println( "Port, " + com.getName()
                            + ", is in use." );
                    }
                    catch ( Exception e )
                    {
                        System.out.println( "Failed to open port "
                            + com.getName() + e );
                    }
            }
        }
        return h;
    }
}
[html] view plain copy print?
  1. <p>  
  2. </p><p></p>package comme64;</p> /*  
  3.   *資料位 8  
  4.  * 校驗位 0  
  5.  * 停止位 1  
  6.  * 波特率 115200  
  7.  * 埠com3  
  8.   */  
  9. import gnu.io.SerialPort;  
  10. import java.util.*;  
  11. public class Test implements Observer{   
  12. public static void main(String []args)  
  13. {  
  14. Test test = new Test();  
  15. test.send("串列埠資料傳送至DTU轉發至伺服器!");  
  16. while(true)  
  17. {  
  18. test.send("串列埠資料傳送至DTU轉發至伺服器!");  
  19. }  
  20. }  
  21. SerialReader sr=new SerialReader();   
  22. //    public Test()  
  23. //    {      
  24. //       openSerialPort("COM3"); //開啟串列埠。  
  25. //    }   
  26.     public void update(Observable o, Object arg){      
  27.     String mt=new String((byte[])arg);    
  28.     System.out.println("---"+mt); //串列埠資料   
  29.     }   
  30.     /**  
  31.      * 往串列埠傳送資料,實現雙向通訊.  
  32.      * @param string message  
  33.      */  
  34.     public  void send(String message)  
  35.     {  
  36.     <span style="white-space:pre">  </span>Test test = new Test();  
  37.     <span style="white-space:pre">  </span>test.openSerialPort(message);  
  38.     }  
  39. <span style="white-space:pre">    </span>  
  40.     /**  
  41.      * 開啟串列埠  
  42.      * @param String message  
  43.      */  
  44. <span style="white-space:pre">    </span>public void openSerialPort(String message)  
  45.     {   
  46.         HashMap<String, Comparable> params = new HashMap<String, Comparable>();    
  47.         String port="COM3";  
  48.         String rate = "115200";  
  49.         String dataBit = ""+SerialPort.DATABITS_8;  
  50.         String stopBit = ""+SerialPort.STOPBITS_1;  
  51.         String parity = ""+SerialPort.PARITY_NONE;      
  52.         int parityInt = SerialPort.PARITY_NONE;   
  53.         params.put( SerialReader.PARAMS_PORT, port ); // 埠名稱  
  54.         params.put( SerialReader.PARAMS_RATE, rate ); // 波特率  
  55.         params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 資料位  
  56.         params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止位  
  57.         params.put( SerialReader.PARAMS_PARITY, parityInt ); // 無奇偶校驗  
  58.         params.put( SerialReader.PARAMS_TIMEOUT,100 ); // 裝置超時時間 1秒  
  59.         params.put( SerialReader.PARAMS_DELAY, 100 ); // 埠資料準備時間 1秒  
  60.         try {  
  61. sr.open(params);  
  62.    sr.addObserver(this);  
  63. if(message!=null&&message.length()!=0)  
  64.  {    
  65. sr.start();    
  66. sr.run(message);    
  67.  }   
  68. } catch (Exception e) {   
  69. }  
  70.     }  
  71.  public String Bytes2HexString(byte[] b) {   
  72.   String ret = "";   
  73.   for (int i = 0; i < b.length; i++) {   
  74.      String hex = Integer.toHexString(b[i] & 0xFF);   
  75.     if (hex.length() == 1) {   
  76.       hex = '0' + hex;   
  77.     }   
  78.    ret += hex.toUpperCase();   
  79.  }  
  80. return ret;  
  81.   }  
  82.  public  String hexString2binaryString(String hexString) {  
  83.  if (hexString == null || hexString.length() % 2 != 0)  
  84. return null;  
  85.  String bString = "", tmp;  
  86. for (int i = 0; i < hexString.length(); i++) {  
  87.  tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));  
  88. bString += tmp.substring(tmp.length() - 4);  
  89.  }  
  90.  return bString;  
  91.  }   
  92. }   
<p>
</p><p></p>package comme64;</p> /*
  *資料位 8
 * 校驗位 0
 * 停止位 1
 * 波特率 115200
 * 埠com3
  */
import gnu.io.SerialPort;


import java.util.*;


public class Test implements Observer{ 
public static void main(String []args)
{
Test test = new Test();
test.send("串列埠資料傳送至DTU轉發至伺服器!");
while(true)
{
test.send("串列埠資料傳送至DTU轉發至伺服器!");
}
}
SerialReader sr=new SerialReader(); 
//    public Test()
//    {    
//       openSerialPort("COM3"); //開啟串列埠。
//    } 
    public void update(Observable o, Object arg){    
    String mt=new String((byte[])arg);  
    System.out.println("---"+mt); //串列埠資料 
    } 
    
    /**
     * 往串列埠傳送資料,實現雙向通訊.
     * @param string message
     */
    public  void send(String message)
    {
    <span style="white-space:pre">	</span>Test test = new Test();
    <span style="white-space:pre">	</span>test.openSerialPort(message);
    }
<span style="white-space:pre">	</span>
    /**
     * 開啟串列埠
     * @param String message
     */
<span style="white-space:pre">	</span>public void openSerialPort(String message)
    { 
        HashMap<String, Comparable> params = new HashMap<String, Comparable>();  
        String port="COM3";
        String rate = "115200";
        String dataBit = ""+SerialPort.DATABITS_8;
        String stopBit = ""+SerialPort.STOPBITS_1;
        String parity = ""+SerialPort.PARITY_NONE;    
        int parityInt = SerialPort.PARITY_NONE; 
        params.put( SerialReader.PARAMS_PORT, port ); // 埠名稱
        params.put( SerialReader.PARAMS_RATE, rate ); // 波特率
        params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 資料位
        params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止位
        params.put( SerialReader.PARAMS_PARITY, parityInt ); // 無奇偶校驗
        params.put( SerialReader.PARAMS_TIMEOUT,100 ); // 裝置超時時間 1秒
        params.put( SerialReader.PARAMS_DELAY, 100 ); // 埠資料準備時間 1秒
        try {
sr.open(params);
   sr.addObserver(this);
if(message!=null&&message.length()!=0)
 {  
sr.start();  
sr.run(message);  
 } 
} catch (Exception e) { 
}
    }
    

 public String Bytes2HexString(byte[] b) { 
  String ret = ""; 
  for (int i = 0; i < b.length; i++) { 
     String hex = Integer.toHexString(b[i] & 0xFF); 
    if (hex.length() == 1) { 
      hex = '0' + hex; 
    } 
   ret += hex.toUpperCase(); 
 }
return ret;
  }


 public  String hexString2binaryString(String hexString) {
 if (hexString == null || hexString.length() % 2 != 0)
return null;
 String bString = "", tmp;
for (int i = 0; i < hexString.length(); i++) {
 tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));
bString += tmp.substring(tmp.length() - 4);
 }
 return bString;
 } 
} 

 通過Test.java的測試，可以成功把資料傳送出去，這裡還是要注意埠的以及波特率的正確。

相關推薦

64位電腦通過串列埠傳送資料到硬體

首先下載：RXTX的包，（僅64位有效）Rxtx開源包下載地址：1、把rxtxParallel.dll、rxtxSerial.dll拷貝到：C:\WINDOWS\system32下。 2、如果是在開發的時候(JDK),需要把RXTXcomm.jar、rxtxParallel

關於arduino通過串列埠傳送到processing的資料混亂（錯誤\顯示不正確）的問題解答

最近的教學中，已經開始使用processing和arduino進行串列埠通訊的互動，使用中發現有的同學遇到了arduino傳送給processing的資料存在顯示不正確，甚至混亂的現象。這裡給予統一解釋。 arduino程式碼完成的工作是將模擬訊號口讀入模擬資料，然後經過map對映為0到

QT 使用QextSerialPort類通過串列埠接收資料時出現readyread()不產生訊號

QT 使用QextSerialPort類通過串列埠接收資料時出現readyread()不產生訊號，槽函式無響應，試了很多辦法，在網上找到的都是QT5自帶的QtSerialPort類問題，對我這個問題都不好使。 其實很簡單，將串列埠設定為事件驅動模式就好

菜鳥江濤帶你學最小物聯網系統之模組篇（02）——STM32通過串列埠傳送AT指令控制ESP模組連線伺服器

接著上一篇繼續，這篇部落格我將帶大家使用STM32的串列埠來發送AT指令給ESP模組連線伺服器。當然目前測試使用的是區域網，自己的電腦當伺服器使用。使用TCP連線伺服器，STM32通過ESP12F模組透傳上傳溫溼度資料到伺服器。看下效果圖片 好了，看下主要的實現程式

串列埠傳送資料查詢方式與中斷方式

微控制器採用中斷或查詢方式使用串列埠，這是根據實際應用的需要確定的，沒有好/壞之分。有時之所以採用查詢方式處理串列埠程式，是因為應用程式不苛刻微控制器的時間資源，採用查詢的方式就能滿足應用的需要，所以沒采用中斷。大量連續的向串列埠傳送資料，就沒有必要使用中斷了，因為微控制器根

STM32的串列埠傳送資料（字元，字串，數字.......）（重點）

#include "stm32f10x.h" #include <stdio.h>    //下面strlen函式需要此標頭檔案 #include "USART.h" /**********************************************

移遠BC95 NB-IoT模組串列埠傳送資料到伺服器

    本文適用於對NB-IoT一無所知的小白。目的是通過NB-IoT協議將資料傳送到伺服器端。     現在已有不少NB-IoT模組，本人採用的是移遠的BC95模組。     接線：外接電源供電 串列埠接右下角三個介面，GND

關於微控制器通過串列埠傳送浮點數資訊

最近弄一個小東西的時候，需要將AD採集的資料，通過串列埠傳送上位機。由於還得在下位機部分顯示出來，所以這個AD採集的資料轉換之後傳送到串列埠，比較容易點。但是問題來了，以前的串列埠，只有從GPS模組接收的資訊是浮點型別外。其他的東西，都只是把字元型別或者字串型別

安卓通過串列埠獲得資料，步驟

1、複製jni資料夾 2、複製lib資料夾 3、複製android_serialport_api 資料夾 4、修改 manifest檔案 <application  android:name="android_serialport_api.sample.Appli

串列埠傳送資料

今晚著急搞F0的處理器，以後會把原因搞明白，現在僅當是做記錄                                                                                          使用串列埠做資料傳送時，使用pri

ubuntu下使用kermit協議,通過串列埠傳送檔案

折騰了一天，終於在ubuntu下面成功通過c-kermit軟體，呼叫kermit協議，將核心檔案傳送到開發板裡面。紀錄一下其中的曲折過程。T____T (1) minicom 首先使用minicom就是一個錯誤，然後鑽牛角尖了，想法設法去使用minicom，其實一開始就應該

C語言實現兩臺電腦通過串列埠通訊

用C語言實現在傳送端控制檯輸入字串並在接收端接收顯示的功能。 /*********************server.c****************/#include<stdio.h>#include<sys/types.h>#include

MSP430按鍵控制串列埠傳送資料

#include <msp430.h> //MSP430G2553  - 使用USCI_A0,Up Mode, DCO SMCLK // //  介紹: 該程式利用USCI_A0來與計算機通訊 通過接在P1.3口的按鍵來實現按一次傳送一個數據 //  波特率96

STM32串列埠傳送資料和接收資料方式總結

       之前寫了篇關於ESP8266使用AT指令進行互相通訊的實驗，在寫STM32串列埠接發資料的程式中，覺得有必要將之前學的有關於串列埠方面的使用經歷加以總結。 串列埠傳送資料：        1. 串列埠傳送資料最直接的方式就是標準呼叫庫函式 。 void

樹莓派3B在Qt下使用串列埠傳送資料

一、解除串口占用 使用putty的時候神奇的發現樹莓派竟然是支援serial進行操作。試了試，和在ssh下使用沒有多少區別，速度也很快。 樹莓派的串列埠主要也就是被這個佔用了，配置釋放之後才能使用它來進行串列埠通訊。 在命令列裡輸入如下指令：

使用python在openwrt下操作串列埠傳送十六進位制資料

#!/usr/bin/python import serial from time import sleep ser = serial.Serial('/dev/ttyS0', 9600, timeout=0.5) print ser.port print ser.baudrate if

FPGA 學習筆記（十二） 如何用串列埠傳送32位資料？

在筆者之前所用的串列埠中，串列埠一次只能傳送資料為8位，這跟串列埠通訊的協議方式有關係。而最近筆者的專案中需要用到一次傳送32位的資料。筆者最開始想到的是32位資料傳送4次。 為了不改動原來的串列埠通訊協議驅動，筆者設計瞭如下發送方式： 設計四個狀態stat

串列埠通訊資料傳送--字元傳送和16進位制傳送--傳送位元組的間隔時間

在計算機中，所有的資料在儲存和運算時都要使用二進位制數表示（因為計算機用高電平和低電平分別表示1和0），例如，像a、b、c、d這樣的52個字母（包括大寫）、以及0、1等數字還有一些常用的符號（例如*、#、@等）在計算機中儲存時也要使用二進位制數來表示，而具體用哪些二進位制數字

VB 串列埠傳送,將文字中的字串轉化成16進位制資料傳送

VB寫一個串列埠傳送程式碼，遇到一個問題，如何將文字中的字串轉化成16進位制資料傳送。 Dim bindate(200) As String Dim senddata As String ‘定義輸入字串變

把資料通過串列埠或USB以1秒間隔實時發給另外一臺計算機，在另外一臺計算機上以同樣方式顯示條形圖或趨勢曲線。

前面兩篇文章已經講過了隨機資料產生，繪製直方圖，趨勢圖，資料儲存，串列埠傳送。接下來則是串列埠接收部分的程式。 注意：如果在一臺電腦上進行除錯，需要用虛擬串列埠軟體把串列埠1，2連結起來。 // 作業Dlg.cpp : 實現檔案 // #includ