STM32H743ZI - SPI DMA HAL Interrupt Probleme

[Dabidududuu (Gast)]

Ich hab leider erneut Probleme bei der Peripherie-Konfiguration des 
STM32H7. Diesmal ist ist es SPI DMA welches nicht funktioniert.
Ich versuche gesteuert von einem Falling-Edge Interrupt eines GPIOs 
einen SPI DMA Transmit/Receive auszulösen.

Dazu meine GPIO-Konfiguration:

  __HAL_RCC_GPIOD_CLK_ENABLE();

  GPIO_InitTypeDef drdy_typedef;
  drdy_typedef.Pin = GPIO_PIN_15;
  drdy_typedef.Mode = GPIO_MODE_IT_FALLING;
  drdy_typedef.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOD, &drdy_typedef);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

mit Interrupt:

  void EXTI15_10_IRQHandler(void) {
    // trigger

    HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_0);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
  }

Meine SPI-Konfiguration:

  spi_handle.Instance = SPI1;
  spi_handle.Init.Mode = SPI_MODE_MASTER;
  spi_handle.Init.Direction = SPI_DIRECTION_2LINES;
  spi_handle.Init.DataSize = SPI_DATASIZE_8BIT;
  spi_handle.Init.CLKPolarity = SPI_POLARITY_LOW;
  spi_handle.Init.CLKPhase = SPI_PHASE_2EDGE;
  spi_handle.Init.NSS = SPI_NSS_SOFT;
  spi_handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
  spi_handle.Init.FirstBit = SPI_FIRSTBIT_MSB;
  spi_handle.Init.TIMode = SPI_TIMODE_DISABLE;
  spi_handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  spi_handle.Init.CRCPolynomial = 0x00;
  spi_handle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  spi_handle.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  spi_handle.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  spi_handle.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  spi_handle.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  spi_handle.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  spi_handle.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  spi_handle.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  spi_handle.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
  spi_handle.Init.IOSwap = SPI_IO_SWAP_DISABLE;

  const HAL_StatusTypeDef ret = HAL_SPI_Init(&spi_handle);
  if(ret != HAL_OK) {
    std::cout << "[Error] HAL_SPI_Init failed!\r\n";
    exit(-1);
  }


  HAL_NVIC_SetPriority(SPI1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(SPI1_IRQn);

und SPI DMA:

    HAL_DMA_MuxSyncConfigTypeDef pSyncConfig;

    __HAL_RCC_DMA1_CLK_ENABLE();

    hdma_spi1_rx.Instance = DMA1_Stream0;
    hdma_spi1_rx.Init.Request = DMA_REQUEST_SPI1_RX;
    hdma_spi1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_spi1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi1_rx.Init.Mode = DMA_NORMAL;
    hdma_spi1_rx.Init.Priority = DMA_PRIORITY_LOW;
    hdma_spi1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_spi1_rx) != HAL_OK)
    {
      Error_Handler();
    }

    pSyncConfig.SyncSignalID = HAL_DMAMUX1_SYNC_EXTI0;
    pSyncConfig.SyncPolarity = HAL_DMAMUX_SYNC_NO_EVENT;
    pSyncConfig.SyncEnable = DISABLE;
    pSyncConfig.EventEnable = ENABLE;
    pSyncConfig.RequestNumber = 1;
    if (HAL_DMAEx_ConfigMuxSync(&hdma_spi1_rx, &pSyncConfig) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(&spi_handle,hdmarx,hdma_spi1_rx);

    /* SPI1_TX Init */
    hdma_spi1_tx.Instance = DMA1_Stream1;
    hdma_spi1_tx.Init.Request = DMA_REQUEST_SPI1_TX;
    hdma_spi1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_spi1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi1_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi1_tx.Init.Mode = DMA_NORMAL;
    hdma_spi1_tx.Init.Priority = DMA_PRIORITY_LOW;
    hdma_spi1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_spi1_tx) != HAL_OK)
    {
      Error_Handler();
    }

    pSyncConfig.SyncSignalID = HAL_DMAMUX1_SYNC_EXTI0;
    pSyncConfig.SyncPolarity = HAL_DMAMUX_SYNC_NO_EVENT;
    pSyncConfig.SyncEnable = DISABLE;
    pSyncConfig.EventEnable = ENABLE;
    pSyncConfig.RequestNumber = 1;
    if (HAL_DMAEx_ConfigMuxSync(&hdma_spi1_tx, &pSyncConfig) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(&spi_handle,hdmatx,hdma_spi1_tx);

    /* DMA interrupt init */
    /* DMA1_Stream0_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
    /* DMA1_Stream1_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
    /* DMAMUX1_OVR_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMAMUX1_OVR_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMAMUX1_OVR_IRQn);

Was passiert:
- EXTI15_10_IRQHandler (GPIO-Interrupt) feuert, ich starte die 
Übertragung mit:

    SCB_CleanDCache_by_Addr(reinterpret_cast<uint32_t*>(((uint32_t)spiTxBuffer) & ~uint32_t(0x1F)), sizeof(spiTxBuffer) + 32);
    SCB_InvalidateDCache_by_Addr((uint32_t*)(((uint32_t)spiRxBuffer) & ~(uint32_t)0x1F), sizeof(spiRxBuffer) + 32);
    const auto ret = HAL_SPI_TransmitReceive_DMA(this->spi_handle, spiTxBuffer, spiRxBuffer, BytesPerTimerInterval);

    if(ret != HAL_OK) {
      std::cout << "HAL_SPI_TransmitReceive failed: " << (int)ret << "\r\n";
    }

(Übertragung liefert "HAL_OK")

- DMA1_Stream0_IRQHandler und DMA1_Stream1_IRQHandler feuern:

  void DMAMUX1_OVR_IRQHandler(void) {
    HAL_DMAEx_MUX_IRQHandler(&hdma_spi1_rx);
    HAL_DMAEx_MUX_IRQHandler(&hdma_spi1_tx);
  }
  void DMA1_Stream0_IRQHandler(void) {
    std::cout << "DMA1 Stream 0 (RX)\r\n";
    HAL_DMA_IRQHandler(&hdma_spi1_rx);
  }
  void DMA1_Stream1_IRQHandler(void) {
    std::cout << "DMA1 Stream 0 (TX)\r\n";
    // Handle Interrupt
    HAL_DMA_IRQHandler(&hdma_spi1_tx);
  }

- ich überprüfe das Ergebnis:

  std::cout << "FIRST 4 STATUS BITS: [";
  std::cout << (int)( spiRxBuffer[0] >> 4 ) << "]\r\n";

Ergebnis ist 0 (sollte es eigentlich nicht sein) und hab hier wird nie 
wieder ein EXTI15_10_IRQHandler (GPIO) gefeuert, sobald ich das 
DMA_Transmit weglasse feuert er wieder ständig (mit Oszi gemessen liegt 
auch ein entsprechendes Signal an).

Warum ich das mit dem Cache gemacht hab:
https://community.st.com/s/article/FAQ-DMA-is-not-working-on-STM32H7-devices

Konkret hab ich die Buffer so global definiert:

__attribute__((section(".dma_buffer"))) __attribute__ ((aligned (32))) uint8_t spiTxBuffer[BytesPerInterval];
__attribute__((section(".dma_buffer"))) __attribute__ ((aligned (32))) uint8_t spiRxBuffer[BytesPerInterval];

Weiterhin hab ich mit dem Oszi festgestellt, dass kein SPI-Transmit 
stattfindet (also SCLK immer auf low Pegel). Bei diesem Transmit sollen 
eigentlich keine Daten übertragen sondern nur empfangen werden (deswegen 
ist der spiTxBuffer-Inhalt auch auf 0 gesetzt), allerdings sehe ich auch 
keine Daten am MISO-Pin.

Hat jemand eine Idee? Vor allem das mit dem GPIO-Interrupt verwirrt 
mich.

P.S: Alle Interrupts sind diesmal in "extern "C"" definiert, daran 
sollte es also nicht liegen (und sie feuern ja auch)

[Simi (Gast)]

Hallo

Hatte letzthin auch Probleme mit dem DMA und ADC. Grund war ein HAL 
Fehler. Die Initialisierung war in der falschen Reihenfolge 
(MX_DMA_Init() und MX_XXX_Init()). Hab es gerade nicht zur Hand, kann 
nicht genau sagen wo es war...

Gruss

Simi

[Johannes S. (Gast)]

ich würde sagen der DMA IRQ wird nicht korrekt benutzt (mit HAL): da 
soll man nicht die ISR selber definieren, sondern einen Callback 
registrieren, z.B.

  HAL_DMA_RegisterCallback(&hdma_memtomem_dma2_stream0,
      HAL_DMA_XFER_CPLT_CB_ID, &dmaXFerComplete);

für einen transfer complete (half complete gäbe es auch noch).
Die ISR muss da ein bisschen mehr erledigen, z.B. andere IRQ Quellen 
quittieren.

Das Cache putzen ist nicht nötig wenn man den Buffer in das CCMRAM legt, 
der wird nicht gepuffert. Das putzen ist eine aufwändige Aktion die 
viele Zyklen kostet.

Und das cout scheint doch dein Freund zu sein, warum nicht ein good old 
printf? Die iostreams sind auf dem µC nicht optimiert und kosten doch 
locker +200 kB Code. Wobei auch ein printf nicht immer in einer ISR 
erlaubt ist, bei Verwendung eines RTOS bekommst du da Faults weil auch 
printf Speicherallokationen enthält.

edit:
bzw für SPI mit DMA gibt es sowas:

void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef * hspi)
{
    if (hspi == mySPI) {
       // do something
    }
}

[Dabidududuu (Gast)]

Johannes S. schrieb:
> Die ISR muss da ein bisschen mehr erledigen, z.B. andere IRQ Quellen
> quittieren.

Okay, ich probier es mal so. Kann gut sein, dass dann irgendwas mit dem 
GPIO Interrupt gemacht wird. Danke!

Johannes S. schrieb:
> Und das cout scheint doch dein Freund zu sein, warum nicht ein good old
> printf?

Bin halt in C++ unterwegs und hab da die __io_putchar Funktion 
umgeschrieben damit std::cout auf den UART printet.

Johannes S. schrieb:
> Die iostreams sind auf dem µC nicht optimiert und kosten doch
> locker +200 kB Code.

Am Ende kommt das cout / printf sowieso aus den Interrupts raus, das ist 
nur um auf der Konsole zu sehen ob es läuft. +/-200kByte Code sind bei 
dem H7 egal.

[Johannes S. (Gast)]

in den HAL .c Quellen ist am Anfang immer eine kurze Beschreibung welche 
Schritte z.B. für SPI mit DMA oder Interrupts nötig ist.
Einfacher ist mittlerweile den Code von CubeMX generieren zu lassen, da 
sind viele Feinheiten drin die in den kurzen Kommentaren des HAL 
Quellcodes nicht unbedingt drin stehen.
Und die iostreams, naja, das ist schon viel Holz und das Exception 
Handling zieht man sich da afaik auch mit rein. Für printf muss auch nur 
eine Funktion definiert werden, auch das erledigt CubeMX.
C++ nutze ich auch, und gleich ein OS mit C++ API: Mbed-OS. Das SPI 
läuft da zwar nicht mit DMA, aber für STM32 wird unter der Haube auch 
HAL verwendet und man es einfach in eigenen Klassen verwenden. Oder 
vorhandene um solche Features per Vererbung erweitern. Für die 
Interrupts kann man dann so nette Sachen wie CThunk verwenden um im 
Interrupt Methoden einer Instanz aufzurufen, damit kann man solche 
Sachen auch zur Laufzeit starten.
Und in den Interrupts kann ich dann eine Trace Funktion verwenden, das 
ist auch schneller als die Interruptbehandlung durch eine lahme 
Schnittstelle auszubremsen.