SPI Kommunikation zwei STM32 mit DMA

[Willem B. (mr_willem)]

Hi Leute,

ich habe eine Frage bezüglich der Kommunikation zweier STM32 mit DMA 
SPI.

Ich möchte mittels SPI 7 16 Bit variablen von Slave zu Master und 
dementsprechend umgekehrt schicken.
Hardwaremäßig habe ich
Ich habe MOSI mit MOSI, CLK mit CLK, NSS mit NSS und MISO mit MISO 
verbunden (PORT A4 bis A7).
In meiner Software habe ich für den SPI1 den DMA Channel 2 als RX und 
den DMA Channel 3 als TX Buffer definiert.

Der Aufbau der Software besteht aus einem endlosen loop der u.a. abfragt 
ob der SPI Bus frei ist (Ich setzte beim senden der Daten vom Master 
eine Variable auf 0 und setze sie in der ISR des RX DMA Kanals wieder 
auf 1) Daher sollten niemals zwei Transfers gleichzeitig stattfinden.

Ich habe für den Transfer drei Puffer definiert, einen RX Puffer und 
einen TX Puffer und einen Puffer mit dem das Programm arbeitet.

In der ISR (void spi_handleDMA1Ch2Interrupt(void), s.u.)des RX DMA warte 
ich bis der Transfer komplett ist, schalte den DMA Kanal ab, kopiere den 
Inhalt des RX Puffers in den Programm Puffer.
Dann setze ich noch das FLAG für den SPI Bus auf 1.

Der DMA wird dann aus dem Programmcode neu gestartet sobald Daten 
gesendet werden sollen (void SPI2_send(void), s.u.)

Auf Slave Seite ist der Code ähnlich, bis auf das natürlich nicht die 
NSS Leitung gezogen wird und der DMA unmittelbar nach dem Austausch der 
Puffer gestartet wird, damit auch Daten anliegen wenn der Master erneut 
eine Transaktion einleitet.

Mein Problem ist nun das folgende.
Es werden anscheinend Daten übermittelt, ich übertrage mit den Daten 
immer noch eine vier bittige Message Nummer von 0 bis 14, 15 ist für den 
Start des Programmes reserviert, damit ich im RX auch sehe auf welche 
anfrage der Slave antwortet.
Diese übertrage ich im letzten byte also in Puffer[6]
Der Master sendet erst eine neue Nachricht insofern er als Bestätigung 
eine Antwort mit der gleichen ID empfangen hat, sonst sendet er die 
vorherige Nachricht noch einmal.
Nach dem übertragen finde ich die Zahl manchmal in Puffer[4], manchmal 
in Puffer[5] und so weiter. Es scheint als ob sie immer eine Stelle 
weiter im Array shiftet.
Zudem habe ich das Programm gerade testweise so geschrieben, das in den 
ersten drei übertragenen Wörtern der gleiche Wert stehen soll.
Steht aber meistens nur in den ersten beiden oder im ersten.

Meine Frage daher,
Kann es sein, das es den SPI stört wenn man mit einem Debugger 
gleichzeitig im Programm unterwegs ist?

Ich nutze den JLink im SWD Modus mit eclipse IDE und gdb.
Die Breakpoints habe ich auch schon nur ausserhalb der ISR gesetzt.

Ist meine überlegung das ein RX und ein TX Puffer benutzt wird falsch, 
ich habe auch schon Code Beispiele mit nur einem Puffer gesehen.

Hat jemand eine Idee woran so ein verhalten liegen kann?? ich habe den 
Clock Prescaler auch schon auf 256 gesetzt damit die Kommunikation etwas 
verlangsamt wird.

Vielen Dank,
Willem

void spi_handleDMA1Ch2Interrupt(void){
   uint8_t i;
   //Test on DMA1 Channel2 Transfer Complete interrupt
   if(DMA_GetITStatus(DMA1_IT_TC2)) 
   {
      //Clear DMA1 Channel1 Half Transfer, Transfer Complete and Global interrupt pending bits
      DMA_ClearITPendingBit(DMA1_IT_GL2);
      while (DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET) {}
      // wait for tx to complete - page 692
      while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) {}
      while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET) {}
      DMA_ClearFlag(DMA1_FLAG_GL3); // Clear the global flag

      // Disable DMA
      DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, DISABLE);
      SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx |  SPI_I2S_DMAReq_Tx, DISABLE);
      DMA_Cmd(DMA1_Channel2, DISABLE);
      DMA_Cmd(DMA1_Channel3, DISABLE);
      // wait until DMA is actually off
      while (DMA1_Channel2->CCR & DMA_CCR2_EN); 
      while (DMA1_Channel3->CCR & DMA_CCR3_EN);
#ifdef SPI2_MASTER      
      // Set NSS High
      GPIO_WriteBit(GPIOA, GPIO_Pin_4, SET);
#endif
      // Copy RX buffer
      for(i=0;i<7;i++)
      {
#ifdef SPI2_SLAVE
         SPI2Buffer[i]=SPI2CommandBuffer[i];
#endif
         SPI2CommandBuffer[i]=SPI2RecBuffer[i];
      }
#ifdef SPI2_MASTER
      // Set the SPI Bus free
      SPI2_FREE=1;
#endif
#ifdef SPI2_SLAVE
   // Set the number of transfers
   DMA_SetCurrDataCounter(DMA1_Channel2, 7);           
   DMA_SetCurrDataCounter(DMA1_Channel3, 7);
   DMA_ClearITPendingBit(DMA1_IT_GL2);     // clear again
   DMA_ClearFlag(DMA1_FLAG_GL3);           // Clear the global flag

   // Start DMA controller again
   DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);
   SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, ENABLE);
   
   // Initiate Transfer
   DMA_Cmd(DMA1_Channel2, ENABLE);
   DMA_Cmd(DMA1_Channel3, ENABLE);
#endif
   }
} 

void SPI2_send(void)
{
   uint8_t i;
   // Lock SPI Bus
   SPI2_FREE=0;
   // Write Commands into TX Buffer
   for(i=0; i<7; i++)
   {
      SPI2Buffer[i]=CommandBuffer[i];
   }
   // Set the number of transfers
   DMA_SetCurrDataCounter(DMA1_Channel2, 7);           
   DMA_SetCurrDataCounter(DMA1_Channel3, 7);
   DMA_ClearITPendingBit(DMA1_IT_GL2);     // clear again
   DMA_ClearFlag(DMA1_FLAG_GL3);           // Clear the global flag

   // Start DMA controller again
   DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);
   SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, ENABLE);
   
   // Pull NSS Low
   GPIO_WriteBit(GPIOA, GPIO_Pin_4, RESET);
   // Initiate Transfer
   DMA_Cmd(DMA1_Channel2, ENABLE);
   DMA_Cmd(DMA1_Channel3, ENABLE);
}

[Willem B. (mr_willem)]

Nun habe ich es raus.
Es war am Ende ein übersehenes Puffer Problem.
Man sollte halt immer aufpassen ob die Pufferzugriffe auch nicht von 
zwei Stellen der Software erfolgen können.
Generell funktioniert der oben gezeigte Code ganz gut.

[newbies (Gast)]

eine Frage von Anfänger:

was bedeutet NSS eigentlich.
SS = Slave Select
N = ?
Negativ bzw. NOT ? oder andere Bedeutung.

[Mike R. (thesealion)]

Willem B. schrieb:
> Ich habe MOSI mit MOSI, CLK mit CLK, NSS mit NSS und MISO mit MISO
> verbunden (PORT A4 bis A7).

Ich denke mal hier meinst du MISO mit MOSI und MOSI mit MISO, oder?


newbies schrieb:
> was bedeutet NSS eigentlich.
> SS = Slave Select
> N = ?
> Negativ bzw. NOT ? oder andere Bedeutung.

Mit NOT SLAVE SELECT kommst du schon sehr gut hin. (die Leitung is low 
aktiv, daher not)