Java --- serial port communication example codes

/*
 * public SerialBean(int PortID) 
本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定。PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推。 
public int Initialize() 
本函数初始化所指定的串口并返回初始化结果。如果初始化成功返回1，否则返回-1。初始化的结果是该串口被SerialBean独占性使用，其参数被设置为9600, N, 8, 1。如果串口被成功初始化，则打开一个进程读取从串口传入的数据并将其保存在缓冲区中。 
public String ReadPort(int Length) 
本函数从串口(缓冲区)中读取指定长度的一个字符串。参数Length指定所返回字符串的长度。 
public void WritePort(String Msg) 
本函数向串口发送一个字符串。参数Msg是需要发送的字符串。 
public void ClosePort() 
本函数停止串口检测进程并关闭串口。
 */

package serial;

import java.io.*;

import gnu.io.*;

/**
 *
 * This bean provides some basic functions to implement full dulplex information
 * exchange through the srial port.
 *
 */
public class SerialBean {
	public final int DEFAULT_BAUT_RATE = 115200;
	private String portName;
	private CommPortIdentifier portId;
	private SerialPort serialPort;
	// static
	private OutputStream out;
	// static
	private InputStream in;
	// static
	public int baudRate;
	private SerialBuffer serialBuffer;
	private SerialReader serialReader;

	/**
	 *
	 * Constructor
	 *
	 * @param portID
	 *            the ID of the serial to be used. 1 for COM1, 2 for COM2, etc.
	 *
	 */
	public SerialBean(int portID) {
		this.portName = "COM" + portID;
		this.baudRate = DEFAULT_BAUT_RATE;
	}
	
	public SerialBean(int portID, int baudRate) {
		this.portName = "COM" + portID;
		this.baudRate = baudRate;
	}

	/**
	 *
	 * This function initialize the serial port for communication. It starts a
	 * thread which consistently monitors the serial port. Any signal captured
	 * from the serial port is stored into a buffer area.
	 *
	 */
	public boolean initializePort() {
		try {
			portId = CommPortIdentifier.getPortIdentifier(portName);
			try {
				serialPort = (SerialPort) portId.open("Serial_Communication",
						2000);
			} catch (PortInUseException e) {
				System.err.println(e.toString());
				return false;
			}
			// Use InputStream in to read from the serial port, and OutputStream
			// out to write to the serial port.
			try {
				in = serialPort.getInputStream();
				out = serialPort.getOutputStream();
			} catch (IOException e) {
				System.err.println(e.toString());
				return false;
			}
			// Initialize the communication parameters to 9600, 8, 1, none.
			try {
				serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_8,
						SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
			} catch (UnsupportedCommOperationException e) {
				System.err.println(e.toString());
				return false;
			}
		} catch (NoSuchPortException e) {
			System.err.println("Port Name : " + portName);
			System.err.println("Port Id : " + portId);
			System.err.println(e.toString());
			return false;
		}
		// when successfully open the serial port, create a new serial buffer,
		// then create a thread that consistently accepts incoming signals from
		// the serial port. Incoming signals are stored in the serial buffer.
		serialBuffer = new SerialBuffer();
		serialReader = new SerialReader(serialBuffer, in);
		serialReader.start();
		// return success information
		//System.out.println("initialize port ok");
		return true;
	}

	/**
	 *
	 * This function returns a string with a certain length from the incomin
	 * messages.
	 *
	 * @param length
	 *            The length of the string to be returned.
	 *
	 */
	public String readMsgFromPort(int length) {
		while (serialBuffer == null)
			try {
				Thread.sleep(10);
				System.out.println("wait for serial Buffer initialization");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		String Msg;
		Msg = serialBuffer.readMsgFromSerialBuffer(length);
		return Msg;
	}

	/**
	 *
	 * This function sends a message through the serial port.
	 *
	 * @param Msg
	 *            The string to be sent.
	 *
	 */
	public void writeMsgToPort(String Msg) {
		try {
			for (int i = 0; i < Msg.length(); i++)
				out.write(Msg.charAt(i));
		} catch (IOException e) {
		}
	}

	/**
	 *
	 * This function closes the serial port in use.
	 *
	 */
	public void closePort() {
		// RT.stop();
		serialPort.close();
	}
}

package serial;

public class SerialBuffer {
	public StringBuffer serialBuffer = new StringBuffer();
	private String currentMsg, remainedBuffer;
	private boolean isAvailable = false;
	private int lengthNeeded = 1;

	/**
	 *
	 * This function returns a string with a certain length from the incomin
	 * messages.
	 *
	 * @param Length
	 *            The length of the string to be returned.
	 *
	 */

	public synchronized String readMsgFromSerialBuffer(int Length) {
		lengthNeeded = Length;
		notifyAll();

		if (lengthNeeded > serialBuffer.length()) {
			isAvailable = false;
			while (isAvailable == false) {
				try {
					wait();
				} catch (InterruptedException e) {
				}
			}
		}

		currentMsg = serialBuffer.substring(0, lengthNeeded);
		remainedBuffer = serialBuffer.substring(lengthNeeded);
		serialBuffer.setLength(0);
		serialBuffer.append(remainedBuffer);
		lengthNeeded = 1;
		notifyAll();
		return currentMsg;
	}

	/**
	 *
	 * This function stores a character captured from the serial port to the
	 * buffer area.
	 *
	 * @param t
	 *            The char value of the character to be stored.
	 *
	 */
	public synchronized void writeCharToSerialBuffer(int c) {
		serialBuffer = serialBuffer.append((char) c);
		if (lengthNeeded < serialBuffer.length()) {
			isAvailable = true;
		}
		notifyAll();
	}
}

package serial;

import java.io.*;

/**
 *
 * This class reads message from the specific serial port and save the message
 * to the serial buffer.
 *
 */
public class SerialReader extends Thread {
	private SerialBuffer comSerialBuffer;
	private InputStream comPortInputStream;

	/**
	 *
	 * Constructor
	 *
	 * @param serialBuffer
	 *            The buffer to save the incoming messages.
	 * @param portInputStream
	 *            The InputStream from the specific serial port.
	 *
	 */
	public SerialReader(SerialBuffer serialBuffer, InputStream portInputStream) {
		comSerialBuffer = serialBuffer;
		comPortInputStream = portInputStream;
	}

	public void run() {
		int c;
		try {
			while (true) {
				c = comPortInputStream.read();
				comSerialBuffer.writeCharToSerialBuffer(c);
			}
		} catch (IOException e) {
		}
	}
}

调用的时候可以写一个封装函数：

	private char readOneByteFromPort() {
		return serialBean.readMsgFromPort(1).charAt(0);
	}