USB-全速设备接口

本篇总结

一根 USB 线枚举出 VCP 虚拟串口——串口工具发什么设备原样回传，实现数据回显功能。

硬件平台：本例程基于 W55MH32L-EVB 开发板运行。

采购推荐：点击前往 WIZnet 官方淘宝店铺 选购 W55MH32L-EVB

USART_TypeDef *USART_TEST = USART1;

void UART_Configuration(uint32_t bound)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    /* 开启外设时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    /* PA9: USART1_TX → 复用推挽输出 */
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* PA10: USART1_RX → 浮空输入 */
    GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* USART 参数：115200 / 8N1 / 全双工 */
    USART_InitStructure.USART_BaudRate            = bound;
    USART_InitStructure.USART_WordLength          = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits            = USART_StopBits_1;
    USART_InitStructure.USART_Parity              = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode                = USART_Mode_Rx | USART_Mode_Tx;

    USART_Init(USART_TEST, &USART_InitStructure);
    USART_Cmd(USART_TEST, ENABLE);
}

void RCC_ClkConfiguration(void)
{
    RCC_DeInit();

    /* 使能 HSE（外部高速时钟） */
    RCC_HSEConfig(RCC_HSE_ON);
    while (RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET);

    /* 配置 PLL：8MHz × 27 = 216MHz */
    RCC_PLLCmd(DISABLE);
    WIZ_RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_27, 1);
    RCC_PLLCmd(ENABLE);
    while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

    /* 选择 PLL 作为系统时钟 */
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

    /* 配置总线分频 */
    RCC_HCLKConfig(RCC_SYSCLK_Div1);   /* HCLK = SYSCLK = 216MHz */
    RCC_PCLK1Config(RCC_HCLK_Div2);    /* PCLK1 = 108MHz */
    RCC_PCLK2Config(RCC_HCLK_Div1);    /* PCLK2 = 216MHz */

    RCC_LSICmd(ENABLE);
    while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET);
    RCC_HSICmd(ENABLE);
    while (RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);
}

void USB_Port_Set(u8 enable)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    if (enable)
        _SetCNTR(_GetCNTR() & (~(1 << 1)));    /* 退出掉电模式 */
    else
    {
        _SetCNTR(_GetCNTR() | (1 << 1));       /* 进入掉电模式 */
        GPIOA->CRH &= 0XFFF00FFF;
        GPIOA->CRH |= 0X00033000;
        PAout(12) = 0;
    }
}

int main(void)
{
    uint16_t t, len, times = 0;
    uint8_t usbstatus = 0;
    RCC_ClocksTypeDef clocks;

    RCC_ClkConfiguration();
    delay_init();
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    UART_Configuration(115200);
    RCC_GetClocksFreq(&clocks);

    printf("\n");
    printf("USB Virtual COM Port\n");
    printf("SYSCLK: %3.1fMhz, HCLK: %3.1fMhz, PCLK1: %3.1fMhz, PCLK2: %3.1fMhz, ADCCLK: %3.1fMhz\n",
           (float)clocks.SYSCLK_Frequency / 1000000,
           (float)clocks.HCLK_Frequency / 1000000,
           (float)clocks.PCLK1_Frequency / 1000000,
           (float)clocks.PCLK2_Frequency / 1000000,
           (float)clocks.ADCCLK_Frequency / 1000000);

    delay_ms(1800);
    USB_Port_Set(0);    /* 先断开 USB */
    delay_ms(700);
    USB_Port_Set(1);    /* 重新连接 USB */
    Set_USBClock();
    USB_Interrupts_Config();
    USB_Init();
    DP_PUUP = 1;        /* 拉高 D+ 上拉，向主机宣告全速设备接入 */

    while (1)
    {
        /* 检测 USB 连接状态变化 */
        if (usbstatus != bDeviceState)
        {
            usbstatus = bDeviceState;
            if (usbstatus == CONFIGURED)
                printf("USB connection successful\n");
            else
                printf("USB disconnected\n");
        }

        /* 如果收到完整一帧数据（以回车换行结束） */
        if (USB_USART_RX_STA & 0x8000)
        {
            len = USB_USART_RX_STA & 0x3FFF;
            usb_printf("\r\nThe length of the message you sent is: %d. The message content is:\r\n", len);
            for (t = 0; t < len; t++)
                USB_USART_SendData(USB_USART_RX_BUF[t]);
            usb_printf("\r\n\r\n");
            USB_USART_RX_STA = 0;
        }
        else
        {
            times++;
            if (times % 200 == 0)
                usb_printf("Please enter data and end with the enter key.\r\n");
            delay_ms(10);
        }
    }
}

/* USB 时钟配置：SYSCLK=216MHz，216 ÷ 4.5 = 48MHz */
void Set_USBClock(void)
{
    RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_4Div5);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE);
}

/* USB 中断配置 */
void USB_Interrupts_Config(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;
    EXTI_InitTypeDef EXTI_InitStructure;

    /* 配置 EXTI Line18（USB 唤醒事件内部连接） */
    EXTI_ClearITPendingBit(EXTI_Line18);
    EXTI_InitStructure.EXTI_Line    = EXTI_Line18;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitStructure.EXTI_Mode    = EXTI_Mode_Interrupt;
    EXTI_Init(&EXTI_InitStructure);

    /* USB 低优先级中断：处理所有 USB 事件（CTR/RESET/SUSP 等） */
    NVIC_InitStructure.NVIC_IRQChannel                   = USB_LP_CAN1_RX0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    /* USB 唤醒中断 */
    NVIC_InitStructure.NVIC_IRQChannel                   = USBWakeUp_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

/* USB 低功耗模式 */
void Enter_LowPowerMode(void)
{
    printf("usb enter low power mode\r\n");
    bDeviceState = SUSPENDED;
}

/* USB 退出低功耗模式 */
void Leave_LowPowerMode(void)
{
    DEVICE_INFO *pInfo = &Device_Info;
    printf("leave low power mode\r\n");
    if (pInfo->Current_Configuration != 0)
        bDeviceState = CONFIGURED;
    else
        bDeviceState = ATTACHED;
}

48MHz 时钟是 USB 全速的硬性要求

USB 全速总线时钟固定为 48MHz，必须由 PLL 分频得到。本例 SYSCLK=216MHz，选用 RCC_USBCLKSource_PLLCLK_4Div5（216÷4.5=48MHz）。DP_PUUP=1 是 W55MH32 专有寄存器位，拉高 D+ 内部上拉电阻即可让主机识别为全速设备，无需外部上拉。

/* FIFO 结构体：用于 USB 发送数据缓存 */
_usb_usart_fifo uu_txfifo;

/* 数据接收缓冲区与状态 */
u8  USB_USART_RX_BUF[USB_USART_REC_LEN];
u16 USB_USART_RX_STA = 0;  /* bit15: 接收完成标志，bit14: 收到0x0d，bit13~0: 有效字节数 */

uint8_t USB_Rx_Buffer[VIRTUAL_COM_PORT_DATA_SIZE];

/* 处理从 USB 虚拟串口接收到的数据（以 0x0d 0x0a 作为帧结束标志） */
void USB_To_USART_Send_Data(u8 *data_buffer, u8 Nb_bytes)
{
    u8 i, res;
    for (i = 0; i < Nb_bytes; i++)
    {
        res = data_buffer[i];
        if ((USB_USART_RX_STA & 0x8000) == 0)
        {
            if (USB_USART_RX_STA & 0x4000)    /* 已收到 0x0d */
            {
                if (res != 0x0a)
                    USB_USART_RX_STA = 0;     /* 错误，重新开始 */
                else
                    USB_USART_RX_STA |= 0x8000; /* 接收完成 */
            }
            else
            {
                if (res == 0x0d)
                    USB_USART_RX_STA |= 0x4000;
                else
                {
                    USB_USART_RX_BUF[USB_USART_RX_STA & 0x3FFF] = res;
                    USB_USART_RX_STA++;
                    if (USB_USART_RX_STA > (USB_USART_REC_LEN - 1))
                        USB_USART_RX_STA = 0;
                }
            }
        }
    }
}

/* EP3_OUT 回调：主机向虚拟串口发数据，存入接收缓冲区 */
void EP3_OUT_Callback(void)
{
    u16 USB_Rx_Cnt;
    USB_Rx_Cnt = USB_SIL_Read(EP3_OUT, USB_Rx_Buffer);
    USB_To_USART_Send_Data(USB_Rx_Buffer, USB_Rx_Cnt);
    SetEPRxValid(ENDP3);
}

/* 向 USB 虚拟串口发送一个字节（写入 FIFO） */
void USB_USART_SendData(u8 data)
{
    uu_txfifo.buffer[uu_txfifo.writeptr] = data;
    uu_txfifo.writeptr++;
    if (uu_txfifo.writeptr == USB_USART_TXFIFO_SIZE)
        uu_txfifo.writeptr = 0;
}

/* USB 虚拟串口 printf 函数（每次发送不超过 USB_USART_REC_LEN 字节） */
void usb_printf(char *fmt, ...)
{
    u16 i, j;
    va_list ap;
    va_start(ap, fmt);
    vsprintf((char *)USART_PRINTF_Buffer, fmt, ap);
    va_end(ap);
    i = strlen((const char *)USART_PRINTF_Buffer);
    for (j = 0; j < i; j++)
        USB_USART_SendData(USART_PRINTF_Buffer[j]);
}

/* EP1_IN 回调：USB 发送完成，继续从 FIFO 取数发送 */
void EP1_IN_Callback(void)
{
    u16 USB_Tx_ptr;
    static u16 USB_Tx_length = 0;

    if (uu_txfifo.readptr == uu_txfifo.writeptr)
    {
        if (USB_Tx_length == VIRTUAL_COM_PORT_DATA_SIZE)
        {
            USB_Tx_length = 0;
            SetEPTxCount(ENDP1, USB_Tx_length);
            SetEPTxValid(ENDP1);
        }
        return;
    }

    /* 计算要发送的数据长度 */
    if (uu_txfifo.readptr < uu_txfifo.writeptr)
        USB_Tx_length = uu_txfifo.writeptr - uu_txfifo.readptr;
    else
        USB_Tx_length = USB_USART_TXFIFO_SIZE - uu_txfifo.readptr;

    if (USB_Tx_length > VIRTUAL_COM_PORT_DATA_SIZE)
        USB_Tx_length = VIRTUAL_COM_PORT_DATA_SIZE;

    USB_Tx_ptr = uu_txfifo.readptr;
    uu_txfifo.readptr += USB_Tx_length;
    if (uu_txfifo.readptr >= USB_USART_TXFIFO_SIZE)
        uu_txfifo.readptr = 0;

    /* 将数据从用户缓冲区拷贝到 PMA 并触发发送 */
    UserToPMABufferCopy(&uu_txfifo.buffer[USB_Tx_ptr], ENDP1_TXADDR, USB_Tx_length);
    SetEPTxCount(ENDP1, USB_Tx_length);
    SetEPTxValid(ENDP1);
}

/* SOF 回调：每 5ms 触发一次，检查 FIFO 是否有数据待发送 */
void SOF_Callback(void)
{
    static uint32_t FrameCount = 0;

    if (bDeviceState == CONFIGURED)
    {
        if (FrameCount++ == 5)
        {
            FrameCount = 0;
            EP1_IN_Callback();
        }
    }
}

/* USB 唤醒中断：清 EXTI Line18（USB 唤醒事件内部连到 EXTI18） */
void USBWakeUp_IRQHandler(void)
{
    EXTI_ClearITPendingBit(EXTI_Line18);
}

/* USB 低优先级中断：调用协议栈分发器，由它根据 ISTR 寄存器调用对应回调 */
void USB_LP_CAN1_RX0_IRQHandler(void)
{
    USB_Istr();
}

int SER_PutChar(int ch)
{
    while (!USART_GetFlagStatus(USART_TEST, USART_FLAG_TC));
    USART_SendData(USART_TEST, (uint8_t)ch);
    return ch;
}

int fputc(int c, FILE *f)
{
    if (c == '\n')
        SER_PutChar('\r');
    return (SER_PutChar(c));
}