详细解读Java的串口编程

driver=com.sun.comm.win32driver

system.setsecuritymanager(null);

string drivername = "com.sun.comm.win32driver"; // or get as a jnlp property
commdriver commdriver = (commdriver)class.forname(drivername).newinstance();
commdriver.initialize();

import javax.comm.*;
import java.util.*;
...
//
// platform specific port name, here= a unix name
//
// note: on at least one unix javacomm implementation javacomm 
//    enumerates the ports as "com1" ... "comx", too, and not
//    by their unix device names "/dev/tty...". 
//    yet another good reason to not hard-code the wanted
//    port, but instead make it user configurable.
//
string wantedportname = "/dev/ttya";
 //
// get an enumeration of all ports known to javacomm
//
enumeration portidentifiers = commportidentifier.getportidentifiers();
//
// check each port identifier if 
//  (a) it indicates a serial (not a parallel) port, and
//  (b) matches the desired name.
//
commportidentifier portid = null; // will be set if port found
while (portidentifiers.hasmoreelements())
{
  commportidentifier pid = (commportidentifier) portidentifiers.nextelement();
  if(pid.getporttype() == commportidentifier.port_serial &&
    pid.getname().equals(wantedportname)) 
  {
    portid = pid;
    break;
  }
}
if(portid == null)
{
  system.err.println("could not find serial port " + wantedportname);
  system.exit(1);
}
//
// use port identifier for acquiring the port
//
...

注意：

javacomm会从与其绑定的特定平台相关的驱动中获得一个默认的可访问串口标识列表。这个列表实际上不能通过javacomm进行配置。方法commportidentifier.addportname()是有误导性的，因为驱动类是与平台相关的，而且它们的实现不是公共api的组成部分。依赖于驱动，这个端口列表可能会在驱动中进行配置/扩展。所以，如果javacomm没有找到某一特定端口，对驱动进行一些改动有时会有所帮助。

某端口标识符一旦被找到，就可以用它取得期望的端口：

//
// use port identifier for acquiring the port
//
serialport port = null;
try {
  port = (serialport) portid.open(
    "name", // name of the application asking for the port 
    10000  // wait max. 10 sec. to acquire port
  );
} catch(portinuseexception e) {
  system.err.println("port already in use: " + e);
  system.exit(1);
}
//
// now we are granted exclusive access to the particular serial
// port. we can configure it and obtain input and output streams.
//
...

import java.io.*;
...
//
// set all the params. 
// this may need to go in a try/catch block which throws unsupportedcommoperationexception
//
port.setserialportparams(
  115200,
  serialport.databits_8,
  serialport.stopbits_1,
  serialport.parity_none);
//
// open the input reader and output stream. the choice of a
// reader and stream are arbitrary and need to be adapted to
// the actual application. typically one would use streams in
// both directions, since they allow for binary data transfer,
// not only character data transfer.
//
bufferedreader is = null; // for demo purposes only. a stream would be more typical.
printstream  os = null;
try {
 is = new bufferedreader(new inputstreamreader(port.getinputstream()));
} catch (ioexception e) {
 system.err.println("can't open input stream: write-only");
 is = null;
}
//
// new linux systems rely on unicode, so it might be necessary to
// specify the encoding scheme to be used. typically this should
// be us-ascii (7 bit communication), or iso latin 1 (8 bit
// communication), as there is likely no modem out there accepting
// unicode for its commands. an example to specify the encoding
// would look like:
//
//   os = new printstream(port.getoutputstream(), true, "iso-8859-1");
//
os = new printstream(port.getoutputstream(), true);
 //
// actual data communication would happen here
// performreadwritecode();
//
//
// it is very important to close input and output streams as well
// as the port. otherwise java, driver and os resources are not released.
//
if (is != null) is.close();
if (os != null) os.close();
if (port != null) port.close();

// write to the output 
os.print("at");
os.print("\r\n"); // append a carriage return with a line feed

is.readline(); // first read will contain the echoed command you sent to it. in this case: "at"
is.readline(); // second read will remove the extra line feed that at generates as output

// read the response
string response = is.readline(); // if you sent "at" then response == "ok"

import javax.comm.*;
 
/**
 * listener to handle all serial port events.
 *
 * note: it is typical that the serialporteventlistener is implemented
 *    in the main class that is supposed to communicate with the
 *    device. that way the listener has easy access to state information
 *    about the communication, e.g. when a particular communication
 *    protocol needs to be followed.
 *
 *    however, for demonstration purposes this example implements a
 *    separate class.
 */ 
class seriallistener implements serialporteventlistener {
 
  /**
   * handle serial events. dispatches the event to event-specific
   * methods.
   * @param event the serial event
   */
  @override
  public void serialevent(serialportevent event){
 
    //
    // dispatch event to individual methods. this keeps this ugly
    // switch/case statement as short as possible.
    //
    switch(event.geteventtype()) {
      case serialportevent.output_buffer_empty:
        outputbufferempty(event);
        break;
 
      case serialportevent.data_available:
        dataavailable(event);
        break;
 
/* other events, not implemented here ->
      case serialportevent.bi:
        breakinterrupt(event);
        break;
 
      case serialportevent.cd:
        carrierdetect(event);
        break;
 
      case serialportevent.cts:
        cleartosend(event);
        break;
 
      case serialportevent.dsr:
        datasetready(event);
        break;
 
      case serialportevent.fe:
        framingerror(event);
        break;
 
      case serialportevent.oe:
        overrunerror(event);
        break;
 
      case serialportevent.pe:
        parityerror(event);
        break;
      case serialportevent.ri:
        ringindicator(event);
        break;
<- other events, not implemented here */
 
    }
  }
 
  /**
   * handle output buffer empty events.
   * note: the reception of this event is optional and not
   *    guaranteed by the api specification.
   * @param event the output buffer empty event
   */
  protected void outputbufferempty(serialportevent event) {
    // implement writing more data here
  }
 
  /**
   * handle data available events.
   *
   * @param event the data available event
   */
  protected void dataavailable(serialportevent event) {
    // implement reading from the serial port here
  }
}

serialport port = ...;
...
//
// configure port parameters here. only after the port is configured it
// makes sense to enable events. the event handler might be called immediately
// after an event is enabled.
...
 
//
// typically, if the current class implements the serialeventlistener interface
// one would call
//
//    port.addeventlistener(this);
//
// but for our example a new instance of seriallistener is created:
//
port.addeventlistener(new seriallistener());
 
//
// enable the events we are interested in
//
port.notifyondataavailable(true);
port.notifyonoutputempty(true);
 
/* other events not used in this example ->
port.notifyonbreakinterrupt(true);
port.notifyoncarrierdetect(true);
port.notifyoncts(true);
port.notifyondsr(true);
port.notifyonframingerror(true);
port.notifyonoverrunerror(true);
port.notifyonparityerror(true);
port.notifyonringindicator(true);
<- other events not used in this example */

/**
 * synchronized ring buffer. 
 * suitable to hand over data from one thread to another.
 **/
public class ringbuffer {
  /** internal buffer to hold the data **/
  protected byte buffer[];
  /** size of the buffer **/
  protected int size;
  /** current start of data area **/
  protected int start;
  /** current end of data area **/
  protected int end;
 
  /**
   * construct a ringbuffer with a default buffer size of 1k.
   */
  public ringbuffer() {
     this(1024);
  }
  /**
   * construct a ringbuffer with a certain buffer size.
   * @param size  buffer size in bytes
   */
  public ringbuffer(int size) {
     this.size = size;
     buffer = new byte[size];
     clear();
  }
  /**
   * clear the buffer contents. all data still in the buffer is lost.
   */
  public void clear() {
    // just reset the pointers. the remaining data fragments, if any,
    // will be overwritten during normal operation.
    start = end = 0;
  }
  /**
   * return used space in buffer. this is the size of the
   * data currently in the buffer.
   * <p>
   * note: while the value is correct upon returning, it
   * is not necessarily valid when data is read from the 
   * buffer or written to the buffer. another thread might
   * have filled the buffer or emptied it in the mean time.
   *
   * @return currently amount of data available in buffer
   */
  public int data() {
     return start <= end
           ? end - start
           : end - start + size;
  }
  /**
   * return unused space in buffer. note: while the value is
   * correct upon returning, it is not necessarily valid when
   * data is written to the buffer or read from the buffer.
   * another thread might have filled the buffer or emptied
   * it in the mean time.
   *
   * @return currently available free space
   */
  public int free() {
     return start <= end
           ? size + start - end
           : start - end;
  }
  /**
   * write as much data as possible to the buffer.
   * @param data  data to be written
   * @return    amount of data actually written
   */
  int write(byte data[]) {
    return write(data, 0, data.length); 
  }
  /**
   * write as much data as possible to the buffer.
   * @param data  array holding data to be written
   * @param off  offset of data in array
   * @param n   amount of data to write, starting from .
   * @return    amount of data actually written
   */
  int write(byte data[], int off, int n) {
    if(n <= 0) return 0;
    int remain = n;
    // @todo check if off is valid: 0= <= off < data.length; throw exception if not
    int i = math.min(remain, (end < start ? start : buffer.length) - end);
    if(i > 0) {
       system.arraycopy(data, off, buffer, end, i);
       off  += i;
       remain -= i;
       end  += i;
    }
    i = math.min(remain, end >= start ? start : 0);
    if(i > 0 ) {
       system.arraycopy(data, off, buffer, 0, i);
       remain -= i;
       end = i;
    }
    return n - remain;
  }
 
  /**
   * read as much data as possible from the buffer.
   * @param data  where to store the data
   * @return    amount of data read
   */
  int read(byte data[]) {
    return read(data, 0, data.length); 
  }
  /**
   * read as much data as possible from the buffer.
   * @param data  where to store the read data
   * @param off  offset of data in array
   * @param n   amount of data to read
   * @return    amount of data actually read
   */
  int read(byte data[], int off, int n) {
    if(n <= 0) return 0;
    int remain = n;
    // @todo check if off is valid: 0= <= off < data.length; throw exception if not
    int i = math.min(remain, (end < start ? buffer.length : end) - start);
    if(i > 0) {
       system.arraycopy(buffer, start, data, off, i);
       off  += i;
       remain -= i;
       start += i;
       if(start >= buffer.length) start = 0;
    }
    i = math.min(remain, end >= start ? 0 : end);
    if(i > 0 ) {
       system.arraycopy(buffer, 0, data, off, i);
       remain -= i;
       start = i;
    }
    return n - remain;
  }
}

  ringbuffer databuffer = ... ;
  /**
  * handle output buffer empty events.
  * note: the reception is of this event is optional and not
  *    guaranteed by the api specification.
  * @param event the output buffer empty event
  */
  protected void outputbufferempty(serialportevent event) {
  }

import javax.comm.*;
...
inputstream is = port.getinputstream();
bufferedoutputstream out = new bufferedoutputstream(new fileoutputstream("out.dat"));
/**
 * listen to port events
 */ 
class filelistener implements serialporteventlistener {

  /**
   * handle serial event.
   */
  void serialevent(serialportevent e) {
    serialport port = (serialport) e.getsource();

    //
    // discriminate handling according to event type
    //
    switch(e.geteventtype()) {
    case serialportevent.data_available:

      //
      // move all currently available data to the file
      //
      try {
         int c;
         while((c = is.read()) != -1) {
            out.write(c);
         }
      } catch(ioexception ex) {
         ...
      }
      break;
    case ...:
      ...
      break;
    ...
    }
    if (is != null) is.close();
    if (port != null) port.close();
  }