typedef struct _USBD_Handle {
  uint8_t              id;
  uint32_t             dev_config;
  uint32_t             dev_default_config;
  uint32_t             dev_config_status;

  USBD_Speed           dev_speed;
  USBD_Endpoint        ep_in[16];
  USBD_Endpoint        ep_out[16];
  __IO uint32_t        ep0_state;
  uint32_t             ep0_data_len;
  __IO uint8_t         dev_state;
  __IO uint8_t         dev_old_state;
  uint8_t              dev_address;
  uint8_t              dev_connection_status;
  uint8_t              dev_test_mode;
  uint32_t             dev_remote_wakeup;
  USBD_SetupReq        request;
  USBD_Descriptors     *pDesc;
  USBD_Class           *pClass;
  uint8_t              ConfIdx;
  
  USBD_ConfigDesc      *config_desc;
  usbd_intf_t          intf[COMPOSITE_INTF_NUM];
  
  PCD_HandleTypeDef    *pPCDHandle;
  
} USBD_Handle;

typedef struct {
    uint8_t   bLength;              /* Size of this descriptor in bytes. 0x09 */
    uint8_t   bDescriptorType;      /* Configuration (assigned by USB). 0x02 */
    uint16_t  wTotalLength;         /* Total length of data returned for this configuration. */
    uint8_t   bNumInterfaces;       /* Number of interfaces supported by this configuration. */
    uint8_t   bConfigurationValue;  /* Value to use as an argument to Set Configuration to
                                       select this configuration.*/
    uint8_t   iConfiguration;       /* Index of string descriptor describing this configuration.
                                       In this case there is none*/
    uint8_t   bmAttributes;         /* Configuration characteristics */
    uint8_t   bMaxPower;            /* Maximum power consumption of USB device from bus
                                       in this specific configuration when the device is fully
                                       operational. Expressed in 2 mA units */
    uint8_t   data[0];              /* Place holder for other descriptors */
} USBD_ConfigDesc;

/************** Descriptor of CUSTOM HID interface ****************/
USBD_Dev0_HID_ConfigDesc dev0_hid_config_desc_template = {

    .interface_desc = {
        .bLength            = sizeof(USBD_InterfaceDesc),
        .bDescriptorType    = USB_DESC_TYPE_INTERFACE,
        .bInterfaceNumber   = TBD,                      /* Initialized at HID_Register() */
        .bAlternateSetting  = 0x00,
        .bNumEndpoints      = 0x02,
        .bInterfaceClass    = 0x03,                     /* USB Class HID = 3 */
        .bInterfaceSubClass = 0x00,                     /* bInterfaceSubClass : 1=BOOT, 0=no boot*/
        .nInterfaceProtocol = 0x00,                     /* nInterfaceProtocol : 0=none, 1=keyb, 2=mouse*/
        .iInterface         = 0x00,
    },

    .hid_desc = {
        .bLength              = sizeof(USBD_HidDesc),
        .bDescriptorType      = HID_DESCRIPTOR_TYPE,    /* bDescriptorType: HID                     */
        .bcdHID               = 0x0111,                 /* HID Class Spec release number 1.11       */
        .bCountryCode         = 0x00,                   /* 0x17 */
        .bNumDescriptors      = 0x01,                   /* Number of class descriptors to follow    */
        .bRepDescriptorType   = HID_REPORT_DESC,        /* bDescriptorType                          */
        .wRepDescriptorLength = host2usb_u16(sizeof(Dev0_HID_ReportDesc)), 
                                                        /* wItemLength: Tot len of Report descriptor*/
    },

    .ep_in = {
        .bLength             = sizeof(USBD_EpDesc),      /* bLength: Endpoint Descriptor size */
        .bDescriptorType     = USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType:                  */
        .bEndpointAddress    = TBD,                      /* Initialized at HID_Register       */
        .bmAttributes        = 0x03,                     /* bmAttributes: Interrupt endpoint  */
        .wMaxPacketSize      = host2usb_u16(sizeof(dev0_in_report_t)), /* wMaxPacketSize: 2 Byte max */
        .bInterval           = DEV0_HID_FS_BINTERVAL,    /* bInterval: Polling Interval       */
    },

    .ep_out = {
        .bLength             = sizeof(USBD_EpDesc),      /* bLength: Endpoint Descriptor size */
        .bDescriptorType     = USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType:                  */
        .bEndpointAddress    = TBD,                      /* Initialized at HID_Register       */
        .bmAttributes        = 0x03,                     /* bmAttributes: Interrupt endpoint  */
        .wMaxPacketSize      = host2usb_u16(sizeof(dev0_out_report_t)), /* wMaxPacketSize: 2 Byte max */
        .bInterval           = DEV0_HID_FS_BINTERVAL,    /* bInterval: Polling Interval       */
    }
};

Где инициализация поля в значение “TBD” означает, что оно будет проинициализированно во время работы в зависимости от положения этого дескриптора в структуре дескриптора устройства.

typedef struct usbd_intf_s {

    /* Interface’s context */
    union intf_dev_handle_u {
        void *ctx;
        struct _USBD_HID_Handle *hid;
        struct _USBD_CDC_Handle *cdc;
    } h;

    void (*Init)(union intf_dev_handle_u h, struct _USBD_Handle *pdev, uint8_t cfgidx);
    void (*DeInit)(union intf_dev_handle_u h, uint8_t cfgidx);
    uint8_t (*EP0_RxReady)(union intf_dev_handle_u h);
    uint8_t (*Setup)(union intf_dev_handle_u h, enum setup_recp_e, uint8_t recp_idx, USBD_SetupReq  *req);
    uint8_t (*DataIn)(union intf_dev_handle_u h, uint8_t epnum);
    uint8_t (*DataOut)(union intf_dev_handle_u h, uint8_t epnum);

} usbd_intf_t;

typedef struct _USBD_CDC_Handle
{
    /* Initialized @ USBD_Composite_Init -> USBD_CDC_Init */
    uint8_t ifnum_cmd;
    uint8_t epnum_cmd;
    uint8_t ifnum_data;
    uint8_t epnum_data;
    struct _USBD_Handle *pdev;

    /* Initialized @ cdc_uart_init */
    cdc_dfi_t *dfi;

    uint8_t  data[CDC_DATA_MAX_PACKET_SIZE] __attribute__ ((aligned (4)));
    uint8_t  CmdOpCode;
    uint8_t  CmdLength;

    __IO uint32_t TxState;
    __IO uint32_t RxState;

    USBD_CDC_ConfigDesc    *cfg_desc;

} USBD_CDC_Handle;

/* CDC downward facing interface - DFI */
typedef struct cdc_dfi_s {
    /* Functional specific part – individual for each DFI type */
    union {
        struct cdc_ictrl_s *cdc_ictrl;
        struct cdc_uart_s *cdc_uart;
    } ctx;

    /* USB specific part common for all CDC interfaces */
    void (*start_rx) (struct cdc_dfi_s *dfi);
    void (*stop_rx) (struct cdc_dfi_s *dfi);
    void (*on_idle) (struct cdc_dfi_s *dfi);
    void (*on_control) (struct cdc_dfi_s *dfi, uint8_t cmd, uint8_t* buf, uint16_t len);
    void (*on_rx) (struct cdc_dfi_s *dfi, uint32_t len);
    uint8_t *(*get_ds_buffer) (struct cdc_dfi_s *dfi);
} cdc_dfi_t;

typedef struct cdc_uart_s {
    uart_cdc_upstream_t	us;
    uart_cdc_downstream_t	ds;
    cdc_dfi_t dfi;
} cdc_uart_t;

typedef struct cdc_ictrl_s {
    ictrl_cdc_upstream_t    us;
    ictrl_cdc_downstream_t  ds;
    cdc_dfi_t               dfi;
} cdc_ictrl_t;

typedef struct _USBD_HID_Handle {

    union {
        USBD_Dev0_HID_ConfigDesc *dev0;        /* Pointer to HID part in Composite device
                                                  descriptor Initialized during HID 
                                                  registration upon startup */
    } hid_cfg_desc;

    /********** Configuration specific parameters *****/
    /* Initialized @ USBD_Composite_Init -> USBD_HID_Init */
    uint8_t ifnum;
    uint8_t epnum;

    size_t epin_size;
    size_t epout_size;

    uint8_t *ReportBuf;
    size_t   ReportBufLen;

    uint8_t *ReportDesc;
    size_t   ReportDescLen;

    struct _USBD_Handle *pdev;
    /***********************************************/

    uint8_t *pReport;
    uint32_t Protocol;
    uint32_t IdleState;
    uint32_t AltSetting;
    uint32_t IsReportAvailable;
    CUSTOM_HID_StateTypeDef     state;

    void (*Register)(struct _USBD_HID_Handle *hhid, USBD_ConfigDesc *config_desc, …
    USBD_HidDesc* (*GetHidDescr)(struct _USBD_HID_Handle *hhid);
    void (*Init)(struct _USBD_HID_Handle *hhid, uint8_t cfgidx);
    void (*DeInit)(struct _USBD_HID_Handle *hhid);
    int8_t (*OutEvent)(struct _USBD_HID_Handle *hhid, uint8_t *buf, int len);

} USBD_HID_Handle;

typedef struct {
    uint32_t last_report_tick;
    USBD_HID_Handle *hid;
    dev0_in_report_t hid_in_report;
    dev0_out_report_t hid_out_report;
} dev0_t;

  HAL_Init();
	SystemClock_Config();

	__disable_irq();

	MX_GPIO_Init();
	MX_DMA_Init();
	MX_ADC1_Init();
	MX_TIM3_Init();	/* Used by ADC as a trigger source */
	MX_USART3_UART_Init();

Типовая автосгенерированная инициализация переферии. Ничего интересного.

За основу взят автоматически сгенерированный код CubeIDE.
По мимо всего прочего вызывает функции регистрации отдельных интерфейсов внутри составного устройства (USB Composite device).

{ /* Link interfaces into composite class */
		int ep_in_use = 1;
		int if_in_use = 0;
		HID_Register(&g_hid0, &pdev->intf[0], pdev->config_desc, &if_in_use, &ep_in_use);
		CDC_Register(&g_cdc0, &pdev->intf[1], pdev->config_desc, &if_in_use, &ep_in_use);
		CDC_Register(&g_cdc1, &pdev->intf[2], pdev->config_desc, &if_in_use, &ep_in_use);
		pdev->config_desc->bNumInterfaces = if_in_use;
	}

Во время регистрации, каждый из интерфейсов добавляет к дескриптору устройства (pdev->config_desc) свою индивидуальную часть и увеличивает счетчик использованных конечных точек (ep_in_use) и их интерфейсов (if_in_use). Указатель на свою часть в дескрипторе устройства каждый интерфейс хранит у себя и использует его во время инициализации в ф-ции pClass->Init().

Соответственно, при добавлении новых интерфейсов сюда надо добавить его регистрацию.

void Dev0_HID_Register (
	USBD_HID_Handle *hhid, USBD_ConfigDesc *config_desc,
	int *ifnum, int *epnum)
{
	USBD_Dev0_HID_ConfigDesc *desc = 
    &dev0_hid_config_desc_template;

	desc->interface_desc.bInterfaceNumber = *ifnum;
	desc->ep_in.bEndpointAddress = EP_IN_ADDR(*epnum);
	desc->ep_out.bEndpointAddress = EP_OUT_ADDR(*epnum);

	hhid->hid_cfg_desc.dev0 = USBD_CfgDescAppend(
       config_desc,
       (uint8_t*)desc,
       sizeof(USBD_Dev0_HID_ConfigDesc));

	*ifnum += 1;
	*epnum += 1;
}

#pragma pack(push, 1)
typedef struct _USBD_Dev0_HID_ConfigDesc {
    USBD_InterfaceDesc  interface_desc;
    USBD_HidDesc        hid_desc;
    USBD_EpDesc         ep_in;
    USBD_EpDesc         ep_out;
} USBD_Dev0_HID_ConfigDesc;
#pragma pack(pop)

#pragma pack(push, 1)
typedef struct _USBD_CDC_ConfigDesc {
    USBD_IADDesc           if_assoc_desc;
    USBD_InterfaceDesc     interface_desc_cmd;
    USBD_FuncDescHdr       func_desc_header;
    USBD_FuncDescCallMng   func_desc_call_mng;
    USBD_FuncDescACM       func_desc_acm;
    USBD_FuncDescUnion     func_desc_union;
    USBD_EpDesc            cmd_ep;
    USBD_InterfaceDesc     interface_desc_data;
    USBD_EpDesc            data_ep_out;
    USBD_EpDesc            data_ep_in;
} USBD_CDC_ConfigDesc;
#pragma pack(pop)

Функции этого устройства сведены к минимуму, поэтому и в инициализации ничего интересного.

Инициализация коэффициентов для вычисления показаний с внутреннего датчика температуры и напряжения с учетом калибровочных значений.

Ф-ция связвает вместе CDC устройство (g_cdc0) с функционалом USB UART конвертера (g_cdc_uart3) и сам конвертер с аппаратным портом UART (huart3). Также инициализируются функции DFI итерфейса.

Ф-ция связывает CDC устройство (g_cdc1) c функционалом ictrl – g_cdc_ictrl. В отличии от UART конвертера, ictrl не предназначен иметь несколько инстанций и поэтому он не передается в ф-цию как параметр, а используется непосредственно как глобальный объект.

АЦП работает по сигналу от таймера и по кругу записывает результат в глобальный массив.

Инициализация таймера с периодом 4.5мс и генерацией сигнала для АЦП

    while (1)  {
        now = HAL_GetTick();
        g_cnt ++;
        
        dev0_on_idle(now);
        imon_on_idle(now);

        g_cdc_uart3.dfi.on_idle(&g_cdc_uart3.dfi);
        g_cdc_ictrl.dfi.on_idle(&g_cdc_ictrl.dfi);

#if NAVIG
	    cdc_uart_dfi_on_idle();
	    cdc_ictrl_dfi_on_idle();
#endif

    }

dev0_on_idle() – периодически собирает данные от imon и отправляет их в USB.

imon_on_idle() – периодически конвертирует данные с каналов АЦП в показания температуры и напряжения питания.

g_cdc_uart3.dfi.on_idle() – функция проверяет состояния приемника UART и если предыдущая транзакция закончилась, то вычисляется оставшееся место в приемном буфере и инициируется новая DMA транзакция с генерацией прерывания по завершению. Также, функция проверяет наличие данных в приемном UART буфере и отправляет их хосту. Фактически, в основном цикле обслуживается только upstream поток. Downstream обслуживается исключительно по прерыванию от USB, т.е. по приходу нового пакета данных.

g_cdc_ictrl.dfi.on_idle() – проверяет наличие данных для отправки на хост и если данных накопилось достаточно много (64байта) или они залежались (>16мс), то формируется новый пакет и отправляется в CDC интерфейс (USBD_CDC_TransmitPacket()).

Здесь и далее все вызовы функций под препроцессорным условием NAVIG не компилируются и необходимы только для удобного чтения и навигации по коду. Так например косвенный вызов g_cdc_uart3.dfi.on_idle() в ходе работы выполняется как cdc_uart_dfi_on_idle(), а g_cdc_ictrl.dfi.on_idle() как cdc_ictrl_dfi_on_idle() и так далее.

Каждый приходящий пакет от USB сперва обрабатывается типовым кодом сгенерированным CubeIDE. Этот обработчик включает в себя разбор служебных пакетов, запросов дескрипторов, обработку ошибок и т.п. По приходу пакета данных, для всех оконечных точек вызываются зарегистрированные функции USB класса pClass->DataOut() или  pClass->EP0_RxReady(), они же USBD_Composite_DataOut() и USBD_Composite_EP0_RxReady(), соответственно.

Для служебных пакетов которые специфичны для конкретного интерфейса вызываются ф-ции  USBD_Composite_Init() и USBD_Composite_Setup().

Основная суть перехода к конфигурируемому массиву USB интерфейсов состоит в том, чтобы не менять обработчик прерываний при добавлении/удалении интерфейсов из кода. Т.е. пакеты поступают на обработчики составного устройства (USBD_Composite_xxx), а затем в цикле передаются на все зарегистрированные интерфейсы пока какой-либо из интерфейсов не заберет  пакет себе (т.е. вернет код USBD_BUSY).

	for (i = 0; i < COMPOSITE_INTF_NUM; i ++) {
		usbd_intf_t *intf = &pdev->intf[i];
		if (!intf || !intf->Init || !intf->h.ctx) continue;
		intf->Init(intf->h, pdev, cfgidx);
#if NAVIG
		USBD_HID_Init(hhid, pdev, cfgidx);
		USBD_CDC_Init(hcdc, pdev, cfgidx);
#endif
	}

Обработчик по очереди вызывает ф-ции Init() для всех зарегистрированных интерфейсов. Эти ф-ции инициализируют оконечные точки USB устройства на уровне периферии микроконтроллера в зависимости от того, что записано в принадлежащей им части дескриптора устройства, которая была создана во время регистрации интерфейса.

Ещё одним важным отличием от оригинального кода CubeIde является выделение специализированной области памяти под оконечные точки (PMA буфера). В оригинальном коде память распределяется полностью вручную и статически, тогда как в предложенном варианте динамически – см. ф-цию HAL_PCD_PMA_Alloc(). Память выделяется при открытии оконечной точки в цепочке вызовов pClass->Init() => USBD_Composite_Init() => USBD_xxx_Init() => USBD_LL_OpenEP() => HAL_PCD_EP_Open() и освобождается при закрытии USB устройства в цепочке pClass->DeInit() => ... => HAL_PCD_EP_Close().

for (i = 0; i < COMPOSITE_INTF_NUM; i++) {
		usbd_intf_t *intf = &pdev->intf[i];
		if (!intf || !intf->Setup) continue;
		rc = intf->Setup(intf->h, recp, recp_idx, req);
#if NAVIG
		USBD_CDC_Setup();
		USBD_HID_Setup();
#endif
		if (rc == USBD_BUSY || rc == USBD_FAIL) break;
	}

Обработчик Setup фазы в соответствии с протоколом обмена USB. Для CDC устройств на этой стадии могут быть сконфигурированны параметры UART интерфейса – скорость, кол-во бит и т.п. Для HID устройства на этой фазе хост запрашивает дескриптор формата пакетов (ака ReportDesc), а также дескриптор HID устройства - USBD_HidDesc.

Функция обработчик входных данных для интерфейсов. Не забываем что название потоков в USB всегда относительно хоста. Т.е. DataOut для USB клиента – это входные данные.

В качестве параметров принимает номер интерфейса и номер оконечной точки данных для которых эти данные предназначены. Как и в других функциях композитного устройства, параметры передаются на все зарегистрированные интерфейсы и если какой-то из интерфейсов признает эти данные своими, то возвращает код USBD_BUSY и  на этом обработка пакета заканчивается.

Выглядит аналогично USBD_Composite_DataOut()

root@OpenWrt:~#
root@OpenWrt:~# lsusb
Bus 001 Device 005: ID 0483:5732 STMicroelectronics
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
root@OpenWrt:~#
root@OpenWrt:~#
root@OpenWrt:~# lsusb -v -d 0483:5732

Bus 001 Device 005: ID 0483:5732 STMicroelectronics
Device Descriptor:
  bLength                18
  bDescriptorType         1
  bcdUSB               2.00
  bDeviceClass          239 Miscellaneous Device
  bDeviceSubClass         2 ?
  bDeviceProtocol         1 Interface Association
  bMaxPacketSize0        64
  idVendor           0x0483 STMicroelectronics
  idProduct          0x5732
  bcdDevice            0.01
  iManufacturer           1 AV
  iProduct                2 2xCDC HID Composite device
  iSerial                 3 104731433332
  bNumConfigurations      1
  Configuration Descriptor:
    bLength                 9
    bDescriptorType         2
    wTotalLength          173
    bNumInterfaces          5
    bConfigurationValue     1
    iConfiguration          2 2xCDC HID Composite device
    bmAttributes         0xc0
      Self Powered
    MaxPower              100mA
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        0
      bAlternateSetting       0
      bNumEndpoints           2
      bInterfaceClass         3 Human Interface Device
      bInterfaceSubClass      0 No Subclass
      bInterfaceProtocol      0 None
      iInterface              0
        HID Device Descriptor:
          bLength                 9
          bDescriptorType        33
          bcdHID               1.11
          bCountryCode            0 Not supported
          bNumDescriptors         1
          bDescriptorType        34 Report
          wDescriptorLength      31
         Report Descriptors:
           ** UNAVAILABLE **
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x81  EP 1 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0002  1x 2 bytes
        bInterval               5
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x01  EP 1 OUT
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0001  1x 1 bytes
        bInterval               5
    Interface Association:
      bLength                 8
      bDescriptorType        11
      bFirstInterface         1
      bInterfaceCount         2
      bFunctionClass          2 Communications
      bFunctionSubClass       2 Abstract (modem)
      bFunctionProtocol       1 AT-commands (v.25ter)
      iFunction               0
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        1
      bAlternateSetting       0
      bNumEndpoints           1
      bInterfaceClass         2 Communications
      bInterfaceSubClass      2 Abstract (modem)
      bInterfaceProtocol      1 AT-commands (v.25ter)
      iInterface              0
      CDC Header:
        bcdCDC               1.10
      CDC Call Management:
        bmCapabilities       0x00
        bDataInterface          2
      CDC ACM:
        bmCapabilities       0x02
          line coding and serial state
      CDC Union:
        bMasterInterface        1
        bSlaveInterface         2
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x82  EP 2 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0008  1x 8 bytes
        bInterval              16
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        2
      bAlternateSetting       0
      bNumEndpoints           2
      bInterfaceClass        10 CDC Data
      bInterfaceSubClass      0 Unused
      bInterfaceProtocol      0
      iInterface              0
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x03  EP 3 OUT
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               0
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x83  EP 3 IN
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               0
    Interface Association:
      bLength                 8
      bDescriptorType        11
      bFirstInterface         3
      bInterfaceCount         2
      bFunctionClass          2 Communications
      bFunctionSubClass       2 Abstract (modem)
      bFunctionProtocol       1 AT-commands (v.25ter)
      iFunction               0
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        3
      bAlternateSetting       0
      bNumEndpoints           1
      bInterfaceClass         2 Communications
      bInterfaceSubClass      2 Abstract (modem)
      bInterfaceProtocol      1 AT-commands (v.25ter)
      iInterface              0
      CDC Header:
        bcdCDC               1.10
      CDC Call Management:
        bmCapabilities       0x00
        bDataInterface          4
      CDC ACM:
        bmCapabilities       0x02
          line coding and serial state
      CDC Union:
        bMasterInterface        3
        bSlaveInterface         4
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x84  EP 4 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0008  1x 8 bytes
        bInterval              16
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        4
      bAlternateSetting       0
      bNumEndpoints           2
      bInterfaceClass        10 CDC Data
      bInterfaceSubClass      0 Unused
      bInterfaceProtocol      0
      iInterface              0
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x05  EP 5 OUT
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               0
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x85  EP 5 IN
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               0
Device Status:     0x0001
  Self Powered
root@OpenWrt:~#
root@OpenWrt:~#
root@OpenWrt:~#

void dev0_on_idle (uint32_t now_tick)
{
....
    if ((imon->temp_degc != INT16_MAX) && g_dbg0 == 0){
        static int cnt = 0;
        ictrl_printf("[%d] %dC, %dmV\n", 
                     cnt++, imon->temp_degc, imon->vref);
    }
...
}

#pragma pack(push, 1)
typedef struct {
    uint8_t temperature;
    uint8_t voltage;
} dev0_in_report_t;
#pragma pack(pop)

void dev0_on_idle (uint32_t now_tick)
{
    dev0_t *dev0 = &g_dev0;
    imon_t *imon = &g_imon;

    if (now_tick - dev0->last_report_tick > 100 ){
        dev0->last_report_tick = now_tick;

        if (dev0->hid && imon->temp_degc != INT16_MAX) {
          
            dev0->hid_in_report.temperature = (int8_t)imon->temp_degc;
          
            dev0->hid_in_report.voltage = 
              (uint8_t)((imon->vref + 50) / 100) ;
          
            HID_SendReport(
              dev0->hid, 
              (uint8_t*)&dev0->hid_in_report,
              sizeof(dev0->hid_in_report));                     
        }
    }
    ...
}

1. Создаем сгенерированный проект визардом STM32CubeIDE со следующей конфигурацией (CompositeUSB-Autogen.ioc ветки Autogen).

1.1. Timer3
Используется как задающий таймер для АЦП, с периодом 4.5мс

1.2. ADC + DMA Channel 1
АЦП работает в цикличном режиме (mode = CIRC) по сигналу от таймера Т3.
Используются два внутренних канала – VrefInt, Temperature Sensor.

1.3. USB Custom HID device
Включем прерывание, конфигурируем пины на PA11, PA12. Параметры HID устройства особого значения не имеют т.к. код будет в последствии заменен.

1.4. USART1 + DMA Channel 2,3
1.5. 3xGPIO
1.6. Clocks – internal High Speed (USB crystal less configuration)

2. Добавляем код модуля «imon» (imon.c, imon.h)
   Помимо файлов самого imon, ещё необходимо добавить файл stm32l0xx_ll_adc.h в директорию  CompositeUSB_L072K\Drivers\STM32L0xx_HAL_Driver\Inc.
   Файл можно взять из SDK соответствующей архитектуры. Например отсюда.
   Файл необходим для описания некоторых констант АЦП (TEMPSENSOR_CAL1_ADDR, и т.п.)

3. Добавляем инициализацию и запуск переферии, глобальный масив для данных АЦП, а также инициализацию и обработчик модуля imon.

/* USER CODE BEGIN Includes */
#include "imon.h"
/* USER CODE END Includes */

/* USER CODE BEGIN PV */
int16_t g_adc_samples[ADC_CH_NUM];		/* DMA destination */

/* USER CODE END PV */
...
int main(void) {
...
  /* USER CODE BEGIN Init */
  __disable_irq();
  /* USER CODE END Init */

  /* USER CODE BEGIN 2 */
  imon_init(g_adc_samples);

  HAL_TIM_Base_Start_IT(&htim6);

  HAL_ADC_Start_DMA(&hadc, (uint32_t*) &g_adc_samples[0], 2);
  HAL_TIM_Base_Start_IT(&htim3);

  __enable_irq();
  /* USER CODE END 2 */

...

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    uint32_t now_tick = HAL_GetTick();
    imon_on_idle(now_tick);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

4. Добавляем калибровку АЦП в ф-цию void MX_ADC_Init(void). Без калибровку датчик температуры будет показывать неправильные значения.

/* USER CODE BEGIN ADC_Init 2 */
  LL_ADC_StartCalibration(ADC1);
  while (LL_ADC_IsCalibrationOnGoing(ADC1)) {
    __asm__ __volatile__ ("nop;nop;nop;nop;" ::);
  };
  /* USER CODE END ADC_Init 2 */

5. Компилируем  и проверяем что таймер и АЦП работает как надо – температура +/- 2С, напряжение питания соответствует действительному, показания в милливольтах.

1.              Заменяем полностью директоорию USB_DEVICE.
2.              Заменяем Middlewares\ST\STM32_USB_Device_Library.
3.              Добавляем dev0.c/.h в Core.
4.              Добавляем пути инклудов.

../Middlewares/ST/STM32_USB_Device_Library/Class/Composite
../Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Inc

5. Меняем знаяения номера прерывания USB в функции HAL_PCD_MspInit() (usbd_conf.c)

HAL_NVIC_SetPriority(USB_LP_IRQn, 0, 0);
		HAL_NVIC_EnableIRQ(USB_LP_IRQn);

		HAL_NVIC_SetPriority(USB_IRQn, 0, 0);
		HAL_NVIC_EnableIRQ(USB_IRQn);

6.    Меняем ..._hal_pcd.c/.h

--- a/Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pcd.h
+++ b/Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pcd.h
@@ -119,6 +119,8 @@ typedef struct
                                        This parameter can be set to ENABLE or DISABLE        */
   void                    *pData;      /*!< Pointer to upper stack Handler */
 
+  uint32_t 				  pma_map;     /* USB memory allocation map */
+
 #if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
   void (* SOFCallback)(struct __PCD_HandleTypeDef *hpcd);                              /*!< USB OTG PCD SOF callback                */
   void (* SetupStageCallback)(struct __PCD_HandleTypeDef *hpcd);                       /*!< USB OTG PCD Setup Stage callback        */
@@ -220,6 +222,10 @@ typedef struct
   */
 HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd);
 HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd);
+
+uint32_t HAL_PCD_PMA_Alloc(PCD_HandleTypeDef *hpcd, uint32_t ep_mps);
+void HAL_PCD_PMA_Free(PCD_HandleTypeDef *hpcd, uint32_t ep_pmaadress, uint32_t ep_mps);
+
 void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd);
 void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd);
 
--- a/Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pcd.c
+++ b/Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pcd.c
@@ -54,8 +54,17 @@
   */
 
 /* Includes ------------------------------------------------------------------*/
+#include <assert.h>
 #include "stm32l0xx_hal.h"
 
+#define PMA_BLOCK_SIZE_EXP 5
+#define PMA_BLOCK_SIZE (1 << PMA_BLOCK_SIZE_EXP)
+#define PMA_BLOCKS_NUM (1024 / PMA_BLOCK_SIZE)
+
+// Note: pma_map - uses 32bit word for segment marking
+// #include "main.h"
+// CTASSERT(PMA_BLOCKS_NUM <= 32);
+
 /** @addtogroup STM32L0xx_HAL_Driver
   * @{
   */
@@ -113,6 +122,51 @@ static uint16_t HAL_PCD_EP_DB_Receive(PCD_HandleTypeDef *hpcd, PCD_EPTypeDef *ep
   * @{
   */
 
+void HAL_PCD_PMA_Free(PCD_HandleTypeDef *hpcd, uint32_t ep_pmaadress, uint32_t ep_mps)
+{
+	uint32_t ep_map;
+
+	int blocks_num = (ep_mps + PMA_BLOCK_SIZE - 1) >> PMA_BLOCK_SIZE_EXP;
+
+	ep_map = (blocks_num == 32) ? UINT32_MAX : (1 << blocks_num) - 1;
+	ep_map <<= ep_pmaadress >> PMA_BLOCK_SIZE_EXP;
+
+	/* Sanity check. All blocks to be allocated
+	 * have to be marked as occupied
+  */
+	assert((ep_map & hpcd->pma_map) == ep_map);
+
+	/* Clear map */
+	hpcd->pma_map &= ~ep_map;
+}
+
+uint32_t HAL_PCD_PMA_Alloc(PCD_HandleTypeDef *hpcd, uint32_t ep_mps)
+{
+	int i, blocks_num;
+	uint32_t ep_map = 0;
+	uint32_t ep_pmaaddress = UINT32_MAX;
+
+	/*
+	 * 1024Bytes split by 32bytes blocks => 32 blocks
+	 * pma_map => 1 bit one block. 1 - occupied, 0 - free.
+	 * LSB = 0x0000
+  */
+	blocks_num = (ep_mps + PMA_BLOCK_SIZE - 1) >> PMA_BLOCK_SIZE_EXP;
+	ep_map = (blocks_num == 32) ? UINT32_MAX : (1 << blocks_num) - 1;
+
+	for (i = 0; i <= PMA_BLOCKS_NUM - blocks_num; i++) {
+		if ((ep_map & hpcd->pma_map) == 0) {
+			/* Free slot were found - allocate them */
+			hpcd->pma_map |= ep_map;
+			ep_pmaaddress = i * PMA_BLOCK_SIZE;
+			break;
+		}
+		ep_map = ep_map << 1;
+	}
+
+	return ep_pmaaddress;
+}
+
 /**
   * @brief  Initializes the PCD according to the specified
   *         parameters in the PCD_InitTypeDef and initialize the associated handle.
@@ -1382,6 +1436,11 @@ HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr,
     ep->is_in = 0U;
   }
 
+  // Allocate PMA memory. No memory - no party
+  uint32_t pma_addr = HAL_PCD_PMA_Alloc(hpcd, ep_mps);
+  assert(pma_addr != UINT32_MAX);
+  HAL_PCDEx_PMAConfig(hpcd, ep_addr, PCD_SNG_BUF, pma_addr);
+
   ep->num = ep_addr & EP_ADDR_MSK;
   ep->maxpacket = ep_mps;
   ep->type = ep_type;
@@ -1426,9 +1485,19 @@ HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
   }
   ep->num   = ep_addr & EP_ADDR_MSK;
 
+  if (ep->maxpacket == 0)
+  {
+    // EP not opened yet
+    return HAL_OK;
+  }
+
   __HAL_LOCK(hpcd);
   (void)USB_DeactivateEndpoint(hpcd->Instance, ep);
   __HAL_UNLOCK(hpcd);
+
+  HAL_PCD_PMA_Free(hpcd,ep->pmaadress,ep->maxpacket);
+  ep->maxpacket = 0;
+
   return HAL_OK;
 }
 

• добавляем определение констант;

• добавляем ф-ции выделения/освобождения памяти под конечные точки USB HAL_PCD_PMA_Free/Alloc();

• добавляем использование этих функций в HAL_PCD_EP_Open/Close();

• добавляем поле pma_map в struct PCD_HandleTypeDef, а также декларацию ф-ций HAL_PCD_PMA_Free/Alloc() в .h файл

7. Меняем main.c/.h

--- a/Core/Inc/main.h
+++ b/Core/Inc/main.h
@@ -27,6 +27,7 @@ extern "C" {
 #endif
 
 /* Includes ------------------------------------------------------------------*/
+#include "av-generic.h"
 #include "stm32l0xx_hal.h"
 
 /* Private includes ----------------------------------------------------------*/
--- a/Core/Src/main.c
+++ b/Core/Src/main.c
@@ -22,7 +22,12 @@
 
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
+//#include "stm32l0xx_ll_adc.h"
 #include "imon.h"
+#include "cdc_uart.h"
+#include "cdc_ictrl.h"
+#include "dev0.h"
+
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -53,6 +58,10 @@ DMA_HandleTypeDef hdma_usart1_tx;
 #define ADC_CH_NUM 2
 int16_t g_adc_samples[ADC_CH_NUM];		/* DMA destination */
 
+
+extern cdc_ictrl_t g_cdc_ictrl;
+extern cdc_uart_t g_cdc_uart1;
+
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -115,6 +124,10 @@ int main(void)
   /* USER CODE BEGIN 2 */
   imon_init(&g_adc_samples[1], &g_adc_samples[0]);
 
+  /* Link USB Device CDC interface with a corresponding Downface Interface (DFI) */
+  cdc_uart_init(&g_cdc_uart1, &g_cdc0, &huart1);
+  cdc_ictrl_init(&g_cdc1);
+
   HAL_TIM_Base_Start_IT(&htim6);
 
   HAL_ADC_Start_DMA(&hadc, (uint32_t*)&g_adc_samples[0], ADC_CH_NUM);
@@ -129,6 +142,14 @@ int main(void)
   {
     uint32_t now_tick = HAL_GetTick();
     imon_on_idle(now_tick);
+    dev0_on_idle(now_tick);
+
+    g_cdc_uart1.dfi.on_idle(&g_cdc_uart1.dfi);
+    g_cdc_ictrl.dfi.on_idle(&g_cdc_ictrl.dfi);
+#if NAVIG
+    cdc_uart_dfi_on_idle();
+    cdc_ictrl_dfi_on_idle();
+#endif
     /* USER CODE END WHILE */
 
     /* USER CODE BEGIN 3 */

• добавляем в инициализацию CDC устройств;

• добавляем в обработчики CDC и HID устройств в главный цикл;

• соль, перец по вкусу.