• 基于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. 

    1. #include "spi.h"
    2. volatile uint8_t SPI2_TxBuf[8];
    3. volatile uint8_t SPI_RX_Buff[8];
    4. u8 Master_Temp =0;
    5. void SPI1_Init(void)
    6. {    
    7.     NVIC_InitTypeDef NVIC_InitStructure;
    8.     GPIO_InitTypeDef  GPIO_InitStructure;
    9.     SPI_InitTypeDef  SPI_InitStructure;
    10.     DMA_InitTypeDef  DMA_Initstructure;  
    11.     
    12.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);     //ʹÄÜPA¶Ë¿ÚʱÖÓ
    13.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO,   ENABLE);
    14.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
    15.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    16.     
    17.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;                
    18.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;          //ÍÆÍìÊä³ö
    19.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    20.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    21.     
    22.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                
    23.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         
    24.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    25.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    26.       
    27.     //SPI_SSOutputCmd(SPI1,ENABLE);
    28.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    29.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;//SPI_Mode_Master    SPI_Mode_Slave                             
    30.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                               
    31.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                       
    32.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                     
    33.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;    //SPI_NSS_Hard        SPI_NSS_Soft                               
    34.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;    
    35.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                           
    36.     SPI_InitStructure.SPI_CRCPolynomial = 7;
    37.     SPI_Init(SPI1, &SPI_InitStructure);    
    38.     SPI_Cmd(SPI1, ENABLE);
    39.     //SPI_I2S_ITConfig(SPI1,SPI_I2S_IT_RXNE,ENABLE);
    40.     
    41.     DMA_DeInit(DMA1_Channel3);
    42.     DMA_Initstructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI1->DR;
    43.     DMA_Initstructure.DMA_MemoryBaseAddr =     (uint32_t)SPI2_TxBuf;
    44.     DMA_Initstructure.DMA_DIR =                DMA_DIR_PeripheralDST;             
    45.     DMA_Initstructure.DMA_BufferSize =         0;
    46.     DMA_Initstructure.DMA_PeripheralInc =      DMA_PeripheralInc_Disable;         
    47.     DMA_Initstructure.DMA_MemoryInc =          DMA_MemoryInc_Enable;              
    48.     DMA_Initstructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;       
    49.     DMA_Initstructure.DMA_MemoryDataSize =     DMA_MemoryDataSize_Byte;           
    50.     DMA_Initstructure.DMA_Mode =               DMA_Mode_Normal;                   
    51.     DMA_Initstructure.DMA_Priority =           DMA_Priority_VeryHigh;                 
    52.     DMA_Initstructure.DMA_M2M =                DMA_M2M_Disable;                   
    53.     DMA_Init(DMA1_Channel3, &DMA_Initstructure);     
    54.   //DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);
    55.     
    56.     SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Tx,ENABLE);
    57.     
    58.     DMA_DeInit(DMA1_Channel2);
    59.     DMA_Initstructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI1->DR;
    60.     DMA_Initstructure.DMA_MemoryBaseAddr =     (uint32_t)SPI_RX_Buff;
    61.     DMA_Initstructure.DMA_DIR =                DMA_DIR_PeripheralSRC;      
    62.     DMA_Initstructure.DMA_BufferSize =         0;
    63.     DMA_Initstructure.DMA_PeripheralInc =      DMA_PeripheralInc_Disable;  
    64.     DMA_Initstructure.DMA_MemoryInc =          DMA_MemoryInc_Enable;       
    65.     DMA_Initstructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    66.     DMA_Initstructure.DMA_MemoryDataSize =     DMA_MemoryDataSize_Byte;    
    67.     DMA_Initstructure.DMA_Mode =               DMA_Mode_Normal;            
    68.     DMA_Initstructure.DMA_Priority =           DMA_Priority_VeryHigh;      
    69.     DMA_Initstructure.DMA_M2M =                DMA_M2M_Disable;            
    70.     DMA_Init(DMA1_Channel2, &DMA_Initstructure);
    71. //    DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);
    72.     SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Rx,ENABLE);
    73.                 
    74.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel3_IRQn;
    75.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    76.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    77.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    78.     NVIC_Init(&NVIC_InitStructure);
    79.     
    80.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn;
    81.     NVIC_Init(&NVIC_InitStructure);
    82.     
    83.     NVIC_InitStructure.NVIC_IRQChannel = SPI1_IRQn;
    84.     NVIC_Init(&NVIC_InitStructure);
    85.     
    86.     GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);    
    87.      //SPI1_ReadWriteByte(0xff);//Æô¶¯´«Êä                         
    88. }   
    89. void SPI1_SetSpeed(u8 SpeedSet)
    90. {
    91.     SPI1->CR1&=0XFFC7;//Fsck=Fcpu/256
    92.     if(SpeedSet==SPI_SPEED_2)//¶þ·ÖƵ
    93.     {
    94.         SPI1->CR1|=0<<3;//Fsck=Fpclk/2=36Mhz    
    95.     }else if(SpeedSet==SPI_SPEED_8)//°Ë·ÖƵ
    96.     {
    97.         SPI1->CR1|=2<<3;//Fsck=Fpclk/8=9Mhz    
    98.     }else if(SpeedSet==SPI_SPEED_16)//Ê®Áù·ÖƵ
    99.     {
    100.         SPI1->CR1|=3<<3;//Fsck=Fpclk/16=4.5Mhz
    101.     }else                  //256·ÖƵ
    102.     {
    103.         SPI1->CR1|=7<<3; //Fsck=Fpclk/256=281.25Khz µÍËÙģʽ
    104.     }
    105.     SPI1->CR1|=1<<6; //SPIÉ豸ʹÄÜ      
    106. }
    107. u8 SPI1_ReadWriteByte(u8 TxData)
    108. {        
    109.     u8 retry=0;                
    110.     while((SPI1->SR&1<<1)==0)//µÈ´ý·¢ËÍÇø¿Õ    
    111.     {
    112.         retry++;
    113.         if(retry>200)return 0;
    114.     }              
    115.     SPI1->DR=TxData;           //·¢ËÍÒ»¸öbyte
    116.     retry=0;
    117.     while((SPI1->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    118.     {
    119.         retry++;
    120.         if(retry>200)return 0;
    121.     }                                  
    122.     return SPI1->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
    123. }
    124.  
    125. u8 SPI1_ReadByte(u8 TxData)
    126. {        
    127.     u8 retry=0;                
    128.     while((SPI1->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    129.     {
    130.         retry++;
    131.         if(retry>200)return 0;
    132.     }                                  
    133.     return SPI1->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
    134. }
    135.  
    136. void SPI1_IRQHandler(void)
    137. {    
    138.     if((SPI1->SR&1<<0)==1)
    139.     {    
    140.         Master_Temp = SPI1_ReadByte(0x00);
    141.     }     
    142. }
    143.  
    144. void DMA1_Channel2_IRQHandler(){//SPI1-RX-DMA    
    145.     if(DMA_GetFlagStatus(DMA1_FLAG_TC2)!=RESET){
    146.             DMA_ClearFlag(DMA1_FLAG_TC2);    
    147.           DMA_Cmd(DMA1_Channel2, DISABLE);
    148.             }
    149. }
    150.  
    151. void DMA1_Channel3_IRQHandler(){//SPI1-TX-DMA
    152.     if(DMA_GetFlagStatus(DMA1_FLAG_TC3)!=RESET){
    153.             DMA_ClearFlag(DMA1_FLAG_TC3);
    154.           //DMA_Cmd(DMA1_Channel3, DISABLE);
    155.             }    
    156. }
    157. /********************************************************/

    2.

    1. /********************************************************/
    2.  
    3.  
    4. #include "stm32f10x.h"
    5. #include <stdio.h>
    6. #include "delay.h"
    7. #include "includes.h"
    8. #include "led.h"
    9. #include "spi.h"
    10.  
    11.  
    12. #define LED_STK_SIZE     64
    13. #define LED1_STK_SIZE    64
    14. #define START_STK_SIZE   128
    15. #define SPI_SPEED_2   0
    16. #define SPI_SPEED_8   1
    17. #define SPI_SPEED_16  2
    18. #define SPI_SPEED_256 3
    19.  
    20. #define LED_TASK_Prio       9
    21. #define LED1_TASK_Prio      5
    22. #define START_TASK_Prio     10
    23.  
    24. str_led pb_13;
    25. str_led pb_14;
    26.  
    27. extern  volatile uint8_t SPI2_TxBuf[8];
    28. extern  volatile uint8_t SPI_RX_Buff[8];
    29. uint8_t  send_data[10];
    30. uint8_t  rev_data[10];
    31.  
    32. OS_STK  TASK_LED1_STK[LED_STK_SIZE];
    33. OS_STK  TASK_LED_STK[LED_STK_SIZE];
    34. OS_STK  TASK_START_STK[START_STK_SIZE];
    35.  
    36. void TaskStart(void *pdata);
    37. void TaskLed(void *pdata);
    38. void TaskLed1(void *pdata);
    39. void SysTick_Configuration(void);
    40.  
    41. void GPIO_Configuration(void)
    42. {     
    43.       pb_13.GPIOX = GPIOB;
    44.       pb_13.pin = GPIO_Pin_13;
    45.       
    46.       pb_14.GPIOX = GPIOB;
    47.       pb_14.pin = GPIO_Pin_14;
    48.     
    49.       gpio_led_init(pb_13);
    50.       gpio_led_init(pb_14);
    51.     
    52. }
    53. void SPI1_DMA_SendBytes(void)
    54. {
    55.     int i = 0 ;    
    56.       for(i = 0;i < 8;i++)
    57.         {
    58.             send_data[i] = (i+2);
    59.         }
    60.         memcpy((u8 *)SPI2_TxBuf,send_data,8);    
    61.     DMA_SetCurrDataCounter(DMA1_Channel3, 8);
    62.     DMA_SetCurrDataCounter(DMA1_Channel2, 8);
    63.         SPI1->DR;
    64.         SPI1->DR;
    65.     DMA_Cmd(DMA1_Channel3, ENABLE);
    66.     DMA_Cmd(DMA1_Channel2, ENABLE);
    67.         while(!DMA_GetFlagStatus(DMA1_FLAG_TC4)){
    68.             i++;
    69.             OSTimeDlyHMSM(0,0,0,005);
    70.             if(i>50){
    71.               DMA_ClearFlag(DMA1_FLAG_GL3|DMA1_FLAG_TC3|DMA1_FLAG_HT3|DMA1_FLAG_TE3);
    72.         DMA_ClearFlag(DMA1_FLAG_GL2|DMA1_FLAG_TC2|DMA1_FLAG_HT2|DMA1_FLAG_TE2);                 
    73.             DMA_Cmd(DMA1_Channel3, DISABLE);
    74.             DMA_Cmd(DMA1_Channel2, DISABLE);
    75.                 return;        
    76.             }
    77.         };
    78.         while((SPI1->SR&1<<1)!=0x0002){};
    79.     while((SPI1->SR&1<<7)!=0x0000){};    
    80.         DMA_ClearFlag(DMA1_FLAG_GL3|DMA1_FLAG_TC3|DMA1_FLAG_HT3|DMA1_FLAG_TE3);
    81.     DMA_ClearFlag(DMA1_FLAG_GL2|DMA1_FLAG_TC2|DMA1_FLAG_HT2|DMA1_FLAG_TE2);                     
    82.         DMA_Cmd(DMA1_Channel3, DISABLE);
    83.         DMA_Cmd(DMA1_Channel2, DISABLE);
    84.         memcpy(rev_data,(u8 *)SPI_RX_Buff,8);
    85.           
    86. }
    87.  
    88. void NVIC_Configuration(void)
    89. {
    90.     //NVIC_InitTypeDef NVIC_InitStructure;
    91.      /* Configure the NVIC Preemption Priority Bits */  
    92.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);    //???????:?????0?,????4?
    93.      //???????????
    94.     #ifdef  VECT_TAB_RAM  
    95.         /* Set the Vector Table base location at 0x20000000 */
    96.         NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);         //?????RAM
    97.     #else  /* VECT_TAB_FLASH  */
    98.         /* Set the Vector Table base location at 0x08000000 */
    99.         NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   //?????FLASH
    100.     #endif
    101. }
    102.  
    103. void RCC_Configuration(void)
    104. {
    105.     SystemInit();        
    106. }
    107. void SPI_Configuration(void)
    108. {
    109.     SPI1_Init();
    110.     memset((u8 *)SPI2_TxBuf,0,8);
    111.     memset((u8 *)SPI_RX_Buff,0,8);
    112.     
    113. }
    114. void Init_All_Periph(void)
    115. {    
    116.     RCC_Configuration();    
    117.      //NVIC_Configuration();
    118.      GPIO_Configuration();
    119.     SPI_Configuration();
    120.  
    121. }
    122.  
    123. void TaskStart(void * pdata)
    124. {
    125.     pdata = pdata;
    126.     OS_ENTER_CRITICAL();   
    127.     OSTaskCreate(TaskLed, (void * )0, (OS_STK *)&TASK_LED_STK[LED_STK_SIZE-1], LED_TASK_Prio);
    128.     OSTaskCreate(TaskLed1, (void * )0, (OS_STK *)&TASK_LED1_STK[LED1_STK_SIZE-1], LED1_TASK_Prio);
    129.     OSTaskSuspend(START_TASK_Prio);    //suspend but not delete
    130.     OS_EXIT_CRITICAL();
    131. }
    132.  
    133. void TaskLed(void *pdata)
    134. {
    135.       GPIO_ResetBits(GPIOA,GPIO_Pin_4);
    136.     
    137.         while(1)
    138.         {    
    139.             SPI1_DMA_SendBytes();            
    140.             
    141.             OSTimeDlyHMSM(0,0,0,300);    
    142.         }
    143. }
    144.  
    145. void TaskLed1(void *pdata)
    146. {
    147.     while(1)
    148.     {
    149.         /*led_on_or_off(pb_13,1);
    150.         led_on_or_off(pb_14,1);
    151.         OSTimeDlyHMSM(0,0,0,200);    
    152.         led_on_or_off(pb_13,0);
    153.         led_on_or_off(pb_14,0);*/
    154.         OSTimeDlyHMSM(0,0,0,200);    
    155.     }
    156. }    
    157.  
    158. void SysTick_Handler(void)
    159. {
    160.     OS_ENTER_CRITICAL(); /* Tell uC/OS-II that we are starting an ISR  */
    161.     OSIntNesting++;
    162.     OS_EXIT_CRITICAL();
    163.     OSTimeTick();        /* Call uC/OS-II's OSTimeTick()               */
    164.     OSIntExit();         /* Tell uC/OS-II that we are leaving the ISR  */
    165. }
    168. void SysTick_Configuration(void)
    169. {
    170.      SysTick->CTRL&=~(1<<2);
    171.     SysTick->CTRL|=1<<1;   
    172.     SysTick ->LOAD=9000;    
    173.     
    174.      SysTick->CTRL|=1<<0;   
    175. }
    178. int main(void)
    179. {  
    180.     Init_All_Periph();
    181.     
    182.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    183.     delay_init();
    184.     SysTick_Configuration();
    185.     OSInit();
    186.     OSTaskCreate( TaskStart,    
    187.                     (void *)0,    
    188.                     (OS_STK *)&TASK_START_STK[START_STK_SIZE-1],    
    189.                     START_TASK_Prio );    
    190.     OSStart();
    191.     return 0;    
    192. }

    从机

    1. 

    1. 从机SPI2通信：
    2.  
    3.  
    4.  #include "spi.h"
    5.  
    6. #define  SPI_SPEED    SPI_BaudRatePrescaler_128
    7.  
    8. volatile uint8_t SPI2_TxBuf[9];
    9. volatile uint8_t SPI_RX_Buff[9];
    10. void SPI2_Init(void)
    11. {    
    12.     NVIC_InitTypeDef NVIC_InitStructure;
    13.     GPIO_InitTypeDef  GPIO_InitStructure;
    14.     SPI_InitTypeDef  SPI_InitStructure;
    15.     DMA_InitTypeDef  DMA_InitStructure;
    16.     
    17.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO,   ENABLE);
    18.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
    19.     RCC_AHBPeriphClockCmd (RCC_AHBPeriph_DMA1, ENABLE);
    20.     
    21.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_13 | GPIO_Pin_14|GPIO_Pin_15;                  
    22.   GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    23.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    24.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    25.               
    26.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;                
    27.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//GPIO_Mode_IPD;         
    28.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    29.   GPIO_Init(GPIOB, &GPIO_InitStructure);    
    30.     GPIO_SetBits(GPIOB,GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
    31.     
    32.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;      
    33.     SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;                                        
    34.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                  
    35.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                          
    36.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                        
    37.     SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;                                              
    38.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_SPEED;      
    39.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                              
    40.     SPI_InitStructure.SPI_CRCPolynomial = 7;                                              
    41.     
    42.     NVIC_InitStructure.NVIC_IRQChannel=SPI2_IRQn;
    43.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
    44.     NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
    45.     NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    46.     NVIC_Init(&NVIC_InitStructure);
    47.  
    48.     SPI_I2S_ITConfig(SPI2,SPI_I2S_IT_RXNE,ENABLE);            
    49.     
    50.     SPI_Init(SPI2, &SPI_InitStructure);    
    51.     //SPI2-TX-DMA
    52.     DMA_DeInit(DMA1_Channel5);
    53.     DMA_InitStructure.DMA_PeripheralBaseAddr =  (uint32_t)&SPI2->DR;
    54.     DMA_InitStructure.DMA_MemoryBaseAddr =      (uint32_t)SPI2_TxBuf;
    55.     DMA_InitStructure.DMA_DIR =                 DMA_DIR_PeripheralDST;         
    56.     DMA_InitStructure.DMA_BufferSize =          9;
    57.     DMA_InitStructure.DMA_PeripheralInc =       DMA_PeripheralInc_Disable;     
    58.     DMA_InitStructure.DMA_MemoryInc =           DMA_MemoryInc_Enable;          
    59.     DMA_InitStructure.DMA_PeripheralDataSize =  DMA_PeripheralDataSize_Byte;   
    60.     DMA_InitStructure.DMA_MemoryDataSize =      DMA_MemoryDataSize_Byte;       
    61.     DMA_InitStructure.DMA_Mode =                DMA_Mode_Normal;               
    62.     DMA_InitStructure.DMA_Priority =            DMA_Priority_High;             
    63.     DMA_InitStructure.DMA_M2M =                 DMA_M2M_Disable;               
    64.     DMA_Init(DMA1_Channel5, &DMA_InitStructure);
    65.     
    66.     //SPI2-RX-DMA            
    67.     DMA_DeInit(DMA1_Channel4);
    68.     DMA_InitStructure.DMA_PeripheralBaseAddr =  (uint32_t)&SPI2->DR;
    69.     DMA_InitStructure.DMA_MemoryBaseAddr =      (uint32_t)SPI_RX_Buff;
    70.     DMA_InitStructure.DMA_DIR =                 DMA_DIR_PeripheralSRC;         
    71.     DMA_InitStructure.DMA_BufferSize =          9;
    72.     DMA_InitStructure.DMA_PeripheralInc =       DMA_PeripheralInc_Disable;     
    73.     DMA_InitStructure.DMA_MemoryInc =           DMA_MemoryInc_Enable;          
    74.     DMA_InitStructure.DMA_PeripheralDataSize =  DMA_PeripheralDataSize_Byte;   
    75.     DMA_InitStructure.DMA_MemoryDataSize =      DMA_MemoryDataSize_Byte;       
    76.     DMA_InitStructure.DMA_Mode =                DMA_Mode_Normal;               
    77.     DMA_InitStructure.DMA_Priority =            DMA_Priority_High;             
    78.     DMA_InitStructure.DMA_M2M =                 DMA_M2M_Disable;               
    79.     DMA_Init(DMA1_Channel4, &DMA_InitStructure);    
    80.                     
    81.     DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, ENABLE);    
    82.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
    83.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    84.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    85.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    86.     NVIC_Init(&NVIC_InitStructure);
    87.                         
    88.     SPI_I2S_DMACmd(SPI2,SPI_I2S_DMAReq_Tx,ENABLE);
    89.     SPI_I2S_DMACmd(SPI2,SPI_I2S_DMAReq_Rx,ENABLE);    
    90.     SPI_Cmd(SPI2, ENABLE);                
    91.     
    92.     SPI2->DR;
    93. }
    94.  
    95.  
    96. //SPI ËÙ¶ÈÉèÖú¯Êý
    97. //SpeedSet:
    98. //SPI_SPEED_2   2·ÖƵ   (SPI 12M    --sys 24M)
    99. //SPI_SPEED_8   8·ÖƵ   (SPI 3M     --sys 24M)
    100. //SPI_SPEED_16  16·ÖƵ  (SPI 1.5M    --sys 24M)
    101. //SPI_SPEED_256 256·ÖƵ (SPI  905.6K --sys 24M)
    102.  
    103. void SPI2_SetSpeed(u8 SpeedSet)
    104. {
    105.     SPI2->CR1&=0XFFC7;//Fsck=Fcpu/256
    106.     if(SpeedSet==SPI_SPEED_2)//¶þ·ÖƵ
    107.     {
    108.         SPI2->CR1|=0<<3;//Fsck=Fpclk/2=36Mhz    
    109.     }
    110.     else if(SpeedSet==SPI_SPEED_8)//°Ë·ÖƵ
    111.     {
    112.         SPI2->CR1|=2<<3;//Fsck=Fpclk/8=9Mhz    
    113.     }
    114.     else if(SpeedSet==SPI_SPEED_16)//Ê®Áù·ÖƵ
    115.     {
    116.         SPI2->CR1|=3<<3;//Fsck=Fpclk/16=4.5Mhz
    117.     }
    118.     else                  //256·ÖƵ
    119.     {
    120.         SPI2->CR1|=7<<3; //Fsck=Fpclk/256=281.25Khz µÍËÙģʽ
    121.     }
    122.     SPI2->CR1|=1<<6; //SPIÉ豸ʹÄÜ      
    123. }
    124. u8 SPI2_ReadWriteByte(u8 TxData)
    125. {        
    126.     u8 retry=0;                
    127.     while((SPI2->SR&1<<1)==0)//µÈ´ý·¢ËÍÇø¿Õ    
    128.     {
    129.         retry++;
    130.         if(retry>200)return 0;
    131.     }              
    132.     SPI2->DR=TxData;           //·¢ËÍÒ»¸öbyte
    133.     retry=0;
    134.     while((SPI2->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    135.     {
    136.         retry++;
    137.         if(retry>200)return 0;
    138.     }                                  
    139.     return SPI2->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
    140. }
    141.  
    142. u8 SPI2_ReadByte(u8 TxData)
    143. {        
    144.     u8 retry=0;                
    145.     while((SPI2->SR&1<<0)==0) //µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
    146.     {
    147.         retry++;
    148.         if(retry>200)return 0;
    149.     }                                  
    150.     return SPI2->DR;          //·µ»ØÊÕµ½µÄÊý¾Ý                    
    151. }

    2. 

    1. #include "sys.h" //ϵͳ×Óº¯Êý    
    2. #include "delay.h" //ÑÓʱ×Óº¯Êý
    3. #include "spi.h"
    4. #include <stdlib.h>
    5. #include <string.h>
    6. extern volatile uint8_t SPI2_TxBuf[9];
    7. extern volatile uint8_t SPI_RX_Buff[9];
    8. uint8_t rev_data[9];
    9. u8 buff = 0;    
    10. u8 Slave_Temp=0;
    11. int count =0 ;
    12. void SPI2_Init(void);             //³õʼ»¯SPI¿Ú
    13. void SPI2_SetSpeed(u8 SpeedSet); //ÉèÖÃSPIËÙ¶È   
    14. u8 SPI2_ReadWriteByte(u8 TxData);
    15. void spi_send_read(void);
    16. //PB13 SPI2_SCK
    17. //PB14 SPI2_MISO
    18. //PB15 SPI2_MOSI
    19.  
    20. int main(void)
    21. {
    22.          SystemInit();
    23.          delay_init(72);         //ÑÓʱ³õʼ»¯
    24.          NVIC_Configuration();    
    25.         SPI2_Init(); //SPI2³õʼ»¯
    26.         
    27.         while(1)
    28.         {    
    29.                 delay_ms(100);    
    30.         }
    31. }
    32.  
    33.  
    34. void DMA1_Channel4_IRQHandler(){//SPI2-RX-DMA    
    35.     if(DMA_GetFlagStatus(DMA1_FLAG_TC4)!=RESET){
    36.          DMA_ClearFlag(DMA1_FLAG_TC4);        
    37.          //memset((u8 *)SPI_RX_Buff,0,8);    
    38.          SPI_I2S_ITConfig(SPI2,SPI_I2S_IT_RXNE,ENABLE);
    39.     }
    40. }
    41.  
    42. void DMA1_Channel5_IRQHandler(){//SPI2-TX-DMA
    43.     if(DMA_GetFlagStatus(DMA1_FLAG_TC5)!=RESET){
    44.           DMA_ClearFlag(DMA1_FLAG_TC5);
    45.     }    
    46. }
    47.  
    48. void SPI2_IRQHandler(void)
    49. {    
    50.     u8 work_up;
    51.     if((SPI2->SR&1<<0)==1) {    
    52.         // buff = SPI2->DR;
    53.          SPI_I2S_ITConfig(SPI2,SPI_I2S_IT_RXNE,DISABLE);
    54.          spi_send_read();
    55.      buff = SPI2->DR;        
    56.     }     
    57. }
    58.  
    59. void spi_send_read(){
    60.       DMA_Cmd(DMA1_Channel5, DISABLE);  
    61.       DMA_Cmd(DMA1_Channel4, DISABLE);
    62.     DMA_SetCurrDataCounter(DMA1_Channel5, 9);
    63.     DMA_SetCurrDataCounter(DMA1_Channel4, 9);
    64.       DMA_ClearFlag(DMA1_FLAG_GL5|DMA1_FLAG_TC5|DMA1_FLAG_HT5|DMA1_FLAG_TE5);
    65.     DMA_ClearFlag(DMA1_FLAG_GL4|DMA1_FLAG_TC4|DMA1_FLAG_HT4|DMA1_FLAG_TE4);    
    66.     DMA_Cmd(DMA1_Channel5, ENABLE);
    67.     DMA_Cmd(DMA1_Channel4, ENABLE);
    68.       memcpy(rev_data,(u8 *)SPI_RX_Buff,9);
    69. }
    70.

  • 相关阅读:
    【应用程序启动过程-三种加载控制器的方式-上午内容复习 Objective-C语言】
    峰会实录 | 镜舟科技CEO孙文现：基于StarRocks打造企业级极速统一数据分析产品
    神经网络结构图怎么看的,神经网络结果图如何看
    Go 存储系列：B+树存储引擎 boltdb
    spring aop
    ObjectProvider学习
    OSPF——基本概念2（多区域与Vlink）
    【Android笔记20】Android中的字符串、颜色、尺寸等资源的介绍及使用
    Java优先级队列（堆）
    Linux内核开发 | Linux内核目录结构分析（5.4.32）
  • 原文地址：https://blog.csdn.net/momodenglu/article/details/132838105