/*

 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

 import gnu.io.CommPort;

 import gnu.io.CommPortIdentifier;

 import gnu.io.SerialPort;

 import gnu.io.SerialPortEvent;

 import gnu.io.SerialPortEventListener;

 import java.util.logging.Logger;

 import org.apache.commons.cli.Options;

 import org.apache.commons.cli.Option;

 import org.apache.commons.cli.OptionBuilder;

 import org.apache.commons.cli.CommandLineParser;

 import org.apache.commons.cli.PosixParser;

 import org.apache.commons.cli.CommandLine;

 import org.apache.commons.cli.HelpFormatter;

 public class UartEchoServer implements SerialPortEventListener

 	{

 	//	Command line options

 	private static final String	OPTION_HELP			="help";

 	private static final String	OPTION_PORT			="port";

 	private static final String	OPTION_BAUD			="baud_rate";

 	private static final String	OPTION_DATA			="data_bits";

 	private static final String	OPTION_STOP			="stop_bits";

 	private static final String	OPTION_PARITY		="parity";

 	private static final String	OPTION_FLOW			="flow_control";

 	//	Default settings for serial port

 	private static final String	DEFAULT_PORT_NAME	= "COM1";

 	private static final int	DEFAULT_BAUD_RATE	= 9600;

 	private static final int	DEFAULT_DATA_BITS	= SerialPort.DATABITS_8;

 	private static final int	DEFAULT_STOP_BITS	= SerialPort.STOPBITS_1;

 	private static final int	DEFAULT_PARITY		= SerialPort.PARITY_NONE;

 	private static final int	DEFAULT_FLOW_CONTROL= SerialPort.FLOWCONTROL_NONE;

 	//	Command format limiters

 	private static final byte	BYTE_IGNORE			= '\0'; // Null

 	private static final byte	BYTE_CLEARBI		= '\1'; // Ctrl A

 	private static final byte	BYTE_QUERYBI		= '\2'; // Ctrl B

 	private static final byte	BYTE_RESET			= '\3'; // Ctrl C

 	private static final byte	BYTE_BLOCK_START	= '[';

 	private static final byte	BYTE_BLOCK_END		= ']';

 	private static final String	BLOCK_ASSIGN		= "=";

 	private static final String	BLOCK_SEPERATOR		= ",";

 	//	Supported commands

 	private static final String	CMD_BAUD_RATE		= "baud_rate";

 	private static final String	CMD_DATA_BITS		= "data_bits";

 	private static final String	CMD_DELAY			= "delay";

 	private static final String	CMD_DISCONNECT		= "disconnect";

 	private static final String	CMD_ECHO			= "echo";

 	private static final String	CMD_FLOW_CONTROL	= "flow_control";

 	private static final String	CMD_LOG				= "log";

 	private static final String	CMD_PARITY			= "parity";

 	private static final String	CMD_STOP_BITS		= "stop_bits";

 	//	Supported data bits

 	private static final String	DATA_BITS_5			= "5";

 	private static final String	DATA_BITS_6			= "6";

 	private static final String	DATA_BITS_7			= "7";

 	private static final String	DATA_BITS_8			= "8";

 	//	Supported flow control

 	private static final String	FLOWCONTROL_NONE	= "none";

 	private static final String	FLOWCONTROL_RTSCTS	= "rtscts";

 	private static final String	FLOWCONTROL_XONXOFF	= "xonxoff";

 	//	Supported parity

 	private static final String	PARITY_NONE			= "none";

 	private static final String	PARITY_EVEN			= "even";

 	private static final String	PARITY_ODD			= "odd";

 	private static final String	PARITY_MARK			= "mark";

 	private static final String	PARITY_SPACE		= "space";

 	//	Supported stop bits

 	private static final String	STOP_BITS_1			= "1";

 	private static final String	STOP_BITS_1_5		= "1.5";

 	private static final String	STOP_BITS_2			= "2";

 	//	Constants

 	private static final int	BUFFER_SIZE			= 1024;

 	private static final int	SLEEP_PERIOD		= 200000;

 	private enum EStatus

 		{

 		EStatusEcho,

 		EStatusCommandStart,

 		};

 	private Thread				iMainThread;

 	private int					iRestartingDelay;

 	private boolean				iRestarting;

 	private boolean				iRunning;

 	private Logger				iLogger;

 	private byte[]				iBuffer;

 	private EStatus				iStatus;

 	private String				iCommand;

 	private String				iPortName;

 	private byte				iBI;

 	private int					iBaudRate;

 	private int					iDataBits;

 	private int					iStopBits;

 	private int					iParity;

 	private int					iFlowControl;

 	private int					iStartupBaudRate;

 	private int					iStartupDataBits;

 	private int					iStartupStopBits;

 	private int					iStartupParity;

 	private int					iStartupFlowControl;

 	private CommPortIdentifier	iPortIdentifier;

 	private SerialPort			iSerialPort;

 	/*

 	 *	Constructor

 	 */

 	protected UartEchoServer() throws Exception

 		{

 		iRestartingDelay=0;

 		iRestarting=true;

 		iRunning=true;

 		iLogger=Logger.getLogger("UartEchoServer");

 		iBuffer=new byte[BUFFER_SIZE];

 		iStatus = EStatus.EStatusEcho;

 		iCommand = "";

 		iBI=0;

 		iPortName=DEFAULT_PORT_NAME;

 		iBaudRate=DEFAULT_BAUD_RATE;

 		iDataBits=DEFAULT_DATA_BITS;

 		iStopBits=DEFAULT_STOP_BITS;

 		iParity=DEFAULT_PARITY;

 		iFlowControl=DEFAULT_FLOW_CONTROL;

 		}

 	/*

 	 *	Second pahse constructor

 	 *

 	 *	@param	aCommandLine	Command line parameters

 	 */

 	protected void Construct(final CommandLine aCommandLine) throws Exception

 		{

 		/*

 		 *	Set port name if passed in command line

 		 */

 		if ( aCommandLine.hasOption(OPTION_PORT) )

 			{

 			iPortName=aCommandLine.getOptionValue(OPTION_PORT);

 			iLogger.info("PortName:" + iPortName);

 			}

 		/*

 		 *	Set baud rate if passed in command line

 		 */

 		if ( aCommandLine.hasOption(OPTION_BAUD) )

 			{

 			setBaudRate(aCommandLine.getOptionValue(OPTION_BAUD));

 			iLogger.info("Baud Rate:" + iBaudRate);

 			}

 		/*

 		 *	Set data bits if passed in command line

 		 */

 		if ( aCommandLine.hasOption(OPTION_DATA) )

 			{

 			setDataBits(aCommandLine.getOptionValue(OPTION_DATA));

 			iLogger.info("Data Bits:" + iDataBits);

 			}

 		/*

 		 *	Set stop bits if passed in command line

 		 */

 		if ( aCommandLine.hasOption(OPTION_STOP) )

 			{

 			setStopBits(aCommandLine.getOptionValue(OPTION_STOP));

 			iLogger.info("Stop Bits:" + iStopBits);

 			}

 		/*

 		 *	Set parity if passed in command line

 		 */

 		if ( aCommandLine.hasOption(OPTION_PARITY) )

 			{

 			setParity(aCommandLine.getOptionValue(OPTION_PARITY));

 			iLogger.info("Parity:" + iParity);

 			}

 		/*

 		 *	Set flow control if passed in command line

 		 */

 		if ( aCommandLine.hasOption(OPTION_FLOW) )

 			{

 			setFlowControl(aCommandLine.getOptionValue(OPTION_FLOW));

 			iLogger.info("Flow Control:" + iFlowControl);

 			}

 		/*

 		 *	Save startup values. Used by reset command

 		 */

 		iStartupBaudRate=iBaudRate;

 		iStartupDataBits=iDataBits;

 		iStartupStopBits=iStopBits;

 		iStartupParity=iParity;

 		iStartupFlowControl=iFlowControl;

 		/*

 		 *	Make sure port is not in use

 		 */

 		iPortIdentifier=CommPortIdentifier.getPortIdentifier(iPortName);

 		if ( iPortIdentifier.isCurrentlyOwned() )

 			{

 			throw new Exception("Error: Port is currently in use");

 			}

 		/*

 		 *	Port not in use so open it

 		 */

 		CommPort	commPort=iPortIdentifier.open(this.getClass().getName(), 2000);

 		/*

 		 *	Save thread

 		 */

 		iMainThread=Thread.currentThread();

 		/*

 		 *	Make sure the port is of type serial

 		 */

 		if ( commPort instanceof SerialPort )

 			{

 			iSerialPort = (SerialPort) commPort;

 			iFlowControl=iSerialPort.getFlowControlMode();

 			while ( iRunning )

 				{

 				initPort();

 				iRestarting=false;

 				while ( iRunning && !iRestarting )

 					{

 					try

 						{

 						iMainThread.sleep(SLEEP_PERIOD);

 						}

 					catch ( InterruptedException e )

 						{

 						}

 					}

 				iSerialPort.close();

 				if ( iRestarting )

 					{

 					iLogger.finest("Restarting");

 					iMainThread.sleep(iRestartingDelay);

 					commPort=iPortIdentifier.open(this.getClass().getName(), 2000);

 					iSerialPort = (SerialPort) commPort;

 					}

 				}

 			}

 		else

 			{

 			throw new Exception("Error: Only serial ports are handled by this example.");

 			}

 		}

 	/*

 	 *	Initialise the port

 	 */

 	private void initPort() throws Exception

 		{

 		iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

 		iSerialPort.setFlowControlMode(iFlowControl);

 		iSerialPort.addEventListener(this);

 		iSerialPort.notifyOnBreakInterrupt(true);

 		iSerialPort.notifyOnCarrierDetect(true);

 		iSerialPort.notifyOnCTS(true);

 		iSerialPort.notifyOnDataAvailable(true);

 		iSerialPort.notifyOnDSR(true);

 		iSerialPort.notifyOnFramingError(true);

 		iSerialPort.notifyOnOutputEmpty(true);

 		iSerialPort.notifyOnOverrunError(true);

 		iSerialPort.notifyOnParityError(true);

 		iSerialPort.notifyOnRingIndicator(true);

 		iSerialPort.setInputBufferSize(BUFFER_SIZE);

 		}

 	/*

 	 *	Set the baud rate

 	 *

 	 *	@param	aValue	String representation of the baud rate

 	 */

 	private void setBaudRate(final String aValue)

 		{

 		try

 			{

 			iBaudRate=Integer.parseInt(aValue);

 			}

 		catch (Exception e)

 			{

 			iLogger.severe("convertToBaudRate(" + aValue + "):exception" + e);

 			}

 		}

 	/*

 	 *	Set the data bits

 	 *

 	 *	@param	aValue	String representation of the data bits

 	 */

 	private void setDataBits(final String aValue)

 		{

 		try

 			{

 			if ( aValue.compareTo(DATA_BITS_5)==0 )

 				{

 				iDataBits=SerialPort.DATABITS_5;

 				}

 			else if ( aValue.compareTo(DATA_BITS_6)==0 )

 				{

 				iDataBits=SerialPort.DATABITS_6;

 				}

 			else if ( aValue.compareTo(DATA_BITS_7)==0 )

 				{

 				iDataBits=SerialPort.DATABITS_7;

 				}

 			else if ( aValue.compareTo(DATA_BITS_8)==0 )

 				{

 				iDataBits=SerialPort.DATABITS_8;

 				}

 			else

 				{

 				iLogger.severe("setDataBits(" + aValue + ")");

 				}

 			}

 		catch (Exception e)

 			{

 			iLogger.severe("setDataBits(" + aValue + "):excpetion" + e);

 			}

 		}

 	/*

 	 *	Set the flow control

 	 *

 	 *	@param	aValue	String representation of the flow control

 	 */

 	private void setFlowControl(final String aValue)

 		{

 		try

 			{

 			if ( aValue.compareTo(FLOWCONTROL_NONE)==0 )

 				{

 				iFlowControl=SerialPort.FLOWCONTROL_NONE;

 				}

 			else if ( aValue.compareTo(FLOWCONTROL_RTSCTS)==0 )

 				{

 				iFlowControl=SerialPort.FLOWCONTROL_RTSCTS_IN | SerialPort.FLOWCONTROL_RTSCTS_OUT;

 				}

 			else if ( aValue.compareTo(FLOWCONTROL_XONXOFF)==0 )

 				{

 				iFlowControl=SerialPort.FLOWCONTROL_XONXOFF_IN | SerialPort.FLOWCONTROL_XONXOFF_OUT;

 				}

 			else

 				{

 				iLogger.severe("setFlowControl(" + aValue + ")");

 				}

 			}

 		catch (Exception e)

 			{

 			iLogger.severe("setFlowControl(" + aValue + "):exception" + e);

 			}

 		}

 	/*

 	 *	Set the parity

 	 *

 	 *	@param	aValue	String representation of the parity

 	 */

 	private void setParity(final String aValue)

 		{

 		try

 			{

 			if ( aValue.compareTo(PARITY_NONE)==0 )

 				{

 				iParity=SerialPort.PARITY_NONE;

 				}

 			else if ( aValue.compareTo(PARITY_EVEN)==0 )

 				{

 				iParity=SerialPort.PARITY_EVEN;

 				}

 			else if ( aValue.compareTo(PARITY_ODD)==0 )

 				{

 				iParity=SerialPort.PARITY_ODD;

 				}

 			else if ( aValue.compareTo(PARITY_MARK)==0 )

 				{

 				iParity=SerialPort.PARITY_MARK;

 				}

 			else if ( aValue.compareTo(PARITY_SPACE)==0 )

 				{

 				iParity=SerialPort.PARITY_SPACE;

 				}

 			else

 				{

 				iLogger.severe("setParity(" + aValue + ")");

 				}

 			}

 		catch (Exception e)

 			{

 			iLogger.severe("setParity(" + aValue + "):exception" + e);

 			}

 		}

 	/*

 	 *	Set the stop bits

 	 *

 	 *	@param	aValue	String representation of the stop bits

 	 */

 	private void setStopBits(final String aValue)

 		{

 		try

 			{

 			if ( aValue.compareTo(STOP_BITS_1)==0 )

 				{

 				iStopBits=SerialPort.STOPBITS_1;

 				}

 			else if ( aValue.compareTo(STOP_BITS_1_5)==0 )

 				{

 				iStopBits=SerialPort.STOPBITS_1_5;

 				}

 			else if ( aValue.compareTo(STOP_BITS_2)==0 )

 				{

 				iStopBits=SerialPort.STOPBITS_2;

 				}

 			else

 				{

 				iLogger.severe("setStopBits(" + aValue + ")");

 				}

 			}

 		catch (Exception e)

 			{

 			iLogger.severe("setStopBits(" + aValue + "):exception" + e);

 			}

 		}

 	/*

 	 *	Process a command from the input

 	 */

 	private void processCommand() throws Exception

 		{

 		final String	values[] = iCommand.split(BLOCK_SEPERATOR);

 		iSerialPort.getOutputStream().flush();

 		for ( int i=0; i<values.length; i++ )

 			{

 			/*

 			 *	Commands should be of the type variable=value

 			 */

 			final String	parts[]=values[i].split(BLOCK_ASSIGN);

 			if ( parts.length==2 )

 				{

 				/*

 				 *	Set baud rate command

 				 */

 				if ( parts[0].compareTo(CMD_BAUD_RATE)==0 )

 					{

 					setBaudRate(parts[1]);

 					iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

 					}

 				/*

 				 *	Set data bits command

 				 */

 				else if ( parts[0].compareTo(CMD_DATA_BITS)==0 )

 					{

 					setDataBits(parts[1]);

 					iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

 					}

 				/*

 				 *	Delay command

 				 */

 				else if ( parts[0].compareTo(CMD_DELAY)==0 )

 					{

 					final int	delay=Integer.parseInt(parts[1]);

 					Thread.sleep(delay);

 					}

 				/*

 				 *	Disconnect command

 				 */

 				else if ( parts[0].compareTo(CMD_DISCONNECT)==0 )

 					{

 					iRestartingDelay=Integer.parseInt(parts[1]);

 					iRestarting=true;

 					}

 				/*

 				 *	Echo command

 				 */

 				else if ( parts[0].compareTo(CMD_ECHO)==0 )

 					{

 					final int		length=parts[1].length();

 					for ( int index=0; index<length; ++index )

 						{

 						final byte	out=(byte)(parts[1].charAt(index));

 						iLogger.finest("<< " + out);

 						iSerialPort.getOutputStream().write(out);

 						}

 					}

 				/*

 				 *	Set flow control command

 				 */

 				else if ( parts[0].compareTo(CMD_FLOW_CONTROL)==0 )

 					{

 					setFlowControl(parts[1]);

 					iSerialPort.setFlowControlMode(iFlowControl);

 					}

 				/*

 				 *	Log command

 				 */

 				else if ( parts[0].compareTo(CMD_LOG)==0 )

 					{

 					iLogger.info(parts[1]);

 					}

 				/*

 				 *	Set parity command

 				 */

 				else if ( parts[0].compareTo(CMD_PARITY)==0 )

 					{

 					setParity(parts[1]);

 					iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

 					}

 				/*

 				 *	Set stop bits command

 				 */

 				else if ( parts[0].compareTo(CMD_STOP_BITS)==0 )

 					{

 					setStopBits(parts[1]);

 					iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

 					}

 				/*

 				 *	Error command

 				 */

 				else

 					{

 					iLogger.severe("Bad command(" + parts[0] + ")");

 					}

 				}

 			else

 				{

 				iLogger.severe("Bad data");

 				}

 			}

 		}

 	/*

 	 *	Process data read from input stream

 	 *

 	 *	@param	aLength	Length of the data in the buffer

 	 */

 	private void processInput(final int aLength) throws Exception

 		{

 		final String	buffer=new String(iBuffer, 0, aLength);

 		iLogger.finest(">> " + buffer);

 		for ( int index=0; index<aLength; ++index )

 			{

 			switch ( iBuffer[index] )

 				{

 			/*

 			 *	Ignored data

 			 */

 			case BYTE_IGNORE:

 				break;

 			/*

 			 *	Clear the break interrupt count

 			 */

 			case BYTE_CLEARBI:

 				iBI=0;

 				break;

 			/*

 			 *	Query the break interrupt count

 			 */

 			case BYTE_QUERYBI:

 				iLogger.finest("BI Count=" + iBI);

 				iLogger.finest("<< " + iBI);

 				iSerialPort.getOutputStream().write(iBI);

 				break;

 			/*

 			 *	Reset port setting to startup values

 			 */

 			case BYTE_RESET:

 				iBaudRate=iStartupBaudRate;

 				iDataBits=iStartupDataBits;

 				iStopBits=iStartupStopBits;

 				iParity=iStartupParity;

 				iFlowControl=iStartupFlowControl;

 				iSerialPort.setFlowControlMode(iFlowControl);

 				iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

 				iStatus=EStatus.EStatusEcho;

 				break;

 			default:

 				/*

 				 *	If in command mode add the byte to the command buffer

 				 *	unless we read the end of command block character

 				 */

 				if ( iStatus==EStatus.EStatusCommandStart ) 

 					{

 					if ( iBuffer[index]==BYTE_BLOCK_END )

 						{

 						processCommand();

 						iStatus=EStatus.EStatusEcho;

 						}

 					else

 						{

 						iCommand += buffer.charAt(index);

 						}

 					}

 				/*

 				 *	If in echo mode, echo the character unless we read the

 				 *	start of command block character

 				 */

 				else if ( iStatus==EStatus.EStatusEcho )

 					{

 					if ( iBuffer[index]==BYTE_BLOCK_START )

 						{

 						iCommand="";

 						iStatus=EStatus.EStatusCommandStart;

 						}

 					else

 						{

 						iLogger.finest("<< " + iBuffer[index]);

 						iSerialPort.getOutputStream().write(iBuffer[index]);

 						}

 					}

 				break;

 				}

 			}

 		}

 	/*

 	 *	Serial port event received

 	 *

 	 *	@param	aEvent	Event received

 	 */

 	public void serialEvent(SerialPortEvent aEvent)

 		{

 		switch ( aEvent.getEventType() )

 			{

 		case SerialPortEvent.DATA_AVAILABLE:

 			/*

 			 *	Process data in input buffer

 			 */

 			try

 				{

 				final int	length = iSerialPort.getInputStream().read(iBuffer);

 				if ( length>0 )

 					{

 					processInput(length);

 					}

 				}

 			catch (Exception e)

 				{

 				e.printStackTrace();

 				}

 			if ( iRestarting )

 				{

 				iMainThread.interrupt();

 				}

 			break;

 		case SerialPortEvent.BI:

 			/*

 			 *	Increment break interrupt count

 			 */

 			++iBI;

 			iLogger.finest("Break Interrupt");

 			break;

 		case SerialPortEvent.CD:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Carrier Detect");

 			break;

 		case SerialPortEvent.CTS:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Clear To Send");

 			break;

 		case SerialPortEvent.DSR:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Data Set Ready");

 			break;

 		case SerialPortEvent.FE:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Framing Error");

 			break;

 		case SerialPortEvent.OE:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Overflow Error");

 			break;

 		case SerialPortEvent.OUTPUT_BUFFER_EMPTY:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Output Buffer Empty");

 			break;

 		case SerialPortEvent.PE:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Parity Error");

 			break;

 		case SerialPortEvent.RI:

 			/*

 			 *	Ignore

 			 */

 			iLogger.finest("Ring Interrupt");

 			break;

 		default:

 			iLogger.finest("Unknown event");

 			break;

 			}

 		}

 	/*

 	 *	Application entry point

 	 *

 	 *	@param	aArgs	COmmand line arguments

 	 */

 	public static void main(String[] aArgs)

 		{

 		final Options	options = new Options();

 		options.addOption(new Option(OPTION_HELP, "print this message"));

 		OptionBuilder.withLongOpt(OPTION_PORT);

 		OptionBuilder.withDescription("set port COMx");

 		OptionBuilder.withValueSeparator( '=' );

 		OptionBuilder.hasArg();

 		options.addOption(OptionBuilder.create());

 		OptionBuilder.withLongOpt(OPTION_BAUD);

 		OptionBuilder.withDescription("set the baud rate");

 		OptionBuilder.withValueSeparator( '=' );

 		OptionBuilder.hasArg();

 		options.addOption(OptionBuilder.create());

 		OptionBuilder.withLongOpt(OPTION_DATA);

 		OptionBuilder.withDescription("set the data bits [" + DATA_BITS_5 +"|" + DATA_BITS_6 + "|" + DATA_BITS_7 + "|" + DATA_BITS_8 + "]");

 		OptionBuilder.withValueSeparator( '=' );

 		OptionBuilder.hasArg();

 		options.addOption(OptionBuilder.create());

 		OptionBuilder.withLongOpt(OPTION_STOP);

 		OptionBuilder.withDescription("set the stop bits [" + STOP_BITS_1 + "|" + STOP_BITS_1_5 + "|" + STOP_BITS_2 + "]");

 		OptionBuilder.withValueSeparator( '=' );

 		OptionBuilder.hasArg();

 		options.addOption(OptionBuilder.create());

 		OptionBuilder.withLongOpt(OPTION_PARITY);

 		OptionBuilder.withDescription("set the parity [" + PARITY_NONE + "|" + PARITY_EVEN + "|" + PARITY_ODD + "|" + PARITY_MARK + "|" + PARITY_SPACE + "]");

 		OptionBuilder.withValueSeparator( '=' );

 		OptionBuilder.hasArg();

 		options.addOption(OptionBuilder.create());

 		OptionBuilder.withLongOpt(OPTION_FLOW);

 		OptionBuilder.withDescription("set the flow control [" + FLOWCONTROL_NONE + "|" + FLOWCONTROL_RTSCTS + "|" + FLOWCONTROL_XONXOFF + "]");

 		OptionBuilder.withValueSeparator( '=' );

 		OptionBuilder.hasArg();

 		options.addOption(OptionBuilder.create());

 		final CommandLineParser	parser = new PosixParser();

 		try

 			{

 			// parse the command line arguments

 			final CommandLine	commandLine = parser.parse(options, aArgs);

 			if ( commandLine.hasOption(OPTION_HELP) )

 				{

 				final HelpFormatter	formatter = new HelpFormatter();

 				formatter.printHelp("UartEchoServer", options);

 				}

 			else

 				{

 				final UartEchoServer	echoServer=new UartEchoServer();

 				echoServer.Construct(commandLine);

 				}

 			}

 		catch ( Exception e )

 			{

 			e.printStackTrace();

 			}

 		}

 	}