Electronic – STM32 SPI DMA timings between data frames and multiple DMA profiles

dmaspistm32

I'm trying to setup the STM32L432 MCU for SPI communication (24 MHz, 16 bit data size, master transmit only), using DMA.

The slave device is a 32 channel amplifier chip. I need to send a specific string of bits only once at the start, to setup the registers on the slave device, and then continuously send another string of bits to let the slave know to keep sampling and cycling through its 32 channels, until it receives a stop command or powers down.

I've generated a code using CubeMx, with the appropriate parameters setup. I've been using the HAL_SPI_Transmit_DMA command to send the data. I'm getting the correct SCLK and MOSI signals however am not getting the correct timings between successive SCLK bursts. My two questions are:

The timing between the successive SCLK bursts is too short when Circular DMA transmission is enabled (shown in screenshot) I would need it to be roughly twice as big (about ~200 ns) Where can I control the timing of this? If I enable Normal DMA and put the HAL_SPI_Transmit_DMA command within a while loop I get the opposite problem, the gap between the successive SCLK bursts become too big, about 5 us. I've also tried using software NSS pin control using writepin, however get the same problem as with using the while loop, too big gaps between the data frames.
How could I setup two different DMA profiles to operate withing one script, and call them up when required? I would need this as the bit stream dataTx2 only needs to be sent once so would require DMA to be set to normal, while dataTx would needed to be sent continuously using circular DMA.

The code can be found here: https://github.com/varkong/SPI-DMA-Ver-C/tree/master/Src

Thank you in advance,

varkong

Best Answer

The issue is that the stock SPI DMA stuff ST provides doesn't actually fit your use case here. When you use their SPI driver, it assumes you want to send the data as fast as the bus will support. This means back-to-back transfers, which is what you are seeing.

See if you can look through the reference manual, find how the SPI Tx signal is triggering the DMA, and see if that trigger can be moved to a timer-counter. This is usually possible on full-featured microcontrollers. Then set up a timer-counter to trigger on the period you are interested in.

If you can use the ST HAL driver at all, it'll have to be rewritten to do what you want.

Related Solutions

Electronic – arduino – Making two Arduinos talk over SPI

I took a quick look at the Arduino SPI library and couldn't find the attachInterrupt() function. I assume that you're using an extended library of some sort and I'll make the assumption that it works although I would like to see how it's implemented underneath.

A couple things that I saw:

This compiles? if (pos < sizeof buf) - it probably needs to be if (pos < sizeof(buf))
In the sample code on the forum, he has a key line right here that you're missing in your slave code:
```
// turn on interrupts
SPCR |= _BV(SPIE);
```

Without this your receive interrupt probably won't fire. I also don't see where global interrupts are being enabled although I have no idea if Arduino takes care of that for you under the hood. I also haven't bothered to look up what any of those registers mean, I'm trying my best to go by memory of AVR's SPI registers.

Electronic – Full duplex slave SPI, DMA and interrupts on STM32F103

Below a code that works for me. DMA channel assignment is critical. DMA1 channel 4 for SPI2 RX request and DMA1 channel 5 for SPI2 TX request. See here, page 147:

http://www.st.com/web/en/resource/technical/document/reference_manual/CD00246267.pdf

uint16_t SPIReceivedValue[2];
uint16_t SPITransmittedValue[2] = {0xFF00,0x00FF};

void SPI_Slave_and_DMA_Configuration(void)
{
    SPI_InitTypeDef SPI_InitStructure; //Variable used to setup the SPI
    DMA_InitTypeDef DMA_InitStructure; //Variable used to setup the DMA


    //--Enable the SPI2 periph
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);

    // Reset SPI Interface
    SPI_I2S_DeInit(SPI2);

    //== SPI2 configuration
    SPI_StructInit(&SPI_InitStructure);
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(SPI2, &SPI_InitStructure);


    //--Enable DMA1 clock--
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

    //==Configure DMA1 - Channel4== (SPI -> memory)
    DMA_DeInit(DMA1_Channel4); //Set DMA registers to default values
    DMA_StructInit(&DMA_InitStructure);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI2->DR; //Address of peripheral the DMA must map to
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&SPIReceivedValue[0]; //Variable to which received data will be stored
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = 2; //Buffer size
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel4, &DMA_InitStructure); //Initialise the DMA
    DMA_Cmd(DMA1_Channel4, ENABLE); //Enable the DMA1 - Channel4         

    //==Configure DMA1 - Channel5== (memory -> SPI)
    DMA_DeInit(DMA1_Channel5); //Set DMA registers to default values
    DMA_StructInit(&DMA_InitStructure);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI2->DR; //Address of peripheral the DMA must map to
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&SPITransmittedValue[0]; //Variable from which data will be transmitted
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_BufferSize = 2; //Buffer size
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel5, &DMA_InitStructure); //Initialise the DMA
    DMA_Cmd(DMA1_Channel5, ENABLE); //Enable the DMA1 - Channel5         

    // Enable SPI2
    SPI_Cmd(SPI2, ENABLE);

    // Enable the SPI2 RX & TX DMA requests
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, ENABLE);
}

Best Answer

Related Solutions

Electronic – arduino – Making two Arduinos talk over SPI

Electronic – Full duplex slave SPI, DMA and interrupts on STM32F103

Related Topic