STM32 DMA SPI SD-Karte

[Stephan (Gast)]

Ich bin gerade dabei zu versuchen per DMA über SPI auf eine SD-Karte zu 
schreiben. Ich habe meinen aktuellen DMA-Code mit angehängt, da ich 
vermute dort irgendwo Fehler eingebaut zu haben.
Als Fehler bekomme ich von dem FatFs manchmal FR_NO_FILESYSTEM oder 
FR_NOT_READY. Meine Vermutung ist jetzt, dass etwas mit dem Lesen nicht 
zu funktionieren scheint, weil die Karte laut Oszi eigentlich richtig 
antwortet, der MCU dies aber zu ignorieren scheint.

Und in der while-Schleife mit DMA_GetFlagStatus scheint auch ein Fehler 
zu sein, denn dort bleibt er immer hängen, wenn sie nicht auskommentiert 
ist.

#define DMA_SPI2_RX_STREAM DMA1_Stream3
#define DMA_SPI2_TX_STREAM DMA1_Stream4

void stm32_dma_transfer(
  UINT receive,    /* FALSE for buff->SPI, TRUE for SPI->buff               */
  const BYTE *buff,  /* receive TRUE  : 512 byte data block to be transmitted
               receive FALSE : Data buffer to store received data    */
  UINT btr       /* receive TRUE  : Byte count (must be multiple of 2)
               receive FALSE : Byte count (must be 512)              */
)
{
  DMA_InitTypeDef DMA_InitStructure;
  WORD rw_workbyte[] = { 0xffff };

  //enable clock
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

  //start with a blank DMA configuration
  DMA_DeInit(DMA_SPI2_RX_STREAM); //SPI-RX
  DMA_DeInit(DMA_SPI2_TX_STREAM); //SPI-TX

  //only these parameters differ from default values
  DMA_InitStructure.DMA_Channel        = DMA_Channel_0;
  DMA_InitStructure.DMA_PeripheralBaseAddr = (DWORD) & (SPI2->DR);
  DMA_InitStructure.DMA_MemoryDataSize    = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_PeripheralInc     = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_BufferSize      = btr;
  DMA_InitStructure.DMA_Priority       = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_Mode          = DMA_Mode_Normal;

  if (receive){
    // DMA1-Channel0-Stream3 configured as SPI2-RX
    DMA_InitStructure.DMA_Memory0BaseAddr   = (DWORD)buff;
    DMA_InitStructure.DMA_DIR          = DMA_DIR_PeripheralToMemory;
    DMA_InitStructure.DMA_MemoryInc      = DMA_MemoryInc_Enable;
    DMA_Init(DMA_SPI2_RX_STREAM, &DMA_InitStructure);

    // DMA1-Channel0-Stream4 configured as SPI2-TX
    DMA_InitStructure.DMA_Memory0BaseAddr    = (DWORD)rw_workbyte;
    DMA_InitStructure.DMA_DIR          = DMA_DIR_MemoryToPeripheral;
    DMA_InitStructure.DMA_MemoryInc      = DMA_MemoryInc_Disable;
    DMA_Init(DMA_SPI2_TX_STREAM, &DMA_InitStructure);
  }
  else {
    // DMA1-Channel0-Stream3 configured as SPI2-RX
    DMA_InitStructure.DMA_Memory0BaseAddr   = (DWORD)rw_workbyte;
    DMA_InitStructure.DMA_DIR          = DMA_DIR_PeripheralToMemory;
    DMA_InitStructure.DMA_MemoryInc      = DMA_MemoryInc_Disable;
    DMA_Init(DMA_SPI2_RX_STREAM, &DMA_InitStructure);

    // DMA1-Channel0-Stream4 configured as SPI2-TX
    DMA_InitStructure.DMA_Memory0BaseAddr    = (DWORD)buff;
    DMA_InitStructure.DMA_DIR          = DMA_DIR_MemoryToPeripheral;
    DMA_InitStructure.DMA_MemoryInc      = DMA_MemoryInc_Enable;
    DMA_Init(DMA_SPI2_TX_STREAM, &DMA_InitStructure);
  }

  //Enable DMA RX/TX
  DMA_Cmd(DMA_SPI2_RX_STREAM, ENABLE); //SPI-RX
  DMA_Cmd(DMA_SPI2_TX_STREAM, ENABLE); //SPI-TX

  /* Enable SPI TX/RX request */
  SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, ENABLE);

  /* Wait until DMA1_Channel 2 Receive Complete */
  //while (DMA_GetFlagStatus(DMA_SPI2_RX_STREAM, DMA_FLAG_TCIF4) == RESET) { ; }

  //Disable DMA RX/TX
  DMA_Cmd(DMA_SPI2_RX_STREAM, DISABLE); //SPI-RX
  DMA_Cmd(DMA_SPI2_TX_STREAM, DISABLE); //SPI-TX

  /* Disable SPI RX/TX request */
  SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, DISABLE);
}

[Moritz M. (moritz_m35)]

Hallo,

guck dir das mal an:
http://mikrocontroller.bplaced.net

Da gibt es auch was für sd karte und fat und ich galube auch mit dma. 
Kann ich nur empfehlen!

Moritz

[Jim M. (turboj)]

Du solltest vielleicht für TX und RX nicht denselben DMA Kanal benutzen. 
Da brauchst Du jeweils einen eigenen IMO.

[Torsten S. (tse)]

auch sehr lesenswert:
http://blog.frankvh.com/category/stm32/

[Stephan (Gast)]

@Jim
also den Kanal habe ich wie im Datenblatt dargestellt belegt, dort ist 
für SPI2-RX/TX nur der Kanal0 und die Streams 3/4 vorgesehen. Daher 
denke ich nicht, dass der Fehler dort liegt.
@Moritz
Die Seite ist sehr interessant, allerdings wird dort nur DMA mit SDIO 
zusammen verwendet und nicht mit SPI.

Ich hab noch einiges ausprobiert, konnte aber bisher den Fehler nicht 
finden. Bin jetzt dabei mal ein einfaches DMA-Beispiel für mich zu 
schreiben, wo ich nur einen Beschleunigungssensor auslesen will. 
Vielleicht bin ich dabei erfolgreicher.

[Stephan (Gast)]

Hey zusammen,
hab DMA jetzt mit einem einfachen Beispiel zum Laufen bekommen. Dabei 
werden jetzt Daten per SPI an ein Display gesendet. Nach beendeter 
Übertragung wird ein Interrupt ausgelöst, in welchem dann das Chip 
Select zurückgesetzt wird.
Vielleicht hilft mein Code ja anderen beim Verstehen.

void DMA_TX(u8* buf, int count){

  DMA_InitTypeDef DMA_InitStructure_TX;

  //enable DMA-clock
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

  DMA_DeInit(DMA1_Stream4); // TX-Stream

  // TX-Configuration
  DMA_InitStructure_TX.DMA_PeripheralBaseAddr = (uint32_t) (&(SPI2->DR));
  DMA_InitStructure_TX.DMA_Channel = DMA_Channel_0;
  DMA_InitStructure_TX.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  DMA_InitStructure_TX.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure_TX.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure_TX.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure_TX.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure_TX.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure_TX.DMA_Priority = DMA_Priority_Medium;
  DMA_InitStructure_TX.DMA_BufferSize = count;
  DMA_InitStructure_TX.DMA_Memory0BaseAddr = (uint32_t)buf;
  DMA_Init(DMA1_Stream4,&DMA_InitStructure_TX);

  NVIC_InitTypeDef NVIC_InitStructure;

  // enable the interrupt in the NVIC
  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  // Enable dma tx request.
  SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

  // Enable the DMA transfer complete interrupt
  DMA_ITConfig(DMA1_Stream4, DMA_IT_TC, ENABLE);

  //Enable DMA RX/TX
  DMA_Cmd(DMA1_Stream4, ENABLE); //SPI3-TX

}

[holger (Gast)]

>Dabei werden jetzt Daten per SPI an ein Display gesendet. Nach beendeter
>Übertragung wird ein Interrupt ausgelöst, in welchem dann das Chip
>Select zurückgesetzt wird.

Das ist aber eine wackelige Angelegenheit. Ich hab festgestellt
das wenn der TX DMA fertig ist das SPI Modul noch ein bis zwei
Byte am senden ist. Mit deiner Konstruktion würdest du die
Chip Select Leitung möglicherweise zu früh hochziehen.