java序列槽多線程一次性發送多條資料

給大家推薦一個開發人員學習使用的好網站：www.it123.top 

package com;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.TooManyListenersException;
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
public final class RXTXtest {
	private static String[] dataOpen = new String[]{"010000b7",
			"010000ac"};
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//獲得系統端口清單
		List<String> comList = getSystemPort();
		if(comList != null && !comList.isEmpty()){
			//開啟端口COM2，波特率9600
			final SerialPort serialPort = openSerialPort(comList.get(0),115200);
			//設定序列槽的listener
	       RXTXtest.setListenerToSerialPort(serialPort, new SerialPortEventListener() {
				@Override
				public void serialEvent(SerialPortEvent arg0) {
					if(arg0.getEventType() == SerialPortEvent.DATA_AVAILABLE) {//資料通知
						byte[] bytes = RXTXtest.readData(serialPort);
						System.out.println("收到的資料長度："+bytes.length);
						System.out.println("收到的資料："+ByteUtils.byteArrayToHexString(bytes));
					}
				}
			});
			//啟動一個線程每2s向序列槽發送資料，發送1000次hello
			new Thread(new Runnable() {
				@Override
				public void run() {
					for(String t : dataOpen){
						String s = t.replace(" ", "");
						byte[] bytes = ByteUtils.hexStr2Byte(s);
						RXTXtest.sendData(serialPort, bytes);//發送資料
						try {
							Thread.sleep(500);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					closeSerialPort(serialPort);
				}
			}).start();
			
		}
	}
	
	/**
	 * 獲得系統可用的端口名稱清單
	 * @return 可用端口名稱清單
	 */
	@SuppressWarnings("unchecked")
	public static List<String> getSystemPort(){
		List<String> systemPorts = new ArrayList<String>();
		//獲得系統可用的端口
		Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
		while(portList.hasMoreElements()) {
			String portName = portList.nextElement().getName();//獲得端口的名字
			systemPorts.add(portName);
		}
		System.out.println("系統可用端口清單："+systemPorts);
		return systemPorts;
	}
	
	/**
	 * 開啟序列槽
	 * @param serialPortName 序列槽名稱
	 * @param baudRate 波特率
	 * @return 序列槽對象
	 */
	public static SerialPort openSerialPort(String serialPortName,int baudRate) {
		try {
			//通過端口名稱得到端口
			CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(serialPortName);
			//打開端口，（自定義名字，打開逾時時間）
			CommPort commPort = portIdentifier.open(serialPortName, 2222);
			//判斷是不是序列槽
            if (commPort instanceof SerialPort) {
                SerialPort serialPort = (SerialPort) commPort;
                //設定序列槽參數（波特率，資料位8，停止位1，校驗位無）
                serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);                              
                System.out.println("開啟序列槽成功，序列槽名稱："+serialPortName);
                return serialPort;
            }        
            else {
                //是其他類型的端口
                throw new NoSuchPortException();
            }
		} catch (NoSuchPortException e) {
			e.printStackTrace();
		} catch (PortInUseException e) {
			e.printStackTrace();
		} catch (UnsupportedCommOperationException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 關閉序列槽
	 * @param serialPort 要關閉的序列槽對象
	 */
	public static void closeSerialPort(SerialPort serialPort) {
		if(serialPort != null) {
			serialPort.close();
			System.out.println("關閉了序列槽："+serialPort.getName());
			serialPort = null;
		}
	}
 
	/**
	 * 向序列槽發送資料
	 * @param serialPort 序列槽對象 
	 * @param data 發送的資料
	 */
	public static void sendData(SerialPort serialPort, byte[] data) {
		OutputStream os = null;
        try {
        	os = serialPort.getOutputStream();//獲得序列槽的輸出流
        	os.write(data);
        	os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (os != null) {
                	os.close();
                	os = null;
                }                
            } catch (IOException e) {
            	e.printStackTrace();
            }
        }
	}
	
	/**
	 * 從序列槽讀取資料
	 * @param serialPort 要讀取的序列槽
	 * @return 讀取的資料
	 */
	public static byte[] readData(SerialPort serialPort) {
		InputStream is = null;
        byte[] bytes = null;
        try {
        	Thread.sleep(200);
        	is = serialPort.getInputStream();//獲得序列槽的輸入流
            int bufflenth = is.available();//獲得資料長度
            while (bufflenth != 0) {                             
                bytes = new byte[bufflenth];//初始化byte數組
                is.read(bytes);
                bufflenth = is.available();
            } 
        } catch (Exception e) {
        	e.printStackTrace();
        } finally {
            try {
                if (is != null) {
                	is.close();
                	is = null;
                }
            } catch(IOException e) {
            	e.printStackTrace();
            }
        }
        return bytes;
	}
	
	/**
	 * 給序列槽設定監聽
	 * @param serialPort
	 * @param listener
	 */
	public static void setListenerToSerialPort(SerialPort serialPort, SerialPortEventListener listener) {
		try {
			//給序列槽添加事件監聽
			serialPort.addEventListener(listener);
		} catch (TooManyListenersException e) {
			e.printStackTrace();
		}
		serialPort.notifyOnDataAvailable(true);//序列槽有資料監聽
		serialPort.notifyOnBreakInterrupt(true);//中斷事件監聽
	}
	
}