For the project I am working on we are using multiple SPI peripherals. I am currently working on a driver that meets up to our abstraction layer written in C++ but I encounter an issue when trying to exchange data on the SPI bus. All measurements are done on the LPC5528 processor and I use FlexComm8 for my SPI interface.
For the input of the exchangeBytes function i use the following data:
uint8_t dataTx[10];
uint8_t dataRx[10];
for(uint32_t i = 0; i < 10; i++)
{
dataTx[i] = i;
dataRx[i] = 0;
}
System::spiFPGA.open();
System::spiFPGA.exchangeBytes(dataTx, dataRx, 10);
System::spiFPGA.close();When I read the user manual for the SPI interfaces the FIFO write data register documentation describes:
Byte, half-word or word writes to FIFOWR will push the data and control bits into the FIFO.
Word writes with the upper half-word of 0, byte writes or half-word writes to FIFOWR will
push the data and the current control bits, into the FIFO. Word writes with a non-zero
upper half-word will modify the control bits before pushing them onto the stack.
The issue I encounter is the unexpected behavior when not always writing the control bits to the FIFO.
The code below shows the blocking exchange function code that is use and which results in a valid SPI transfer:
SpiMasterBase::SpiResult SpiMasterDriver::exchangeBytes(uint8_t *in, uint8_t *out, uint32_t nrOfBytes)
{
SpiMasterBase::SpiResult result = SpiMasterBase::SPI_SUCCESS;
uint32_t rxCount = 0;
uint32_t txCount = 0;
while((rxCount < nrOfBytes) || (txCount < nrOfBytes))
{
if((rxCount < nrOfBytes) && (ports[PORT].peripheral->FIFOSTAT & SPI_FIFOSTAT_RXNOTEMPTY_MASK)) // Check if there is data in the RX FIFO
{
// There is data in the rx fifo, read the next byte.
out[rxCount++] = ports[PORT].peripheral->FIFORD;
}
else if((txCount < nrOfBytes) && (ports[PORT].peripheral->FIFOSTAT & SPI_FIFOSTAT_TXNOTFULL_MASK)) // Check if there is space in the TX FIFO
{
if(0 < txCount)
{
ports[PORT].peripheral->FIFOWR = in[txCount++] + config;
}
else
{
ports[PORT].peripheral->FIFOWR = in[txCount++] + config;
}
}
else
{
// Nothing to do now. Wait for data in the Rx FIFO or an empty space in the tx FIFO
}
}
return result;
}The code above works like a charm because it always writes the control bits. The result on the SPI output signals is
shown in the image blow.
When I change the code to:
SpiMasterBase::SpiResult SpiMasterDriver::exchangeBytes(uint8_t *in, uint8_t *out, uint32_t nrOfBytes)
{
SpiMasterBase::SpiResult result = SpiMasterBase::SPI_SUCCESS;
uint32_t rxCount = 0;
uint32_t txCount = 0;
while((rxCount < nrOfBytes) || (txCount < nrOfBytes))
{
if((rxCount < nrOfBytes) && (ports[PORT].peripheral->FIFOSTAT & SPI_FIFOSTAT_RXNOTEMPTY_MASK)) // Check if there is data in the RX FIFO
{
// There is data in the rx fifo, read the next byte.
out[rxCount++] = ports[PORT].peripheral->FIFORD;
}
else if((txCount < nrOfBytes) && (ports[PORT].peripheral->FIFOSTAT & SPI_FIFOSTAT_TXNOTFULL_MASK)) // Check if there is space in the TX FIFO
{
if(0 < txCount)
{
ports[PORT].peripheral->FIFOWR = in[txCount++];// + config;
}
else
{
ports[PORT].peripheral->FIFOWR = in[txCount++] + config;
}
}
else
{
// Nothing to do now. Wait for data in the Rx FIFO or an empty space in the tx FIFO
}
}
return result;
}The control bits should not be modified if I am not mistaking and thus the result should be the same. Unfortunately I get an unexpected output signal on the SPI output.
The first byte is exchanged correctly but from the second byte the data is not correct anymore and even the clock speed seems to be changed which is totally unexpected to me because there is no option for this in the control bits.
I know I could always add the control bits and forget about the issue but I do not like to keep unexpected behavior in my code and forget about it 
I would like to know what I am doing wrong.
Hi, Rik,
I have tested the SPI8 module with SPI master plus DMA with Byte transfer on MY LPC55S69-EVK, it is okay.
i copy the result here.
BR
XiangJun Rong
Hi, Rik,
I just tested the lpcxpresso55s69_spi_dma_b2b_transfer_master project based on my lpc55s69-EVK board, I close the pin PIO0_19 to PIO0_20 with a resistor on the EVK, it works fine. As the following fig, the SPI transfer length is Byte.
Maybe our initialization code for SPI is incorrect somewhere.
BR
XiangJun Rong
Hi, Rik,
sorry for the delay.
I have checked the SDK package, it has the example for both SPI plus DMA, it uses Byte transfer.
You can download SDK package from the link:
MCUXpresso SDK | Software Development for Kinetis, LPC, and i.MX MCUs | NXP
After you download the SDK package based on the LPC55S28, you can try to test the code.
anyway, pls have a try.
BR
XiangJun Rong
Ok i did some testing on the question "Is the same issue there with the use of a DMA transfer". I expected that the issue is also there when using a DMA transfer because it also uses a memory/register write which should result in the same faulty behaviour. But to be sure is tested it with a dummy data arrey and here are my results:
For the input data i used the same data array as in the first implementation but only now a 50 bytes array instead of the 10 bytes i used previously. The code in my exchangeBytes function is now modified to DMA usage and for the Tx transfer is have implemented 2 versions. The first is an byte oriented write action and the second implementation uses a word oriented data transfer. For the word oriented data transfer i copied the input data(uint8_t) to an internal uint32_t array and added the desired configuration bits to each word.
SpiMasterBase::SpiResult SpiMasterDriverDMA::exchangeBytes(uint8_t *in, uint8_t *out, uint32_t nrOfBytes)
{
SpiMasterBase::SpiResult result = SpiMasterBase::SPI_SUCCESS;
// Enable the SPI DMA triggers.
SPI_EnableTxDMA(ports[PORT].peripheral, true);
SPI_EnableRxDMA(ports[PORT].peripheral, true);
DEBUG_ASSERT(TRANSFER_SIZE >= nrOfBytes);
// Copy the input data from the byte array to an internal word size tx buffer. This is needed to add the config
// data to every single byte...
for(uint32_t i = 0; i < nrOfBytes; i++)
{
masterTxData[i] = in[i] + config;
}
/******************************************************************************************************************
* Use the DMA transfer in byte mode. This is totally unsuccessful because not all the control bits are written
* every time. Probably a bug in the processor peripheral.
******************************************************************************************************************/
// First write the first data byte + config bits.
// ports[PORT].peripheral->FIFOWR = config + in[0];
//
// uint32_t xferConfTx = DMA_CHANNEL_XFER(0, 1, 0, 0, kDMA_Transfer8BitWidth, kDMA_AddressInterleave1xWidth, kDMA_AddressInterleave0xWidth, nrOfBytes - 1);
// DMA_SubmitChannelTransferParameter(&masterTxHandle, xferConfTx, &in[1], (uint32_t*)&ports[PORT].peripheral->FIFOWR, NULL);
/******************************************************************************************************************
* Use the DMA transfer in word mode. This results in a successful transfer but unfortunately all the data must
* be copied from a byte array to a word array with added configuration data to work.
******************************************************************************************************************/
// Functional configuration with 32 bits array (data + config).
uint32_t xferConfTx = DMA_CHANNEL_XFER(0, 1, 0, 0, kDMA_Transfer32BitWidth, kDMA_AddressInterleave1xWidth, kDMA_AddressInterleave0xWidth, nrOfBytes * 4);
DMA_SubmitChannelTransferParameter(&masterTxHandle, xferConfTx, &masterTxData[0], (uint32_t*)&ports[PORT].peripheral->FIFOWR, NULL);
uint32_t xferConfRx = DMA_CHANNEL_XFER(0, 1, 0, 0, kDMA_Transfer32BitWidth, kDMA_AddressInterleave0xWidth, kDMA_AddressInterleave1xWidth, nrOfBytes * 4);
DMA_SubmitChannelTransferParameter(&masterRxHandle, xferConfRx, (uint32_t*)&ports[PORT].peripheral->FIFORD, &masterRxData[0], NULL);
// Start the transfer.
DMA_StartTransfer(&masterTxHandle);
DMA_StartTransfer(&masterRxHandle);
// Wait for the transfer to finish.
while(DMA_ChannelIsActive(masterTxHandle.base, masterTxHandle.channel));
while(DMA_ChannelIsActive(masterRxHandle.base, masterRxHandle.channel));
// Disable the SPI DMA triggers.
SPI_EnableTxDMA(ports[PORT].peripheral, false);
SPI_EnableRxDMA(ports[PORT].peripheral, false);
return result;
}
Unfortunately the result with the uint8_t transfer was as expected:
The word oriented transfer gave me the desired result:
While i did manage to create a successful SPI transfer on the high speed SPI port I do have the issue that is only works with the uint32_t/word oriented operations. To do this i have to copy all data from an byte array to a word array and add the configuration data to each word. Although i can communicate on high speeds this way it does impact the performance and memory usage a lot and this is totally undesired...
