Recipe 12.2 Opening a Serial Port

Problem

You want to set up a serial port and open it for input/output.

Solution

Use a CommPortIdentifier 's open( ) method to get a SerialPort object.

Discussion

Now you've picked your serial port, but it's not yet ready to go. Baud rate. Parity. Stop bits. These things have been the bane of many a programmer's life. Having needed to work out the details of setting them on many platforms over the years, including CP/M systems, IBM PCs, and IBM System/370 mainframes, I can report that it's no fun. Finally, Java has provided a portable interface for setting all these parameters.

The steps in setting up and opening a serial port are as follows:

1. Get the name and CommPortIdentifier (which you can do using my PortChooser class).

2. Call the CommPortIdentifier's open( ) method; cast the resulting CommPort object to a SerialPort object (this cast fails if the user chooses a parallel port!).

3. Set the serial communications parameters, such as baud rate, parity, stop bits, and the like, either individually or all at once, using the convenience routine setSerialPortParams( ).

4. Call the getInputStream and getOutputStream methods of the SerialPort object, and construct any additional Stream or Writer objects (see Chapter 10).

You are then ready to read and write on the serial port. Example 12-2 is code that implements all these steps for a serial port. Some of this code is for parallel ports, which we'll discuss in Recipe 12.3.

Example 12-2. CommPortOpen.java

import java.awt.*; import java.io.*; import javax.comm.*; import java.util.*; /**  * Open a serial port using Java Communications.  *  */ public class CommPortOpen {     /** How long to wait for the open to finish up. */     public static final int TIMEOUTSECONDS = 30;     /** The baud rate to use. */     public static final int BAUD = 9600;     /** The parent Frame, for the chooser. */     protected Frame parent;     /** The input stream */     protected DataInputStream is;     /** The output stream */     protected PrintStream os;     /** The chosen Port Identifier */     CommPortIdentifier thePortID;     /** The chosen Port itself */     CommPort thePort;     public static void main(String[] argv)         throws IOException, NoSuchPortException, PortInUseException,             UnsupportedCommOperationException {         new CommPortOpen(null).converse( );         System.exit(0);     }     /* Constructor */     public CommPortOpen(Frame f)         throws IOException, NoSuchPortException, PortInUseException,             UnsupportedCommOperationException {                  // Use the PortChooser from before. Pop up the JDialog.         PortChooser chooser = new PortChooser(null);         String portName = null;         do {             chooser.setVisible(true);                          // Dialog done. Get the port name.             portName = chooser.getSelectedName( );             if (portName == null)                 System.out.println("No port selected. Try again.\n");         } while (portName == null);         // Get the CommPortIdentifier.         thePortID = chooser.getSelectedIdentifier( );         // Now actually open the port.         // This form of openPort takes an Application Name and a timeout.         //          System.out.println("Trying to open " + thePortID.getName( ) + "...");         switch (thePortID.getPortType( )) {         case CommPortIdentifier.PORT_SERIAL:             thePort = thePortID.open("DarwinSys DataComm",                 TIMEOUTSECONDS * 1000);             SerialPort myPort = (SerialPort) thePort;             // set up the serial port             myPort.setSerialPortParams(BAUD, SerialPort.DATABITS_8,                 SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);             break;         case CommPortIdentifier.PORT_PARALLEL:             thePort = thePortID.open("DarwinSys Printing",                 TIMEOUTSECONDS * 1000);             ParallelPort pPort = (ParallelPort)thePort;             // Tell API to pick "best available mode" - can fail!             // myPort.setMode(ParallelPort.LPT_MODE_ANY);             // Print what the mode is             int mode = pPort.getMode( );             switch (mode) {                 case ParallelPort.LPT_MODE_ECP:                     System.out.println("Mode is: ECP");                     break;                 case ParallelPort.LPT_MODE_EPP:                     System.out.println("Mode is: EPP");                     break;                 case ParallelPort.LPT_MODE_NIBBLE:                     System.out.println("Mode is: Nibble Mode.");                     break;                 case ParallelPort.LPT_MODE_PS2:                     System.out.println("Mode is: Byte mode.");                     break;                 case ParallelPort.LPT_MODE_SPP:                     System.out.println("Mode is: Compatibility mode.");                     break;                 // ParallelPort.LPT_MODE_ANY is a "set only" mode;                 // tells the API to pick "best mode"; will report the                 // actual mode it selected.                 default:                     throw new IllegalStateException                         ("Parallel mode " + mode + " invalid.");             }             break;         default:    // Neither parallel nor serial??             throw new IllegalStateException("Unknown port type " + thePortID);         }         // Get the input and output streams         // Printers can be write-only         try {             is = new DataInputStream(thePort.getInputStream( ));         } catch (IOException e) {             System.err.println("Can't open input stream: write-only");             is = null;         }         os = new PrintStream(thePort.getOutputStream( ), true);     }     /** This method will be overridden by nontrivial subclasses      * to hold a conversation.       */     protected void converse( ) throws IOException {         System.out.println("Ready to read and write port.");         // Input/Output code not written -- must subclass.         // Finally, clean up.         if (is != null)             is.close( );         os.close( );     } }

As noted in the comments, this class contains a dummy version of the converse method. In following sections we'll expand on the input/output processing by subclassing and overriding this method.