Java串口编程

import java.util.Enumeration;
import java.util.HashSet;

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;

public class ListPort {
	/**
	 * @Description:列出所有可用串口
	 * @author:dengchaoqun
	 * @date:2015-8-29 上午11:34:04
	 */
	public static void listPorts() {
		HashSet<CommPortIdentifier> portSet = getAvailableSerialPorts();
		for (CommPortIdentifier comm : portSet) {
			System.out.println(comm.getName() + " - " + getPortTypeName(comm.getPortType()));
		}
	}

	/**
	 * @Description:列出所有通信端口
	 * @author:dengchaqun
	 * @date:2015-8-29 下午2:06:17
	 */
	@SuppressWarnings("unchecked")
	public static void listCommPorts() {
		CommPortIdentifier.getPortIdentifiers();
		/*
		 * 不带参数的getPortIdentifiers方法可以获得一个枚举对象，该对象包含了
		 * 系统中每个端口的CommPortIdentifier对象。注意这里的端口不仅仅是指串口，也包括并口。
		 * 这个方法还可以带参数，getPortIdentifiers(CommPort)获得已经被应用程序打开的端口
		 * 相对应的CommPortIdentifier对象。getPortIdentifier(String portName)
		 * 获取指定端口名（比如“COM1”）的CommPortIdentifier对象。
		 */
		java.util.Enumeration<CommPortIdentifier> portEnum = CommPortIdentifier.getPortIdentifiers();
		while (portEnum.hasMoreElements()) {
			CommPortIdentifier portIdentifier = portEnum.nextElement();
			System.out.println(portIdentifier.getName() + " - " + getPortTypeName(portIdentifier.getPortType()));
		}
	}

	/**
	 * @Description:获取通信端口类型名称
	 * @author:Lu
	 * @date:2015-8-29 上午11:35:32
	 */
	public 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: // RS485端口
			return "RS485";
		case CommPortIdentifier.PORT_SERIAL: // 串口
			return "Serial";
		default:
			return "unknown type";
		}
	}

	/**
	 * @Description:获取所有可用的串口集合
	 * @author:dengchaoqun
	 * @date:2015-8-29 上午11:37:54
	 */
	@SuppressWarnings("unchecked")
	public static HashSet<CommPortIdentifier> getAvailableSerialPorts() {
		HashSet<CommPortIdentifier> h = new HashSet<CommPortIdentifier>();
		Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
		while (portList.hasMoreElements()) {
			CommPortIdentifier com = (CommPortIdentifier) portList.nextElement();
			switch (com.getPortType()) {
			case CommPortIdentifier.PORT_SERIAL:
				try {
					// open:（应用程序名【随意命名】，阻塞时等待的毫秒数）
					/*
					 * open方法打开通讯端口，获得一个CommPort对象，它使程序独占端口。
					 * 如果端口正被其他应用程序占用，将使用CommPortOwnershipListener事件机制
					 * 传递一个PORT_OWNERSHIP_REQUESTED事件。
					 * 每个端口都关联一个InputStream和一个OutputStream,如果端口是用
					 * open方法打开的，那么任何的getInputStream都将返回相同的数据流对象，除非 有close被调用。
					 */
					CommPort thePort = com.open(Object.class.getSimpleName(), 50);
					thePort.close();
					h.add(com);
				} catch (PortInUseException e) {
					// 不可用串口
					System.out.println("Port, " + com.getName() + ", is in use.");
				} catch (Exception e) {
					System.err.println("Failed to open port " + com.getName());
					e.printStackTrace();
				}
			}
		}
		return h;
	}

	public static void main(String[] args) {
		/**
		 * 可列出当前系统所有可用的串口名称，本机输出COM1 - Serial， COM2 - Serial.....COM6 - Serial
		 */
		listPorts();
		listCommPorts();
	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import java.util.Enumeration;
import java.util.TooManyListenersException;

import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;

public class SerialPortTest1 implements Runnable, SerialPortEventListener {
	// 检测系统中可用的通讯端口类
	private CommPortIdentifier portId;
	// 枚举类型
	private Enumeration<CommPortIdentifier> portList;

	// RS232串口
	private SerialPort serialPort;

	// 输入输出流
	private InputStream inputStream;
	private OutputStream outputStream;

	// 保存串口返回信息
	private String test = "";

	// 单例创建
	private static SerialPortTest1 uniqueInstance = new SerialPortTest1();

	// 初始化串口
	@SuppressWarnings("unchecked")
	public void init() {
		// 获取系统中所有的通讯端口
		portList = CommPortIdentifier.getPortIdentifiers();
		// 循环通讯端口
		while (portList.hasMoreElements()) {
			portId = portList.nextElement();
			// 判断是否是串口
			if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
				// 比较串口名称是否是"COM3"
				if ("COM2".equals(portId.getName())) {
					System.out.println("找到串口COM2");
					// 打开串口
					try {
						// open:（应用程序名【随意命名】，阻塞时等待的毫秒数）
						serialPort = (SerialPort) portId.open(Object.class.getSimpleName(), 2000);
						System.out.println("获取到串口对象,COM2");
						//实例化输入流
						inputStream = serialPort.getInputStream();
						// 设置串口监听
						serialPort.addEventListener(this);
						// 设置串口数据时间有效(可监听)
						serialPort.notifyOnDataAvailable(true);
						// 设置串口通讯参数
						// 波特率，数据位，停止位和校验方式
						// 波特率2400,偶校验
						serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, //
								SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

					} catch (PortInUseException e) {
						e.printStackTrace();
					} catch (TooManyListenersException e) {
						e.printStackTrace();
					} catch (UnsupportedCommOperationException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}

				}
			}
		}
	}

	// 实现接口SerialPortEventListener中的方法 读取从串口中接收的数据
	@Override
	public void serialEvent(SerialPortEvent event) {
		switch (event.getEventType()) {
		case SerialPortEvent.BI: // 通讯中断
		case SerialPortEvent.OE: // 溢位错误
		case SerialPortEvent.FE: // 帧错误
		case SerialPortEvent.PE: // 奇偶校验错误
		case SerialPortEvent.CD: // 载波检测
		case SerialPortEvent.CTS: // 清除发送
		case SerialPortEvent.DSR: // 数据设备准备好
		case SerialPortEvent.RI: // 响铃侦测
		case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 输出缓冲区已清空
			break;
		case SerialPortEvent.DATA_AVAILABLE: // 有数据到达
			readComm();
			break;
		default:
			break;
		}
	}

	// 读取串口返回信息
	public void readComm() {
		byte[] readBuffer = new byte[1024];
		try {
			inputStream = serialPort.getInputStream();
			// 从线路上读取数据流
			int len = 0;
			while ((len = inputStream.read(readBuffer)) != -1) {
				System.out.println("实时反馈：" + new String(readBuffer, 0, len).trim() + new Date());
				test += new String(readBuffer, 0, len).trim();
				break;
			}
			System.out.println(test + " ");
			//closeSerialPort();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void closeSerialPort() {
		uniqueInstance.serialPort.close();
	}
	
	//向串口发送数据
	public void sendMsg(){
		String information = "AT\r";
		try {
			//实例化输出流
			outputStream = serialPort.getOutputStream();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		try {
			outputStream.write(information.getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		init();
		sendMsg();
		
	}
}

public class TestDemo {

	public static void main(String[] args) {

		Thread thread=new Thread(new SerialPortTest1());
		thread.start();
	}

}