src/com/ftdi/usb/FtdiUart.java

   1 package com.ftdi.usb;
   2 import java.io.*;
   3
   4 /**
   5  *  A Java wrapper around libftdi.
   6  *
   7  *  Note: blocking reads are currently implemented by busy-waiting.
   8  *  This is really ugly.  Check the linux kernel source to see how to
   9  *  get libftdi to do it properly.
  10  *
  11  *  Flow control is also not properly supported.
  12  */
  13 public class FtdiUart {
  14
  15     private SWIGTYPE_p_ftdi_context context = example.new_ftdi_context();
  16
  17     public OutputStream getOutputStream() { return out; }
  18     public InputStream  getInputStream() { return in; }
  19
  20     public FtdiUart(int vendor, int product, int baud) throws IOException {
  21         example.ftdi_init(context);
  22         example.ftdi_usb_open(context, vendor, product);
  23         example.ftdi_usb_reset(context);
  24         example.ftdi_set_baudrate(context, baud);
  25         example.ftdi_set_line_property(context, 8, 0, 0);
  26         purge();
  27     }
  28
  29     /**
  30      *  Switch to uart mode, with read/write access to four CBUS lines.
  31      *  This function is used to write to the CBUS lines (re-invoke it to change their state).
  32      *  I think readPins() is used to read from them, but I'm not sure.
  33      *
  34      *  @param cbus_mask a four-bit mask; set bit=1 to write to a CBUS line, bit=0 to read from it
  35      *  @param cbus_bits a four-bit mask; the bits to assert on the write-enabled CBUS lines
  36      */
  37     public synchronized void uart_and_cbus_mode(int cbus_mask, int cbus_bits) throws IOException {
  38         example.ftdi_set_bitmode(context, (short)((cbus_mask << 4) | cbus_bits), (short)0x20);
  39     }
  40
  41     /**
  42      *  Switch to dbus mode; CBUS lines will be released (ie they will float).
  43      *  Use getInputStream()/getOutputStream() to read/write the eight DBUS lines.
  44      *
  45      *  @param dbus_mask an eight-bit mask; set bit=1 to write to a DBUS line, bit=0 to read from it
  46      */
  47     public synchronized void dbus_mode(int dbus_mask) throws IOException {
  48         example.ftdi_set_bitmode(context, (short)dbus_mask, (short)0x01);
  49     }
  50
  51     /** returns the instantaneous value present on the DBUS pins */
  52     public synchronized int readPins() throws IOException {
  53         getOutputStream().flush();
  54         byte[] b = new byte[1];
  55         example.ftdi_read_pins(context, b);
  56         return b[0];
  57     }
  58
  59     /** purge the on-chip buffers */
  60     public synchronized void purge() throws IOException {
  61         example.ftdi_usb_purge_buffers(context);
  62     }
  63
  64     private final InputStream in = new InputStream() {
  65             public int available() throws IOException {
  66                 // FIXME
  67                 return 0;
  68             }
  69             public int read() throws IOException {
  70                 byte[] b = new byte[1];
  71                 int result = 0;
  72                 while(result==0) result = read(b, 0, 1);
  73                 return b[0] & 0xff;
  74             }
  75             public int read(byte[] b, int off, int len) throws IOException {
  76                 // FIXME: blocking reads?
  77                 int result = 0;
  78                 while(true) {
  79                     if (len==0) return 0;
  80                     byte[] b0 = new byte[len];
  81                     synchronized(FtdiUart.this) {
  82                         result = example.ftdi_read_data(context, b0, len);
  83                     }
  84                     if (result>0) {
  85                         System.arraycopy(b0, 0, b, off, result);
  86                         return result;
  87                     }
  88                     try { Thread.sleep(50); } catch (Exception e) { e.printStackTrace(); }
  89                 }
  90             }
  91         };
  92
  93     private final OutputStream out = new BufferedOutputStream(new OutputStream() {
  94             public void write(int b) throws IOException {
  95                 byte[] d = new byte[1];
  96                 d[0] = (byte)b;
  97                 write(d, 0, 1);
  98             }
  99             public void write(byte[] b, int off, int len) throws IOException {
 100                 byte[] b2 = new byte[64];
 101                 while(len > 0) {
 102                     System.arraycopy(b, off, b2, 0, Math.min(b2.length, len));
 103                     int result;
 104                     synchronized(FtdiUart.this) {
 105                         result = example.ftdi_write_data(context, b2, Math.min(b2.length, len));
 106                     }
 107                     off += result;
 108                     len -= result;
 109                 }
 110             }
 111         });
 112 }