STM32F4 USB VCP, PC recibe todos los 0x00

Estoy utilizando la biblioteca ST USB para un microcontrolador ST ARM diferente (STM32F105), pero la estructura es la misma. Yo también he basado mi código en el ejemplo de VCP.

Primero, se requiere una inicialización adicional para que funcione el USB. A continuación hay una lista de cosas para verificar. Quizás deba ajustar algunos de estos ejemplos para que funcionen con su microcontrolador:

1. Debe haber habilitado la interrupción OTG_FS_IRQHandler :

   NVIC_InitStructure.NVIC_IRQChannel = OTG_FS_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 7;
   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);
   

   Lo siguiente está en mi archivo de vector de interrupción:

   #include "usb_core.h"
   #include "usbd_core.h"
   #include "usbd_cdc_core.h"
   
   extern USB_OTG_CORE_HANDLE USB_OTG_dev;
   extern uint32_t USBD_OTG_ISR_Handler (USB_OTG_CORE_HANDLE *pdev);
   
   void OTG_FS_IRQHandler(void)
   {
       USBD_OTG_ISR_Handler (&USB_OTG_dev);
   } // end OTG_FS_IRQHandler()
   

2. Debe seleccionar y habilitar una fuente de reloj de 48 MHz para el modelo OTG / USB antes de llamar a USBD_Init . En mi caso, esto se derivó dividiendo el PLLVCO de 144 MHz por 3. El árbol del reloj puede ser complicado; Asegúrate de que entiendes esa sección del Manual de referencia.

   // Configure USB Clock Source
   RCC_OTGFSCLKConfig(RCC_OTGFSCLKSource_PLLVCO_Div3);
   
   // Enable USB Clock
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_OTG_FS, ENABLE);
   

3. En la biblioteca USB está el archivo usb_conf.h . Esta es una maraña de definiciones condicionales. Asegúrese de que estos se estén definiendo realmente (si son adecuados para su aplicación):

   #define USE_USB_OTG_FS
   #define USB_OTG_FS_CORE
   #define USE_EMBEDDED_PHY
   #define VBUS_SENSING_ENABLED
   #define USE_DEVICE_MODE
   

A continuación, como @Tut señaló en los comentarios, su función VCP_DataTX necesita modificaciones. Actualmente está utilizando el periférico USART como fuente de los datos USB. Desea cambiarlo para que use Buf y Len . Aunque la llamada a la función incluye los argumentos Buf y Len , estos no se utilizan realmente en la función.

El VCP_DataTx rellena los datos, un byte a la vez, en la matriz APP_Rx_Buffer . Cada vez que escribe un byte en la matriz también incrementa el valor APP_Rx_ptr_in . Este búfer es regularmente verificado y procesado por el código de la biblioteca OTG / USB.

Mi función se ve así:

uint16_t VCP_DataTx(uint8_t *Buf, uint32_t Len)
{
    uint32_t i;

    // Put the data into the buffer. It will be processed by the USB stack.
    for (i=0; i<Len; i++)
    {
        // Add a byte to the buffer
        APP_Rx_Buffer[APP_Rx_ptr_in] = Buf[i];

        // Update the circular buffer index
        APP_Rx_ptr_in++;

        // Loop the index if necessary
        if (APP_Rx_ptr_in == APP_RX_DATA_SIZE)
        {
            APP_Rx_ptr_in = 0;
        }
    }
    return USB_SUCCESS;
}

Finalmente, hay algunos otros problemas en su código. Espero que conozca algunos de estos, pero los enumeraré por si acaso:

1. La instrucción uint8_t Buf[6] = "A"; solo inicializa el primer valor a 'A'. Los cinco valores restantes son '\ 0'. Consulte aquí para obtener más información.

2. Cuando la variable de contador i excede su límite de demora, debe volver a cero. Este podría ser un problema principal . Actualmente, cuando el retraso finaliza la primera vez, nunca más se retrasa. El bucle while externo comienza a llamar a VCP_DataTx(Buf, 6); continuamente. Esto desbordará el búfer USB y dará lugar a todo tipo de problemas.

3. Una vez que solucione el problema de demora, todavía recibirá dos llamadas a VCP_DataTx(Buf, 6); back-to-back sin demoras. Una vez antes del bucle de retardo, e inmediatamente antes del primer retardo. Esto no debería causar un problema, pero quería señalarlo.

Para su información, si solo está intentando enviar datos de un PC a otro mediante USB, no necesita habilitar ninguna funcionalidad USART en el microcontrolador. El ejemplo de VCP usa el USART como fuente de datos (y destino), pero no está intentando hacerlo. Su fuente de datos es su matriz Buf[] .