Any example of working CDC in device mode?

[JoeyLiang-0]

Not sure if device CDC is supported, I modified examples/usb_device from HID to CDC, but it doesn't work. When connecting both native USB port and Pio/USB port to PC, the native USB port reports a COMM device and it actually works (with tud_cdc_rx_cb/tud_cdc_read/tud_cdc_write). However, Pio/USB port shows as another COMM port on PC and it could not be connected, sometimes it's access denied, but also saw mulfunctional error, or file not found.
The same hardware works well with un-modified examples/usb_device for HID device, so I think the wiring should be good.
My test code attached (no change for CMakeLists.txt; tried both values for class/subclass/protocol in desc_device):
Thanks,

#include <stdio.h>
#include <string.h>

#include "pico/stdlib.h"
#include "pico/multicore.h"
#include "pico/bootrom.h"

#include "pio_usb.h"

// Use tinyUSB header to define USB descriptors
#include "device/usbd.h"
#include "class/cdc/cdc_device.h"

static usb_device_t *usb_device = NULL;

tusb_desc_device_t const desc_device = {.bLength = sizeof(tusb_desc_device_t),
                                        .bDescriptorType = TUSB_DESC_DEVICE,
                                        .bcdUSB = 0x0200,
                                        .bDeviceClass = TUSB_CLASS_MISC, //239, 0x00,
                                        .bDeviceSubClass = MISC_SUBCLASS_COMMON, // 2, 0x00,
                                        .bDeviceProtocol = MISC_PROTOCOL_IAD, // 1, 0x00,
                                        .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE, // 64, 64,

                                        .idVendor = 0xCafe,
                                        .idProduct = (0x4000 | 1), // 0x4001, 0,
                                        .bcdDevice = 0x0100,

                                        .iManufacturer = 0x01,
                                        .iProduct = 0x02,
                                        .iSerialNumber = 0x03,

                                        .bNumConfigurations = 0x01};

enum {
  ITF_NUM_CDC = 0,
  ITF_NUM_CDC_DATA,
  ITF_NUM_TOTAL,
};

#define EPNUM_CDC_NOTIF   0x81
#define EPNUM_CDC_OUT     0x02
#define EPNUM_CDC_IN      0x82

#define CONFIG_TOTAL_LEN  (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN)

uint8_t const desc_configuration[] = {
    TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0x00, 100),
    TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 4, EPNUM_CDC_NOTIF, 8, EPNUM_CDC_OUT, EPNUM_CDC_IN, 64),
};

static_assert(sizeof(desc_device) == 18, "device desc size error");

const char *string_descriptors_base[] = {
    [0] = (const char[]){0x09, 0x04},
    [1] = "Pico PIO USB",
    [2] = "Pico PIO USB Device",
    [3] = "123456",
    [4] = "PIO-USB CDC",
};
static string_descriptor_t str_desc[5];

static void init_string_desc(void) {
  for (int idx = 0; idx < 5; idx++) {
    uint8_t len = 0;
    uint16_t *wchar_str = (uint16_t *)&str_desc[idx];
    if (idx == 0) {
      wchar_str[1] = string_descriptors_base[0][0] |
                     ((uint16_t)string_descriptors_base[0][1] << 8);
      len = 1;
    } else if (idx <= 4) {
      len = strnlen(string_descriptors_base[idx], 31);
      for (int i = 0; i < len; i++) {
        wchar_str[i + 1] = string_descriptors_base[idx][i];
      }

    } else {
      len = 0;
    }

    wchar_str[0] = (TUSB_DESC_STRING << 8) | (2 * len + 2);
  }
}

static usb_descriptor_buffers_t desc = {
    .device = (uint8_t *)&desc_device,
    .config = desc_configuration,
    .hid_report = NULL,
    .string = str_desc
};


void core1_main() {
  sleep_ms(10);

  static pio_usb_configuration_t config = PIO_USB_DEFAULT_CONFIG;
  config.pin_dp = 6;
  init_string_desc();
  usb_device = pio_usb_device_init(&config, &desc);

  while (true) {
    pio_usb_device_task();
  }
}

int main() {
  // default 125MHz is not appropreate. Sysclock should be multiple of 12MHz.
  set_sys_clock_khz(120000, true);

  stdio_init_all();
  printf("hello!");

  sleep_ms(10);

  multicore_reset_core1();
  // all USB task run in core1
  multicore_launch_core1(core1_main);

  while (true) {
    if (usb_device != NULL) {

      for (int dev_idx = 0; dev_idx < PIO_USB_DEVICE_CNT; dev_idx++) {
        usb_device_t *device = &usb_device[dev_idx];
        if (!device->connected) {
          continue;
        }

        // Print received packet to EPs
        for (int ep_idx = 0; ep_idx < PIO_USB_DEV_EP_CNT; ep_idx++) {
          endpoint_t *ep = pio_usb_get_endpoint(device, ep_idx);

          if (ep == NULL) {
            break;
          }

          uint8_t temp[64];
          int len = pio_usb_get_in_data(ep, temp, sizeof(temp));

          if (len > 0) {
            // echo back
            pio_usb_set_out_data(ep, temp, len);

            printf("%04x:%04x EP 0x%02x:\t", device->vid, device->pid, ep->ep_num);
            for (int i = 0; i < len; i++) {
              printf("%02x ", temp[i]);
            }
            //printf("\n");
          }
        }
      }
    }
    stdio_flush();
    sleep_ms(5);
  }
}

// Invoked when CDC interface received data from host
void tud_cdc_rx_cb(uint8_t itf)
{
  (void) itf;

  char buf[64];
  uint32_t count = tud_cdc_read(buf, sizeof(buf));

  if (count > 0)
  {
    // echo back
    tud_cdc_write(buf, count);
    tud_cdc_write_flush();

    for (uint32_t i = 0; i < count; i++) {
      printf("%02x ", buf[i]);
    }
    //printf("\n");
  }
}

[adirobu84]

Have you been able to make any progress on this?
I am having a similar issue and my code is very similar to yours. On Linux I can see the device just fine and I can even send data from the device to the host and see it in a terminal window, but I am so far not able to reliably receive data from the OUT endpoint. One of the reasons for this is that pio_usb_get_endpoint seems to only return IN endpoint (IN to host) and not OUT endpoints (OUT from host). See #95 for more details. I might be missing something, though...

Even with fixing up the code so I can get the OUT endopint and then read from it, it is not reliable, but I have been able to do a loopback once.
I have noticed that when I do lsusb -d <VID:PID> -v it prints the correct device information, but then hangs for a bit and then reports "cannot read device status, Resource temporarily unavailable (11)". I am wondering if this is because our implementation doesn't handle the control endpoint at all. I am going to try this next.

[JoeyLiang-0]

No luck for me. I added a CH340 instead, a tiny MSOP-10 chip just needs a decoupling capacitor on the power pin.

[adirobu84]

So I have just found why the receive is not working: In order to receive data on the OUT endpoint you have to first prime it using pio_usb_ll_transfer_start. This will only set the specified endpoint up for receiving data (if it is an OUT endpoint).
In the application's while loop you can then receive data using pio_usb_get_in_data. Just calling pio_usb_get_in_data only without ever initiating a transfer (pio_usb_ll_transfer_start) you will never receive data on an OUT endpoint.

This is actually very similar to TinyUSB, but the difference is that TinyUSB has a callback mechanism when a "driver" is opened (basically when the device is enumerated). In this callback we would then initiate a transfer on a CDC's OUT endpoint so the application can receive data using pio_usb_get_in_data.
The Pico-PIO-USB library does not offer such a callback and so I have to add extra logic (and modify the library) to detect when a device has been enumerated.
Calling pio_usb_ll_transfer_start right after initialization will not work as the endpoints are not setup at that point. Endpoints are setup/initialized when the device enumerates.

@sekigon-gonnoc Am I fundamentally missing something or is this still evolving?

[thewh1teagle]

I'm looking for the same thing. correct me if I wrong:
You would like to make the PI act as HID device (emulate mouse / keyboard) and in the same time send serial output to PC so we can read debug messages from it?