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