* ]% p" u9 q1 f1 W/ ]
, E  [& I+ C1 n5 M/*
" v! g( ~3 O6 a  O1 P! t+ W# f * spi2.c
8 T* x" U0 ~% A" z- f. v5 a *
*  Created on: 2015年6月22日
*      Author: WJ
  [, y" t+ ~$ L! b+ Z. u9 u/ @$ w8 x */
! A: [5 c; }" M' g

1 x3 n8 d4 M/ m; ^4 |$ n  ]& S8 S( g/* Includes ------------------------------------------------------------------*/
& m9 e7 I& j4 W9 h, }) e( x; O#include "stm32f10x_conf.h"
4 O$ M; y7 f; }! L. E' H$ J
#define SPI_Flash_CS_Low()  {GPIO_ResetBits(GPIOC, GPIO_Pin_13);}
#define SPI_Flash_CS_High() {GPIO_SetBits(GPIOC, GPIO_Pin_13);}

uint8_t SPI2_Rx_Buf[4096];
uint8_t SPI2_Tx_Buf[4096];
) k6 n- C2 ]$ n9 M0 [
extern uint16_t Flag_DMA_Rxd_Finished;

2 e* l) B$ t. cextern uint8_t SPI2_Byte_Read_Write(uint8_t SPI_Byte);
6 K5 q3 M% Z* [: L7 l2 {( U' }
  v6 Q& I- ?) n5 z5 A" W1 ^/**
  * @brief  Configures the SPI2 Peripheral.
  * @param  None
  * @retval None
* l+ V8 T6 F8 D2 p- }* L3 D3 O5 |  */
5 U* }/ q# T2 j3 hvoid SPI2_Config(void){
9 g, J  A9 i' M3 s# A2 y/ m        GPIO_InitTypeDef GPIO_InitStructure;
        SPI_InitTypeDef  SPI_InitStructure;
7 u4 n- f" ]; h8 p+ O2 ?2 z+ x        DMA_InitTypeDef  DMA_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
/ j  l' j+ F* j$ F$ v
8 J6 k/ u" _1 l        /* Forces or releases High Speed APB (APB2) peripheral reset --------------*/
, I8 _! [0 X! k/ p8 s2 g4 O2 ]( t' w        RCC_APB2PeriphResetCmd(RCC_APB2Periph_AFIO, ENABLE);
        RCC_APB2PeriphResetCmd(RCC_APB2Periph_AFIO, DISABLE);

        RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOA, ENABLE);
        RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOA, DISABLE);

" g+ R4 C* o& m9 p. a4 q' D        RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOB, ENABLE);
+ Q9 U3 K' c/ t! u! w        RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOB, DISABLE);
( g5 A9 c% A7 r
$ v  N2 Y8 T5 j        RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOC, ENABLE);
& |+ x' a5 p: K; j3 v1 S6 G        RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOC, DISABLE);

3 t: V5 Q; G' E% p1 U3 p+ ?        RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE);
        RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, DISABLE);
        /* Peripheral Clock Enable -------------------------------------------------*/
* F6 b, Z0 B4 O, M$ i7 h/ O* b        /* DMA1 clock enable */
/ n) q* |" y/ S7 n/ W0 u        RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, DISABLE);
1 f( n7 z6 @$ Y5 ?% Q8 C/ f        RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
$ J6 R% P5 t8 `4 m2 s9 U        /* Enable GPIO clocks */
! k; V1 E7 a- c! ]7 P8 q* S        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
! K# _. E( \/ ?! Z. C        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
3 d- ?1 o) m5 n# X        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

4 S& N5 u1 ^# B; i" G- D% C        RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
7 M5 b3 w5 v  m9 ^* V! |  F        RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
        /* SPI GPIO Configuration --------------------------------------------------*/
        /*
1 x+ b9 o* O, t7 l3 S, L; i         * PB13 --> SPI1 SCK         Mode: GPIO_Mode_AF_PP
* V# i& y) m) |' p/ p, x& w         * PB15 --> SPI1 MOSI Write  Mode: GPIO_Mode_AF_PP
         * PB14 --> SPI1 MISO Read   Mode: GPIO_Mode_IPU
         * PC13 --> SPI1 CS
& S% V3 O+ ]5 B$ I4 s% P& b: ?4 Z         */

        GPIO_DeInit(GPIOB);
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_15;
5 m; B* m) E' d. Q2 d        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
' Y# I# @- P/ l! r; F        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_Init(GPIOB, &GPIO_InitStructure);
+ v2 z! _. p. ~3 x) V3 U/ E        GPIO_SetBits(GPIOB, GPIO_Pin_15);

        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
* I) t% l( K  u$ B  j' Z1 @        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
% J6 g+ U+ i* [( B0 ~        GPIO_Init(GPIOB, &GPIO_InitStructure);
0 N" `) |4 }' i        GPIO_SetBits(GPIOB, GPIO_Pin_14);
% X' l' R0 H7 ?$ `4 l
        GPIO_DeInit(GPIOC);
) b; h/ W$ u% C2 C1 z' e% R& W        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
" c4 T! {+ H+ B5 e/ ?- H        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
        GPIO_Init(GPIOC, &GPIO_InitStructure);
( Z# t5 Z" \) g! p& Z        GPIO_SetBits(GPIOC, GPIO_Pin_13);

8 K4 @5 G- L7 W' o% i        SPI_Cmd(SPI2, DISABLE);
6 Z$ \3 c; G7 [! q6 Y2 s  |        SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
- `+ w* r/ s9 e& s( J        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
        SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
5 D' N" x) Y. X3 E. p* H        SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
9 @. w% @9 j5 a7 ]; K; Z+ {        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
: ^2 W- x+ Y2 F( s7 K- L/ m        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
        SPI_InitStructure.SPI_CRCPolynomial = 7;
. @+ G1 j8 F5 z        SPI_Init(SPI2, &SPI_InitStructure);
        if(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) != RESET){
  x0 H/ E4 @, Z  h% T                SPI_I2S_ReceiveData(SPI2);
1 A6 r" W+ F% f' ?& K# r                SPI_I2S_ClearFlag(SPI2, SPI_FLAG_CRCERR);
, i! J' x2 G  [. d        }

        /* DMA1 Channel4 Configures for SPIS Receive */
5 N. p; z$ R! V        DMA_DeInit(DMA1_Channel4);
        DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&SPI2->DR);
5 `) R9 A: N( G8 O( @- f5 E5 Z8 ^        DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI2_Rx_Buf;
        DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
! ^$ J2 N- H: z; K  U2 ^        DMA_InitStructure.DMA_BufferSize = 0;
6 t. R' j7 s* c) n        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;
' o* [1 K) r8 E3 m& J) Q        DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
        DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
        DMA_Init(DMA1_Channel4, &DMA_InitStructure);
) C( Z% c% \# c3 A& R
% T. O4 d; d1 M! U" a# t! p        if(DMA_GetITStatus(DMA1_IT_TC4)!= RESET){
                DMA_ClearITPendingBit(DMA1_IT_TC4);
9 [. ^' O  |5 x4 D        }
        DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, ENABLE);
        SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
7 X' ]$ J2 M, M+ _3 T
9 W$ H' |7 A0 z: r: k% D: J' d" E        /* Enable DMA1 Channel4 SPI2_RX */
        DMA_Cmd(DMA1_Channel4, DISABLE);
, o1 s/ m2 ?# b# l! n4 T
        /* DMA1 Channel5 Configures for SPI2 Send */
        DMA_DeInit(DMA1_Channel5);
5 h' U# H+ A* Z9 x4 k        DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&SPI2->DR);
        DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI2_Tx_Buf;
; v0 F1 i5 b0 Z$ ^2 K4 p        DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
. b+ @$ K2 e5 I! a6 p        DMA_InitStructure.DMA_BufferSize = 0;
0 q# Y4 ?6 n1 C7 Z        DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
        DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
3 l" L7 b! e, p6 C  p        DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
1 [  |( m# C, Z; c: I        DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
! v2 u  ~+ ~. B+ w' r        DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
* ?1 e1 Z" L# N" k1 K        DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
$ T% Y# @4 Y7 E0 _: I        DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
        DMA_Init(DMA1_Channel5, &DMA_InitStructure);

, H9 ], s* O- H  k3 n        if(DMA_GetITStatus(DMA1_IT_TC5)!= RESET){
2 F; W: x7 W) a6 l8 O                DMA_ClearITPendingBit(DMA1_IT_TC5);
9 s5 `! E- Q, [- X        }
$ v" H; }0 x. Z/ x8 L* B5 L" K  `        DMA_ITConfig(DMA1_Channel5, DMA_IT_TC, ENABLE);
: E3 m# b# P: \: C$ h0 r        SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

0 J" j! U  G# X) |- k6 p        /* Enable DMA1 Channel5 SPI1_TX */
- @1 X$ t) t  v& ?( x5 Q3 \+ g        DMA_Cmd(DMA1_Channel5, DISABLE);
" I1 T* {* V! j; \" V7 E0 H
        /* Enable the DMA1_Channel4、DMA1_Channel5 Interrupt */
        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
. @; _! q2 y. `+ O# [& b        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
+ r" z0 I$ z) Z: W; A        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
4 |/ J3 R: e/ _3 Y/ B0 E  C        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
5 }2 J. Y, b* h& s+ p+ m! @        NVIC_Init(&NVIC_InitStructure);

& Y- M5 ?: b: ~. P        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel5_IRQn;
1 k4 q1 |0 ?9 O) m6 x        NVIC_Init(&NVIC_InitStructure);

+ u3 c( ^/ f, k! b- N5 i+ x        /* Enable SPI2  */
        SPI_Cmd(SPI2, ENABLE);
' Y/ m; j, [/ F% [}
; d5 {2 b# c  V, e# \/**
0 R# v5 {+ a1 q% O  * @brief  SPI1_DMA_Start
  * @param  len <= 4096
  * @retval None
  */

* r8 V: v: [, }/ i2 o0 Q" {( Hvoid SPI2_DMA_Read_Write(uint16_t len) {
        SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
        SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
+ k+ Y; i# W9 b1 R: s' z        DMA1_Channel4->CMAR  = (uint32_t)SPI2_Rx_Buf;
        DMA1_Channel5->CMAR  = (uint32_t)SPI2_Tx_Buf;
0 l+ `8 {( g" {. u3 y# X        DMA1_Channel4->CNDTR = len;
        DMA1_Channel5->CNDTR = len;
# t4 {# s* o2 B+ h, S        DMA_Cmd(DMA1_Channel4, ENABLE);
5 Q3 q, Y8 c) e+ Z7 u- L        DMA_Cmd(DMA1_Channel5, ENABLE);
        SPI_Cmd(SPI2, ENABLE);
}

3 O" O4 k2 [2 K- a5 q" ]/**
  * @brief  SPI2_Set_Speed
  * @param  SPI2 CR1 bit 9 8 7
9 L6 M1 }: P1 Y# ?- Y2 |  *          SPI_BaudRatePrescaler_2   ---> 000
+ m) d  g, ?8 y5 N" x  *          SPI_BaudRatePrescaler_4   ---> 001
, }( o3 P8 {) ~2 {9 c  *          SPI_BaudRatePrescaler_8   ---> 010
  *          SPI_BaudRatePrescaler_16  ---> 011
  *          SPI_BaudRatePrescaler_32  ---> 100
  *          SPI_BaudRatePrescaler_64  ---> 101
  *          SPI_BaudRatePrescaler_128 ---> 110
" x2 Y" H) \1 C( Q: o) y' i( Y  *          SPI_BaudRatePrescaler_256 ---> 111
: e) z. x/ ^& A( u$ P" r+ W# \  * @retval None
  */

void SPI2_Set_Speed(uint8_t BaudRatePrescaler) {
+ K6 r  D0 c7 U( e2 i$ H        SPI2->CR1 &= 0xFFC7; /* Clear BaudRatePrescaler Value (bit 9 8 7) */
        SPI2->CR1 |= BaudRatePrescaler;
        SPI_Cmd(SPI2,ENABLE);
}
3 U9 L. [' x3 k# P; X! s9 D
2 Z# S; F3 @" Z/ v/**
& s3 |/ C6 p) D  v# r! X  * @brief  SPI1_Byte_Read_Write
' ]) c$ s6 Q# b! @7 c) A1 V  * @param  None
  * @retval None
3 w7 `/ c- r% R3 ?0 |* R6 F2 |2 e! e  */
8 ?: Z7 V; U7 |" X5 Q% q- M9 b( nuint8_t SPI2_Byte_Read_Write(uint8_t SPI_Byte) {
        // 发送一字节
        while((SPI2->SR & SPI_I2S_FLAG_TXE) == RESET);
+ w7 X, o, h9 q! i/ s+ d: y3 c' a        SPI2->DR = SPI_Byte;
1 W8 N# s! R: Y7 N7 C        // 接收一字节
        while((SPI2->SR & SPI_I2S_FLAG_RXNE) == RESET);
        return(SPI2->DR);
' p+ q8 V( q& I0 y$ W}

+ D+ s6 n1 {& i# w. V! d/*
* Function Name  : DMA1_Channel4_IRQHandler
& T5 A' {. j" }( E% K2 x * Description    : None
" ~- K+ h' Y/ j: g* ^ * Input          : None
, N, d, [6 L1 F: { * Output         : None
* Return         : None
+ c0 \; L- Y$ k: W */
7 a5 q2 i) f$ p* w; T) V: X( Q: K. ]void DMA1_Channel4_IRQHandler(void) {
  D8 t7 v: \! J8 x; e        if (DMA_GetITStatus(DMA1_IT_TC4))  {
                SPI_Flash_CS_High();
$ a& K0 |" g: T. G7 J                DMA_Cmd(DMA1_Channel4, DISABLE);
                DMA_ClearITPendingBit(DMA1_IT_TC4);
0 ~; n4 l8 E3 V- i; g6 x                SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, DISABLE);
                SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, DISABLE);
0 h1 f% h0 q3 H                Flag_DMA_Rxd_Finished = 1;
6 q5 `) r' l; `+ H* ]        }
1 G" L, i" K7 {# Z}

# Q' p5 P  b" b3 }9 ]# ~4 i; c8 m1 ^% N/*
* Function Name  : DMA1_Channel5_IRQHandler
* Description    : None
* Input          : None
0 l# N7 k# D% s7 m" P( D3 ]% {& }* _ * Output         : None
* Return         : None
0 m& w# s8 w+ ~7 a  u3 h$ P */
7 O+ Z! {$ y; q, ~/ d) @4 \void DMA1_Channel5_IRQHandler(void) {
. b& h  v9 X/ Q        if (DMA_GetITStatus(DMA1_IT_TC5)) {
                DMA_Cmd(DMA1_Channel5, DISABLE);
                DMA_ClearITPendingBit(DMA1_IT_TC5);
0 F! r" p3 y; A8 o0 o1 C  E        }
( G: L4 G2 W) J! T$ w. X/ o# J}



  ]4 ]. J! o' X7 g5 y, y- D

多谢分享，支持个

命令字节发送和接收, 可以使用SPI2_Byte_Read_Write, 也可以使用SPI2_DMA_Read_Write,
/ R% f- E( i" N( b; y这里使用SPI2读写SPI_Flash, SPI2_DMA_Read_Write 可以按照下面的方法使用:
' v5 U1 k1 e- {! M
SP2_Tx_Buf_load();            // 数据装入发送缓冲
SPI2_Flash_CS_Low();         // 片选使能
SPI2_DMA_Read_Write(6);   // 启动发送和接收, 在DMA传输完毕中断里片选关闭
while(Flag_DMA_Rxd_Finished==0) {
) ~1 P+ A* p7 M1 Y8 @// 使用DMA连续收发时, 可以利用这个空闲做一些事情
// 如果是用SPI2_Byte_Read_Write, 单字节收发就没有多少空闲时间了
0 {. L; `1 ?1 K8 n+ M;
, y3 M4 v- R! ?1 Z' l}
! A) Z3 c! y. t: I9 h8 ^0 [) W" dFlag_DMA_Rxd_Finished = 0; // DMA收发完毕,标志清0
3 F7 h+ X' [: ^/ u1 @# E

. Z" A8 z6 t$ y+ ^. I" \
, X- f3 f1 b1 N4 A4 Y
! o, E7 ^2 M' E% }9 a1 m! i

看看，，，，，，，，，，，

楼主这个问题解决了吗，我也遇到这个问题求指教

mark下,下次需要研究下

研究,研究