USB Device 기초 — Descriptor·Enumeration·Endpoint·HID/CDC

1
Application      (CDC, HID, MSC, ...)
2
   ↓
3
Class driver     (각 class별 protocol)
4
   ↓
5
USB stack        (descriptor 관리, control transfer, transfer queue)
6
   ↓
7
USB peripheral   (HAL, endpoint hardware)
8
   ↓
9
PHY              (D+/D- driver, OTG)

1
#define CFG_TUSB_RHPORT0_MODE   OPT_MODE_DEVICE
2
#define CFG_TUD_CDC             1
3
#define CFG_TUD_CDC_RX_BUFSIZE  512
4
#define CFG_TUD_CDC_TX_BUFSIZE  512
5
#define CFG_TUD_CDC_EP_BUFSIZE  64

1
#include "tusb.h"
2

3
tusb_desc_device_t const desc_device = {
4
    .bLength            = sizeof(tusb_desc_device_t),
5
    .bDescriptorType    = TUSB_DESC_DEVICE,
6
    .bcdUSB             = 0x0200,
7
    .bDeviceClass       = TUSB_CLASS_MISC,
8
    .bDeviceSubClass    = MISC_SUBCLASS_COMMON,
9
    .bDeviceProtocol    = MISC_PROTOCOL_IAD,
10
    .bMaxPacketSize0    = CFG_TUD_ENDPOINT0_SIZE,
11
    .idVendor           = 0xCafe,
12
    .idProduct          = 0x4001,
13
    .bcdDevice          = 0x0100,
14
    .iManufacturer      = 0x01,
15
    .iProduct           = 0x02,
16
    .iSerialNumber      = 0x03,
17
    .bNumConfigurations = 0x01
18
};
19

20
uint8_t const desc_configuration[] = {
21
    TUD_CONFIG_DESCRIPTOR(1, 2, 0, 75, 0x00, 100),
22

23
    TUD_CDC_DESCRIPTOR(0, 4, 0x81, 8, 0x02, 0x82, 64),
24
};
25

26
uint8_t const *tud_descriptor_device_cb(void) {
27
    return (uint8_t const *)&desc_device;
28
}
29
uint8_t const *tud_descriptor_configuration_cb(uint8_t idx) {
30
    (void)idx;
31
    return desc_configuration;
32
}

1
void usb_init(void) {
2
    // GPIO PA11/12 (D-/D+), AF10
3
    gpio_init(GPIOA, 11, &(gpio_config_t){.mode=GPIO_MODE_AF, .speed=GPIO_SPEED_VH, .af=10});
4
    gpio_init(GPIOA, 12, &(gpio_config_t){.mode=GPIO_MODE_AF, .speed=GPIO_SPEED_VH, .af=10});
5

6
    // OTG_FS clock enable
7
    RCC->AHB2ENR |= RCC_AHB2ENR_OTGFSEN;
8

9
    tusb_init();
10
}
11

12
int main(void) {
13
    clock_init_168mhz();
14
    usb_init();
15

16
    while (1) {
17
        tud_task();    // TinyUSB device task
18

19
        if (tud_cdc_available()) {
20
            char buf[64];
21
            uint32_t n = tud_cdc_read(buf, sizeof(buf));
22
            tud_cdc_write(buf, n);
23
            tud_cdc_write_flush();
24
        }
25
    }
26
}

1
int _write(int file, char *data, int len) {
2
    (void)file;
3
    tud_cdc_write(data, len);
4
    tud_cdc_write_flush();
5
    return len;
6
}
7

8
// main
9
printf("Hello USB\n");

1
#define CFG_TUD_HID  1
2

3
// 8-byte report (custom application data)
4
uint8_t const desc_hid_report[] = {
5
    HID_USAGE_PAGE_N (0xFFAB, 2),
6
    HID_USAGE (0x0001),
7
    HID_COLLECTION (HID_COLLECTION_APPLICATION),
8
        HID_REPORT_ID (1)
9
        HID_USAGE (0x0002),
10
        HID_LOGICAL_MIN (0x00),
11
        HID_LOGICAL_MAX_N (0xFF, 2),
12
        HID_REPORT_SIZE (8),
13
        HID_REPORT_COUNT (8),
14
        HID_INPUT (HID_DATA | HID_VARIABLE | HID_ABSOLUTE),
15
        HID_USAGE (0x0003),
16
        HID_REPORT_COUNT (8),
17
        HID_OUTPUT (HID_DATA | HID_VARIABLE | HID_ABSOLUTE),
18
    HID_COLLECTION_END
19
};
20

21
// Send 8-byte report
22
void send_hid(uint8_t *data) {
23
    if (tud_hid_ready()) {
24
        tud_hid_report(1, data, 8);
25
    }
26
}
27

28
// Receive 8-byte
29
void tud_hid_set_report_cb(uint8_t instance, uint8_t report_id,
30
                           hid_report_type_t report_type,
31
                           uint8_t const *buffer, uint16_t bufsize) {
32
    process_hid_command(buffer, bufsize);
33
}

1
uint8_t const keyboard_desc[] = {
2
    HID_USAGE_PAGE ( HID_USAGE_PAGE_DESKTOP     ),
3
    HID_USAGE      ( HID_USAGE_DESKTOP_KEYBOARD ),
4
    HID_COLLECTION ( HID_COLLECTION_APPLICATION ),
5
        // ...
6
    HID_COLLECTION_END
7
};
8

9
void send_key(uint8_t keycode) {
10
    uint8_t report[8] = {0};
11
    report[2] = keycode;   // single key press
12
    tud_hid_keyboard_report(0, 0, report + 2);
13
    delay_ms(10);
14
    tud_hid_keyboard_report(0, 0, NULL);   // release
15
}