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