STM32F767 with SPI and DMA

[raphaelvalentin]

Hi,
I am interested about SPI and DMA for a project within Arduino environment. I am at the concept for the moment and I would like to override the SPIClass.
I am having a pretty bad time to figure out a working code with my SMT32F767 despite many source references that help me to understand (documentation PDF references, the web, STM-CUBE-IDE and chatGPT). My code shall run within the Arduino environment.
Below is my code for which I can not figure out why SPI works but not DMA.
I apologize for this code mostly adapted from HAL, this was the advice from the SPI library.

// Could be used to mix Arduino API and STM32Cube HAL API (ex: DMA). Use at your own risk.
    SPI_HandleTypeDef *getHandle(void)
    {
      return &(_spi.handle);
    }

This code compiles but crashes when HAL_SPI_Transmit_DMA is called. I tried many other ways without success. I definitely missed something.
Maybe, you can help me to figure out my issue.
Thanks a lot for any support !

--
Raphael.

/** STM32F767ZI MCU with LED display controlled using
 *  a list of ShiftRegister 74HC595s.
 *  To avoid library and code mixing, SPI follows STM-CUBE HAL syntax at this stage,
 *  ideally, I would like to overwrite `SPIClass` and use `SPI_HandleTypeDef
 * *getHandle(void)`; idea is taken from `STM32F4_SPI_DMA @ github.com` This
 * following code is a concept of proof and may turn to use LL. Links:
 * https://www.st.com/resource/en/reference_manual/rm0410-stm32f76xxx-and-stm32f77xxx-advanced-armbased-32bit-mcus-stmicroelectronics.pdf
 */

#include <ArduinoTrace.h>
// #include <SPI.h> // SPI is an external library, so not loaded with the Arduino.h
#include "Arduino.h"

#define PIN_SSEL_DISPLAY (PA4)  // ==> CS = LATCH pin, signal handled via software
#define PIN_OE_DISPLAY (PC8)  // = 595 output enable/disable pin
#define PIN_ENP_DISPLAY (PC7)  // enable LDO dc power for display board

// Set up DMA
DMA_HandleTypeDef hdma_spi3_tx;
DMA_HandleTypeDef hdma_spi3_rx;
SPI_HandleTypeDef hspi3;

static void MX_DMA_Init(void);
static void MX_SPI3_Init(void);

// DMA interrupt handler
void DMA1_Stream5_IRQHandler(void) {
    HAL_DMA_IRQHandler(&hdma_spi3_tx);
    // HAL_SPI_TxRxCpltCallback(&hspi3);
}

// DMA interrupt handler
void DMA1_Stream0_IRQHandler(void) {
    HAL_DMA_IRQHandler(&hdma_spi3_tx);
    // HAL_SPI_TxRxCpltCallback(&hspi3);
}


void setup() {
    uint8_t tx_buffer[] = {0, 0, 0, 0, 0, 0, 8};  // turn on only first led
    uint8_t rx_buffer[7];  // can be used to check previous transmitted data
    uint8_t zeros[] = {0, 0, 0, 0, 0, 0, 0};

    Serial.begin(115200);

    pinMode(LED_BUILTIN, OUTPUT);

    digitalWrite(PIN_ENP_DISPLAY, HIGH);
    pinMode(PIN_ENP_DISPLAY, OUTPUT);

    digitalWrite(PIN_SSEL_DISPLAY, LOW); 
    pinMode(PIN_SSEL_DISPLAY, OUTPUT);

    digitalWrite(PIN_OE_DISPLAY, HIGH); 
    pinMode(PIN_OE_DISPLAY, OUTPUT);
    delay(100); // wait the power-up.

    MX_DMA_Init();   // first, DMA init
    MX_SPI3_Init();  // then SPI

    // link the dma with the spi
    __HAL_LINKDMA(&hspi3, hdmatx, hdma_spi3_tx);
    __HAL_LINKDMA(&hspi3, hdmarx, hdma_spi3_rx);

    __HAL_DMA_ENABLE_IT(&hdma_spi3_tx, DMA_IT_TC);

    // do not work
    // HAL_DMA_Start(&hdma_spi3_tx, (uint32_t)tx_buffer,
    // (uint32_t)&(hspi3.Instance->DR), sizeof(tx_buffer));
    /** !!! crash of the code at this point !!!
     */
    if (HAL_SPI_Transmit_DMA(&hspi3, (uint8_t*)tx_buffer, sizeof(tx_buffer)) != HAL_OK) {
        TRACE();
    }

    /** this section works using classic SPI
     */
    // HAL_SPI_Transmit(&hspi3, tx_buffer, sizeof(tx_buffer), HAL_MAX_DELAY);
    // digitalWrite(PIN_SSEL_DISPLAY, HIGH);
    // digitalWrite(PIN_SSEL_DISPLAY, LOW);
    // digitalWrite(PIN_OE_DISPLAY, LOW);

    TRACE();
    Serial.flush();
}

void loop() {
    // check if no crash
    digitalToggle(LED_BUILTIN);
    delay(500);
}

static void MX_DMA_Init(void) {
    __HAL_RCC_DMA1_CLK_ENABLE(); // clock shall be enable first

    /* Configure DMA request on DMA1_Stream5 and 0 */
    hdma_spi3_tx.Instance = DMA1_Stream5;
    hdma_spi3_tx.Init.Channel = DMA_CHANNEL_0;
    hdma_spi3_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_spi3_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi3_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi3_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi3_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi3_tx.Init.Mode = DMA_NORMAL;
    hdma_spi3_tx.Init.Priority = DMA_PRIORITY_HIGH;
    hdma_spi3_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    hdma_spi3_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    hdma_spi3_tx.Init.MemBurst = DMA_MBURST_SINGLE;
    hdma_spi3_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_Init(&hdma_spi3_tx) != HAL_OK) {
        Error_Handler();
    }

    hdma_spi3_rx.Instance = DMA1_Stream0;
    hdma_spi3_rx.Init.Channel = DMA_CHANNEL_0;
    hdma_spi3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_spi3_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi3_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi3_rx.Init.Mode = DMA_NORMAL;
    hdma_spi3_rx.Init.Priority = DMA_PRIORITY_HIGH;
    hdma_spi3_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    hdma_spi3_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    hdma_spi3_tx.Init.MemBurst = DMA_MBURST_SINGLE;
    hdma_spi3_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_Init(&hdma_spi3_rx) != HAL_OK) {
        Error_Handler();
    }

    /* DMA interrupt init */
    /* DMA1_Stream{5,0}_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
    HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
}

void MX_SPI3_Init(void) {
    __HAL_RCC_SPI3_CLK_ENABLE();

    hspi3.Instance = SPI3;
    hspi3.Init.Mode = SPI_MODE_MASTER;
    hspi3.Init.Direction = SPI_DIRECTION_2LINES;
    hspi3.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi3.Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi3.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi3.Init.NSS = SPI_NSS_SOFT;
    hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
    hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi3.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi3.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi3.Init.CRCPolynomial = 7;
    if (HAL_SPI_Init(&hspi3) != HAL_OK) {
        Error_Handler();
    }

    /* Configure GPIO pins for SPI3 (PC10, PC11, PC12) */
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef* hspi) {
    // after RX/TX completion, latch the shiftregisters
    digitalWrite(PIN_SSEL_DISPLAY, HIGH); // latch signal after data transmitted
    digitalWrite(PIN_SSEL_DISPLAY, LOW);
    digitalWrite(PIN_OE_DISPLAY, LOW);  // = output enable
}

---

EDIT1:
Thanks @fpistm, the crash can be fixed by modifying the handlers :

// DMA interrupt handler
extern "C" void DMA1_Stream5_IRQHandler(void) {
    HAL_DMA_IRQHandler(&hdma_spi3_tx);
    // HAL_SPI_TxRxCpltCallback(&hspi3);
}

// DMA interrupt handler
extern "C" void DMA1_Stream0_IRQHandler(void) {
    HAL_DMA_IRQHandler(&hdma_spi3_tx);
    // HAL_SPI_TxRxCpltCallback(&hspi3);
}

However, the code still not send data ... But, I can see that the TRACE after the HAL_SPI_Transmit_DMA is not printed, so it returns HAL_OK.
If I modify HAL_SPI_TxRxCpltCallback to HAL_SPI_TxCpltCallback, I can see that the callback is called now, but the data are garbage.

[fpistm]

Hi @raphaelvalentin ,
Add extern "C" before each handler. Ex:

extern "C" void DMA1_Stream5_IRQHandler(void)

[raphaelvalentin]

That's a large improvement.
No crash but still no data transfer...
Thanks a lot and sorry for the Sunday. ;)

[fpistm]

Here example of how using dma. https://www.stm32duino.com/viewtopic.php?t=110
Hope that help.

[raphaelvalentin]

I am having a look. DMA is something great on paper but its implementation is pretty complex until we understand pretty well each of the detail. If i have some improvements, I will add my next comments on the discussion (it may help someone else)