TM4C1294NCPDT USB Bulk Device Communication Problem

Hi,

we have a serious communication problem using the usb_bulk_driver library: Receiving information from the host works very well but the transmit function ceases to work from time to time. This may happen after a system uptime of five minutes, three hours or even 40 hours.

Our firmware is based on the bulk device demo software package with a little modification. Our transmit function is called "static uint32_t SendStringToHost(uint8_t *pui8Info, uint_fast32_t ui32NumBytes)". This function starts a new transmission only if the old transmission is completely finished. For this purpose, we set a global flag "USB_TXR" in the TX interrupt function "uint32_t TxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData)". Even a 50 µs delay inside the TxHandler does not solve the problem.

NB: "g_ui32USBTXTimer" is being incremented every 1 ms inside the SysTick procedure.

Please find the source code below:

//*****************************************************************************
//
// Handles bulk driver notifications related to the transmit channel (data to
// the USB host).
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ulEvent identifies the event we are being notified about.
// \param ulMsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the bulk driver to notify us of any events
// related to operation of the transmit data channel (the IN channel carrying
// data to the USB host).
//
// \return The return value is event-specific.
//
//*****************************************************************************
uint32_t
TxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
          void *pvMsgData)
{
    //
    // We are not required to do anything in response to any transmit event.
    // All we do is update our transmit counter.
    //
    if (ui32Event == USB_EVENT_TX_COMPLETE)
    {
        g_ui32TxCount += ui32MsgValue;

        /*
        //
        // wait a little bit...
        // NB: character time is about 8 µs
        // ... does not solve the problem
        //
        delay_us(50);
        */

        //
        // set USB TX ready flag
        //
        USB_TXR = true;
    }
    return(0);
}

static uint32_t
SendStringToHost(uint8_t *pui8Info, uint_fast32_t ui32NumBytes)
{
    uint_fast32_t ui32Loop, ui32Count;
    uint_fast32_t ui32ReadIndex;
    uint_fast32_t ui32WriteIndex;
    tUSBRingBufObject sTxRing;
    bool bWriteTimeout, bUSBRingBufEmpty;

    //
    // initialize TX timeout counter
    //
    g_ui32USBTXTimer = 0;

    //
    // ui32NumBytes characters to process;
    // wait until transmit buffer is completely empty
    //
    do
    {
        //
        // Get the current buffer information to allow us to write directly to
        // the transmit buffer (we already have enough information from the
        // parameters to access the receive buffer directly).
        //
        // Copy the current ring buffer settings to the clients storage.
        //
        /*
        USBBufferInfoGet(&g_sTxBuffer, &sTxRing);
        bUSBRingBufEmpty = USBRingBufEmpty(&sTxRing);
        */

        //
        // replacement for "USBBufferInfoGet(&g_sTxBuffer, &sTxRing)" without any function calls
        //
        (&sTxRing)->pui8Buf = (&g_sTxBuffer)->sPrivateData.sRingBuf.pui8Buf;
        (&sTxRing)->ui32ReadIndex = (&g_sTxBuffer)->sPrivateData.sRingBuf.ui32ReadIndex;
        (&sTxRing)->ui32Size = (&g_sTxBuffer)->sPrivateData.sRingBuf.ui32ReadIndex;
        (&sTxRing)->ui32WriteIndex = (&g_sTxBuffer)->sPrivateData.sRingBuf.ui32WriteIndex;

        //
        // replacement for "USBRingBufEmpty(&sTxRing)" without any function calls
        //
        ui32WriteIndex = (&sTxRing)->ui32WriteIndex;
        ui32ReadIndex = (&sTxRing)->ui32ReadIndex;
        bUSBRingBufEmpty = (ui32WriteIndex == ui32ReadIndex) ? true : false;

        //
        // calculate timeout condition
        //
        bWriteTimeout = (g_ui32USBTXTimer > 20);

    } while (!(bUSBRingBufEmpty && USB_TXR) && !bWriteTimeout);

    //
    // check for USB TX timeout
    //
    if (bWriteTimeout)
    {
        //
        // flush TX buffer and discard input string because transmission is not possible at the moment
        //
        USBBufferInfoGet(&g_sTxBuffer, &sTxRing);
        USBRingBufFlush(&sTxRing);
        USB_TXR = true;
        ui32Count = 0;
    }
    else
    {
        //
        // prepare transmission: clear USB TX ready flag
        //
        USB_TXR = false;

        //
        // How many characters can we process this time round?
        // Calculation is no more necessary because we write when buffer is free.
        //
        //ui32Loop = (ui32Space < ui32NumBytes) ? ui32Space : ui32NumBytes;
        //ui32Count = ui32Loop;
        ui32Count = ui32Loop = ui32NumBytes;

        //
        // Set up to process the characters by directly accessing the USB buffers.
        //
        ui32ReadIndex = 0;
        ui32WriteIndex = sTxRing.ui32WriteIndex;

        while (ui32Loop)
        {
            //
            // copy string to the transmit buffer
            //
            g_pui8USBTxBuffer[ui32WriteIndex] = pui8Info[ui32ReadIndex];

            //
            // Move to the next character taking care to adjust the pointer for
            // the buffer wrap if necessary.
            //
            ui32WriteIndex++;
            ui32WriteIndex = (ui32WriteIndex == BULK_BUFFER_SIZE) ? 0 : ui32WriteIndex;
            ui32ReadIndex++;
            ui32ReadIndex = ((ui32ReadIndex == BULK_BUFFER_SIZE) ? 0 : ui32ReadIndex);

            ui32Loop--;
        }

        //
        // We've processed the data in place so now send the processed data
        // to the host.
        //
        USBBufferDataWritten(&g_sTxBuffer, ui32Count);
    }

    //
    // We processed as much data as we can directly from the receive buffer so
    // we need to return the number of bytes to allow the lower layer to
    // update its read pointer appropriately.
    //
    return (ui32Count);
}

Thanks,

Juergen