About USB bulk transfer with buffer: Modification of usb_dev_bulk example

Hi Amit, I 'm not really sure; after posting, I tried a little more before going home and I think that the TxHandler() function is not called. I compared what happens in the usb_dev_bulk example with what happens in my modified code that I posted.

The USB monitoring application does show data when I run the usb_dev_bulk example; it shows exactly what I type - and is sent to the uC - and what the uC returns. By the way, having the Win32 application for the usb_dev_bulk example running but with my modified code, it shows some random activity when I try to send characters through the WIn32 application. This shows that something - or everything? - is completely messed up in the uC's memory!

I am really sure that there is something that I have not understood and is rather obscure. Something is not called or not properly called in my modified code. Please explain to me about callbacks etc. so that I get a firm grasp on how to use the API to write a useful program.

Let me be more specific, Amit.

What I find hard to understand is how I should call that handler, TxHandler(). At present, when I want to send bytes over the USB, I copy the contents of a buffer array that I have set up, g_RX_buffer, to g_pui8USBTxBuffer. Upon completion of that, a USB_TX_COMPLETE event is sent.

Up to now, I thought that as being correct but it does not work. Where am I wrong?

I just thought of a possible reason: g_pui8USBTxBuffer is a member of struct :

// Extract from usb_bulk_structs.c:
uint8_t g_pui8USBTxBuffer[BULK_BUFFER_SIZE];
uint8_t g_pui8TxBufferWorkspace[USB_BUFFER_WORKSPACE_SIZE];
const tUSBBuffer g_sTxBuffer =
{
    true,                            // This is a transmit buffer.
    TxHandler,                       // pfnCallback
    (void *)&g_sBulkDevice,          // Callback data is our device pointer.
    USBDBulkPacketWrite,             // pfnTransfer
    USBDBulkTxPacketAvailable,       // pfnAvailable
    (void *)&g_sBulkDevice,          // pvHandle
    g_pui8USBTxBuffer,               // pi8Buffer
    BULK_BUFFER_SIZE,                // ui32BufferSize
    g_pui8TxBufferWorkspace          // pvWorkspace
};

Then should I write my data to g_sTxBuffer.g_pui8USBTxBuffer? To be honest, I feel a little dumb with those typedefs and so on after hours on end...

Here I am again with updates on that project:

The objective is to read data from an SPI slave device and send them to a host PC through USB bulk transfers.

I have attached here the entire project with its source files.

To do that, I implemented a multiple buffer on the TM4C1294 as follows:

I create an array of bytes, having NO_OF_BUFFERS elements in the first dimension ("rows", I would say) and NO_OF_BUF_SAMPLES*NO_OF_PACKET_BYTES in the second dimension ("columns").

volatile uint8_t g_DataBuffer[NO_OF_BUFFERS][NO_OF_BUF_SAMPLES*NO_OF_PACKET_BYTES]; // this is a multiple buffer
volatile int8_t i8BufIndex = 0; // indicates which buffer is in use for data transfer FROM the SPI
volatile uint8_t ui8BufToUSB = 0; // indicates which buffer is in use for data transfer TO the USB

Each row of that array is a buffer and is written with data coming from the SPI slave device.  When half of the rows are full, I continue writing data to the buffers and I start to send data to USB. Furthermore, I have implemented an elementary flow-control: for each buffer that is received by the host PC, the characters 'O' and 'K' (for OK) are sent back to the uC and only after receiving them a new transmission is made.

Here is the while(1) loop in my code:

	while(1)
	{
		// When Timer4 overflows, it is time to get a new sample
		if(g_bSampleNow)
		{
			g_bSampleNow = false;	// Reset flag
			// Get a sample of the ADXL362 output in the form of an 8-byte packet.
			SPITransfer(pui8DataTx, &g_DataBuffer[ui8BufIndex][(ui8Index++)*NO_OF_PACKET_BYTES], 2, NO_OF_PACKET_BYTES);
			//TestPattern(&g_DataBuffer[ui8BufIndex][(ui8Index++)*NO_OF_PACKET_BYTES], 2, NO_OF_PACKET_BYTES); // TEST ONLY with multiple buffer
			// At this point, a total of NO_OF_PACKET_BYTES bytes are placed in the buffer.

			// When the buffer is full, send its contents to USB.
			if((ui8Index % NO_OF_BUF_SAMPLES) == 0)
			{
				ui8Index = 0;	// Reset counter

				if(!g_bIsFirstTime)
				{
					// Send data to the host over USB from the buffer that is NOT in use
					g_ui32TxCount += SendDataToHost(&g_sBulkDevice, &g_DataBuffer[ui8BufToUSB][0], NO_OF_BUF_SAMPLES*NO_OF_PACKET_BYTES);
					
					// ui8BufToUSB is an index to the buffer that is currently SENT to USB					
					ui8BufToUSB++;
					ui8BufToUSB = ui8BufToUSB % NO_OF_BUFFERS;

					// Take a snapshot of the latest transmit count.
					ui32TxCount = g_ui32TxCount;

					// ui8BufIndex is an index to the buffer that is currently WRITTEN with SPI data
					ui8BufIndex++;
					ui8BufIndex = i8BufIndex % NO_OF_BUFFERS; 

					// Clear the contents of the receive buffer - flow control
					ClearBuffer(pui8USBRXData, sizeof(pUSBRXOK));

					// Perform elementary flow control
					while(!g_ui8ClearToSend)
						g_ui8ClearToSend = CompareArrays(pui8USBRXData, pUSBRXOK, sizeof(pUSBRXOK));
				}
				else
				{
					ui8BufIndex++;
					uif(i8BufIndex == (NO_OF_BUFFERS/2)) // arrived halfway (since NO_OF_BUFFERS is a power of 2)
					{
						g_bIsFirstTime = false;
						ui8BufToUSB = 0;	// send data to the host PC starting from the first buffer
					}
				}
			}
			//...
		}
	//...
	}

In addition to that, I have implemented a function that generates simulated data for testing: I just copied the function that performs SPI transfers and replaced the part of the code that gets data from the SPI slave device with the following:

...
// TestPattern(uint8_t* pui8RX, uint8_t NoOfTXBytes, uint8_t NoOfRXBytes)
//
// Fills array pui8RX with bytes, starting from 0x00 and ending at (NoOfRXBytes-1).
// Used for TESTING ONLY.
static void TestPattern(uint8_t* pui8RX, uint8_t NoOfTXBytes, uint8_t NoOfRXBytes)
{
    uint8_t i = 0;
    uint8_t j = 0;
    uint8_t temp;
    static int8_t step = 1;
    static uint8_t testPattern = 0;

    CS_Low();	// set ~CS to logic LOW - start of transmission
    ROM_SysCtlDelay(1);
    while(i < NoOfTXBytes)
    {
    	temp = 0x00;
    	ROM_SSIDataPut(SSI3_BASE, temp);
    	while(SSIBusy(SSI3_BASE));
    	ROM_SSIDataGet(SSI3_BASE, (uint32_t*)&temp);
    	i++;
    }
    while(j < NoOfRXBytes)
    {
    	temp = 0x00;
    	ROM_SSIDataPut(SSI3_BASE, temp);
    	while(SSIBusy(SSI3_BASE));
    	//*(pui8RX+j) = (j == 0) ? testPattern : 0; // for a sawtooth/triangular waveform on X only
    	*(pui8RX+j) = (j % 2 == 0) ? testPattern : 0; // for a sawtooth/triangular waveform on X, Y, Z and T
    	//ROM_SSIDataGet(SSI3_BASE, (uint32_t*)(pui8RX+j)); // This is part of the original SPITransfer() function
    	j++;
    }
    // The following lines result in a triangular waveform
    if(testPattern == 255)
    	step = -1;
    else
    	if(testPattern == 0)
    		step = 1;

    testPattern += step;

    ROM_SysCtlDelay(1);
    CS_High();	// ~CS - set it to logic HIGH - end of transmission
}

Despite my tedious efforts, I have been stuck for almost an entire day on the following issue:

When I call the TestPattern() function in my while(1) loop, everything works OK; I can capture the data that flow back and forth the USB lines and confirm that they are as they should be.

However, when I call the SPITransfer() function in my while(1) loop, the uC program hangs when the variable ui8BufIndex has the value of the index of the last element in my multiple buffer. After calling SendDataToHost(), program execution continues with the FaultISR() function, which is an endless loop in my case. Moreover, register NVIC_FAULT_STAT has the value 0x00008200 (Configurable Fault Status [Memory Mapped]) and register NVIC_FAULT_ADDR has the value 0x40000200 (Bus Fault Address [Memory Mapped]). (I checked out for those after having read this, albeit it is kind of "fine print" for me...)

I cannot think of any apparent reason for having that issue. I do not understand what the SPITransfer() function has to do with the multiple buffer itself.

Any hints, anyone?

SPI_demo_USB_20151102.zip

OK Amit, I''l try this tomorrow morning at work and let you know about the result. One more question, though: What could fire the watchdog and halt program execution? Function SPITransfer() has been used from the very beginning of my development and was debugged to work as intended to.