STM32f3 8bit SPI DMA Problem

[Alex R. (edge0xc)]

Hallo Leute,
ich habe ein sehr merkwürdiges Problem mit meinem SPI Code. Er läuft mit 
16bit perfekt und ohne probleme. da ich ein modul habe, das 8bit SPI 
braucht, wollte ich das ganze mal umstellen. für die ersten tests habe 
ich einfach MISO und MOSI gebürckt. leider wird der DMA TC Interrupt 
nicht mehr ausgelöst. könnt ihr mal drüberschauen? ich habe eigentlich 
nur die datengröße von 16 auf 8 bit gesenkt.

LG

#define BUFFER_SIZE              1
uint8_t SPIBufferRX=0;
uint8_t SPIBufferTX=0b11111111;


/**
 * @brief  Init SPI2 module for DMA transfers
 * @param  none
 * @retval  none
 */
void init_SPI_DMA(void){
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  SPI_InitTypeDef SPI_InitStructure;
  DMA_InitTypeDef DMA_InitStructure;

  // Enable clocks
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

  // GPIO settings
  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_5);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_5);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_5);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_SetBits(GPIOA, GPIO_Pin_4);        // Set SS pin

  // Init SPI
  SPI_StructInit(&SPI_InitStructure);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;//MSB
  SPI_InitStructure.SPI_CRCPolynomial = 0;
  SPI_Init(SPI1, &SPI_InitStructure);

  // DMA Channel 4 - SPI RX
  DMA_StructInit(&DMA_InitStructure);                                //SPI2 Tx DMA is DMA1/Stream4/Channel0
  DMA_InitStructure.DMA_PeripheralBaseAddr  = (uint32_t)&(SPI1->DR);             //Set the SPI2 Tx
  DMA_InitStructure.DMA_MemoryBaseAddr  = (uint32_t)&SPIBufferRX;                //Set the memory location
  DMA_InitStructure.DMA_DIR  = DMA_DIR_PeripheralSRC;                       //Sending data from memory to the peripheral's Tx register
  DMA_InitStructure.DMA_BufferSize  = BUFFER_SIZE;                              //Define the number of bytes to send
  DMA_InitStructure.DMA_PeripheralInc  = DMA_PeripheralInc_Disable;             //Don't increment the peripheral 'memory'
  DMA_InitStructure.DMA_MemoryInc  = DMA_MemoryInc_Disable;                        //Increment the memory location
  DMA_InitStructure.DMA_PeripheralDataSize  = DMA_PeripheralDataSize_Byte;    //Byte size memory transfers
  DMA_InitStructure.DMA_MemoryDataSize  = DMA_MemoryDataSize_Byte;           //Byte size memory transfers
  DMA_InitStructure.DMA_Mode  = DMA_Mode_Normal;                                   //Normal mode (not circular)
  DMA_InitStructure.DMA_Priority  = DMA_Priority_High; //Priority is high to avoid saturating the FIFO since we are in direct mode
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel2, &DMA_InitStructure);
  DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);

  // DMA Channel 5 - SPI TX                             //SPI2 Tx DMA is DMA1/Stream4/Channel0
  DMA_InitStructure.DMA_PeripheralBaseAddr  = (uint32_t)&(SPI1->DR);             //Set the SPI2 Tx
  DMA_InitStructure.DMA_MemoryBaseAddr  = (uint32_t)&SPIBufferTX;                 //Set the memory location
  DMA_InitStructure.DMA_DIR  = DMA_DIR_PeripheralDST;                      //Sending data from memory to the peripheral's Tx register
  DMA_InitStructure.DMA_BufferSize  = BUFFER_SIZE;                              //Define the number of bytes to send
  DMA_InitStructure.DMA_PeripheralInc  = DMA_PeripheralInc_Disable;             //Don't increment the peripheral 'memory'
  DMA_InitStructure.DMA_MemoryInc  = DMA_MemoryInc_Disable;                        //Increment the memory location
  DMA_InitStructure.DMA_PeripheralDataSize  = DMA_PeripheralDataSize_Byte;    //Byte size memory transfers
  DMA_InitStructure.DMA_MemoryDataSize  = DMA_MemoryDataSize_Byte;           //Byte size memory transfers
  DMA_InitStructure.DMA_Mode  = DMA_Mode_Normal;                                 //Normal mode (not circular)
  DMA_InitStructure.DMA_Priority  = DMA_Priority_High;                           //Priority is high to avoid saturating the FIFO since we are in direct mode
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel3, &DMA_InitStructure);
  DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);

  DMA_ClearITPendingBit(DMA1_IT_TC2);
  DMA_ClearITPendingBit(DMA1_IT_TC3);

  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);


  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn;
  NVIC_Init(&NVIC_InitStructure);

  SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
  SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
  SPI_Cmd(SPI1, ENABLE);
}

/**
 * @brief  Start new SPI transfer
 * @param  none
 * @retval  none
 */
void SPI_DMA_start(void){
  // Prevent errors
  //while((DMA_GetCmdStatus(DMA1_Stream4) == ENABLE) || (DMA_GetCmdStatus(DMA1_Stream3) == ENABLE)){
    // DMA transfer still running
  //}

  DMA_SetCurrDataCounter(DMA1_Channel2, BUFFER_SIZE); //nur notwendig bei mehr als 1 transfer
  DMA_SetCurrDataCounter(DMA1_Channel3, BUFFER_SIZE);

  // Chip Select Low
  GPIO_WriteBit(GPIOA, GPIO_Pin_4, RESET);

  DMA_Cmd(DMA1_Channel2, ENABLE);
  DMA_Cmd(DMA1_Channel3, ENABLE);

}

/**
 * @brief  DMA RX complete interrupt
 * @param  none
 * @retval  none
 */
void DMA1_Channel2_IRQHandler(void){

  if(DMA_GetITStatus( DMA1_IT_TC2))  {      // Test on DMA Stream Transfer Complete interrupt
    DMA_ClearITPendingBit( DMA1_IT_TC2);    // Clear DMA Stream Transfer Complete interrupt pending bit
    GPIO_WriteBit(GPIOA, GPIO_Pin_4, SET);          // Chip Select Low
    //USART_puts(USART1, "DMA fertig\n");
    DMA_Cmd(DMA1_Channel2, DISABLE);
    DMA_Cmd(DMA1_Channel3, DISABLE);
    // ToDo
  }
}

/**
 * @brief  DMA TX Complete interrupt
 * @param  none
 * @retval  none
 */

void DMA1_Channel3_IRQHandler(void){

  if(DMA_GetITStatus( DMA1_IT_TC3))  {      // Test on DMA Stream Transfer Complete interrupt
    //DMA_ClearITPendingBit(DMA1_Stream4, DMA_IT_TCIF4);    // Clear DMA Stream Transfer Complete interrupt pending bit
    DMA_ClearITPendingBit(DMA1_IT_TC3);

  }
}

[SPI (Gast)]

Hallo,

der STM32F3 hat eine blöde Eigenschaft in der SPI-Hardware. Wenn das 
SPI-Peripheral im 8Bit Modus läuft und per DMA 'gefüttert' wird, ist 
Vorsicht geboten.

Vgl. STM32F3 Reference Manual RM0316 --> Packing with DMA, Seiten 731 u. 
732.

Das Problem ist, dass du für 8Bit Übertragungen per DMA das FRXTH Bit im 
SPI Modul (SPIx_CR2) noch setzten mußt (siehe Beschreibung der beiden 
Bits).

Gruß Bernd

[Alex R. (edge0xc)]

Perfekt, vielen Dank, genau das wars :)

LG

[Phantomix X. (phantomix)]

SPI schrieb:
> Das Problem ist, dass du für 8Bit Übertragungen per DMA das FRXTH Bit im
> SPI Modul (SPIx_CR2) noch setzten mußt (siehe Beschreibung der beiden
> Bits).


Hallo und danke für den Hinweis.


Das FRXTH-Bit ist auch für DMA-lose Übertragungen relevant.
FRXTH = 1 -> Das RXNE-Flag im Statusregister wird bereits nach 8 Bit 
gesetzt (wünschenswert, wenn man den SPI byteweise abhandeln will)
FRXTH = 0 (default) -> Das RXNE-Flag im Statusregister wird erst nach 16 
Bit gesetzt.

Desweiteren für 8 Bit-Übertragung (ohne DMA) sei dieser Code-Schnipsel 
interessant:

    #if defined(__STM32F30x_H)
        //Only write low byte of the 16bit DR register!
        //A 16 bit write would lead to an undesired push of an additional 0x00 to the FIFO
        *( (volatile uint8_t*) &periph_ptr->spi_device->DR) = txbyte;
    #else
        periph_ptr->spi_device->DR = txbyte;
    #endif

Schreibt man DR direkt, werden 16 bit in den Fifo gepusht, was zu einer 
abwechselnden Ausgabe von <Datenbyte0> <0x00> <Datenbyte1> <0x00> ... 
führt