基于UCOSII的DMA-SPI通信

基于UCOSII的DMA-SPI通信_fluffy_floppy的博客-CSDN博客

代码有点小bug，比如主机的dma定义长度为8位，发送8为数据为：0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08,从机第一次接收数据格式：0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08。第二次接收数据：0x01 0x01 0x02 0x03 0x04 0x05 0x06 0x07。第三次0x08 0x01 0x02 0x03 0x04 0x05 0x06 0x07。经修改，从机接收长度为9位:接收的格式为：0x01 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08。
 

主机DMA_SPI1：

1. 

#include "spi.h"
volatile uint8_t SPI2_TxBuf[8];
volatile uint8_t SPI_RX_Buff[8];
u8 Master_Temp =0;
void SPI1_Init(void)
{    
    NVIC_InitTypeDef NVIC_InitStructure;
    GPIO_InitTypeDef  GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;
    DMA_InitTypeDef  DMA_Initstructure;  
    
     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);     //ʹÄÜPA¶Ë¿ÚʱÖÓ
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO,   ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;                
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;          //ÍÆÍìÊä³ö
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
      
    //SPI_SSOutputCmd(SPI1,ENABLE);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;//SPI_Mode_Master    SPI_Mode_Slave                             
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                               
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                       
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                     
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;    //SPI_NSS_Hard        SPI_NSS_Soft                               
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;    
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                           
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(SPI1, &SPI_InitStructure);    
    SPI_Cmd(SPI1, ENABLE);
    //SPI_I2S_ITConfig(SPI1,SPI_I2S_IT_RXNE,ENABLE);
    
    DMA_DeInit(DMA1_Channel3);
    DMA_Initstructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI1->DR;
    DMA_Initstructure.DMA_MemoryBaseAddr =     (uint32_t)SPI2_TxBuf;
    DMA_Initstructure.DMA_DIR =                DMA_DIR_PeripheralDST;             
    DMA_Initstructure.DMA_BufferSize =         0;
    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_Channel3, &DMA_Initstructure);     
  //DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);
    
    SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Tx,ENABLE);
    
    DMA_DeInit(DMA1_Channel2);
    DMA_Initstructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI1->DR;
    DMA_Initstructure.DMA_MemoryBaseAddr =     (uint32_t)SPI_RX_Buff;
    DMA_Initstructure.DMA_DIR =                DMA_DIR_PeripheralSRC;      
    DMA_Initstructure.DMA_BufferSize =         0;
    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_Channel2, &DMA_Initstructure);
//    DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);
    SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Rx,ENABLE);
                
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn;
    NVIC_Init(&NVIC_InitStructure);
    
    NVIC_InitStructure.NVIC_IRQChannel = SPI1_IRQn;
    NVIC_Init(&NVIC_InitStructure);
    
    GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);    
     //SPI1_ReadWriteByte(0xff);//Æô¶¯´«Êä                         
}   
void SPI1_SetSpeed(u8 SpeedSet)
{
    SPI1->CR1&=0XFFC7;//Fsck=Fcpu/256
    if(SpeedSet==SPI_SPEED_2)//¶þ·ÖƵ
    {
        SPI1->CR1|=0<<3;//Fsck=Fpclk/2=36Mhz    
    }else if(SpeedSet==SPI_SPEED_8)//°Ë·ÖƵ
    {
        SPI1->CR1|=2<<3;//Fsck=Fpclk/8=9Mhz    
    }else if(SpeedSet==SPI_SPEED_16)//Ê®Áù·ÖƵ
    {
        SPI1->CR1|=3<<3;//Fsck=Fpclk/16=4.5Mhz
    }else                  //256·ÖƵ
    {
        SPI1->CR1|=7<<3; //Fsck=Fpclk/256=281.25Khz µÍËÙģʽ
    }
    SPI1->CR1|=1<<6; //SPIÉ豸ʹÄÜ      
}
u8 SPI1_ReadWriteByte(u8 TxData)
{        
    u8 retry=0;                
    while((SPI1->SR&1<<1)==0)//µÈ´ý·¢ËÍÇø¿Õ    
    {
        retry++;
        if(retry>200)return 0;
    }              
    SPI1->DR=TxData;           //·¢ËÍÒ»¸öbyte
    retry=0;
    while((SPI1->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    {
        retry++;
        if(retry>200)return 0;
    }                                  
    return SPI1->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
}

u8 SPI1_ReadByte(u8 TxData)
{        
    u8 retry=0;                
    while((SPI1->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    {
        retry++;
        if(retry>200)return 0;
    }                                  
    return SPI1->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
}

void SPI1_IRQHandler(void)
{    
    if((SPI1->SR&1<<0)==1)
    {    
        Master_Temp = SPI1_ReadByte(0x00);
    }     
}

void DMA1_Channel2_IRQHandler(){//SPI1-RX-DMA    
    if(DMA_GetFlagStatus(DMA1_FLAG_TC2)!=RESET){
            DMA_ClearFlag(DMA1_FLAG_TC2);    
          DMA_Cmd(DMA1_Channel2, DISABLE);
            }
}

void DMA1_Channel3_IRQHandler(){//SPI1-TX-DMA
    if(DMA_GetFlagStatus(DMA1_FLAG_TC3)!=RESET){
            DMA_ClearFlag(DMA1_FLAG_TC3);
          //DMA_Cmd(DMA1_Channel3, DISABLE);
            }    
}
/********************************************************/

2.

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


#include "stm32f10x.h"
#include 
#include "delay.h"
#include "includes.h"
#include "led.h"
#include "spi.h"


#define LED_STK_SIZE     64
#define LED1_STK_SIZE    64
#define START_STK_SIZE   128
#define SPI_SPEED_2   0
#define SPI_SPEED_8   1
#define SPI_SPEED_16  2
#define SPI_SPEED_256 3

#define LED_TASK_Prio       9
#define LED1_TASK_Prio      5
#define START_TASK_Prio     10

str_led pb_13;
str_led pb_14;

extern  volatile uint8_t SPI2_TxBuf[8];
extern  volatile uint8_t SPI_RX_Buff[8];
uint8_t  send_data[10];
uint8_t  rev_data[10];

OS_STK  TASK_LED1_STK[LED_STK_SIZE];
OS_STK  TASK_LED_STK[LED_STK_SIZE];
OS_STK  TASK_START_STK[START_STK_SIZE];

void TaskStart(void *pdata);
void TaskLed(void *pdata);
void TaskLed1(void *pdata);
void SysTick_Configuration(void);

void GPIO_Configuration(void)
{     
      pb_13.GPIOX = GPIOB;
      pb_13.pin = GPIO_Pin_13;
      
      pb_14.GPIOX = GPIOB;
      pb_14.pin = GPIO_Pin_14;
    
      gpio_led_init(pb_13);
      gpio_led_init(pb_14);
    
}
void SPI1_DMA_SendBytes(void)
{
    int i = 0 ;    
      for(i = 0;i < 8;i++)
        {
            send_data[i] = (i+2);
        }
        memcpy((u8 *)SPI2_TxBuf,send_data,8);    
    DMA_SetCurrDataCounter(DMA1_Channel3, 8);
    DMA_SetCurrDataCounter(DMA1_Channel2, 8);
        SPI1->DR;
        SPI1->DR;
    DMA_Cmd(DMA1_Channel3, ENABLE);
    DMA_Cmd(DMA1_Channel2, ENABLE);
        while(!DMA_GetFlagStatus(DMA1_FLAG_TC4)){
            i++;
            OSTimeDlyHMSM(0,0,0,005);
            if(i>50){
              DMA_ClearFlag(DMA1_FLAG_GL3|DMA1_FLAG_TC3|DMA1_FLAG_HT3|DMA1_FLAG_TE3);
        DMA_ClearFlag(DMA1_FLAG_GL2|DMA1_FLAG_TC2|DMA1_FLAG_HT2|DMA1_FLAG_TE2);                 
            DMA_Cmd(DMA1_Channel3, DISABLE);
            DMA_Cmd(DMA1_Channel2, DISABLE);
                return;        
            }
        };
        while((SPI1->SR&1<<1)!=0x0002){};
    while((SPI1->SR&1<<7)!=0x0000){};    
        DMA_ClearFlag(DMA1_FLAG_GL3|DMA1_FLAG_TC3|DMA1_FLAG_HT3|DMA1_FLAG_TE3);
    DMA_ClearFlag(DMA1_FLAG_GL2|DMA1_FLAG_TC2|DMA1_FLAG_HT2|DMA1_FLAG_TE2);                     
        DMA_Cmd(DMA1_Channel3, DISABLE);
        DMA_Cmd(DMA1_Channel2, DISABLE);
        memcpy(rev_data,(u8 *)SPI_RX_Buff,8);
          
}

void NVIC_Configuration(void)
{
    //NVIC_InitTypeDef NVIC_InitStructure;
     /* Configure the NVIC Preemption Priority Bits */  
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);    //???????:?????0?,????4?
     //???????????
    #ifdef  VECT_TAB_RAM  
        /* Set the Vector Table base location at 0x20000000 */
        NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);         //?????RAM
    #else  /* VECT_TAB_FLASH  */
        /* Set the Vector Table base location at 0x08000000 */
        NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   //?????FLASH
    #endif
}

void RCC_Configuration(void)
{
    SystemInit();        
}
void SPI_Configuration(void)
{
    SPI1_Init();
    memset((u8 *)SPI2_TxBuf,0,8);
    memset((u8 *)SPI_RX_Buff,0,8);
    
}
void Init_All_Periph(void)
{    
    RCC_Configuration();    
     //NVIC_Configuration();
     GPIO_Configuration();
    SPI_Configuration();
 
}

void TaskStart(void * pdata)
{
    pdata = pdata;
    OS_ENTER_CRITICAL();   
    OSTaskCreate(TaskLed, (void * )0, (OS_STK *)&TASK_LED_STK[LED_STK_SIZE-1], LED_TASK_Prio);
    OSTaskCreate(TaskLed1, (void * )0, (OS_STK *)&TASK_LED1_STK[LED1_STK_SIZE-1], LED1_TASK_Prio);
    OSTaskSuspend(START_TASK_Prio);    //suspend but not delete
    OS_EXIT_CRITICAL();
}

void TaskLed(void *pdata)
{
      GPIO_ResetBits(GPIOA,GPIO_Pin_4);
    
        while(1)
        {    
            SPI1_DMA_SendBytes();            
            
            OSTimeDlyHMSM(0,0,0,300);    
        }
}

void TaskLed1(void *pdata)
{
    while(1)
    {
        /*led_on_or_off(pb_13,1);
        led_on_or_off(pb_14,1);
        OSTimeDlyHMSM(0,0,0,200);    
        led_on_or_off(pb_13,0);
        led_on_or_off(pb_14,0);*/
        OSTimeDlyHMSM(0,0,0,200);    
    }
}    

void SysTick_Handler(void)
{
    OS_ENTER_CRITICAL(); /* Tell uC/OS-II that we are starting an ISR  */
    OSIntNesting++;
    OS_EXIT_CRITICAL();
    OSTimeTick();        /* Call uC/OS-II's OSTimeTick()               */
    OSIntExit();         /* Tell uC/OS-II that we are leaving the ISR  */
}


void SysTick_Configuration(void)
{
     SysTick->CTRL&=~(1<<2);
    SysTick->CTRL|=1<<1;   
    SysTick ->LOAD=9000;    
    
     SysTick->CTRL|=1<<0;   
}


int main(void)
{  
    Init_All_Periph();
    
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    delay_init();
    SysTick_Configuration();
    OSInit();
    OSTaskCreate( TaskStart,    
                    (void *)0,    
                    (OS_STK *)&TASK_START_STK[START_STK_SIZE-1],    
                    START_TASK_Prio );    
    OSStart();
    return 0;    
}

从机

1. 

从机SPI2通信：


 #include "spi.h"

#define  SPI_SPEED    SPI_BaudRatePrescaler_128

volatile uint8_t SPI2_TxBuf[9];
volatile uint8_t SPI_RX_Buff[9];
void SPI2_Init(void)
{    
    NVIC_InitTypeDef NVIC_InitStructure;
    GPIO_InitTypeDef  GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;
    DMA_InitTypeDef  DMA_InitStructure;
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO,   ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
    RCC_AHBPeriphClockCmd (RCC_AHBPeriph_DMA1, 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_IPU;//GPIO_Mode_IPD;         
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);    
    GPIO_SetBits(GPIOB,GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
    
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;      
    SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;                                        
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                  
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                          
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                        
    SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;                                              
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_SPEED;      
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                              
    SPI_InitStructure.SPI_CRCPolynomial = 7;                                              
    
    NVIC_InitStructure.NVIC_IRQChannel=SPI2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
    NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    SPI_I2S_ITConfig(SPI2,SPI_I2S_IT_RXNE,ENABLE);            
    
    SPI_Init(SPI2, &SPI_InitStructure);    
    //SPI2-TX-DMA
    DMA_DeInit(DMA1_Channel5);
    DMA_InitStructure.DMA_PeripheralBaseAddr =  (uint32_t)&SPI2->DR;
    DMA_InitStructure.DMA_MemoryBaseAddr =      (uint32_t)SPI2_TxBuf;
    DMA_InitStructure.DMA_DIR =                 DMA_DIR_PeripheralDST;         
    DMA_InitStructure.DMA_BufferSize =          9;
    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_High;             
    DMA_InitStructure.DMA_M2M =                 DMA_M2M_Disable;               
    DMA_Init(DMA1_Channel5, &DMA_InitStructure);
    
    //SPI2-RX-DMA            
    DMA_DeInit(DMA1_Channel4);
    DMA_InitStructure.DMA_PeripheralBaseAddr =  (uint32_t)&SPI2->DR;
    DMA_InitStructure.DMA_MemoryBaseAddr =      (uint32_t)SPI_RX_Buff;
    DMA_InitStructure.DMA_DIR =                 DMA_DIR_PeripheralSRC;         
    DMA_InitStructure.DMA_BufferSize =          9;
    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_High;             
    DMA_InitStructure.DMA_M2M =                 DMA_M2M_Disable;               
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);    
                    
    DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, ENABLE);    
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
                        
    SPI_I2S_DMACmd(SPI2,SPI_I2S_DMAReq_Tx,ENABLE);
    SPI_I2S_DMACmd(SPI2,SPI_I2S_DMAReq_Rx,ENABLE);    
    SPI_Cmd(SPI2, ENABLE);                
    
    SPI2->DR;
}


//SPI ËÙ¶ÈÉèÖú¯Êý
//SpeedSet:
//SPI_SPEED_2   2·ÖƵ   (SPI 12M    --sys 24M)
//SPI_SPEED_8   8·ÖƵ   (SPI 3M     --sys 24M)
//SPI_SPEED_16  16·ÖƵ  (SPI 1.5M    --sys 24M)
//SPI_SPEED_256 256·ÖƵ (SPI  905.6K --sys 24M)

void SPI2_SetSpeed(u8 SpeedSet)
{
    SPI2->CR1&=0XFFC7;//Fsck=Fcpu/256
    if(SpeedSet==SPI_SPEED_2)//¶þ·ÖƵ
    {
        SPI2->CR1|=0<<3;//Fsck=Fpclk/2=36Mhz    
    }
    else if(SpeedSet==SPI_SPEED_8)//°Ë·ÖƵ
    {
        SPI2->CR1|=2<<3;//Fsck=Fpclk/8=9Mhz    
    }
    else if(SpeedSet==SPI_SPEED_16)//Ê®Áù·ÖƵ
    {
        SPI2->CR1|=3<<3;//Fsck=Fpclk/16=4.5Mhz
    }
    else                  //256·ÖƵ
    {
        SPI2->CR1|=7<<3; //Fsck=Fpclk/256=281.25Khz µÍËÙģʽ
    }
    SPI2->CR1|=1<<6; //SPIÉ豸ʹÄÜ      
}
u8 SPI2_ReadWriteByte(u8 TxData)
{        
    u8 retry=0;                
    while((SPI2->SR&1<<1)==0)//µÈ´ý·¢ËÍÇø¿Õ    
    {
        retry++;
        if(retry>200)return 0;
    }              
    SPI2->DR=TxData;           //·¢ËÍÒ»¸öbyte
    retry=0;
    while((SPI2->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    {
        retry++;
        if(retry>200)return 0;
    }                                  
    return SPI2->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
}

u8 SPI2_ReadByte(u8 TxData)
{        
    u8 retry=0;                
    while((SPI2->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    {
        retry++;
        if(retry>200)return 0;
    }                                  
    return SPI2->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
}

2. 

#include "sys.h" //ϵͳ×Óº¯Êý    
#include "delay.h" //ÑÓʱ×Óº¯Êý
#include "spi.h"
#include 
#include 
extern volatile uint8_t SPI2_TxBuf[9];
extern volatile uint8_t SPI_RX_Buff[9];
uint8_t rev_data[9];
u8 buff = 0;    
u8 Slave_Temp=0;
int count =0 ;
void SPI2_Init(void);             //³õʼ»¯SPI¿Ú
void SPI2_SetSpeed(u8 SpeedSet); //ÉèÖÃSPIËÙ¶È   
u8 SPI2_ReadWriteByte(u8 TxData);
void spi_send_read(void);
//PB13 SPI2_SCK
//PB14 SPI2_MISO
//PB15 SPI2_MOSI

int main(void)
{
         SystemInit();
         delay_init(72);         //ÑÓʱ³õʼ»¯
         NVIC_Configuration();    
        SPI2_Init(); //SPI2³õʼ»¯
        
        while(1)
        {    
                delay_ms(100);    
        }
}


void DMA1_Channel4_IRQHandler(){//SPI2-RX-DMA    
    if(DMA_GetFlagStatus(DMA1_FLAG_TC4)!=RESET){
         DMA_ClearFlag(DMA1_FLAG_TC4);        
         //memset((u8 *)SPI_RX_Buff,0,8);    
         SPI_I2S_ITConfig(SPI2,SPI_I2S_IT_RXNE,ENABLE);
    }
}

void DMA1_Channel5_IRQHandler(){//SPI2-TX-DMA
    if(DMA_GetFlagStatus(DMA1_FLAG_TC5)!=RESET){
          DMA_ClearFlag(DMA1_FLAG_TC5);
    }    
}

void SPI2_IRQHandler(void)
{    
    u8 work_up;
    if((SPI2->SR&1<<0)==1) {    
        // buff = SPI2->DR;
         SPI_I2S_ITConfig(SPI2,SPI_I2S_IT_RXNE,DISABLE);
         spi_send_read();
     buff = SPI2->DR;        
    }     
}

void spi_send_read(){
      DMA_Cmd(DMA1_Channel5, DISABLE);  
      DMA_Cmd(DMA1_Channel4, DISABLE);
    DMA_SetCurrDataCounter(DMA1_Channel5, 9);
    DMA_SetCurrDataCounter(DMA1_Channel4, 9);
      DMA_ClearFlag(DMA1_FLAG_GL5|DMA1_FLAG_TC5|DMA1_FLAG_HT5|DMA1_FLAG_TE5);
    DMA_ClearFlag(DMA1_FLAG_GL4|DMA1_FLAG_TC4|DMA1_FLAG_HT4|DMA1_FLAG_TE4);    
    DMA_Cmd(DMA1_Channel5, ENABLE);
    DMA_Cmd(DMA1_Channel4, ENABLE);
      memcpy(rev_data,(u8 *)SPI_RX_Buff,9);
}