Hilfestellung: STM32 - SPI - TX/RX-DMA

[Leonhardt (Gast)]

Hallo,

ich verwende auf dem STM32F207 das SPI Interface mit DMA. Das Senden von 
SPI Frames ohne DMA funktioniert.
Die Daten werden auch korrekt über den RX DMA empfangen. Nun möchte ich 
das Senden über den TX DMA realisieren.
Ein Kommando besteht aus zwei 16bit SPI Frames. Je nach Bedarf sollen 
zwei 16bit SPI Frames via TX DMA über die SPI Schnittstelle versendet 
werden. Hierfür habe ich für den TX DMA einen Puffer bereitgestellt, der 
2*16Bit groß ist. Für den RX DMA habe ich einen 64*16Bit Puffer 
angelegt. Ja nach Kommando können auch mehr als zwei 16Bit SPi Frames 
empfangen werden. Müsste der Puffer für TX DMA ebenfalls 64*16Bit groß 
sein ? Wie kann man in der Software veranlassen, dass das dritte und 
vierte 16Bit SPI Frame gesendet werden soll ? Gibt es hierfür eine 
inkrement Funktion die das ermöglichen kann ?

uint16_t SPI_MASTER_Buffer_Rx[64];
uint16_t SPI_MASTER_Buffer_Tx[2];


static void SPI_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
 
  /* Enable the SPI clock */
  SPIx_CLK_INIT(SPIx_CLK, ENABLE);

  /* Enable GPIO clocks */
  RCC_AHB1PeriphClockCmd(SPIx_SCK_GPIO_CLK | SPIx_MISO_GPIO_CLK | SPIx_MOSI_GPIO_CLK, ENABLE);

  /* Connect SPI pins to AF5 */  
  GPIO_PinAFConfig(SPIx_SCK_GPIO_PORT, SPIx_SCK_SOURCE, SPIx_SCK_AF);
  GPIO_PinAFConfig(SPIx_MOSI_GPIO_PORT, SPIx_MOSI_SOURCE, SPIx_MOSI_AF);
  GPIO_PinAFConfig(SPIx_MISO_GPIO_PORT, SPIx_MISO_SOURCE, SPIx_MISO_AF);

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;

  /* SPI SCK pin configuration */
  GPIO_InitStructure.GPIO_Pin = SPIx_SCK_PIN;
  GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStructure);

  /* SPI  MOSI pin configuration */
  GPIO_InitStructure.GPIO_Pin =  SPIx_MOSI_PIN;
  GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStructure);
  
  /* SPI  MISO pin configuration */
  GPIO_InitStructure.GPIO_Pin =  SPIx_MISO_PIN;
  GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStructure);
 
  /* SPI configuration -------------------------------------------------------*/
  SPI_I2S_DeInit(SPIx);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  
  SPI_Init(SPIx, &SPI_InitStructure);
   
  /* Configure the Priority Group to 1 bit */                
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  /* Configure the SPI interrupt priority */
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannel = SPI_DMA_RX_IRQn;
  NVIC_Init(&NVIC_InitStructure);
  
  SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
   
  /* The Data transfer is performed in the SPI interrupt routine */
  /* Enable the SPI peripheral */
  SPI_Cmd(SPIx, ENABLE);
}

void DMA_Config(void)
{
  /* Dma config */
  RCC_AHB1PeriphClockCmd(SPI_DMAx_CLK, ENABLE);
  
  /* DMA RX */
  DMA_StructInit(&DMA_InitStructure);
  DMA_DeInit(SPI_RX_DMA_STREAM);
  DMA_InitStructure.DMA_PeripheralBaseAddr = SPI_DR_ADDRESS;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
  DMA_InitStructure.DMA_Channel = SPI_RX_DMA_CHANNEL;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;  
  DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)SPI_MASTER_Buffer_Rx;
  DMA_InitStructure.DMA_BufferSize = 64;
  DMA_Init(SPI_RX_DMA_STREAM, &DMA_InitStructure);     

  DMA_Cmd(SPI_RX_DMA_STREAM, ENABLE);  
  
  /* DMA TX */
  DMA_StructInit(&DMA_InitStructure);
  DMA_DeInit(SPI_TX_DMA_STREAM);
  DMA_InitStructure.DMA_PeripheralBaseAddr = SPI_DR_ADDRESS;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
  DMA_InitStructure.DMA_Channel = SPI_TX_DMA_CHANNEL;
  DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;  
  DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)SPI_MASTER_EmptyBuffer_Tx;
  DMA_InitStructure.DMA_BufferSize = 2;
  DMA_Init(SPI_TX_DMA_STREAM, &DMA_InitStructure);      

  DMA_Cmd(SPI_TX_DMA_STREAM, ENABLE); 
  
DMA_ITConfig(SPI_RX_DMA_STREAM, DMA_IT_TC | DMA_IT_TE | DMA_IT_FE , ENABLE);
}

[Leonhardt (Gast)]

Wenn der TxDma Puffer 64*16Bit groß ist und in der Applikation wird 
derte den TxDma gestartet, dann wird der Inhalt des gesamten Puffers 
gesendet.

      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
      DMA_Config();
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

Was kann man da tun, damit immer nur die nächsten 2*16Bit gesendet 
werden ?

[ttl (Gast)]

DMA ist für diese Anwendung ungeeignet

[Leonhardt (Gast)]

Warum das denn ? Gibt es da keine Möglichkeit ?
Und wenn ich den Puffer für den Tx Dma nur 2*16Bit groß mache ?

[Leonhardt (Gast)]

Die Kommunikation läuft folgendermaßen ab:

STM32 sendet 2 Spi Frames an den Fpga. Fpga löst daraufhin auf dem STm32 
einen externen Interrupt aus. In dem externen Interrupt Handler sende 
ich nochmals 2 Spi Frames allerdings mit den Dateninhalten NULL. Der 
FPGA sendet dann seine Daten entweder 2 Spi Frames oder 64 Spi Frames 
zum STM32.

[Narfie (Gast)]

Hi,

der STM ist der Master, d.h. er generiert den Takt für die 
Datenübertragung (es wird dabei immer gleichzeitig wird gesendet und 
empfangen). Das tut er nur solange er Daten sendet. D.h. wenn du 128 
Byte empfangen willst musst du auch 128 Byte hinschicken (können ja 
lauter 0'er sein o.ä.).

Viele Grüße,
Narfie

[Leonhardt (Gast)]

Guten Morgen,

vielen Dank für die Beiträge. Mir geht es eigentlich nur darum, wie kann 
man byteweise oder wordweise die Daten im Tx Dma Puffer versenden ? Gibt 
es hier eine Inkrementfunktion, die das bewältigen kann ? Wenn ich dich 
den Tx Dma aktiviere, swerden alle Daten im Tx Puffer auf einmal 
versendet. Dies möchte ich aber nicht.

Beispiel - TxPuffer 8 Byte:

Initialisierung:
TxPuffer[0] = 0;
TxPuffer[1] = 0;
TxPuffer[2] = 0;
TxPuffer[3] = 0;
TxPuffer[4] = 0;
TxPuffer[5] = 0;
TxPuffer[6] = 0;
TxPuffer[7] = 0;

--> TxPuffer[0] und TxPuffer[1] senden
Nächste Aktion:
--> TxPuffer[2] und TxPuffer[3] senden
usw.

[ttl (Gast)]

Da bringt dir DMA aber keinen Vorteil. DMA ist dafür gemacht große 
Datenmengen zu bewegen. Bei 2 Byte lohnt sich der Einsatz von DMA nicht.

[Leonhardt (Gast)]

Ob es sich lohnt oder nicht. Ich möchte nur wissen, ob es eine Funktion 
gibt, mit der man byteweise oder wordweise Daten vom Tx Dma Puffer 
senden kann.

[ttl (Gast)]

nein, gibt es nicht

[Leonhardt (Gast)]

Ok vielen Dank. Wie kann man ein weiteres mal den Tx Puffer mit DMA 
senden ? Wenn ich folgende Zeile nochmals ausführe passirert nichts:

SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

[Leonhardt (Gast)]

Ich habe jetzt mal für das Senden und Empfangen jeweils 2*16Bit 
angelegt.
Sobald der external Interrupt ausgelöst wird, werden zum erstenmal die 
2*16Bit gesendet. Das funktioniert hier nur einmal. Was müsste ich genau 
tun, damit ich nochmals 2*16Bit mit dem Tx Dma senden kann ?

[c]

void main(void)
{
...
...
  while (1)
  {
    if (STM_EVAL_PBGetState(BUTTON_WAKEUP) != 0)
    {
      while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
      SPI_I2S_SendData(SPIx, Command[0]);

      __no_operation();
      __no_operation();
      __no_operation();
      __no_operation();
      __no_operation();

      while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
      SPI_I2S_SendData(SPIx, Command[1]);

      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
      DMA_Config();
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
    }
  }
}

void SPI_DMA_RX_IRQHandler(void)
{
  if (SET == DMA_GetITStatus(SPI_RX_DMA_STREAM, SPI_RX_DMA_FLAG_TCIF))
  {
    /* clear int pending bit */
    DMA_ClearITPendingBit(SPI_RX_DMA_STREAM, SPI_RX_DMA_FLAG_TCIF);

    RxBuffer[RxCounter] = SPI_MASTER_Buffer_Rx[0];
    RxCounter = RxCounter + 1;
    RxBuffer[RxCounter] = SPI_MASTER_Buffer_Rx[1];
    RxCounter = RxCounter + 1;

    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
    DMA_Config();
  }
}

void EXTI15_10_IRQHandler(void)
{
  if(EXTI_GetITStatus(EXTI_Line15) != RESET)
  {
      /* Clear the EXTI line 15 pending bit */
      EXTI_ClearITPendingBit(EXTI_Line15);

      SPIx->DR;

      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
  }
}

[Leonhardt (Gast)]

Für jede Hilfe bin ich sehr dankbar!

[Artikel (Gast)]

Nachdem Du die Kapitel "13 Direct memory access controller (DMA)"
und "25 Serialperipheral interface (SPI)" des
ST Dokuments "RM0008 Reference manual", Doc ID 13902
gelesen hast, sollten alle Deine Fragen beantwortet sein.

[Leonhardt (Gast)]

Danke. Hab in der Doku auch schon nachgeschaut. Sind viele 
Einstellmöglichkeiten.

[Leonhardt (Gast)]

Meine Applikation läuft nun fast so wie ich es möchte. Ich habe für den 
Tx Dma und auch für den Rx Dma jeweils 2*16bit reserviert. Nun habe ich 
noch ein kleines Problem. Nachdem die ersten 2*16bit gesendet werden, 
steht im RxPuffer vom Rx Dma NULL drin. Diesen Inhalt möchte ich 
verwerfen. Welche Funktion gibt es hierfür ? Ohne Dma müsste ich diese 
Codezeile einfügen SPIx->DR bevor ich wieder 2*16bit Daten sende.

[Leonhardt (Gast)]

Gibt es keine Möglichekt, das erste Byte oder Word im RxBuffer zu 
verwerfen ?

[Leonhardt (Gast)]

Im folgenden habe ich mal einen Ausschnitt aus meiner Apllikation 
angehängt. Das Problem besteht nach wie vor.

[c]
while(1)
{
    if (STM_EVAL_PBGetState(BUTTON_WAKEUP) != 0)
    {

      SPI_MASTER_Buffer_Tx[0] = Command[0];
      SPI_MASTER_Buffer_Tx[1] = Command[1];

      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
      DMA_Config();
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
    }
}

/* External Interrupt Handler - Request ausgelöst von Slave */
void EXTI15_10_IRQHandler(void)
{
  if(EXTI_GetITStatus(EXTI_Line15) != RESET)
  {
    /* Clear the EXTI line 15 pending bit */
    EXTI_ClearITPendingBit(EXTI_Line15);

    /* dummy read - Clear flag RXNE */
    SPI2->DR; // dummy = SPI_I2S_ReceiveData( SPI2 );

    SPI_MASTER_Buffer_Tx[0] = 0;
    SPI_MASTER_Buffer_Tx[1] = 0;

    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
    DMA_Config();
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
  }
}

[Leonhardt (Gast)]

Hier nochmal mit richtiger Code Formatierung:

while(1)
{
    if (STM_EVAL_PBGetState(BUTTON_WAKEUP) != 0)
    {

      SPI_MASTER_Buffer_Tx[0] = Command[0];
      SPI_MASTER_Buffer_Tx[1] = Command[1];

      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
      DMA_Config();
      SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
    }
}

/* External Interrupt Handler - Request ausgelöst von Slave */
void EXTI15_10_IRQHandler(void)
{
  if(EXTI_GetITStatus(EXTI_Line15) != RESET)
  {
    /* Clear the EXTI line 15 pending bit */
    EXTI_ClearITPendingBit(EXTI_Line15);

    /* dummy read - Clear flag RXNE */
    SPI2->DR; // dummy = SPI_I2S_ReceiveData( SPI2 );

    SPI_MASTER_Buffer_Tx[0] = 0;
    SPI_MASTER_Buffer_Tx[1] = 0;

    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
    DMA_Config();
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
  }
}

[Leonhardt (Gast)]

Bin noch am verzweifeln.

Für jede Hilfe bin sehr dankbar.

[Leonhardt (Gast)]

Wenn ich ein neues Kommando sende, bestehend aus 2x16Bit, wie kann man 
das erste empfangene 16Bit Word ignorieren ? Es sollte nachdem das 
Kommando gesendet wurde im SPI_MASTER_Buffer_Rx[0] nichts gespeichert 
werden.

[Artikel (Gast)]

>Es sollte nachdem das
>Kommando gesendet wurde im SPI_MASTER_Buffer_Rx[0] nichts gespeichert
>werden.

Was ist das Problem, ab &SPI_MASTER_Buffer_Rx[2] zu kopieren?

Wenn Dir das zu einfach ist...

Du könntest aber auch Deinen SPI_MASTER_Buffer_Rx
so in's RAM legen, dass die ersten 2 Bytes in's Leere
geschrieben werden.

[R. K. (uc_student)]

Ich versuche aktell etwas ähnliches zu realisieren...

Das Einlesend der SPI mittels DMA funktioniert wunderbar mit 8-Bit. Wenn 
ich die Paketgrösse jedoch auf 16 Bit erhöhe, so sind die oberen 8 bit 
immer 0. Mir scheint da ist noch ein kleines Problem...

Im RM0008 steht unter 25.2 SPI and I2S main features
1-byte transmission and reception buffer with DMA capability: Tx and Rx 
requests

Kann es sein dass es gar nicht möglich ist 16 Bit zu übertragen?

uint16_t SPI_SLAVE_Buffer_Rx[BufferSize_RX];   // DMA-Buffer
#define BufferSize_RX       64

void InitSPI2(void)
{
  SPI_InitTypeDef  SPI_InitStructure;
  DMA_InitTypeDef  DMA_InitStructure;
  
   /* SPI_SLAVE_Rx_DMA_Channel configuration ------------------*/
  DMA_DeInit(SPI_SLAVE_Rx_DMA_Channel);
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&(SPI2->DR);
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_SLAVE_Buffer_Rx;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = BufferSize_RX;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(SPI_SLAVE_Rx_DMA_Channel, &DMA_InitStructure);
  
  /* Enable SPI_SLAVE_Rx_DMA_Channel Transfer Complete & Half interrupt */
  DMA_ITConfig(SPI_SLAVE_Rx_DMA_Channel, DMA_IT_TC, ENABLE);
  DMA_ITConfig(SPI_SLAVE_Rx_DMA_Channel,DMA_IT_HT, ENABLE);  
  
  /* SPI_SLAVE configuration ------------------------------------------------------*/
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_Init(SPI2, &SPI_InitStructure);
    
  SPI_Cmd(SPI2, ENABLE);                              // Enable SPI 2
  DMA_Cmd(SPI_SLAVE_Rx_DMA_Channel, ENABLE);          // Enable DMA1 Channel4
}

[Stahlemann (Gast)]

Hallo wurde dieses Problem von ihnen gelöst?
ich stehe auch vor diesen Problem und bräuchte Hilfe.