NUC126如何枚举USB Audio&hid 混合 请给出代码例子

以下是一个简单的NUC126 USB Audio&HID混合设备的代码例子，仅供参考：

#include "NUC126.h"
#include "usb_device.h"
#include "hid_transfer.h"
#include "audio_transfer.h"

#define HID_BUF_SIZE    64
#define AUDIO_BUF_SIZE  1024

uint8_t g_hid_buff[HID_BUF_SIZE];
uint8_t g_audio_buff[AUDIO_BUF_SIZE];

void SYS_Init(void)
{
    // 系统时钟初始化
    CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    CLK_SetCoreClock(64000000);
    CLK_EnableModuleClock(USBD_MODULE);
    CLK_EnableModuleClock(GPB_MODULE);
    CLK_EnableModuleClock(GPA_MODULE);
}

void GPIO_Init(void)
{
    // GPIO初始化
    GPIO_SetMode(PB, BIT0, GPIO_MODE_OUTPUT);
    GPIO_SetMode(PA, BIT15, GPIO_MODE_OUTPUT);
    GPIO_SetMode(PA, BIT12, GPIO_MODE_OUTPUT);
}

int main()
{
    SYS_Init();
    GPIO_Init();

    USBD_Open(&gsInfo, HID_ClassRequest, NULL);
    USBD_SetConfigCallback(HID_SetConfig);

    HID_Init();
    USBD_Start();
    NVIC_EnableIRQ(USBD_IRQn);

    while(1)
    {
        // Do something
    }
}

void HID_IRQHandler(void)
{
    HID_SetInReport();
}

void ADC_IRQHandler(void)
{
    static uint32_t u32SampleCnt = 0;
    static uint32_t u32SampleIdx = 0;

    uint32_t u32Data;
    uint32_t u32Addr;

    if(ADC_GET_INT_FLAG(ADC, ADC_ADF_INT))
    {
        u32Data = ADC_GET_CONVERSION_DATA(ADC, 0);
        g_audio_buff[u32SampleIdx++] = (uint8_t)(u32Data >> 2);
        g_audio_buff[u32SampleIdx++] = (uint8_t)(u32Data >> 10);

        if(u32SampleIdx >= AUDIO_BUF_SIZE)
        {
            u32SampleIdx = 0;
            u32Addr = (uint32_t)&g_audio_buff[0];
            USBD_SET_PAYLOAD_LEN(EP3, AUDIO_BUF_SIZE);
            while(USBD_IS_ATTACHED() == 1)
            {
                if(USBD_GET_EP_BUF_ADDR(EP3) != u32Addr)
                    USBD_SET_EP_BUF_ADDR(EP3, u32Addr);
                else
                    break;
            }
        }

        u32SampleCnt++;
        if(u32SampleCnt >= 1024)
        {
            u32SampleCnt = 0;
            GPIO_TOGGLE(PA, BIT12);
        }

        ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);
    }
}

void USBD_IRQHandler(void)
{
    __IO uint32_t IrqStL, IrqSt;

    IrqStL = USBD->GINTSTS;
    IrqSt = USBD->GINTSTS & USBD->GINTEN;

    if(IrqSt & USBD_GINTSTS_USBIF_Msk)
    {
        USBD_ISAttach();
    }

    if(IrqSt & USBD_GINTSTS_IEPINT_Msk)
    {
        if(IrqSt & USBD_GINTSTS_IEP0IF_Msk)
        {
            USBD_Ep0Handler();
        }
        else if(IrqSt & USBD_GINTSTS_IEP3IF_Msk)
        {
            USBD_SET_PAYLOAD_LEN(EP3, 0);
        }
    }

    if(IrqSt & USBD_GINTSTS_OEPINT_Msk)
    {
        if(IrqSt & USBD_GINTSTS_OEP2IF_Msk)
        {
            HID_SetOutReport();
        }
    }
}

void HID_SetInReport(void)
{
    static uint8_t u8LedState = 0;

    if(USBD_GET_EP_BUF_ADDR(EP1) != (uint32_t)g_hid_buff)
        USBD_SET_EP_BUF_ADDR(EP1, (uint32_t)g_hid_buff);

    u8LedState ^= 1;
    g_hid_buff[0] = u8LedState;
    USBD_SET_PAYLOAD_LEN(EP1, 1);
}

void HID_SetOutReport(void)
{
    uint8_t *pu8EpBuf = (uint8_t *)USBD_GET_EP_BUF_ADDR(EP2);
    uint8_t u8LEDState = pu8EpBuf[0];

    if(u8LEDState)
        GPIO_SET(PB, BIT0);
    else
        GPIO_CLR(PB, BIT0);

    USBD_SET_PAYLOAD_LEN(EP2, 0);
}

void HID_ClassRequest(void)
{
    uint8_t buf[8];
    USBD_GetSetupPacket(buf);

    if(buf[0] & 0x80)
    {
        // request data transfer direction
        USBD_PrepareCtrlIn((uint8_t *)NULL, 0);
    }
    else
    {
        // request data transfer direction
        USBD_PrepareCtrlOut((uint8_t *)NULL, 0);
    }
}

void HID_SetConfig(uint8_t u8CfgNum)
{
    USBD_SetEpStall(EP1);
    USBD_SetEpStall(EP2);
    USBD_SetEpStall(EP3);

    USBD_ClrEpStall(EP1);
    USBD_ClrEpStall(EP2);
    USBD_ClrEpStall(EP3);

    USBD_SetEpBufAddr(EP1, (uint32_t)g_hid_buff);
    USBD_SetEpBufAddr(EP2, (uint32_t)g_hid_buff);
    USBD_SetEpBufAddr(EP3, (uint32_t)g_audio_buff);
    USBD_SetEpMaxPayload(EP1, HID_BUF_SIZE);
    USBD_SetEpMaxPayload(EP2, HID_BUF_SIZE);
    USBD_SetEpMaxPayload(EP3, AUDIO_BUF_SIZE);

    HID_Init();
}

void HID_Init(void)
{
    // HID初始化
    HID_Open(0, g_hid_buff, HID_BUF_SIZE);
    USBD_SetVendorRequest(HID_ClassRequest);
    USBD_SetConfigCallback(HID_SetConfig);
}

void AUDIO_SetConfig(uint8_t u8CfgNum)
{
    uint32_t u32SampleRate, u32N;

    // ADC初始化
    ADC_Open(ADC, ADC_INPUT_MODE_SINGLE_END, ADC_OPERATION_MODE_CONTINUOUS, ADC_CH_0_MASK);
    ADC_POWER_ON(ADC);
    ADC_EnableInt(ADC, ADC_ADF_INT);
    NVIC_EnableIRQ(ADC_IRQn);

    u32SampleRate = 48000;
    u32N = 12000000 / u32SampleRate - 1;
    ADC_SET_MODIFY_CYCLE(ADC, u32N);

    GPIO_CLR(PA, BIT15);
}

void AUDIO_ClassRequest(void)
{
    uint8_t buf[8];
    USBD_GetSetupPacket(buf);

    if(buf[0] & 0x80)
    {
        // request data transfer direction
        USBD_PrepareCtrlIn((uint8_t *)NULL, 0);
    }
    else
    {
        // request data transfer direction
        USBD_PrepareCtrlOut((uint8_t *)NULL, 0);
    }
}

void AUDIO_Init(void)
{
    USBD_SetVendorRequest(AUDIO_ClassRequest);
    USBD_SetConfigCallback(AUDIO_SetConfig);
}

该代码使用了NUC126的USB库函数和示例代码中的HID和Audio传输函数，实现了一个简单的USB Audio&HID混合设备。其中，HID设备用于控制LED灯的开关，Audio设备用于实现一个简单的音频输入设备。