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 ready to go yet. 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 will fail if the user chose 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 routing setSerialPortParams( ).

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

You are then ready to read and write on the serial port. Example 11-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 Section 11.4.

Example 11-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 last line read from the serial port. */
    protected String response;
    /** A flag to control debugging output. */
    protected boolean debug = true;
    /** 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.
");
        } 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 non-trivial 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.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.116.60.62