moparisthebest
/
USBHost_t36
mirror of https://github.com/gdsports/USBHost_t36
1
0
Fork 0
Code Issues Releases Wiki Activity

CDCACM - Serial support 

Have some support in place for the CDCACM serial class code.

It appears to be working for talking to a
Teensy that is programmed USB=Serial
or USB=Serial+...

Also test with an USB2AX board which is a Servo controller for Dynamixel servos (AX-12), that is an Atmega32u2 board programmed using LUFA as the USB library.
This commit is contained in:
Kurt Eckhardt 2017-10-27 09:35:46 -07:00
parent bd5f7d9486
commit 6e1f0c379c
3 changed files with 587 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
USBHost_t36.h
View File

@ -900,6 +900,7 @@ public:
virtual int read(void);
virtual int availableForWrite();
virtual size_t write(uint8_t c);
using Print::write;
protected:
virtual bool claim(Device_t *device, int type, const uint8_t *descriptors, uint32_t len);
@ -941,6 +942,7 @@ private:
volatile uint8_t rxstate;// bitmask: which receive packets are queued
volatile uint8_t txstate;
uint8_t pending_control;
uint8_t interface;
bool control_queued;
enum { CDCACM, FTDI, PL2303, CH341 } sertype;
};

267
examples/SerialTest/SerialTest.ino Normal file
View File

@ -0,0 +1,267 @@
// Simple test of USB Host Mouse/Keyboard
//
// This example is in the public domain
#include "USBHost_t36.h"
USBHost myusb;
USBHub hub1(myusb);
USBHub hub2(myusb);
USBHIDParser hid1(myusb);
USBHIDParser hid2(myusb);
USBHIDParser hid3(myusb);
USBSerial userial(myusb);
USBDriver *drivers[] = {&hub1, &hub2, &hid1, &hid2, &hid3, &userial};
#define CNT_DEVICES (sizeof(drivers)/sizeof(drivers[0]))
const char * driver_names[CNT_DEVICES] = {"Hub1", "Hub2", "HID1", "HID2", "HID3", "USERIAL1" };
bool driver_active[CNT_DEVICES] = {false, false, false, false};
void setup()
{
pinMode(13, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
for (int i = 0; i < 5; i++) {
digitalWrite(2, HIGH);
delayMicroseconds(50);
digitalWrite(2, LOW);
delayMicroseconds(50);
}
while (!Serial && (millis() < 5000)) ; // wait for Arduino Serial Monitor
Serial.println("\n\nUSB Host Testing - Serial");
myusb.begin();
Serial1.begin(115200); // We will echo stuff Through Serial1...
}
void loop()
{
digitalWrite(13, !digitalRead(13));
myusb.Task();
// Print out information about different devices.
for (uint8_t i = 0; i < CNT_DEVICES; i++) {
if (*drivers[i] != driver_active[i]) {
if (driver_active[i]) {
Serial.printf("*** Device %s - disconnected ***\n", driver_names[i]);
driver_active[i] = false;
} else {
Serial.printf("*** Device %s %x:%x - connected ***\n", driver_names[i], drivers[i]->idVendor(), drivers[i]->idProduct());
driver_active[i] = true;
const uint8_t *psz = drivers[i]->manufacturer();
if (psz && *psz) Serial.printf(" manufacturer: %s\n", psz);
psz = drivers[i]->product();
if (psz && *psz) Serial.printf(" product: %s\n", psz);
psz = drivers[i]->serialNumber();
if (psz && *psz) Serial.printf(" Serial: %s\n", psz);
// If this is a new Serial device.
if (drivers[i] == &userial) {
// Lets try first outputting something to our USerial to see if it will go out...
userial.begin(1000000);
#if 0
userial.println("abcdefghijklmnopqrstuvwxyz");
userial.println("ABCDEFGHIJKLMNOPQURSTUVWYZ");
userial.flush(); // force it out now.
userial.println("0123456789");
userial.flush();
delay(2);
userial.println("abcdefghijklmnopqrstuvwxyz");
userial.println("ABCDEFGHIJKLMNOPQURSTUVWYZ");
delay(2);
userial.println("!@#$%^&*()");
userial.flush();
#endif
}
}
}
}
while (Serial.available()) {
Serial.println("Serial Available");
int ch = Serial.read();
if (ch == '$') {
BioloidTest();
while (Serial.read() != -1);
}
else userial.write(ch);
}
while (Serial1.available()) {
// Serial.println("Serial1 Available");
Serial1.write(Serial1.read());
}
while (userial.available()) {
// Serial.println("USerial Available");
Serial.write(userial.read());
}
}
//#define ID_MASTER 200
#define ID_MASTER 0xfd
// Extract stuff from Bioloid library..
#define AX12_BUFFER_SIZE 128
#define COUNTER_TIMEOUT 12000
/** Instruction Set **/
#define AX_PING 1
#define AX_READ_DATA 2
#define AX_WRITE_DATA 3
#define AX_REG_WRITE 4
#define AX_ACTION 5
#define AX_RESET 6
#define AX_SYNC_WRITE 131
#define AX_TORQUE_ENABLE 24
#define AX_LED 25
#define AX_CW_COMPLIANCE_MARGIN 26
#define AX_CCW_COMPLIANCE_MARGIN 27
#define AX_CW_COMPLIANCE_SLOPE 28
#define AX_CCW_COMPLIANCE_SLOPE 29
#define AX_GOAL_POSITION_L 30
#define AX_GOAL_POSITION_H 31
#define AX_GOAL_SPEED_L 32
#define AX_GOAL_SPEED_H 33
#define AX_TORQUE_LIMIT_L 34
#define AX_TORQUE_LIMIT_H 35
#define AX_PRESENT_POSITION_L 36
#define AX_PRESENT_POSITION_H 37
void BioloidTest() {
uint8_t master_id = 200;
Serial.println("\n*** Bioloid Test ***");
if (ax12GetRegister(master_id, 0, 1) != -1) {
Serial.println("Controller found at 200");
} else {
Serial.println("Controller not at 200 try 0xfd");
master_id = 0xfd;
if (ax12GetRegister(master_id, 0, 1) != -1) {
Serial.println("Controller found at 0xfd");
} else {
Serial.println("Controller not found");
}
}
for (uint8_t reg = 0; reg < 10; reg++) {
myusb.Task();
Serial.print(ax12GetRegister(master_id, reg, 1), HEX);
Serial.print(" ");
}
Serial.println();
// Now assuming we found controller...
// May need to turn on power on controller
ax12SetRegister(master_id, AX_TORQUE_ENABLE, 1);
delay(2);
// Lets see if we can get the current position for any servo
for (int i = 0; i < 254; i++) {
int servo_pos = ax12GetRegister(i, AX_PRESENT_POSITION_L, 2);
if (servo_pos != -1) {
Serial.printf("Servo: %d Pos: %d\n", i, servo_pos);
}
}
}
unsigned char ax_rx_buffer[AX12_BUFFER_SIZE];
int ax12GetRegister(int id, int regstart, int length) {
// 0xFF 0xFF ID LENGTH INSTRUCTION PARAM... CHECKSUM
int return_value;
digitalWriteFast(2, HIGH);
int checksum = ~((id + 6 + regstart + length) % 256);
userial.write(0xFF);
userial.write(0xFF);
userial.write(id);
userial.write(4); // length
userial.write(AX_READ_DATA);
userial.write(regstart);
userial.write(length);
userial.write(checksum);
userial.flush(); // make sure the data goes out.
if (ax12ReadPacket(length + 6) > 0) {
// ax12Error = ax_rx_buffer[4];
if (length == 1)
return_value = ax_rx_buffer[5];
else
return_value = ax_rx_buffer[5] + (ax_rx_buffer[6] << 8);
} else {
digitalWriteFast(3, !digitalReadFast(3));
return_value = -1;
}
digitalWriteFast(2, LOW);
return return_value;
}
void ax12SetRegister(int id, int regstart, int data){
int checksum = ~((id + 4 + AX_WRITE_DATA + regstart + (data&0xff)) % 256);
userial.write(0xFF);
userial.write(0xFF);
userial.write(id);
userial.write(4); // length
userial.write(AX_WRITE_DATA);
userial.write(regstart);
userial.write(data&0xff);
// checksum =
userial.write(checksum);
userial.flush();
//ax12ReadPacket();
}
int ax12ReadPacket(int length) {
unsigned long ulCounter;
unsigned char offset, checksum;
unsigned char *psz;
unsigned char *pszEnd;
int ch;
offset = 0;
psz = ax_rx_buffer;
pszEnd = &ax_rx_buffer[length];
while (userial.read() != -1) ;
uint32_t ulStart = millis();
// Need to wait for a character or a timeout...
do {
ulCounter = COUNTER_TIMEOUT;
while ((ch = userial.read()) == -1) {
if ((millis() - ulStart) > 10) {
//if (!--ulCounter) {
// Serial.println("Timeout");
return 0; // Timeout
}
}
} while (ch != 0xff) ;
*psz++ = 0xff;
while (psz != pszEnd) {
ulCounter = COUNTER_TIMEOUT;
while ((ch = userial.read()) == -1) {
//Serial.printf("Read ch: %x\n", ch);
if (!--ulCounter) {
return 0; // Timeout
}
}
*psz++ = (unsigned char)ch;
}
checksum = 0;
for (offset = 2; offset < length; offset++)
checksum += ax_rx_buffer[offset];
if (checksum != 255) {
return 0;
} else {
return 1;
}
}

336
serial.cpp
View File

@ -27,6 +27,16 @@
#define print USBHost::print_
#define println USBHost::println_
/************************************************************/
// Control Transfer For Configuration
/************************************************************/
typedef struct {
uint32_t dwDTERate; // Data Terminal Rate in bits per second
uint8_t bCharFormat; // 0 - 1 stop bit, 1 - 1.5 stop bits, 2 - 2 stop bits
uint8_t bParityType; // 0 - None, 1 - Odd, 2 - Even, 3 - Mark, 4 - Space
uint8_t bDataBits; // Data bits (5, 6, 7, 8 or 16)
} LINE_CODING;
/************************************************************/
// Initialization and claiming of devices & interfaces
/************************************************************/
@ -44,7 +54,11 @@ bool USBSerial::claim(Device_t *dev, int type, const uint8_t *descriptors, uint3
// only claim at interface level
println("USBSerial claim this=", (uint32_t)this, HEX);
print("vid=", dev->idVendor, HEX);
println(", pid=", dev->idProduct, HEX);
print(", pid=", dev->idProduct, HEX);
print(", bDeviceClass = ", dev->bDeviceClass);
print(", bDeviceSubClass = ", dev->bDeviceSubClass);
println(", bDeviceProtocol = ", dev->bDeviceProtocol);
print_hexbytes(descriptors, len);
if (type == 0) {
if (dev->idVendor == 0x0403 && dev->idProduct == 0x6001) {
// FTDI FT232
@ -90,9 +104,266 @@ bool USBSerial::claim(Device_t *dev, int type, const uint8_t *descriptors, uint3
queue_Control_Transfer(dev, &setup, NULL, this);
control_queued = true;
return true;
} else if ((dev->bDeviceClass == 2) && (dev->bDeviceSubClass == 0)) {
// It is a communication device see if we can extract the data...
// Try some ttyACM types?
// This code may be similar to MIDI code.
// But first pass see if we can simply look at the interface...
// Lets walk through end points and see if we
// can find an RX and TX bulk transfer end point.
// 0 1 2 3 4 5 6 7 8 *9 10 1 2 3 *4 5 6 7 *8 9 20 1 2 *3 4 5 6 7 8 9*30 1 2 3 4 5 6 7 8 *9 40 1 2 3 4 5 *6 7 8 9 50 1 2
// USB2AX
//09 04 00 00 01 02 02 01 00 05 24 00 10 01 04 24 02 06 05 24 06 00 01 07 05 82 03 08 00 FF 09 04 01 00 02 0A 00 00 00 07 05 04 02 10 00 01 07 05 83 02 10 00 01
//09 04 01 00 02 0A 00 00 00 07 05 04 02 10 00 01 07 05 83 02 10 00 01
// Teensy 3.6
//09 04 00 00 01 02 02 01 00 05 24 00 10 01 05 24 01 01 01 04 24 02 06 05 24 06 00 01 07 05 82 03 10 00 40 09 04 01 00 02 0A 00 00 00 07 05 03 02 40 00 00 07 05 84 02 40 00 00
//09 04 01 00 02 0A 00 00 00 07 05 03 02 40 00 00 07 05 84 02 40 00 00
const uint8_t *p = descriptors;
const uint8_t *end = p + len;
if (p[0] != 9 || p[1] != 4) return false; // interface descriptor
//println(" bInterfaceClass=", p[5]);
//println(" bInterfaceSubClass=", p[6]);
if (p[5] != 2) return false; // bInterfaceClass: 2 Communications
if (p[6] != 2) return false; // bInterfaceSubClass: 2 serial
p += 9;
println(" Interface is Serial");
uint8_t rx_ep = 0;
uint8_t tx_ep = 0;
uint16_t rx_size = 0;
uint16_t tx_size = 0;
interface = 0; // clear out any interface numbers passed in.
while (p < end) {
len = *p;
if (len < 4) return false;
if (p + len > end) return false; // reject if beyond end of data
uint32_t type = p[1];
//println("type: ", type);
// Unlike Audio, we need to look at Interface as our endpoints are after them...
if (type == 4 ) { // Interface - lets remember it's number...
interface = p[2];
println(" Interface: ", interface);
}
else if (type == 0x24) { // 0x24 = CS_INTERFACE,
uint32_t subtype = p[2];
print(" CS_INTERFACE - subtype: ", subtype);
if (len >= 4) print(" ", p[3], HEX);
if (len >= 5) print(" ", p[4], HEX);
if (len >= 6) print(" ", p[5], HEX);
switch (subtype) {
case 0: println(" - Header Functional Descriptor"); break;
case 1: println(" - Call Management Functional"); break;
case 2: println(" - Abstract Control Management"); break;
case 4: println(" - Telephone Ringer"); break;
case 6: println(" - union Functional"); break;
default: println(" - ??? other"); break;
}
// First pass ignore...
} else if (type == 5) {
// endpoint descriptor
if (p[0] < 7) return false; // at least 7 bytes
if (p[3] == 2) { // First try ignore the first one which is interrupt...
println(" Endpoint: ", p[2], HEX);
switch (p[2] & 0xF0) {
case 0x80:
// IN endpoint
if (rx_ep == 0) {
rx_ep = p[2] & 0x0F;
rx_size = p[4] | (p[5] << 8);
println(" rx_size = ", rx_size);
}
break;
case 0x00:
// OUT endpoint
if (tx_ep == 0) {
tx_ep = p[2];
tx_size = p[4] | (p[5] << 8);
println(" tx_size = ", tx_size);
}
break;
default:
println(" invalid end point: ", p[2]);
return false;
}
}
} else {
println(" Unknown type: ", type);
return false; // unknown
}
p += len;
}
print(" exited loop rx:", rx_ep);
println(", tx:", tx_ep);
if (!rx_ep || !tx_ep) return false; // did not get our two end points
if (!init_buffers(rx_size, tx_size)) return false;
rxpipe = new_Pipe(dev, 2, rx_ep & 15, 1, rx_size);
if (!rxpipe) return false;
txpipe = new_Pipe(dev, 2, tx_ep, 0, tx_size);
if (!txpipe) {
// TODO: free rxpipe
return false;
}
sertype = CDCACM;
rxpipe->callback_function = rx_callback;
queue_Data_Transfer(rxpipe, rx1, (rx_size < 64)? rx_size : 64, this);
rxstate = 1;
if (rx_size > 128) {
queue_Data_Transfer(rxpipe, rx2, rx_size, this);
rxstate = 3;
}
txstate = 0;
txpipe->callback_function = tx_callback;
baudrate = 115200;
// Wish I could just call Control to do the output... Maybe can defer until the user calls begin()
// control requires that device is setup which is not until this call completes...
println("Control - CDCACM DTR...");
// Need to setup the data the line coding data
mk_setup(setup, 0x21, 0x22, 3, 0, 0);
queue_Control_Transfer(dev, &setup, NULL, this);
control_queued = true;
pending_control = 0x0; // Maybe don't need to do...
return true;
}
#if 0
if (dev->idVendor == 0x67B && dev->idProduct == 0x2303) {
// Prolific Technology, Inc. PL2303 Serial Port
println("len = ", len);
uint8_t count_end_points = descriptors[4];
if (count_end_points < 2) return false; // not enough end points
if (len < 23) return false;
if (descriptors[0] != 9) return false; // length 9
// Lets walk through end points and see if we
// can find an RX and TX bulk transfer end point.
//vid=67B, pid=2303
// 0 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 20 1 2 3 4 5 6 7 8 9
//09 04 00 00 03 FF 00 00 00 07 05 81 03 0A 00 01 07 05 02 02 40 00 00 07 05 83 02 40 00 00
uint32_t rxep = 0;
uint32_t txep = 0;
uint16_t descriptor_index = 9;
while (count_end_points-- && ((rxep == 0) || txep == 0)) {
if (descriptors[descriptor_index] != 7) return false; // length 7
if (descriptors[descriptor_index+1] != 5) return false; // ep desc
if ((descriptors[descriptor_index+3] == 2)
&& (descriptors[descriptor_index+4] == 64)
&& (descriptors[descriptor_index+5] == 0)) {
// have a bulk EP size
if (descriptors[descriptor_index+2] & 0x80 ) {
rxep = descriptors[descriptor_index+2];
} else {
txep = descriptors[descriptor_index+2];
}
}
descriptor_index += 7; // setup to look at next one...
}
// Try to verify the end points.
if (!check_rxtx_ep(rxep, txep)) return false;
print("FTDI, rxep=", rxep & 15);
println(", txep=", txep);
if (!init_buffers(64, 64)) return false;
rxpipe = new_Pipe(dev, 2, rxep & 15, 1, 64);
if (!rxpipe) return false;
txpipe = new_Pipe(dev, 2, txep, 0, 64);
if (!txpipe) {
// TODO: free rxpipe
return false;
}
sertype = PL2303;
rxpipe->callback_function = rx_callback;
queue_Data_Transfer(rxpipe, rx1, 64, this);
rxstate = 1;
if (rxsize > 128) {
queue_Data_Transfer(rxpipe, rx2, 64, this);
rxstate = 3;
}
txstate = 0;
txpipe->callback_function = tx_callback;
baudrate = 115200;
pending_control = 0x0F;
mk_setup(setup, 0x40, 0, 0, 0, 0); // reset port
queue_Control_Transfer(dev, &setup, NULL, this);
control_queued = true;
return true;
}
#endif
} else if (type != 1) return false;
#if 1
// Try some ttyACM types?
// This code may be similar to MIDI code.
// But first pass see if we can simply look at the interface...
// Lets walk through end points and see if we
// can find an RX and TX bulk transfer end point.
// 0 1 2 3 4 5 6 7 8 *9 10 1 2 3 *4 5 6 7 *8 9 20 1 2 *3 4 5 6 7 8 9*30 1 2 3 4 5 6 7 8 *9 40 1 2 3 4 5 *6 7 8 9 50 1 2
// USB2AX
//09 04 00 00 01 02 02 01 00 05 24 00 10 01 04 24 02 06 05 24 06 00 01 07 05 82 03 08 00 FF
//09 04 01 00 02 0A 00 00 00 07 05 04 02 10 00 01 07 05 83 02 10 00 01
// Teensy 3.6
//09 04 00 00 01 02 02 01 00 05 24 00 10 01 05 24 01 01 01 04 24 02 06 05 24 06 00 01 07 05 82 03 10 00 40
//09 04 01 00 02 0A 00 00 00 07 05 03 02 40 00 00 07 05 84 02 40 00 00
if (descriptors[0] != 9 || descriptors[1] != 4) return false; // interface descriptor
if (descriptors[4] < 2) return false; // less than 2 end points
if (descriptors[5] != 0xA) return false; // bInterfaceClass, 0xa = CDC data
if (descriptors[6] != 0) return false; // bInterfaceSubClass
if (descriptors[7] != 0) return false; // bInterfaceProtocol, 1 = Keyboard
if (descriptors[9] != 7) return false; // length 7
if (descriptors[10] != 5) return false; // ep desc
uint32_t txep = descriptors[11];
uint32_t txsize = descriptors[13];
if (descriptors[12] != 2) return false; // bulk type
if (descriptors[13] > 64) return false; // size 64 Max
if (descriptors[14] != 0) return false;
if (descriptors[16] != 7) return false; // length 7
if (descriptors[17] != 5) return false; // ep desc
uint32_t rxep = descriptors[18];
uint32_t rxsize = descriptors[20];
if (descriptors[19] != 2) return false; // bulk type
if (descriptors[20] > 64) return false; // size 64 Max
if (descriptors[21] != 0) return false;
if (!check_rxtx_ep(rxep, txep)) return false;
interface = descriptors[2];
print("CDC, rxep=", rxep & 15);
println(", txep=", txep);
if (!init_buffers(rxsize, txsize)) return false;
rxpipe = new_Pipe(dev, 2, rxep & 15, 1, rxsize);
if (!rxpipe) return false;
txpipe = new_Pipe(dev, 2, txep, 0, txsize);
if (!txpipe) {
// TODO: free rxpipe
return false;
}
sertype = CDCACM;
rxpipe->callback_function = rx_callback;
queue_Data_Transfer(rxpipe, rx1, 64, this);
rxstate = 1;
if (rxsize > 128) {
queue_Data_Transfer(rxpipe, rx2, 64, this);
rxstate = 3;
}
txstate = 0;
txpipe->callback_function = tx_callback;
// See if we can do just the inteface...
baudrate = 115200;
println("Control - CDCACM LINE_CODING");
setupdata[0] = 0; // Setup baud rate 115200 - 0x1C200
setupdata[1] = 0xc2;
setupdata[2] = 0x1;
setupdata[3] = 0;
setupdata[4] = 0; // 0 - 1 stop bit, 1 - 1.5 stop bits, 2 - 2 stop bits
setupdata[5] = 0; // 0 - None, 1 - Odd, 2 - Even, 3 - Mark, 4 - Space
setupdata[6] = 8; // Data bits (5, 6, 7, 8 or 16)
mk_setup(setup, 0x21, 0x20, 0, 0, 7);
queue_Control_Transfer(dev, &setup, setupdata, this);
pending_control = 0x04; // Maybe don't need to do...
control_queued = true;
return true;
#else
return false;
#endif
}
// check if two legal endpoints, 1 receive & 1 transmit
@ -115,7 +386,8 @@ bool USBSerial::check_rxtx_ep(uint32_t &rxep, uint32_t &txep)
// initialize buffer sizes and pointers
bool USBSerial::init_buffers(uint32_t rsize, uint32_t tsize)
{
// buffer must be able to hold 2 of each packet, plus have room to
// buffer must be able to hold 2 of each packet, plus buffer
// space to hold RX and TX data.
if (sizeof(bigbuffer) < (rsize + tsize) * 3 + 2) return false;
rx1 = (uint8_t *)bigbuffer;
rx2 = rx1 + rsize;
@ -139,14 +411,10 @@ void USBSerial::disconnect()
}
/************************************************************/
// Control Transfer For Configuration
/************************************************************/
void USBSerial::control(const Transfer_t *transfer)
{
println("control callback (serial)");
println("control callback (serial) ", pending_control, HEX);
control_queued = false;
// set data format
@ -160,18 +428,45 @@ void USBSerial::control(const Transfer_t *transfer)
// set baud rate
if (pending_control & 2) {
pending_control &= ~2;
uint32_t baudval = 3000000 / baudrate;
mk_setup(setup, 0x40, 3, baudval, 0, 0);
queue_Control_Transfer(device, &setup, NULL, this);
control_queued = true;
if (sertype == FTDI) {
uint32_t baudval = 3000000 / baudrate;
mk_setup(setup, 0x40, 3, baudval, 0, 0);
queue_Control_Transfer(device, &setup, NULL, this);
control_queued = true;
} else if (sertype == CDCACM) {
// Should probably use data structure, but that may depend on byte ordering...
setupdata[0] = (baudrate) & 0xff; // Setup baud rate 115200 - 0x1C200
setupdata[1] = (baudrate >> 8) & 0xff;
setupdata[2] = (baudrate >> 16) & 0xff;
setupdata[3] = (baudrate >> 24) & 0xff;
setupdata[4] = 0; // 0 - 1 stop bit, 1 - 1.5 stop bits, 2 - 2 stop bits
setupdata[5] = 0; // 0 - None, 1 - Odd, 2 - Even, 3 - Mark, 4 - Space
setupdata[6] = 8; // Data bits (5, 6, 7, 8 or 16)
print("CDCACM setup: ");
print_hexbytes(&setupdata, 7);
mk_setup(setup, 0x21, 0x20, 0, 0, 7);
queue_Control_Transfer(device, &setup, setupdata, this);
control_queued = true;
}
return;
}
// configure flow control
if (pending_control & 4) {
pending_control &= ~4;
mk_setup(setup, 0x40, 2, 0, 0, 0);
queue_Control_Transfer(device, &setup, NULL, this);
control_queued = true;
if (sertype == FTDI) {
mk_setup(setup, 0x40, 2, 0, 1, 0);
queue_Control_Transfer(device, &setup, NULL, this);
control_queued = true;
} else if (sertype == CDCACM) {
println("Control - CDCACM DTR...");
// Need to setup the data the line coding data
mk_setup(setup, 0x21, 0x22, 1, interface, 0);
queue_Control_Transfer(device, &setup, NULL, this);
control_queued = true;
return;
}
return;
}
// set DTR
@ -221,10 +516,10 @@ void USBSerial::rx_data(const Transfer_t *transfer)
len = 0;
}
}
//if (len > 0) {
//print("rx: ");
//print_hexbytes(p, len);
//}
if (len > 0) {
print("rx: ");
print_hexbytes(p, len);
}
// Copy data from packet buffer to circular buffer.
// Assume the buffer will always have space, since we
// check before queuing the buffers
@ -340,6 +635,7 @@ void USBSerial::timer_event(USBDriverTimer *whichTimer)
uint32_t head = txhead;
uint32_t tail = txtail;
if (head == tail) {
println(" *** Empty ***");
return; // nothing to transmit
} else if (head > tail) {
count = head - tail;
@ -355,6 +651,7 @@ void USBSerial::timer_event(USBDriverTimer *whichTimer)
txstate |= 0x02;
} else {
txtimer.start(1200);
println(" *** No buffers ***");
return; // no outgoing buffers available, try again later
}
if (++tail >= txsize) tail = 0;
@ -370,6 +667,9 @@ void USBSerial::timer_event(USBDriverTimer *whichTimer)
tail = len - 1;
}
txtail = tail;
print(" TX data (", count);
print(") ");
print_hexbytes(p, count);
queue_Data_Transfer(txpipe, p, count, this);
}