|
/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.com/, 1996-2002.
* All rights reserved. Software written by Ian F. Darwin and others.
* $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Java, the Duke mascot, and all variants of Sun's Java "steaming coffee
* cup" logo are trademarks of Sun Microsystems. Sun's, and James Gosling's,
* pioneering role in inventing and promulgating (and standardizing) the Java
* language and environment is gratefully acknowledged.
*
* The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
* inventing predecessor languages C and C++ is also gratefully acknowledged.
*/
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.TooManyListenersException;
import javax.comm.CommPort;
import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.ParallelPort;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.comm.UnsupportedCommOperationException;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* Read from a Serial port, notifying when data arrives.
* Simulation of part of an event-logging service.
* @version $Id: SerialReadByEvents.java,v 1.4 2004/04/11 23:50:40 ian Exp $
* @author Ian F. Darwin, http://www.darwinsys.com/
*/
public class SerialReadByEvents extends CommPortOpen
implements SerialPortEventListener {
public static void main(String[] argv)
throws IOException, NoSuchPortException, PortInUseException,
UnsupportedCommOperationException {
new SerialReadByEvents(null).converse();
}
/* Constructor */
public SerialReadByEvents(JFrame f)
throws IOException, NoSuchPortException, PortInUseException,
UnsupportedCommOperationException {
super(f);
}
/**
* Hold the conversation.
*/
protected void converse() throws IOException {
if (!(thePort instanceof SerialPort)) {
System.err.println("But I wanted a SERIAL port!");
System.exit(1);
}
// Tell the Comm API that we want serial events.
((SerialPort)thePort).notifyOnDataAvailable(true);
try {
((SerialPort)thePort).addEventListener(this);
} catch (TooManyListenersException ev) {
// "CantHappen" error
System.err.println("Too many listeners(!) " + ev);
System.exit(0);
}
}
public void serialEvent(SerialPortEvent ev) {
String line;
try {
line = is.readLine();
if (line == null) {
System.out.println("EOF on serial port.");
System.exit(0);
}
os.println(line);
} catch (IOException ex) {
System.err.println("IO Error " + ex);
}
}
}
/**
* Open a serial port using Java Communications.
*
* @author Ian F. Darwin, http://www.darwinsys.com/
*/
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 = 19200;
/** The parent JFrame, for the chooser. */
protected JFrame parent;
/** The input stream */
protected BufferedReader 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(JFrame 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 BufferedReader(new InputStreamReader(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();
}
}
class PortChooser extends JDialog implements ItemListener {
/** A mapping from names to CommPortIdentifiers. */
protected HashMap map = new HashMap();
/** The name of the choice the user made. */
protected String selectedPortName;
/** The CommPortIdentifier the user chose. */
protected CommPortIdentifier selectedPortIdentifier;
/** The JComboBox for serial ports */
protected JComboBox serialPortsChoice;
/** The JComboBox for parallel ports */
protected JComboBox parallelPortsChoice;
/** The JComboBox for anything else */
protected JComboBox other;
/** The SerialPort object */
protected SerialPort ttya;
/** To display the chosen */
protected JLabel choice;
/** Padding in the GUI */
protected final int PAD = 5;
/** This will be called from either of the JComboBoxen when the
* user selects any given item.
*/
public void itemStateChanged(ItemEvent e) {
// Get the name
selectedPortName = (String)((JComboBox)e.getSource()).getSelectedItem();
// Get the given CommPortIdentifier
selectedPortIdentifier = (CommPortIdentifier)map.get(selectedPortName);
// Display the name.
choice.setText(selectedPortName);
}
/* The public "getter" to retrieve the chosen port by name. */
public String getSelectedName() {
return selectedPortName;
}
/* The public "getter" to retrieve the selection by CommPortIdentifier. */
public CommPortIdentifier getSelectedIdentifier() {
return selectedPortIdentifier;
}
/** A test program to show up this chooser. */
public static void main(String[] ap) {
PortChooser c = new PortChooser(null);
c.setVisible(true); // blocking wait
System.out.println("You chose " + c.getSelectedName() +
" (known by " + c.getSelectedIdentifier() + ").");
System.exit(0);
}
/** Construct a PortChooser --make the GUI and populate the ComboBoxes.
*/
public PortChooser(JFrame parent) {
super(parent, "Port Chooser", true);
makeGUI();
populate();
finishGUI();
}
/** Build the GUI. You can ignore this for now if you have not
* yet worked through the GUI chapter. Your mileage may vary.
*/
protected void makeGUI() {
Container cp = getContentPane();
JPanel centerPanel = new JPanel();
cp.add(BorderLayout.CENTER, centerPanel);
centerPanel.setLayout(new GridLayout(0,2, PAD, PAD));
centerPanel.add(new JLabel("Serial Ports", JLabel.RIGHT));
serialPortsChoice = new JComboBox();
centerPanel.add(serialPortsChoice);
serialPortsChoice.setEnabled(false);
centerPanel.add(new JLabel("Parallel Ports", JLabel.RIGHT));
parallelPortsChoice = new JComboBox();
centerPanel.add(parallelPortsChoice);
parallelPortsChoice.setEnabled(false);
centerPanel.add(new JLabel("Unknown Ports", JLabel.RIGHT));
other = new JComboBox();
centerPanel.add(other);
other.setEnabled(false);
centerPanel.add(new JLabel("Your choice:", JLabel.RIGHT));
centerPanel.add(choice = new JLabel());
JButton okButton;
cp.add(BorderLayout.SOUTH, okButton = new JButton("OK"));
okButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
PortChooser.this.dispose();
}
});
}
/** Populate the ComboBoxes by asking the Java Communications API
* what ports it has. Since the initial information comes from
* a Properties file, it may not exactly reflect your hardware.
*/
protected void populate() {
// get list of ports available on this particular computer,
// by calling static method in CommPortIdentifier.
Enumeration pList = CommPortIdentifier.getPortIdentifiers();
// Process the list, putting serial and parallel into ComboBoxes
while (pList.hasMoreElements()) {
CommPortIdentifier cpi = (CommPortIdentifier)pList.nextElement();
// System.out.println("Port " + cpi.getName());
map.put(cpi.getName(), cpi);
if (cpi.getPortType() == CommPortIdentifier.PORT_SERIAL) {
serialPortsChoice.setEnabled(true);
serialPortsChoice.addItem(cpi.getName());
} else if (cpi.getPortType() == CommPortIdentifier.PORT_PARALLEL) {
parallelPortsChoice.setEnabled(true);
parallelPortsChoice.addItem(cpi.getName());
} else {
other.setEnabled(true);
other.addItem(cpi.getName());
}
}
serialPortsChoice.setSelectedIndex(-1);
parallelPortsChoice.setSelectedIndex(-1);
}
protected void finishGUI() {
serialPortsChoice.addItemListener(this);
parallelPortsChoice.addItemListener(this);
other.addItemListener(this);
pack();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
|
