STM32 DMA mit SPI funktioniert nicht

[Leon L. (leonelf)]

Ich versuche gerade SPI mit DMA zum laufen zu bringen. Der 
DMA2_IRQHandler wird zwar aufgerufen, es ist aber nie ein "DMA_IT_TC". 
Die Base Adress im Register wird auch nicht inkrementiert, obwohl ich es 
auf DMA_MemoryInc_Enable gestellt habe.

Hiermit initialisiere ich DMA:

void initDMA(){
  RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;

  DMA_InitTypeDef dmaInitStruct;
  dmaInitStruct.DMA_Channel = DMA_Channel_3;
  dmaInitStruct.DMA_Memory0BaseAddr = (uint32_t) tlcValues;
  dmaInitStruct.DMA_PeripheralBaseAddr = (uint32_t) &(SPI1->DR);
  dmaInitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  dmaInitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  dmaInitStruct.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  dmaInitStruct.DMA_Mode = DMA_Mode_Normal;
  dmaInitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
  dmaInitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  dmaInitStruct.DMA_BufferSize = 288; //192*12bit
  dmaInitStruct.DMA_Priority = DMA_Priority_High;
  dmaInitStruct.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  dmaInitStruct.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  dmaInitStruct.DMA_FIFOMode = DMA_FIFOMode_Disable;

  DMA_Init(DMA2_Stream3, &dmaInitStruct);
  DMA_Cmd(DMA2_Stream3, ENABLE);

  SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);


    NVIC_InitTypeDef nvicInitStruct;
    nvicInitStruct.NVIC_IRQChannel = DMA2_Stream3_IRQn;
    nvicInitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    nvicInitStruct.NVIC_IRQChannelSubPriority = 0;
    nvicInitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&nvicInitStruct);

  DMA_ITConfig(DMA2_Stream3, DMA_IT_TC, ENABLE);
}

Und hiermit SPI1:

void initSPI(){
  RCC->APB2ENR |= RCC_APB2Periph_SPI1;

  SPI_InitTypeDef spiInitStruct;
  spiInitStruct.SPI_Direction = SPI_Direction_1Line_Tx;
  spiInitStruct.SPI_Mode = SPI_Mode_Master;
  spiInitStruct.SPI_DataSize = SPI_DataSize_8b;
  spiInitStruct.SPI_CPOL = SPI_CPOL_Low;
  spiInitStruct.SPI_CPHA = SPI_CPHA_1Edge;
  spiInitStruct.SPI_NSS = SPI_NSS_Soft;
  spiInitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
  spiInitStruct.SPI_FirstBit = SPI_FirstBit_MSB;

  SPI_Init(SPI1, &spiInitStruct);
  SPI_Cmd(SPI1, ENABLE);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);

  SPI_Init(SPI2, &spiInitStruct);

  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_SPI2);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_SPI2);
  SPI_Cmd(SPI2, ENABLE);
}

Das hier ist der Interrupt:

void DMA2_Stream3_IRQHandler(){
  if(DMA_GetFlagStatus(DMA2_Stream3, DMA_IT_TC)){
    DMA_ClearITPendingBit(DMA2_Stream3, DMA_IT_TC);
    printf("LOL");
  }
}

Aufgerufen wird er, der breakpoint am if wird aufgerufen. Aber zum 
Clearflag und zum printf kommt es nie.
Aus SPI1 kommen auch keine Daten, das Oszilloskop zeigt nur das Rauschen 
an (0V+-20mV), das auf GND liegt.

Das GPIO ist richtig konfiguriert, da das SPI selbst funktioniert, wenn 
ich es manuell ansteuere. Genutzt wird das STM32F4-Discovery Board

[Little B. (lil-b)]

Um das Verhalten des Controllers nachzuvollziehen, wäre es schön zu 
wissen, warum die ISR aufgerufen wird.

Ein Transfer Complete Interrupt ist wohl nicht die Ursache. Welches Flag 
ist denn gesetzt?

Leon Loeser schrieb:
> dmaInitStruct.DMA_BufferSize = 288; //192*12bit

das sieht ungewöhnlich aus! sollte aber nicht die fehlerquelle sein.
wie sind denn deine Daten im Speicher abgelegt? nicht im 16-bit Raster?

Leon Loeser schrieb:
> nvicInitStruct.NVIC_IRQChannelPreemptionPriority = 0;
>     nvicInitStruct.NVIC_IRQChannelSubPriority = 0;

Es ist auch ungewöhnlich, dem DMA die höchste Priorität zu geben. Sollte 
geändert werden, muss aber auch nicht die Fehlerquelle sein

[brt (Gast)]

Hallo,

versuch doch mal mit geringerer SPI-Geschwindigkeit. Hatte gerade ein 
ähnliches Problem, was ich auch noch nicht genauer eruiert habe. Aber ab 
und zu wurde der IRQ nicht mehr aufgerufen, die DMA "hatte sich 
aufgehängt".
Seitdem ich die SPI-Baudrate verringert habe funktioniert es fehlerfrei.
Nur mal so zu Eingrenzen des Problems...

Grüße, Brt

[Torsten C. (torsten_c)]

Sorry, ich blicke es spontan nicht. Vielleicht hilft der Hinweis:

> Der RX Interrupt wird ausgelöst, sobald das letzte Byte empfangen
> wurde, der gesamte SPI Transfer also abgeschlossen ist. Jetzt kann
> die Chip Select Leitung wieder auf high gelegt werden. TX sollte in
> keinem Fall für diesen Zweck genutzt werden, weil dieser zu früh
> mit der Arbeit fertig ist.

http://www.diller-technologies.de/stm32.html

Sorry, falls ich daneben liege.

[Leon Loeser (Gast)]

Ich übertrage it DMA in diesem Fall. Das Datenformat wären 8bit (byte, 
siehe DMA config)

[Herbschi (Gast)]

Hier ein paar nützliche Link, die weiterhelfen könnten:

http://electronics.stackexchange.com/questions/100685/full-duplex-slave-spi-dma-and-interrupts-on-stm32f103
http://www.eevblog.com/forum/microcontrollers/stm32-spi-with-dma/
http://www.micromouseonline.com/2012/03/11/adding-dma-to-the-spi-driver-with-the-stm32f4/

Und ja, die eingestellte Buffer Size ist falsch. DMA kann nicht die 
Bits im Speicher zusammenschieben oder auseinanderziehen. Umformatieren 
über DMA geht nur zwischen Byte, 16-Bit-Halbwort oder 32-Bit-Wort.

LG Herbert

[Leon L. (leonelf)]

das mit den 12 byte ist anders gemeint. im speicher liegen 288 bit rum. 
die sind für den TLC 5941, es sind also 12*24 bit. Das wären 36 byte, 
aber es sind 8 tlcs, also 288 byte. Habe das wohl etwas missverständlich 
kommuniziert^^
Es liegt aber im zusammengeschobenen format im Speicher vor^^

[Dieter Graef (Gast)]

Ich würde vor der Initialisierung die DMA Register in einen definierten 
Zustand bringen z.B. mit

DMA_ClearFlag(DMA2_Stream3, DMA_FLAG_FEIF3 | DMA_FLAG_DMEIF3 | 
DMA_FLAG_TEIF3 | DMA_FLAG_HTIF3 | DMA_FLAG_TCIF3);

  /* Disable DMA2 Stream3 */
  DMA_Cmd(DMA2_Stream3, DISABLE);

  /* Deinit DMA2 Stream3 */
  DMA_DeInit(DMA2_Stream3);

 und dann zwischen init und cmd noch die transfer complete Unterbrechung 
sowie die flow control freischalten z.B. mit

DMA_ITConfig(DMA2_Stream3, DMA_IT_TC, ENABLE);
DMA_FlowControllerConfig(DMA2_Stream3, DMA_FlowCtrl_Peripheral);

[Leon L. (leonelf)]

Ich habe jetzt mal das deInit und flowcontrol eingefügt. Aktuell zeigt 
er mir im statusregister während dem interrupt an, dass Transfer 
Complete, Half Complete und FiFo-Error auf 1 gesetzt sind.

[Little B. (lil-b)]

Interessant, dass das FIFO Error Flag gesetzt ist, obwohl du den FIFO 
ausgeschaltet hast...

Leon Loeser schrieb:
> DMA_Cmd(DMA2_Stream3, ENABLE);

setze das mal ganz ans ende, nachdem tatsächlich ALLES initialisiert 
ist.
Dies startet nämlich die DMA übertragung.

Momentan startest du die Übertragung zu einem Zeitpunkt, an dem der 
SPI_DMA_Request noch nicht aktiviert ist. KANN probleme machen, MUSS 
aber nicht.

Ich erwarte natürlich, dass du zuerst den SPI initialisierst, dann den 
DMA.

Leon Loeser schrieb:
> dmaInitStruct.DMA_Memory0BaseAddr = (uint32_t) tlcValues;

Ich gehe hier davon aus, dass tlcValues ein Array oder Pointer ist.

Zusätzlich kannst du noch Probieren, dmaInitStruct.DMA_FIFOThreshold auf 
einen definierten Wert zu setzen. Sollte für die Hardware kein 
Unterschied machen, da der FIFO ja deaktiviert ist, aber vieleicht zickt 
die Init-Routine dabei rum, und du merkst es nicht.
Siehe

assert_param(IS_DMA_FIFO_THRESHOLD(DMA_InitStruct->DMA_FIFOThreshold));

in der Init Routine des DMA. Dann wäre dein DMA nicht initialisiert.

Ich habe auch schon viel über den DMA geflucht, der Fehler liegt meist 
im Detail. Vieleicht helfen dir diese Ideen.

~Lil B

[Leon L. (leonelf)]

Ok, habe es jetzt zum laufen gebracht. (Um genau zu sein, heute morgen 
um halb drei).

initDMA() sieht jetzt so aus:

void initDMA(){
  RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;

  DMA_Cmd(DMA2_Stream3, DISABLE);
  DMA_DeInit(DMA2_Stream3);

  dmaInitStruct.DMA_Channel = DMA_Channel_3;
  dmaInitStruct.DMA_Memory0BaseAddr = (uint32_t) tlcValues;
  dmaInitStruct.DMA_PeripheralBaseAddr = (uint32_t) &(SPI1->DR);
  dmaInitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  dmaInitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  dmaInitStruct.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  dmaInitStruct.DMA_Mode = DMA_Mode_Normal;
  dmaInitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
  dmaInitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  dmaInitStruct.DMA_BufferSize = 288; //192*12bit
  dmaInitStruct.DMA_Priority = DMA_Priority_High;
  dmaInitStruct.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  dmaInitStruct.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  dmaInitStruct.DMA_FIFOMode = DMA_FIFOMode_Disable;

  DMA_Init(DMA2_Stream3, &dmaInitStruct);

  DMA_SetCurrDataCounter(DMA2_Stream3, 288);

  NVIC_InitTypeDef nvicInitStruct;
  nvicInitStruct.NVIC_IRQChannel = DMA2_Stream3_IRQn;
  nvicInitStruct.NVIC_IRQChannelPreemptionPriority = 1;
  nvicInitStruct.NVIC_IRQChannelSubPriority = 0;
  nvicInitStruct.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&nvicInitStruct);

  DMA_ITConfig(DMA2_Stream3, DMA_IT_TC, ENABLE);

  DMA_Cmd(DMA2_Stream3, ENABLE);
}

Es wahr wohl wirklich die reihenfolge der Aufrufe.

der IRQHandler sieht dann so aus:

void DMA2_Stream3_IRQHandler(){
  if(DMA_GetFlagStatus(DMA2_Stream3, DMA_IT_TCIF3)){
  DMA_Cmd(DMA2_Stream3, DISABLE);
  DMA_SetCurrDataCounter(DMA2_Stream3, 288);
  DMA_ClearFlag(DMA2_Stream3, DMA_IT_TCIF3);
  DMA_Cmd(DMA2_Stream3, ENABLE);
    DMA_ClearITPendingBit(DMA2_Stream3, DMA_IT_TC);
  }
}

Ich glaube da habe ich die ganze Zeit die Flags und IT Bits verwechselt.
Der Interrupt startet momentan nur die Übertragung neu (proof of 
concept). Das wird dann bald mit einem Timer verbunden. Gedacht ist es, 
um TLC5941 mit daten für nen RGB LED Cube zu füllen^^

Eine Frage hätte ich noch:

All diese Utility Funktionen haben dieses assert_param(...) in sich. Ist 
das für den Compiler? oder wird das während dem Programmablauf 
aufgerufen? Ich frage, da ich auch direkte Registermanipulation nutzen 
würde, falls das schneller ist...

Achja: Ist es möglich, die MemoryAdress zu ändern, ohne das ganze 
initStruct zu nutzen? also einfach ins register schreiben oder so?

[Torsten C. (torsten_c)]

Leon Loeser schrieb:
> All diese Utility Funktionen haben dieses assert_param(...) in sich. Ist
> das für den Compiler?

Nein.

> oder wird das während dem Programmablauf
> aufgerufen?

Ja.

> Ich frage, da ich auch direkte Registermanipulation nutzen
> würde, falls das schneller ist...

Das ginge schneller.

> Achja: Ist es möglich, die MemoryAdress zu ändern, ohne das ganze
> initStruct zu nutzen? also einfach ins register schreiben oder so?

Ja, aber vorher den DMA stoppen und anschließend wieder starten.

[Leon L. (leonelf)]

danke!