SPI工作在主模式接收数据可以用DMA吗?如果可以的话该怎么用呢？

硬件为stm32+m25p40

void SPIx_Init(void)                 //spi2初始化

{  

   SPI_InitTypeDef  SPI_InitStructure;

   GPIO_InitTypeDef GPIO_InitStructure;

   RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE ); 

   RCC_APB1PeriphClockCmd( RCC_APB1Periph_SPI2,  ENABLE ); 

   

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;

   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

   GPIO_Init(GPIOB, &GPIO_InitStructure);

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;

   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

   GPIO_Init(GPIOB, &GPIO_InitStructure);        //NSS    PB12



   /* Deselect the FLASH: Chip Select high */

   SPI_FLASH_CS_HIGH();

   /* SPI2 configuration */

   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;       //SPI 设置为双线双向全双工 

   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                    //设置为主SPI

   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                //SPI 发送接收8 位帧结构

   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                       //时钟悬空高

   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                    //数据捕获于第二个时钟沿

   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                             //内部NSS 信号有SSI 位控制

   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;//波特率预分频值为64 

   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                    //数据传输从MSB位开始

   SPI_InitStructure.SPI_CRCPolynomial = 7;

   SPI_Init(SPI2, &SPI_InitStructure);

     /* Enable SPI1  */

   SPI_Cmd(SPI2, ENABLE);                //使能SPI 外设 

}



u8 DuumyClock[4] = {0xA5,0xA5,0xA5,0xA5};

void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)

{

   DMA_InitTypeDef   DMA_InitStructure;

   //配置DMA通道

   DMA_DeInit(DMA1_Channel4);

   DMA_DeInit(DMA1_Channel5);                   

   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SPI2->DR;

   DMA_InitStructure.DMA_MemoryBaseAddr = (u32)pBuffer;

   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;

   DMA_InitStructure.DMA_BufferSize = NumByteToRead;

   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;

   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;

   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;

   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;

   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;

   DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

   DMA_Init(DMA1_Channel4, &DMA_InitStructure); 



   DMA_InitStructure.DMA_MemoryBaseAddr = (u32)DuumyClock;  //dummy

   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;

   DMA_InitStructure.DMA_Priority = DMA_Priority_Low;

   DMA_Init(DMA1_Channel5, &DMA_InitStructure);



   SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

   SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);  

   SPI_FLASH_StartReadSequence(ReadAddr);      //发送开始读命令与地址

   DMA_Cmd(DMA1_Channel4,ENABLE);

   DMA_Cmd(DMA1_Channel5,ENABLE);

   while(!DMA_GetFlagStatus(DMA1_FLAG_TC4)) ;

   while(!DMA_GetFlagStatus(DMA1_FLAG_TC5)) ;

   DMA_Cmd(DMA1_Channel4, DISABLE);

   DMA_Cmd(DMA1_Channel5, DISABLE);

   SPI_FLASH_CS_HIGH();

   SPI_FLASH_SendByte(Dummy_Byte) ；

}



u8 SPI_FLASH_SendByte(u8 byte)

{

    u16 count = 0;//

  /* Loop while DR register in not emplty */

  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET)

  {

      count++;

    if (count > 65533)

    {

        return 0;

    }

  }

  /* Send byte through the SPI1 peripheral */

  SPI_I2S_SendData(SPI2, byte);

  /* Wait to receive a byte */

  count = 0;

  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)

  {

     

    count++;

     if (count > 65533)

     {

        return 0;

     }

  }

  /* Return the byte read from the SPI bus */

  return SPI_I2S_ReceiveData(SPI2);

}

u8 SPI_FLASH_ReadByte(void)

{

  return (SPI_FLASH_SendByte(Dummy_Byte));

}

void SPI_FLASH_StartReadSequence(u32 ReadAddr)

{

  /* Select the FLASH: Chip Select low */

  SPI_FLASH_CS_LOW();

  /* Send "Read from Memory " instruction */

  SPI_FLASH_SendByte(READ);

  /* Send the 24-bit address of the address to read from -----------------------*/

  /* Send ReadAddr high nibble address byte */

  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);

  /* Send ReadAddr medium nibble address byte */

  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);

  /* Send ReadAddr low nibble address byte */

  SPI_FLASH_SendByte(ReadAddr & 0xFF);

}

/*******************************************************************************

* Function Name  : SPI_FLASH_SectorErase

* Description    : Erases the specified FLASH sector.

* Input          : SectorAddr: address of the sector to erase.

* Output         : None

* Return         : None

*******************************************************************************/

void SPI_FLASH_SectorErase(u32 SectorAddr)

{

  /* Send write enable instruction */

  SPI_FLASH_WriteEnable();

  /* Sector Erase */

  /* Select the FLASH: Chip Select low */

  SPI_FLASH_CS_LOW();

  /* Send Sector Erase instruction */

  SPI_FLASH_SendByte(SE);

  /* Send SectorAddr high nibble address byte */

  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);

  /* Send SectorAddr medium nibble address byte */

  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);

  /* Send SectorAddr low nibble address byte */

  SPI_FLASH_SendByte(SectorAddr & 0xFF);

  /* Deselect the FLASH: Chip Select high */

  SPI_FLASH_CS_HIGH();

  /* Wait the end of Flash writing */

  SPI_FLASH_WaitForWriteEnd();

}

/*******************************************************************************

* Function Name  : SPI_FLASH_BulkErase

* Description    : Erases the entire FLASH.

* Input          : None

* Output         : None

* Return         : None

*******************************************************************************/

void SPI_FLASH_BulkErase(void)

{

  /* Send write enable instruction */

  SPI_FLASH_WriteEnable();

  /* Bulk Erase */

  /* Select the FLASH: Chip Select low */

  SPI_FLASH_CS_LOW();

  /* Send Bulk Erase instruction  */

  SPI_FLASH_SendByte(BE);

  /* Deselect the FLASH: Chip Select high */

  SPI_FLASH_CS_HIGH();

  /* Wait the end of Flash writing */

  SPI_FLASH_WaitForWriteEnd();

}

/*******************************************************************************

* Function Name  : SPI_FLASH_PageWrite

* Description    : Writes more than one byte to the FLASH with a single WRITE

*                  cycle(Page WRITE sequence). The number of byte can't exceed

*                  the FLASH page size.

* Input          : - pBuffer : pointer to the buffer  containing the data to be

*                    written to the FLASH.

*                  - WriteAddr : FLASH's internal address to write to.

*                  - NumByteToWrite : number of bytes to write to the FLASH,

*                    must be equal or less than "SPI_FLASH_PageSize" value.

* Output         : None

* Return         : None

*******************************************************************************/

void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)

{

  /* Enable the write access to the FLASH */

  SPI_FLASH_WriteEnable();

  /* Select the FLASH: Chip Select low */

  SPI_FLASH_CS_LOW();

  /* Send "Write to Memory " instruction */

  SPI_FLASH_SendByte(WRITE);

  /* Send WriteAddr high nibble address byte to write to */

  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);

  /* Send WriteAddr medium nibble address byte to write to */

  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);

  /* Send WriteAddr low nibble address byte to write to */

  SPI_FLASH_SendByte(WriteAddr & 0xFF);

  /* while there is data to be written on the FLASH */

  while (NumByteToWrite--)

  {

    /* Send the current byte */

    SPI_FLASH_SendByte(*pBuffer);

    /* Point on the next byte to be written */

    pBuffer++;

  }

  /* Deselect the FLASH: Chip Select high */

  SPI_FLASH_CS_HIGH();

  /* Wait the end of Flash writing */

  SPI_FLASH_WaitForWriteEnd();

}

/*******************************************************************************

* Function Name  : SPI_FLASH_BufferWrite

* Description    : Writes block of data to the FLASH. In this function, the

*                  number of WRITE cycles are reduced, using Page WRITE sequence.

* Input          : - pBuffer : pointer to the buffer  containing the data to be

*                    written to the FLASH.

*                  - WriteAddr : FLASH's internal address to write to.

*                  - NumByteToWrite : number of bytes to write to the FLASH.

* Output         : None

* Return         : None

*******************************************************************************/

void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)

{

  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;

  Addr = WriteAddr % SPI_FLASH_PageSize;

  count = SPI_FLASH_PageSize - Addr;

  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;

  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

  if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned  */

  {

    if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */

    {

      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);

    }

    else /* NumByteToWrite > SPI_FLASH_PageSize */

    {

      while (NumOfPage--)

      {

        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);

        WriteAddr +=  SPI_FLASH_PageSize;

        pBuffer += SPI_FLASH_PageSize;

      }

      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);

    }

  }

  else /* WriteAddr is not SPI_FLASH_PageSize aligned  */

  {

    if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */

    {

      if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */

      {

        temp = NumOfSingle - count;

        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);

        WriteAddr +=  count;

        pBuffer += count;

        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);

      }

      else

      {

        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);

      }

    }

    else /* NumByteToWrite > SPI_FLASH_PageSize */

    {

      NumByteToWrite -= count;

      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;

      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);

      WriteAddr +=  count;

      pBuffer += count;

      while (NumOfPage--)

      {

        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);

        WriteAddr +=  SPI_FLASH_PageSize;

        pBuffer += SPI_FLASH_PageSize;

      }

      if (NumOfSingle != 0)

      {

        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);

      }

    }

  }

}

}