STM32: SPI - HAL durch eigenen code ersetzen

[Malte _. (malte)]

Hallo,
ich versuche gerade den HAL Code durch selbst geschriebenen zu ersetzen. 
Ziel ist hinterher DMA zu verwenden, was leider mit der HAL Lib nicht 
funktioniert.
Leider funktioniert aber das eigentlich recht einfache SPI ohne DMA 
schon nicht mit meinem eigenem Code. Und ich kann einfach keinen Fehler 
erkennen.
Die SPI Initialisierung ist in beiden Fällen gleich, und der unten 
auskommentierte HAL Code kommuniziert einwandfrei. Auch kann ich mir mit 
PerPrint die Register ausgeben lassen und auch diese sind gleich 
eingestellt.

Bei meinem eigenem Code mache ich folgende Beobachtung:
SPI_SR_TXE ist gesetzt, ich schicke also Daten hin. SPI_SR_RXNE hingegen 
wird nie gesetzt und "RX1\r\n" folglich nie ausgegeben. Auch ein am 
Ausgabepin angeschlossenes Oszi zeigt keine gesendeten Daten an.
Die Konfigurationsregister der SPI Schnittstelle initialisiere ich mit:

g_spi->CR1 = SPI_CR1_MSTR | SPI_CR1_SPE | SPI_BAUDRATEPRESCALER_64 | SPI_CR1_SSM | SPI_CR1_SSI;
g_spi->CR2 = SPI_CR2_DS_0 | SPI_CR2_DS_1 | SPI_CR2_DS_2| SPI_CR2_FRXTH; //8Bit, 8Bit RX threshold

Der Chip ist ein STM32L452.

SPI_TypeDef * g_spi = (SPI_TypeDef *)SPI2_BASE;

void PerPrint(void) {
  printf("CR1: %08x\r\n", (unsigned int)g_spi->CR1);
  printf("CR2: %08x\r\n", (unsigned int)g_spi->CR2);
  printf("SR : %08x\r\n", (unsigned int)g_spi->SR);
}

void PeripheralTransfer(const uint8_t * dataOut, uint8_t * dataIn, size_t len) {
#if 1
  printf("Data %u, %x %x\r\n", len, dataOut, dataIn);
  uint32_t timeStop = HAL_GetTick() + 100;
  uint32_t txLen = len;
  uint32_t rxLen = len;
  while ((HAL_GetTick() != timeStop) && ((txLen) || (rxLen))) {
    //PerPrint();
    if ((g_spi->SR & SPI_SR_TXE) && (txLen)) { //something to transmit
      //printf("Wr1\r\n");
      uint8_t data = 0;
      if (dataOut) {
        data = *dataOut;
        dataOut += sizeof(uint8_t);
      }
      *(__IO uint8_t *)g_spi->DR = data;
      txLen -= 1;
    }
    if (g_spi->SR & SPI_SR_RXNE) { //something to receive
      printf("RX1\r\n");
      uint8_t data = *(__IO uint8_t *)g_spi->DR;
      if ((dataIn) && (rxLen >= 1)) {
        *dataIn = data;
        dataIn += sizeof(uint8_t);
        rxLen -= 1;
      }
    }
  }
  //while (g_spi->SR & SPI_FLAG_BSY);
#else
  if ((dataIn) && (dataOut)) {
    HAL_SPI_TransmitReceive(&hspi2, (uint8_t*)dataOut, dataIn, len, 100);
  } else if (dataOut) {
    HAL_SPI_Transmit(&hspi2, (uint8_t*)dataOut, len, 100);
  } else if (dataIn) {
    HAL_SPI_Receive(&hspi2 ,dataIn, len, 100);
  }
#endif
}

PS: Keine Ahnung wo die ganzen Leerzeilen im Code herkommen. Im Beitrag 
Editieren Feld sind sie nicht da.

[Erwin (Gast)]

Warum sollte SPI mit DMA über die HAL nicht funktionieren?

[Kevin M. (arduinolover)]

Malte _. schrieb:
> Ziel ist hinterher DMA zu verwenden, was leider mit der HAL Lib nicht
> funktioniert.

Der funktioniert ziemlich sicher mit der HAL. Habe ich aktuell mit F2, 
F3, G4, F4, F7 und H7 in Benutzung.

Hast du alle benötigten Interrupts aktiviert?

[Malte _. (malte)]

Kevin M. schrieb:
> Der funktioniert ziemlich sicher mit der HAL. Habe ich aktuell mit F2,
> F3, G4, F4, F7 und H7 in Benutzung.

Mein Versuch endete in einer HAL Funktion, die einfach nicht zurück 
kehrte. Meine Initialisierung war wie folgt:

DMA_HandleTypeDef g_hdma_spi2_tx;
volatile bool g_lcdDmaDone;

void LcdDmaTransferComplete(SPI_HandleTypeDef *hspi) {
  printfNowait("D\r\n"); //safe from interrupt
  g_lcdDmaDone = true;
}

void LcdWaitDmaDone(void) {
  if (hspi2.State != HAL_SPI_STATE_READY) {
    while (!g_lcdDmaDone);
    g_lcdDmaDone = false;
  }
}

void LcdInit(void) {
  //Copied from the STM cube generator output:
  __HAL_RCC_DMA1_CLK_ENABLE();
  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
  g_hdma_spi2_tx.Instance = DMA1_Channel5;
  g_hdma_spi2_tx.Init.Request = DMA_REQUEST_1;
  g_hdma_spi2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
  g_hdma_spi2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
  g_hdma_spi2_tx.Init.MemInc = DMA_MINC_ENABLE;
  g_hdma_spi2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  g_hdma_spi2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  g_hdma_spi2_tx.Init.Mode = DMA_NORMAL;
  g_hdma_spi2_tx.Init.Priority = DMA_PRIORITY_LOW;
  if (HAL_DMA_Init(&g_hdma_spi2_tx) != HAL_OK) {
    printf("Error, failed to init DMA\r\n");
  }
  __HAL_LINKDMA(&hspi2,hdmatx,g_hdma_spi2_tx);
  HAL_SPI_RegisterCallback(&hspi2, HAL_SPI_TX_COMPLETE_CB_ID, &LcdDmaTransferComplete);
}

void LcdTransfer(const uint8_t * dataOut, size_t len) {
  LcdCsOn();
  LcdWaitDmaDone();
  if (len <= 4) {
    HAL_SPI_Transmit(&hspi2, (uint8_t*)dataOut, len, 100);
  } else {
    printf("A\r\n");
    HAL_SPI_Transmit_DMA(&hspi2, (uint8_t*)dataOut, len);
    printf("B\r\n");
  }
  LcdCsOff(); //TODO: Should be done after DMA is done
}

Die Meldung "A\r\n" kommt, die "B\r\n" hingegen nicht.

[PittyJ (Gast)]

Bei meinem H7 hat SPI mit DMA über die HAL wunderbar funktioniert. 
Gerade letzten Monat erst implementiert. Keine Probleme gehabt.

[Harry L. (mysth)]

Du hast das Prinzip der Callbacks in HAL nict verstanden!

Nachlesen kannst du das u.A. hier:
https://www.st.com/resource/en/user_manual/um1786-description-of-stm32f3-hal-and-lowlayer-drivers-stmicroelectronics.pdf

Ab Seite 476 wird SPI erklärt.

Ein Beispiel von mir, wo SPI mit DMA genutzt wird, gibts hier:
Beitrag "[STM32/HAL] Treiber für ST7735 160 x 80 TFT"

[Malte _. (malte)]

Harry L. schrieb:
> Du hast das Prinzip der Callbacks in HAL nict verstanden!
Ok, ich hab jetzt DMA am laufen :)
Das Callback funktioniert wie von mir erwartet, was hingegen fehlte war

void DMA1_Channel5_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel5_IRQn 0 */

  /* USER CODE END DMA1_Channel5_IRQn 0 */
  HAL_DMA_IRQHandler(&g_hdma_spi2_tx);
  /* USER CODE BEGIN DMA1_Channel5_IRQn 1 */

  /* USER CODE END DMA1_Channel5_IRQn 1 */
}

Den Code hatte ich beim Neugenerieren durch CubeMX übersehen, und so 
nicht ins eigene Projekt übernommen.

Es wäre zwecks Erkenntnisgewinn trotzdem schön zu wissen, was bei meinem 
eigenem SPI Code falsch ist.

[Harry L. (mysth)]

Malte _. schrieb:
> Den Code hatte ich beim Neugenerieren durch CubeMX übersehen, und so
> nicht ins eigene Projekt übernommen.

Verstehe ich nicht!
Der generierte Code wird doch autom. ins Projekt übernommen...

Nutzt du nicht die CubeIDE oder hast du bei den Einstellungen von CubeMX 
was zerrissen?
Wenn das alles korrekt wäre, würde da garantiert nichts fehlen nach dem 
Code generieren.

[Malte _. (malte)]

Harry L. schrieb:
> Verstehe ich nicht!
> Der generierte Code wird doch autom. ins Projekt übernommen...
>
> Nutzt du nicht die CubeIDE oder hast du bei den Einstellungen von CubeMX
> was zerrissen?
> Wenn das alles korrekt wäre, würde da garantiert nichts fehlen nach dem
> Code generieren.
Naja, aus meiner Sicht generiert CubeMX eher Samplecode. Man hat zwar in 
den Quelltexten Stellen um eigenen Code einzufügen, aber wie ich auch 
nur eine extra .c Datei oder zusätzliche Include Suchpfade im Cube 
hinzufüge habe ich nicht herausgefunden. Stattdessen wird das Makefile 
einfach immer überschrieben. Selbiges gilt für Anpassungen im 
Linkerskript. Also verwalte ich mein Projekt lieber in einem separatem 
Verzeichnis.

Ich hätte die Änderungen natürlich leicht bemerkt, wenn ich das 
Ausgabeverzeichnis des CubeMX mit GIT o.ä. getrackt hätte. Dann hätte 
ein git diff direkt alle relevanten CubeMX Änderungen aufgelistet.

[Harry L. (mysth)]

Malte _. schrieb:
> Naja, aus meiner Sicht generiert CubeMX eher Samplecode. Man hat zwar in
> den Quelltexten Stellen um eigenen Code einzufügen, aber wie ich auch
> nur eine extra .c Datei oder zusätzliche Include Suchpfade im Cube
> hinzufüge habe ich nicht herausgefunden. Stattdessen wird das Makefile
> einfach immer überschrieben. Selbiges gilt für Anpassungen im
> Linkerskript. Also verwalte ich mein Projekt lieber in einem separatem
> Verzeichnis.

Vollkommen falsche Vorgehensweise!
Einfach in der IDE im Project-Explorer eine neue C-Datei erzeugen und 
fertig.
Alle C-Files in deinem Projekt werden autom. verwendet.
Um das makefile musst du dich überhaupt nicht kümmern.

Und nein!
CubeMX erzeugt keinen "Sample-Code" sondern alles, was du brauchst.

Du solltest dich erstmal mit dem Umgang mit CubeIDE beschäftigen!

[STK500-Besitzer (Gast)]

Harry L. schrieb:
> Einfach in der IDE im Project-Explorer eine neue C-Datei erzeugen und
> fertig.

Und selbst da kann man einen Zielordner angeben.

[Harry L. (mysth)]

STK500-Besitzer schrieb:
> Harry L. schrieb:
>> Einfach in der IDE im Project-Explorer eine neue C-Datei erzeugen und
>> fertig.
>
> Und selbst da kann man einen Zielordner angeben.

Ja natürlich!

Muß man sogar.
Re-Klick auf den gewünschten Ordner -> New -> Source-File