64位电脑通过串口发送数据到硬件

本文提供了一个Java串口通信的示例代码,演示了如何使用RXTX库进行串口配置、数据发送与接收,并展示了如何实现串口监听及数据处理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

首先下载: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).

  1. package comme64;  
  2. import gnu.io.*;  
  3. import java.io.*;   
  4. import java.util.*;    
  5.    
  6.    
  7. public class SerialReader extends Observable implements Runnable,SerialPortEventListener  
  8.     {  
  9.     static CommPortIdentifier portId;  
  10.     int delayRead = 100;  
  11.     int numBytes; //   
  12.     private static byte[] readBuffer = new byte[1024]; //  
  13.     static Enumeration portList;  
  14.     InputStream inputStream;  
  15.     OutputStream outputStream;  
  16.     static SerialPort serialPort;  
  17.     HashMap serialParams;  
  18.     Thread readThread;  
  19.      
  20.     boolean isOpen = false;  
  21.      
  22.     public static final String PARAMS_DELAY = "delay read"; //   
  23.     public static final String PARAMS_TIMEOUT = "timeout"; // 超时时间  
  24.     public static final String PARAMS_PORT = "port name"; // 端口名称  
  25.     public static final String PARAMS_DATABITS = "data bits"; //  
  26.     public static final String PARAMS_STOPBITS = "stop bits"; //  
  27.     public static final String PARAMS_PARITY = "parity"; // 奇偶校验  
  28.     public static final String PARAMS_RATE = "rate"; //   
  29.   
  30.   
  31.     public boolean isOpen(){  
  32.     <span style="white-space:pre">  </span>return isOpen;  
  33.     }  
  34.     /**  
  35.      * 初始化端口操作的参数.  
  36.      * @throws SerialPortException   
  37.      *   
  38.      * @see  
  39.      */  
  40.     public SerialReader()  
  41.     {  
  42.     <span style="white-space:pre">  </span>isOpen = false;  
  43.     }  
  44.   
  45.   
  46.     public void open(HashMap params)  
  47.     {   
  48.     <span style="white-space:pre">  </span>serialParams = params;  
  49.     <span style="white-space:pre">  </span>if(isOpen){  
  50.     <span style="white-space:pre">      </span>close();  
  51.     <span style="white-space:pre">  </span>}  
  52.         try  
  53.         {  
  54.             // 参数初始  
  55.             int timeout = Integer.parseInt( serialParams.get( PARAMS_TIMEOUT )  
  56.                 .toString() );  
  57.             int rate = Integer.parseInt( serialParams.get( PARAMS_RATE )  
  58.                 .toString() );  
  59.             int dataBits = Integer.parseInt( serialParams.get( PARAMS_DATABITS )  
  60.                 .toString() );  
  61.             int stopBits = Integer.parseInt( serialParams.get( PARAMS_STOPBITS )  
  62.                 .toString() );  
  63.             int parity = Integer.parseInt( serialParams.get( PARAMS_PARITY )  
  64.                 .toString() );  
  65.             delayRead = Integer.parseInt( serialParams.get( PARAMS_DELAY )  
  66.                 .toString() );  
  67.             String port = serialParams.get( PARAMS_PORT ).toString();  
  68.             // 打开端口  
  69.             portId = CommPortIdentifier.getPortIdentifier( port );  
  70.             serialPort = ( SerialPort ) portId.open( "SerialReader", timeout );  
  71.             inputStream = serialPort.getInputStream();  
  72.             serialPort.addEventListener( this );  
  73.             serialPort.notifyOnDataAvailable( true );  
  74.             serialPort.setSerialPortParams( rate, dataBits, stopBits, parity );  
  75.             isOpen = true;  
  76.         }  
  77.         catch ( PortInUseException e )  
  78.         {  
  79.            // 端口"+serialParams.get( PARAMS_PORT ).toString()+"已经被占�?;  
  80.         }  
  81.         catch ( TooManyListenersException e )  
  82.         {  
  83.            //"端口"+serialParams.get( PARAMS_PORT ).toString()+"监听者过�?;  
  84.         }  
  85.         catch ( UnsupportedCommOperationException e )  
  86.         {  
  87.            //"端口操作命令不支�?;  
  88.         }  
  89.         catch ( NoSuchPortException e )  
  90.         {  
  91.           //"端口"+serialParams.get( PARAMS_PORT ).toString()+"不存�?;  
  92.         }  
  93.         catch ( IOException e )  
  94.         {  
  95.            //"打开端口"+serialParams.get( PARAMS_PORT ).toString()+"失败";  
  96.         }  
  97.         serialParams.clear();  
  98.         Thread readThread = new Thread( this );  
  99.         readThread.start();  
  100.     }  
  101.   
  102.   
  103.        
  104.     public void run()  
  105.     {  
  106.         try  
  107.         {  
  108.             Thread.sleep(50);  
  109.         }  
  110.         catch ( InterruptedException e )  
  111.         {  
  112.         }  
  113.     }   
  114.     public void start(){  
  115.   try {    
  116.  outputStream = serialPort.getOutputStream();  
  117.     }   
  118.  catch (IOException e) {}  
  119.   try{   
  120.     readThread = new Thread(this);  
  121.     </span>readThread.start();  
  122.     </span>}   
  123.     </span>catch (Exception e) {  }  
  124.    }  //start() end  
  125.   
  126.   
  127.   
  128.   
  129.    public void run(String message) {  
  130.    try {   
  131.    Thread.sleep(4);   
  132.            }   
  133.    catch (InterruptedException e) {  }   
  134.  try {  
  135.  if(message!=null&&message.length()!=0)  
  136.     {   
  137.  System.out.println("run message:"+message);  
  138.          outputStream.write(message.getBytes());    
  139.  }  
  140. } catch (IOException e) {}  
  141.    }   
  142.       
  143.   
  144.   
  145.     public void close()   
  146.     {   
  147.         if (isOpen)  
  148.         {  
  149.             try  
  150.             {  
  151.             <span style="white-space:pre">  </span>serialPort.notifyOnDataAvailable(false);  
  152.             <span style="white-space:pre">  </span>serialPort.removeEventListener();  
  153.                 inputStream.close();  
  154.                 serialPort.close();  
  155.                 isOpen = false;  
  156.             } catch (IOException ex)  
  157.             {  
  158.             //"关闭串口失败";  
  159.             }  
  160.         }  
  161.     }  
  162.       
  163.     public void serialEvent( SerialPortEvent event )  
  164.     {  
  165.         try  
  166.         {  
  167.             Thread.sleep( delayRead );  
  168.         }  
  169.         catch ( InterruptedException e )  
  170.         {  
  171.             e.printStackTrace();  
  172.         }  
  173.         switch ( event.getEventType() )  
  174.         {  
  175.             case SerialPortEvent.BI: // 10  
  176.             case SerialPortEvent.OE: // 7  
  177.             case SerialPortEvent.FE: // 9  
  178.             case SerialPortEvent.PE: // 8  
  179.             case SerialPortEvent.CD: // 6  
  180.             case SerialPortEvent.CTS: // 3  
  181.             case SerialPortEvent.DSR: // 4  
  182.             case SerialPortEvent.RI: // 5  
  183.             case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2  
  184.                 break;  
  185.             case SerialPortEvent.DATA_AVAILABLE: // 1  
  186.                 try  
  187.                 {  
  188.                     // 多次读取,将所有数据读�?  
  189.                      while (inputStream.available() > 0) {  
  190.                      numBytes = inputStream.read(readBuffer);  
  191.                      }  
  192.                        
  193.                      //打印接收到的字节数据的ASCII�?  
  194.                      for(int i=0;i<numBytes;i++){  
  195.                     <span style="white-space:pre">  </span>// System.out.println("msg[" + numBytes + "]: [" +readBuffer[i] + "]:"+(char)readBuffer[i]);  
  196.                      }  
  197. //                    numBytes = inputStream.read( readBuffer );  
  198.                     changeMessage( readBuffer, numBytes );  
  199.                 }  
  200.                 catch ( IOException e )  
  201.                 {  
  202.                     e.printStackTrace();  
  203.                 }  
  204.                 break;  
  205.         }  
  206.     }  
  207.   
  208.   
  209.     // 通过observer pattern将收到的数据发�?给observer  
  210.     // 将buffer中的空字节删除后再发送更新消�?通知观察�?  
  211.     public void changeMessage( byte[] message, int length )  
  212.     {  
  213.         setChanged();  
  214.         byte[] temp = new byte[length];  
  215.         System.arraycopy( message, 0, temp, 0, length );  
  216.         notifyObservers( temp );  
  217.     }  
  218.   
  219.   
  220.     static void listPorts()  
  221.     {  
  222.         Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();  
  223.         while ( portEnum.hasMoreElements() )  
  224.         {  
  225.             CommPortIdentifier portIdentifier = ( CommPortIdentifier ) portEnum  
  226.                 .nextElement();  
  227.               
  228.         }  
  229.     }  
  230.       
  231.       
  232.     public void openSerialPort(String message)  
  233.     {  
  234.         HashMap<String, Comparable> params = new HashMap<String, Comparable>();    
  235.         String port="COM1";  
  236.         String rate = "9600";  
  237.         String dataBit = ""+SerialPort.DATABITS_8;  
  238.         String stopBit = ""+SerialPort.STOPBITS_1;  
  239.         String parity = ""+SerialPort.PARITY_NONE;      
  240.         int parityInt = SerialPort.PARITY_NONE;   
  241.         params.put( SerialReader.PARAMS_PORT, port ); // 端口名称  
  242.         params.put( SerialReader.PARAMS_RATE, rate ); // 波特�?  
  243.         params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 数据�?  
  244.         params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止�?  
  245.         params.put( SerialReader.PARAMS_PARITY, parityInt ); // 无奇偶校�?  
  246.         params.put( SerialReader.PARAMS_TIMEOUT, 100 ); // 设备超时时间 1�?  
  247.         params.put( SerialReader.PARAMS_DELAY, 100 ); // 端口数据准备时间 1�?  
  248.         try {  
  249. open(params);//打开串口  
  250. //LoginFrame cf=new LoginFrame();  
  251. //addObserver(cf);  
  252. //也可以像上面�?��通过LoginFrame来绑定串口的通讯输出.  
  253. if(message!=null&&message.length()!=0)  
  254.  {  
  255. String str="";  
  256. for(int i=0;i<10;i++)  
  257. {  
  258. str+=message;  
  259. }  
  260.  start();   
  261.     run(str);    
  262.  }   
  263. } catch (Exception e) {   
  264. }  
  265.     }  
  266.   
  267.   
  268.     static String getPortTypeName( int portType )  
  269.     {  
  270.         switch ( portType )  
  271.         {  
  272.             case CommPortIdentifier.PORT_I2C:  
  273.                 return "I2C";  
  274.             case CommPortIdentifier.PORT_PARALLEL:  
  275.                 return "Parallel";  
  276.             case CommPortIdentifier.PORT_RAW:  
  277.                 return "Raw";  
  278.             case CommPortIdentifier.PORT_RS485:  
  279.                 return "RS485";  
  280.             case CommPortIdentifier.PORT_SERIAL:  
  281.                 return "Serial";  
  282.             default:  
  283.                 return "unknown type";  
  284.         }  
  285.     }  
  286.   
  287.   
  288.        
  289.     public  HashSet<CommPortIdentifier> getAvailableSerialPorts()//本来static  
  290.     {  
  291.         HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();  
  292.         Enumeration thePorts = CommPortIdentifier.getPortIdentifiers();  
  293.         while ( thePorts.hasMoreElements() )  
  294.         {  
  295.             CommPortIdentifier com = ( CommPortIdentifier ) thePorts  
  296.                 .nextElement();  
  297.             switch ( com.getPortType() )  
  298.             {  
  299.                 case CommPortIdentifier.PORT_SERIAL:  
  300.                     try  
  301.                     {  
  302.                         CommPort thePort = com.open( "CommUtil", 50 );  
  303.                         thePort.close();  
  304.                         h.add( com );  
  305.                     }  
  306.                     catch ( PortInUseException e )  
  307.                     {  
  308.                         System.out.println( "Port, " + com.getName()  
  309.                             + ", is in use." );  
  310.                     }  
  311.                     catch ( Exception e )  
  312.                     {  
  313.                         System.out.println( "Failed to open port "  
  314.                             + com.getName() + e );  
  315.                     }  
  316.             }  
  317.         }  
  318.         return h;  
  319.     }  
  320. }  
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;
    }
}
  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.   
  11.   
  12. import java.util.*;  
  13.   
  14.   
  15. public class Test implements Observer{   
  16. public static void main(String []args)  
  17. {  
  18. Test test = new Test();  
  19. test.send("串口数据发送至DTU转发至服务器!");  
  20. while(true)  
  21. {  
  22. test.send("串口数据发送至DTU转发至服务器!");  
  23. }  
  24. }  
  25. SerialReader sr=new SerialReader();   
  26. //    public Test()  
  27. //    {      
  28. //       openSerialPort("COM3"); //打开串口。  
  29. //    }   
  30.     public void update(Observable o, Object arg){      
  31.     String mt=new String((byte[])arg);    
  32.     System.out.println("---"+mt); //串口数据   
  33.     }   
  34.       
  35.     /**  
  36.      * 往串口发送数据,实现双向通讯.  
  37.      * @param string message  
  38.      */  
  39.     public  void send(String message)  
  40.     {  
  41.     <span style="white-space:pre">  </span>Test test = new Test();  
  42.     <span style="white-space:pre">  </span>test.openSerialPort(message);  
  43.     }  
  44. <span style="white-space:pre">    </span>  
  45.     /**  
  46.      * 打开串口  
  47.      * @param String message  
  48.      */  
  49. <span style="white-space:pre">    </span>public void openSerialPort(String message)  
  50.     {   
  51.         HashMap<String, Comparable> params = new HashMap<String, Comparable>();    
  52.         String port="COM3";  
  53.         String rate = "115200";  
  54.         String dataBit = ""+SerialPort.DATABITS_8;  
  55.         String stopBit = ""+SerialPort.STOPBITS_1;  
  56.         String parity = ""+SerialPort.PARITY_NONE;      
  57.         int parityInt = SerialPort.PARITY_NONE;   
  58.         params.put( SerialReader.PARAMS_PORT, port ); // 端口名称  
  59.         params.put( SerialReader.PARAMS_RATE, rate ); // 波特率  
  60.         params.put( SerialReader.PARAMS_DATABITS,dataBit  ); // 数据位  
  61.         params.put( SerialReader.PARAMS_STOPBITS, stopBit ); // 停止位  
  62.         params.put( SerialReader.PARAMS_PARITY, parityInt ); // 无奇偶校验  
  63.         params.put( SerialReader.PARAMS_TIMEOUT,100 ); // 设备超时时间 1秒  
  64.         params.put( SerialReader.PARAMS_DELAY, 100 ); // 端口数据准备时间 1秒  
  65.         try {  
  66. sr.open(params);  
  67.    sr.addObserver(this);  
  68. if(message!=null&&message.length()!=0)  
  69.  {    
  70. sr.start();    
  71. sr.run(message);    
  72.  }   
  73. } catch (Exception e) {   
  74. }  
  75.     }  
  76.       
  77.   
  78.  public String Bytes2HexString(byte[] b) {   
  79.   String ret = "";   
  80.   for (int i = 0; i < b.length; i++) {   
  81.      String hex = Integer.toHexString(b[i] & 0xFF);   
  82.     if (hex.length() == 1) {   
  83.       hex = '0' + hex;   
  84.     }   
  85.    ret += hex.toUpperCase();   
  86.  }  
  87. return ret;  
  88.   }  
  89.   
  90.   
  91.  public  String hexString2binaryString(String hexString) {  
  92.  if (hexString == null || hexString.length() % 2 != 0)  
  93. return null;  
  94.  String bString = "", tmp;  
  95. for (int i = 0; i < hexString.length(); i++) {  
  96.  tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));  
  97. bString += tmp.substring(tmp.length() - 4);  
  98.  }  
  99.  return bString;  
  100.  }   
  101. }   
<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的测试,可以成功把数据发送出去,这里还是要注意端口的以及波特率的正确。

<think>我们正在讨论如何通过串口将单片机数据发送到电脑。根据提供的引用内容,我们可以总结出以下关键步骤: 1. **硬件连接**:确保单片机与电脑通过串口(如USB转TTL模块)正确连接。 2. **单片机串口配置**:配置单片机的串口相关寄存器,包括工作模式、波特率等。 3. **数据包设计**(可选):如果需要发送多个数据或更复杂的信息,可以设计数据包(包括数据头、数据尾等)。 4. **发送数据**:单片机通过串口发送数据(单个字节或数据包)。 5. **电脑端接收**:使用串口助手等工具设置相同的波特率等参数,接收并显示数据。 下面详细说明: ### 1. 硬件连接 - 使用USB转TTL模块连接单片机与电脑: - 单片机的TXD引脚连接USB转TTL模块的RXD。 - 单片机的RXD引脚连接USB转TTL模块的TXD。 - 共地(GND连接)。 ### 2. 单片机串口配置(以51单片机为例) 根据引用[2][^2]和引用[3][^3],配置串口的工作模式和波特率: - 设置SCON寄存器:选择工作模式1(8UART,波特率可变)。将SM0置0,SM1置1,即`SM0=0, SM1=1`。如果需要接收数据,将REN置1(允许接收),否则可以置0。因此,SCON可以设置为`0x50`(允许接收)或`0x40`(不允许接收)。 - 设置波特率:使用定时器1作为波特率发生器。通常设置为模式2(8自动重装),所以TMOD寄存器的定时器1部分设置为`0x20`(即高4为0010,低4不变,通常低4用于定时器0,如果定时器0不用,则整个TMOD可设为0x20)。 - 计算定时器1的初值(TH1, TL1)以得到所需的波特率。例如,当波特率为4800时,若晶振频率为11.0592MHz,则初值计算如下: 波特率计算公式:$$ \text{波特率} = \frac{2^{SMOD}}{32} \times \frac{\text{定时器1溢出率}}{12} $$ 在模式2下,定时器1溢出率 = 晶振频率 / (12 × (256 - TH1))。 因此,$$ 4800 = \frac{2^0}{32} \times \frac{11059200}{12 \times (256 - TH1)} $$ 解得:TH1 = 256 - 11059200/(32×12×4800) ≈ 244(即0xF4)。 - 开启定时器1:将TCON中的TR1置1(`TR1=1`)。 - 开启串口中断(可选):如果需要中断方式发送/接收,则需设置中断允许寄存器IE(EA=1, ES=1)。 ### 3. 数据包设计(可选) 根据引用[1][^1],为了发送更多信息,可以设计固定格式的数据包。例如: - 数据头:1字节,如'@'(0x40) - 数据内容:若干字节(根据需求定义) - 数据尾:1字节,如'&'(0x26) ### 4. 发送数据 - 单个字节发送:将数据写入SBUF寄存器,硬件会自动发送。 例如:`SBUF = 'A';` 发送字符'A'。 - 数据包发送:按照设计的格式依次发送每个字节。 例如: ```c void UART_SendData(unsigned char dat) { SBUF = dat; while(TI == 0); // 等待发送完成 TI = 0; // 清除发送中断标志 } void UART_SendPacket(unsigned char *data, unsigned char len) { UART_SendData('@'); // 数据头 for (unsigned char i=0; i<len; i++) { UART_SendData(data[i]); } UART_SendData('&'); // 数据尾 } ``` ### 5. 电脑端接收 - 使用串口助手(如STC-ISP自带的串口助手、友善串口助手等): - 选择正确的串口号(COM口)。 - 设置波特率(与单片机一致,如4800)。 - 设置数据(8)、停止(1)、校验(无)。 - 打开串口,即可接收单片机发送的数据。 ### 示例代码(51单片机) ```c #include <reg52.h> void UART_Init() { SCON = 0x50; // 工作方式1,允许接收(REN=1) TMOD = 0x20; // 定时器1工作方式2(8自动重装) TH1 = 0xF4; // 波特率4800(11.0592MHz晶振) TL1 = 0xF4; TR1 = 1; // 启动定时器1 // 如果需要中断,则开启中断:EA=1; ES=1; } void UART_SendByte(unsigned char dat) { SBUF = dat; while(TI == 0); // 等待发送完成 TI = 0; // 清除发送中断标志 } void main() { UART_Init(); while(1) { // 发送单个字符 UART_SendByte('H'); UART_SendByte('e'); UART_SendByte('l'); UART_SendByte('l'); UART_SendByte('o'); // 或者发送数据包 // unsigned char data[] = {'H','e','l','l','o'}; // UART_SendPacket(data, 5); // 需要先定义UART_SendPacket函数 // 延时 for (int i=0; i<30000; i++); } } ``` ### 注意事项 - 波特率设置必须一致:单片机与串口助手的波特率、数据、停止、校验必须相同。 - 发送数据时,注意等待TI标志置后再清除,才能发送下一个字节。 - 如果使用中断方式,则需要在中断服务程序中处理发送完成和接收完成事件。 以上步骤实现了单片机通过串口电脑发送数据电脑端通过串口助手可以接收到单片机发送的字符"Hello"。 §§相关问题§§ 1. 如何设计串口通信的数据包格式以提高数据传输效率? 2. 单片机串口通信中如何实现双向通信(既发送又接收)? 3. 如何通过串口发送浮点数或结构体数据?</think>### 单片机串口数据发送到电脑的实现方法 #### 1. **硬件连接** - **接线方式**: - 单片机 `TXD` 引脚 → USB转TTL模块的 `RXD` 引脚 - 单片机 `RXD` 引脚 → USB转TTL模块的 `TXD` 引脚 - 单片机 `GND` 引脚 → USB转TTL模块的 `GND` 引脚 - **工具**:使用 USB 转 TTL 模块(如 CH340、CP2102 等)连接电脑 USB 口。 #### 2. **单片机串口配置** 根据引用[2][^2]和引用[3][^3],配置步骤如下: - **工作模式**:选择模式 1(8 UART,波特率可变) ```c SCON = 0x50; // SM0=0, SM1=1(模式1), REN=1(允许接收) ``` - **波特率设置**(以 4800bps 为例): ```c TMOD = 0x20; // 定时器1工作模式2(8自动重装) TH1 = 0xF4; // 波特率4800(11.0592MHz晶振) TL1 = 0xF4; TR1 = 1; // 启动定时器1 ``` - **注意**:波特率需与电脑端完全一致(如 4800/9600/115200)[^3]。 #### 3. **数据发送方法** - **发送单个字节**: ```c void UART_SendByte(unsigned char dat) { SBUF = dat; // 数据写入发送缓冲器 while(TI == 0); // 等待发送完成 TI = 0; // 清除发送中断标志 } ``` - **发送字符串**: ```c void UART_SendString(char *str) { while(*str != '\0') { UART_SendByte(*str++); } } ``` - **发送数据包**(引用[1][^1]): ```c // 示例:发送固定格式数据包 "@abc&" void UART_SendPacket() { UART_SendByte('@'); // 数据头 UART_SendByte('a'); // 数据1 UART_SendByte('b'); // 数据2 UART_SendByte('c'); // 数据3 UART_SendByte('&'); // 数据尾 } ``` #### 4. **电脑端接收设置** 1. 打开串口助手(如 STC-ISP、XCOM 等) 2. 关键参数匹配: - 波特率:与单片机一致(如 4800) - 数据:8 - 停止:1 - 校验:无 3. 选择正确的 COM 端口(在设备管理器中查看) #### 5. **完整示例代码(51单片机)** ```c #include <reg52.h> void UART_Init() { SCON = 0x50; // 串口模式1,允许接收 TMOD = 0x20; // 定时器1模式2 TH1 = 0xF4; // 4800bps@11.0592MHz TL1 = 0xF4; TR1 = 1; // 启动定时器 } void UART_SendByte(unsigned char dat) { SBUF = dat; while(!TI); // 等待发送完成 TI = 0; } void main() { UART_Init(); while(1) { UART_SendString("Hello PC!\r\n"); // 发送字符串 // 或发送数据包 UART_SendByte('@'); UART_SendByte(0x41); // 'A'的ASCII UART_SendByte('&'); delay(1000); // 延时1秒 } } ``` #### 6. **调试技巧** 1. 用示波器检查单片机 TXD 引脚是否有波形 2. 检查 USB 转 TTL 模块的驱动是否安装 3. 确保共地连接(GND 相连) 4. 初次测试建议发送 ASCII 字符(如 `"TEST"`) > **关键点总结**: > - 波特率必须严格匹配 > - 数据包格式可自定义(头/尾标识提高可靠性)[^1] > - 8 UART 模式每次发送 1 字节[^2] > - 电脑串口助手需正确配置参数[^3]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值