com.hoho.android.usbserial.driver.CdcAcmSerialDriver Java Examples

private void usbParameters(int baudRate, int dataBits, int stopBits, int parity) throws IOException, InterruptedException {
    usbSerialPort.setParameters(baudRate, dataBits, stopBits, parity);
    if(usbSerialDriver instanceof CdcAcmSerialDriver)
        Thread.sleep(10); // arduino_leonardeo_bridge.ini needs some time
    else
        Thread.sleep(1);
}
 

/**
 * Called once we have permission, this will open a connection to the radio
 */
private void openConnection() {
    Log.v(TAG, "Opening connection to device");

    usbDeviceConnection = usbManager.openDevice(usbDevice);
    UsbSerialDriver driver = new CdcAcmSerialDriver(usbDevice);

    Log.v(TAG, "Device has " + String.valueOf(driver.getPorts().size()) + " ports");
    deviceSerialInterface = driver.getPorts().get(0);

    try {
        deviceSerialInterface.open(usbDeviceConnection);
        deviceSerialInterface.setParameters(RadioDevice.BAUD_RATE, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
        deviceSerialInterface.setDTR(false);
        deviceSerialInterface.setRTS(true);

        readBuffer.clear();

        readBufferFillerThread = new Thread(readBufferFillerRunnable);
        readBufferFillerThread.start();

        running = true;
        if (connectionStateListener != null) {
            connectionStateListener.onStart();
        }
    } catch (IOException e) {
        e.printStackTrace();
        closeConnection();
        if (connectionStateListener != null) {
            connectionStateListener.onFail();
        }
    }
}
 

private void usbParameters(int baudRate, int dataBits, int stopBits, int parity) throws IOException, InterruptedException {
    usbSerialPort.setParameters(baudRate, dataBits, stopBits, parity);
    if(usbSerialDriver instanceof CdcAcmSerialDriver)
        Thread.sleep(10); // arduino_leonardeo_bridge.ini needs some time
    else
        Thread.sleep(1);
}
 

static UsbSerialProber getCustomProber() {
    ProbeTable customTable = new ProbeTable();
    customTable.addProduct(0x16d0, 0x087e, CdcAcmSerialDriver.class); // e.g. Digispark CDC
    return new UsbSerialProber(customTable);
}
 

@Test
// data loss es expected, if data is not consumed fast enough
public void readBuffer() throws Exception {
    if(usbSerialDriver instanceof CdcAcmSerialDriver)
        telnetWriteDelay = 10; // arduino_leonardo_bridge.ino sends each byte in own USB packet, which is horribly slow
    usbParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);

    StringBuilder expected = new StringBuilder();
    StringBuilder data = new StringBuilder();
    final int maxWait = 2000;
    int bufferSize = 0;
    for(bufferSize = 8; bufferSize < (2<<15); bufferSize *= 2) {
        int linenr = 0;
        String line;
        expected.setLength(0);
        data.setLength(0);

        Log.i(TAG, "bufferSize " + bufferSize);
        usbReadBlock = true;
        for (linenr = 0; linenr < bufferSize/8; linenr++) {
            line = String.format("%07d,", linenr);
            telnetWrite(line.getBytes());
            expected.append(line);
        }
        usbReadBlock = false;

        // slowly write new data, until old data is comletely read from buffer and new data is received again
        boolean found = false;
        for (; linenr < bufferSize/8 + maxWait/10 && !found; linenr++) {
            line = String.format("%07d,", linenr);
            telnetWrite(line.getBytes());
            Thread.sleep(10);
            expected.append(line);
            data.append(new String(usbRead(0)));
            found = data.toString().endsWith(line);
        }
        if(!found) {
            // use waiting read to clear input queue, else next test would see unexpected data
            byte[] rest = null;
            while(rest==null || rest.length>0)
                rest = usbRead(-1);
            fail("end not found");
        }
        if (data.length() != expected.length())
            break;
    }
    int pos = indexOfDifference(data, expected);
    Log.i(TAG, "bufferSize " + bufferSize + ", first difference at " + pos);
    // actual values have large variance for same device, e.g.
    //  bufferSize 4096, first difference at 164
    //  bufferSize 64, first difference at 57
    assertTrue(bufferSize > 16);
    assertTrue(data.length() != expected.length());
}
 

@Test
public void readSpeed() throws Exception {
    // see logcat for performance results
    //
    // CDC arduino_leonardo_bridge.ini has transfer speed ~ 100 byte/sec
    // all other devices are near physical limit with ~ 10-12k/sec
    int baudrate = 115200;
    usbParameters(baudrate, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(baudrate, 8, 1, UsbSerialPort.PARITY_NONE);

    // fails more likely with larger or unlimited (-1) write ahead
    int writeSeconds = 5;
    int writeAhead = 5*baudrate/10; // write ahead for another 5 second read
    if(usbSerialDriver instanceof CdcAcmSerialDriver)
        writeAhead = 50;

    int linenr = 0;
    String line="";
    StringBuilder data = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    int dlen = 0, elen = 0;
    Log.i(TAG, "readSpeed: 'read' should be near "+baudrate/10);
    long begin = System.currentTimeMillis();
    long next = System.currentTimeMillis();
    for(int seconds=1; seconds <= writeSeconds; seconds++) {
        next += 1000;
        while (System.currentTimeMillis() < next) {
            if((writeAhead < 0) || (expected.length() < data.length() + writeAhead)) {
                line = String.format("%07d,", linenr++);
                telnetWrite(line.getBytes());
                expected.append(line);
            } else {
                Thread.sleep(0, 100000);
            }
            data.append(new String(usbRead(0)));
        }
        Log.i(TAG, "readSpeed: t="+(next-begin)+", read="+(data.length()-dlen)+", write="+(expected.length()-elen));
        dlen = data.length();
        elen = expected.length();
    }
    boolean found = false;
    long maxwait = Math.max(1000, (expected.length() - data.length()) * 20000L / baudrate );
    next = System.currentTimeMillis() + maxwait;
    Log.d(TAG, "readSpeed: rest wait time " + maxwait + " for " + (expected.length() - data.length()) + " byte");
    while(!found && System.currentTimeMillis() < next) {
        data.append(new String(usbRead(0)));
        found = data.toString().endsWith(line);
        Thread.sleep(1);
    }
    //next = System.currentTimeMillis();
    //Log.i(TAG, "readSpeed: t="+(next-begin)+", read="+(data.length()-dlen));

    int errcnt = 0;
    int errlen = 0;
    int datapos = indexOfDifference(data, expected);
    int expectedpos = datapos;
    while(datapos != -1) {
        errcnt += 1;
        int nextexpectedpos = -1;
        int nextdatapos = datapos + 2;
        int len = -1;
        if(nextdatapos + 10 < data.length()) { // try to sync data+expected, assuming that data is lost, but not corrupted
            String nextsub = data.substring(nextdatapos, nextdatapos + 10);
            nextexpectedpos = expected.indexOf(nextsub, expectedpos);
            if(nextexpectedpos >= 0) {
                len = nextexpectedpos - expectedpos - 2;
                errlen += len;
            }
        }
        Log.i(TAG, "readSpeed: difference at " + datapos + " len " + len );
        Log.d(TAG, "readSpeed:        got " +     data.substring(Math.max(datapos - 20, 0), Math.min(datapos + 20, data.length())));
        Log.d(TAG, "readSpeed:   expected " + expected.substring(Math.max(expectedpos - 20, 0), Math.min(expectedpos + 20, expected.length())));
        datapos = indexOfDifference(data, expected, nextdatapos, nextexpectedpos);
        expectedpos = nextexpectedpos + (datapos  - nextdatapos);
    }
    if(errcnt != 0)
        Log.i(TAG, "readSpeed: got " + errcnt + " errors, total len " + errlen+ ", avg. len " + errlen/errcnt);
    assertTrue("end not found", found);
    assertEquals("no errors", 0, errcnt);
}
 

@Test
public void writeSpeed() throws Exception {
    // see logcat for performance results
    //
    // CDC arduino_leonardo_bridge.ini has transfer speed ~ 100 byte/sec
    // all other devices can get near physical limit:
    // longlines=true:, speed is near physical limit at 11.5k
    // longlines=false: speed is 3-4k for all devices, as more USB packets are required
    usbParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    boolean longlines = !(usbSerialDriver instanceof CdcAcmSerialDriver);

    int linenr = 0;
    String line="";
    StringBuilder data = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    int dlen = 0, elen = 0;
    Log.i(TAG, "writeSpeed: 'write' should be near "+115200/10);
    long begin = System.currentTimeMillis();
    long next = System.currentTimeMillis();
    for(int seconds=1; seconds<=5; seconds++) {
        next += 1000;
        while (System.currentTimeMillis() < next) {
            if(longlines)
                line = String.format("%060d,", linenr++);
            else
                line = String.format("%07d,", linenr++);
            usbWrite(line.getBytes());
            expected.append(line);
            data.append(new String(telnetRead(0)));
        }
        Log.i(TAG, "writeSpeed: t="+(next-begin)+", write="+(expected.length()-elen)+", read="+(data.length()-dlen));
        dlen = data.length();
        elen = expected.length();
    }
    boolean found = false;
    for (linenr=0; linenr < 2000 && !found; linenr++) {
        data.append(new String(telnetRead(0)));
        Thread.sleep(1);
        found = data.toString().endsWith(line);
    }
    next = System.currentTimeMillis();
    Log.i(TAG, "writeSpeed: t="+(next-begin)+", read="+(data.length()-dlen));
    assertTrue(found);
    int pos = indexOfDifference(data, expected);
    if(pos!=-1) {

        Log.i(TAG, "writeSpeed: first difference at " + pos);
        String datasub     =     data.substring(Math.max(pos - 20, 0), Math.min(pos + 20, data.length()));
        String expectedsub = expected.substring(Math.max(pos - 20, 0), Math.min(pos + 20, expected.length()));
        assertThat(datasub, equalTo(expectedsub));
    }
}
 

static UsbSerialProber getCustomProber() {
    ProbeTable customTable = new ProbeTable();
    customTable.addProduct(0x16d0, 0x087e, CdcAcmSerialDriver.class); // e.g. Digispark CDC
    return new UsbSerialProber(customTable);
}
 

@Test
public void writeTimeout() throws Exception {
    usbOpen();
    usbParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);

    // Basically all devices have a UsbEndpoint.getMaxPacketSize() 64. When the timeout
    // in usbSerialPort.write() is reached, some packets have been written and the rest
    // is discarded. bulkTransfer() does not return the number written so far, but -1.
    // With 115200 baud and 1/2 second timeout, typical values are:
    //   ch340    6080 of 6144
    //   pl2302   5952 of 6144
    //   cp2102   6400 of 7168
    //   cp2105   6272 of 7168
    //   ft232    5952 of 6144
    //   ft2232   9728 of 10240
    //   arduino   128 of 144
    int timeout = 500;
    int len = 0;
    int startLen = 1024;
    int step = 1024;
    int minLen = 4069;
    int maxLen = 12288;
    int bufferSize = 511;
    TestBuffer buf = new TestBuffer(len);
    if(usbSerialDriver instanceof CdcAcmSerialDriver) {
        startLen = 16;
        step = 16;
        minLen = 128;
        maxLen = 256;
        bufferSize = 31;
    }

    try {
        for (len = startLen; len < maxLen; len += step) {
            buf = new TestBuffer(len);
            Log.d(TAG, "write buffer size " + len);
            usbSerialPort.write(buf.buf, timeout);
            while (!buf.testRead(telnetRead(-1)))
                ;
        }
        fail("write timeout expected between " + minLen + " and " + maxLen + ", is " + len);
    } catch (IOException e) {
        Log.d(TAG, "usbWrite failed", e);
        while (true) {
            byte[] data = telnetRead(-1);
            if (data.length == 0) break;
            if (buf.testRead(data)) break;
        }
        Log.d(TAG, "received " + buf.len + " of " + len + " bytes of failing usbWrite");
        assertTrue("write timeout expected between " + minLen + " and " + maxLen + ", is " + len, len > minLen);
    }

    // With smaller writebuffer, the timeout is used per bulkTransfer and each call 'fits'
    // into this timout, but shouldn't further calls only use the remaining timeout?
    ((CommonUsbSerialPort) usbSerialPort).setWriteBufferSize(bufferSize);
    len = maxLen;
    buf = new TestBuffer(len);
    Log.d(TAG, "write buffer size " + len);
    usbSerialPort.write(buf.buf, timeout);
    while (!buf.testRead(telnetRead(-1)))
        ;
}
 

@Test
// provoke data loss, when data is not read fast enough
public void readBufferOverflow() throws Exception {
    if(usbSerialDriver instanceof CdcAcmSerialDriver)
        telnetWriteDelay = 10; // arduino_leonardo_bridge.ino sends each byte in own USB packet, which is horribly slow
    usbOpen();
    usbParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);

    StringBuilder expected = new StringBuilder();
    StringBuilder data = new StringBuilder();
    final int maxWait = 2000;
    int bufferSize;
    for(bufferSize = 8; bufferSize < (2<<15); bufferSize *= 2) {
        int linenr;
        String line="-";
        expected.setLength(0);
        data.setLength(0);

        Log.i(TAG, "bufferSize " + bufferSize);
        usbReadBlock = true;
        for (linenr = 0; linenr < bufferSize/8; linenr++) {
            line = String.format("%07d,", linenr);
            telnetWrite(line.getBytes());
            expected.append(line);
        }
        usbReadBlock = false;

        // slowly write new data, until old data is completely read from buffer and new data is received
        boolean found = false;
        for (; linenr < bufferSize/8 + maxWait/10 && !found; linenr++) {
            line = String.format("%07d,", linenr);
            telnetWrite(line.getBytes());
            Thread.sleep(10);
            expected.append(line);
            data.append(new String(usbRead(0)));
            found = data.toString().endsWith(line);
        }
        while(!found) {
            // use waiting read to clear input queue, else next test would see unexpected data
            byte[] rest = usbRead(-1);
            if(rest.length == 0)
                fail("last line "+line+" not found");
            data.append(new String(rest));
            found = data.toString().endsWith(line);
        }
        if (data.length() != expected.length())
            break;
    }

    findDifference(data, expected);
    assertTrue(bufferSize > 16);
    assertTrue(data.length() != expected.length());
}
 

private int readSpeedInt(int writeSeconds, int readTimeout) throws Exception {
    int baudrate = 115200;
    if(usbSerialDriver instanceof Ch34xSerialDriver)
        baudrate = 38400;
    int writeAhead = 5*baudrate/10; // write ahead for another 5 second read
    if(usbSerialDriver instanceof CdcAcmSerialDriver)
        writeAhead = 50;

    usbOpen(EnumSet.noneOf(UsbOpenFlags.class), readTimeout);
    usbParameters(baudrate, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(baudrate, 8, 1, UsbSerialPort.PARITY_NONE);

    int linenr = 0;
    String line="";
    StringBuilder data = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    int dlen = 0, elen = 0;
    Log.i(TAG, "readSpeed: 'read' should be near "+baudrate/10);
    long begin = System.currentTimeMillis();
    long next = System.currentTimeMillis();
    for(int seconds=1; seconds <= writeSeconds; seconds++) {
        next += 1000;
        while (System.currentTimeMillis() < next) {
            if((writeAhead < 0) || (expected.length() < data.length() + writeAhead)) {
                line = String.format("%07d,", linenr++);
                telnetWrite(line.getBytes());
                expected.append(line);
            } else {
                Thread.sleep(0, 100000);
            }
            data.append(new String(usbRead(0)));
        }
        Log.i(TAG, "readSpeed: t="+(next-begin)+", read="+(data.length()-dlen)+", write="+(expected.length()-elen));
        dlen = data.length();
        elen = expected.length();
    }

    boolean found = false;
    while(!found) {
        // use waiting read to clear input queue, else next test would see unexpected data
        byte[] rest = usbRead(-1);
        if(rest.length == 0)
            break;
        data.append(new String(rest));
        found = data.toString().endsWith(line);
    }
    return findDifference(data, expected);
}
 

@Test
public void writeSpeed() throws Exception {
    // see logcat for performance results
    //
    // CDC arduino_leonardo_bridge.ini has transfer speed ~ 100 byte/sec
    // all other devices can get near physical limit:
    // longlines=true:, speed is near physical limit at 11.5k
    // longlines=false: speed is 3-4k for all devices, as more USB packets are required
    usbOpen();
    usbParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
    boolean longlines = !(usbSerialDriver instanceof CdcAcmSerialDriver);

    int linenr = 0;
    String line="";
    StringBuilder data = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    int dlen = 0, elen = 0;
    Log.i(TAG, "writeSpeed: 'write' should be near "+115200/10);
    long begin = System.currentTimeMillis();
    long next = System.currentTimeMillis();
    for(int seconds=1; seconds<=5; seconds++) {
        next += 1000;
        while (System.currentTimeMillis() < next) {
            if(longlines)
                line = String.format("%060d,", linenr++);
            else
                line = String.format("%07d,", linenr++);
            usbWrite(line.getBytes());
            expected.append(line);
            data.append(new String(telnetRead(0)));
        }
        Log.i(TAG, "writeSpeed: t="+(next-begin)+", write="+(expected.length()-elen)+", read="+(data.length()-dlen));
        dlen = data.length();
        elen = expected.length();
    }
    boolean found = false;
    for (linenr=0; linenr < 2000 && !found; linenr++) {
        data.append(new String(telnetRead(0)));
        Thread.sleep(1);
        found = data.toString().endsWith(line);
    }
    next = System.currentTimeMillis();
    Log.i(TAG, "writeSpeed: t="+(next-begin)+", read="+(data.length()-dlen));
    assertTrue(found);
    int pos = indexOfDifference(data, expected);
    if(pos!=-1) {

        Log.i(TAG, "writeSpeed: first difference at " + pos);
        String datasub     =     data.substring(Math.max(pos - 20, 0), Math.min(pos + 20, data.length()));
        String expectedsub = expected.substring(Math.max(pos - 20, 0), Math.min(pos + 20, expected.length()));
        assertThat(datasub, equalTo(expectedsub));
    }
}
 

@Test
public void readTimeout() throws Exception {
    if (usbSerialDriver instanceof FtdiSerialDriver)
        return; // periodically sends status messages, so does not block here
    final Boolean[] closed = {Boolean.FALSE};

    Runnable closeThread = new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            usbClose();
            closed[0] = true;
        }
    };

    usbOpen(EnumSet.of(UsbOpenFlags.NO_IOMANAGER_THREAD));
    usbParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);

    byte[] buf = new byte[]{1};
    int len,i,j;
    long time;

    // w/o timeout
    telnetWrite(buf);
    len = usbSerialPort.read(buf, 0); // not blocking because data is available
    assertEquals(1, len);

    time = System.currentTimeMillis();
    closed[0] = false;
    Executors.newSingleThreadExecutor().submit(closeThread);
    len = usbSerialPort.read(buf, 0); // blocking until close()
    assertEquals(0, len);
    assertTrue(System.currentTimeMillis()-time >= 100);
    // wait for usbClose
    for(i=0; i<100; i++) {
        if(closed[0]) break;
        Thread.sleep(1);
    }
    assertTrue("not closed in time", closed[0]);

    // with timeout
    usbOpen(EnumSet.of(UsbOpenFlags.NO_IOMANAGER_THREAD));
    usbParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
    telnetParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);

    int longTimeout = 1000;
    int shortTimeout = 10;
    time = System.currentTimeMillis();
    len = usbSerialPort.read(buf, shortTimeout);
    assertEquals(0, len);
    assertTrue(System.currentTimeMillis()-time < 100);

    // no issue with slow transfer rate and short read timeout
    time = System.currentTimeMillis();
    for(i=0; i<50; i++) {
        Thread.sleep(10);
        telnetWrite(buf);
        for(j=0; j<20; j++) {
            len = usbSerialPort.read(buf, shortTimeout);
            if (len > 0)
                break;
        }
        assertEquals("failed after " + i, 1, len);
    }
    Log.i(TAG, "average time per read " + (System.currentTimeMillis()-time)/i + " msec");

    if(!(usbSerialDriver instanceof CdcAcmSerialDriver)) {
        int diffLen;
        usbClose();
        // no issue with high transfer rate and long read timeout
        diffLen = readSpeedInt(5, longTimeout);
        if(usbSerialDriver instanceof Ch34xSerialDriver && diffLen == -1)
            diffLen = 0; // todo: investigate last packet loss
        assertEquals(0, diffLen);
        usbClose();
        // date loss with high transfer rate and short read timeout !!!
        diffLen = readSpeedInt(5, shortTimeout);
        assertNotEquals(0, diffLen);

        // data loss observed with read timeout up to 200 msec, e.g.
        //  difference at 181 len 64
        //        got 000020,0000021,0000030,0000031,0000032,0
        //   expected 000020,0000021,0000022,0000023,0000024,0
        // difference at 341 len 128
        //        got 000048,0000049,0000066,0000067,0000068,0
        //   expected 000048,0000049,0000050,0000051,0000052,0
        // difference at 724 len 704
        //        got 0000112,0000113,0000202,0000203,0000204,
        //   expected 0000112,0000113,0000114,0000115,0000116,
        // difference at 974 len 8
        //        got 00231,0000232,0000234,0000235,0000236,00
        //   expected 00231,0000232,0000233,0000234,0000235,00
    }
}