1. #include <stm32f10x_conf.h>
   
2. #include "sys.h"
   
3. #include "delay.h"
   ' i/ z- ?5 \2 ^. Z2 J1 A0 ~
4. #include "usart.h"
   
5. #include "timer.h"
   9 o( m( i  [$ @( t$ m+ i
6. #include "pwm.h"
   ! d( x$ _  h1 G5 K) D% ?$ l
7. #include "gpio.h"
   
8. #include "fsmc.h"
   & p* X- J  X  f- r* ]
9. #include "iic.h"
   
10. #include "FreeRTOS.h"
    
11. #include "task.h"
    5 J: F% G' E6 \3 {4 M
12. #include "semphr.h"
    . [3 \0 t7 r+ E9 N3 x8 R# H
13. #include "task_com.h"
    8 l/ F& D4 P% W* V  g. W( d
14. #include "task_motor.h"
    - P% ]1 h8 Z' W0 {7 S/ @1 E
15. #include "task_led.h"
    
16. #include "at_cmd.h"
    
17. #include "string.h"
    
18. #include "lib5500.h"
    ! K- G/ w$ ]6 D+ ?
19. #include "flash.h"
    
20. #include "iwdg.h"
    
21. #include "ws2812_sim.h"
    ( F3 R% C" O# {
22. 
    
23. #define LOG_LEVEL_DISABLE      -1
    
24. #define LOG_LEVEL_ERROR        0
    
25. #define LOG_LEVEL_WARNING      1
      r/ a1 m" [( V
26. #define LOG_LEVEL_INFO         2
    , c7 }; O# A3 H
27. #define LOG_LEVEL_DEBUG        3
    4 }+ Z! N: U) u7 L$ S  o: ?
28. 
    ( ?9 [* C2 }9 U. c( J9 f4 _
29. #define LOG_LEVEL   LOG_LEVEL_DEBUG
    & u9 u* C: h- y  e( ?' h
30. 
    
31. #if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_DEBUG)
    & }' k0 R; x- d' J: W4 u
32. #define LOGD(fmt, ...)  printf("[D %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)   //%16s,%3d
    
33. #else
    
34. #define LOGD(fmt, ...)
    
35. #endif
    
36. 
    4 f8 g( t0 q. \6 X) k$ D' f+ [# s
37. #if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_INFO)
    9 ?0 O/ B+ {1 F8 w8 v- `) I
38. #define LOGI(fmt, ...)  printf("[I %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)
    ' t; k( M" `6 o6 H
39. #else
    9 s/ H5 V" h9 w1 P
40. #define LOGI(fmt, ...)
    + ]0 ^5 l8 w% X* {6 q$ u
41. #endif
    
42. 
    
43. #if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_WARNING)
    
44. #define LOGW(fmt, ...)  printf( "[W %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)
    
45. #else
    ' j0 k$ X6 y8 R& f* A
46. #define LOGW(fmt, ...)
    % m" U5 I, a% o: u) F% U
47. #endif
    " Y, q5 c7 G; r; X
48. 
    ) B. p" g9 u+ s2 R, `0 I0 e9 `
49. #if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_ERROR)
    * M( Z3 K+ `: y, ?5 Z0 i
50. #define LOGE(fmt, ...)  printf( "[E %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)
    
51. #else
    " `& W6 _$ r" `+ I+ P
52. #define LOGE(fmt, ...)
    
53. #endif
    
54. 
    
55. #define MARK    LOGD("\n");
    
56. 
    
57. SemaphoreHandle_t SensorReadLock;
    1 Y, E8 l  N1 o& ^7 |
58. SemaphoreHandle_t UdpSendLock;
    ! e/ Q' ?+ Q8 R) I  ^
59. SemaphoreHandle_t slave_ready_lock;
    
60. 
    ( _/ ^1 t& _$ D- s
61. 
    & e! \: P$ B* |3 l8 [7 e) |
62. void TaskMaster( void *pvParameters );
    + m& W& H- }# ~7 l# U! }, e+ k
63. void TaskSlave( void *pvParameters );
    
64. static void SPI1_init(void);
    
65. static void SPI2_init(void);
    
66. 
    6 P  l& i3 \- V1 r
67. void Initialization()
    
68. {
    
69.     MCU_INIT(RCC_PLLMul_9);        //?????: 12MHz * 6 = 72MHz
    " Y# U6 B% Q5 P8 C+ s( }
70.     Delay_Init(72);
    
71.     Uart_Init(USART1,115200,72);    //???????,PCLK1??????PCLK??RCC_HCLK_Div1???
    
72.     Uart_Init(USART2,9600,36);    //?????????,PCLK2??????PCLK??RCC_HCLK_Div1???
    
73. //     Uart_Init(USART3,115200,36);    //???????????
    2 E' _) S7 ]9 E9 X
74.     printf("\r\n\r\n****************Build:%s %s****************\r\n",__DATE__,__TIME__);
    
75. //     UartSendStr(USART2,"System start\r\n");
    
76. }
    
77. 
    4 Y6 [3 z! S& O' Y
78. int main(void)
    
79. {
    % J0 s8 A: y% x/ U, m; m
80.     Initialization();
    & S+ h8 I" v% W+ m2 B2 ?: ?3 o
81.    
    . h. _! h3 H& J7 w! B
82. //    QStepMotorCommand = xQueueCreate( 1,sizeof(int) );
    " ^! v! p' Z6 b# o
83. //    QHostCommand = xQueueCreate( 16,sizeof(int) );
    2 I$ m) W! n5 m% w9 y& F7 _) f
84.    
    0 B# F2 u) z  [, Y% Z, d
85.     SensorReadLock = xSemaphoreCreateMutex();
    
86.     xSemaphoreGive(SensorReadLock);
    
87.    
    - H8 r) {& Q2 v. q6 o$ S, z# I# }
88.     UdpSendLock = xSemaphoreCreateMutex();
    
89.     xSemaphoreGive(UdpSendLock);
    ( {! _6 B& U7 ?5 b) T
90. 
    : j9 q8 Q& u5 I7 Z( d- d" v
91.     slave_ready_lock = xSemaphoreCreateMutex();
    
92.     xSemaphoreTake(slave_ready_lock, 0 * portTICK_PERIOD_MS);
    
93. 
    - n+ z7 Z; a: B  p5 @' F: g
94.     /* Start the tasks defined within this file/specific to this demo. */
    
95. //    xTaskCreate( TaskComm,    "task2", 2 * 256, NULL, 2, NULL );
    
96.     xTaskCreate( TaskMaster,    "task1", 4 * 256, NULL, 3, NULL );
    * g* u3 M9 J' M: B/ m
97.     xTaskCreate( TaskSlave,    "task2", 4 * 256, NULL, 1, NULL );
    
98.    
    
99.     /* Start the scheduler. */
    
100.     vTaskStartScheduler();
     3 w6 Y/ t" P! x  @- A  \8 }
101.    
     
102.     while(1);
     
103.    
     7 N( X. D# N8 b9 t9 f
104. }
     
105. 
     % s* `5 m5 w0 Z. a. `! K$ G% ]4 g
106. 
     
107. #define USART1_RX_DMA_BUFF_SIZE        128
     1 T/ T2 X/ i5 k+ B- k
108. #define SPI2_RX_DMA_BUFF_SIZE        32
     5 u9 N; M9 P% S4 }* {# G* L" @9 Z: [
109. #define SPI2_TX_DMA_BUFF_SIZE        32
     
110. 
     1 y0 j- X) _4 m  s: I$ Z  ?/ _
111. 
     / E1 a3 {3 F% R1 i8 e3 D/ u9 [
112. static void read_uart_input_buff(void);
     
113. static void USART1_RX_DMA_Init(void);
     
114. static void SPI2_RX_DMA_Init(void);
     
115. static void SPI2_TX_DMA_Init(void);
     
116. static void read_spi2_input_buff(void);
     
117. static void SPI2_frame_handler(uint8_t data);
     7 v& L! F' g8 C' |3 s- K+ _
118. 
     
119. static u32 s_frame_buff[1024];
     
120. static u8 USART1_RX_DMA_Buff[USART1_RX_DMA_BUFF_SIZE];    //????????????��????????????????????��????????????
     
121. static u8 SPI2_RX_DMA_Buff[SPI2_RX_DMA_BUFF_SIZE];
     
122. static u8 SPI2_TX_DMA_Buff[SPI2_TX_DMA_BUFF_SIZE] = {0xA0, 0x0 , 0x1 , 0x2 , 0x3 , 0x4 , 0x5 , 0x6 , 0x7 , 0x8 , 0x9 , 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30};
     
123. 
     : V8 {$ t8 t7 x2 Y) G
124. void TaskMaster( void *pvParameters )
     
125. {
     
126.     LOGI("TaskMaster start...\r\n");
     8 _6 e7 y6 l7 o9 Y5 p. I, j* k5 Q/ j+ ?
127. 
     
128.     // USART1_RX_DMA_Init();
     
129.     // ws2812_sim_init();
     % B! h1 ^4 N) M6 ]5 @4 p! ~
130.     SPI1_init();
       u) i' n. {* U) S3 ?% g' g
131.    
     $ v1 B$ f7 J  ^/ `) P1 n/ f2 s
132.     GPIO_InitTypeDef GPIO_InitStructure;                    //定义一个GPIO结构体变量
     
133.     SPI_InitTypeDef SPI_InitStructure;
     
134. 
     
135.     //初始化片选引脚
     
136.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);   
     
137. 
     4 S& H8 ~# |0 U4 Y+ o! v3 g4 v
138.     //chip select/reset pin init
     
139.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
     " o0 m, K: Y' d! f9 u0 I
140.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
141.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
142.     GPIO_Init(GPIOC, &GPIO_InitStructure);
     
143. 
     % F! m8 F, r0 |' m# i
144. 
     
145.     xSemaphoreTake(slave_ready_lock, portMAX_DELAY);
     # K2 X. z$ y0 M& k$ W
146. 
     7 i$ V; C8 p5 k
147.     uint8_t count = 0;
     * v2 M4 D9 H1 s* P
148. 
     
149.     while(1)
     
150.     {
     
151.         // LOGI("test %d %d\r\n", count, DMA_GetCurrDataCounter(DMA1_Channel4));
     7 N# R+ k8 D' H1 k; x! T# x( g
152. 
     
153.         // read_uart_input_buff();
     
154. 
     
155.         static int state = 0;
     
156.         if (state == 0) {
     
157.             SPIx_ReadWriteByte(0xA5);   // preamble
     1 h3 }" b5 m: _0 U
158.             SPIx_ReadWriteByte(0x5A);
     ; [8 b8 m. t9 p# u/ M. S6 u
159.             SPIx_ReadWriteByte(0x55);
     
160.             SPIx_ReadWriteByte(0xAA);
     5 r+ \) U* Z9 w9 P- d) k0 `; d% ]1 h
161.             SPIx_ReadWriteByte(count);   // addr
     ( Q" j/ X- ^/ }% c
162.             SPIx_ReadWriteByte(~count);   // cmd
     + r2 u, Z+ K+ V; I, Q* v
163. 
     $ F& O! k& \7 \8 @: w- U0 X
164.             // count++;
     1 ^! N8 E7 f$ @( F7 v
165. 
     
166.             state = 1;
     ; M# C9 d+ g. r2 e* P
167.         } else if (state == 1) {
     ' |+ K5 n; A0 R0 f
168.             static int timeout = 0;
     
169.             uint8_t data = SPIx_ReadWriteByte(0xFF);   // dummy byte
     
170.             // LOGI("%.2X\r\n", data);
     
171.             if (data == 0xA0) {
     ( |4 {. c) f$ q0 m, g+ u
172.                 for (int i = 0; i < 32; i++) {
     ! T* l$ F& N4 L0 D
173.                     uint8_t data = SPIx_ReadWriteByte(0xFF);
     ) q# G6 M: {9 J8 Q. h/ o/ Z
174.                     // printf("%.2X ", data);
     , X7 {% {9 |, t2 S2 k3 I* W6 \
175.                 }
     5 i8 E6 \- `$ \/ m# F) c
176.                 // printf("\r\n");
     
177.                 timeout = 0;
     # m( ^$ o2 |4 i" R2 a$ d
178.                 state = 0;
     
179.                 PCout(13) = ~PCout(13);
     
180.                 // vTaskDelay(100);
     . C, W& o0 w$ Q& ?4 {: k" h
181.             } else {
     9 I4 H( j- }7 _
182.                 if (timeout++ == 10) {
     & K1 D! Z# d- `9 D3 |4 }. e
183.                     timeout = 0;
     
184.                     printf("timeout\r\n");
     ; \- A* e$ y. e; n$ a/ V. v6 L
185.                     vTaskDelay(1000);
     ( q$ v3 b, `0 w  s& ?; K
186.                     state = 0;
     
187.                 }
     
188.             }
     
189.         } else if (state == 2) {
     . X' B& W* Q$ U1 D0 ~! D; u
190.         }
     ; W+ Z- @$ N) }! ]( e1 ^
191. 
     7 r# G) y, ^! h2 }0 J8 q; c' W- z; _
192.         vTaskDelay(1);
     
193.     }
     
194. }
     $ z8 G; H- C  g
195. 
     / g3 ?" S, E* N+ i( m- ]  N
196. void TaskSlave( void *pvParameters )
     
197. {
     
198.     LOGI("TaskSlave start...\r\n");
     
199. 
     
200.     SPI2_init();
     
201.     SPI2_RX_DMA_Init();
     
202.     SPI2_TX_DMA_Init();
     8 j) O2 D( e# J  [; c+ e
203. 
     
204.     xSemaphoreGive(slave_ready_lock);
     
205.    
     7 }6 y! ~! n9 \
206.     uint8_t count = 0;
     % s5 M% n! S% ~* z; [2 L* z# A9 H# P
207. 
     # }; X) ]5 y. A0 k- R
208.     while(1)
     3 s5 }4 X7 o3 P' r7 h
209.     {
     ( _1 `! X+ i" n' J
210.         read_spi2_input_buff();
     
211.         
     
212.         vTaskDelay(1);
     
213.     }
     ) F! V) `  F% l4 _) c# G2 L( a
214. }
     
215. 
     ; U, T5 ^  p. R2 ^2 I* |
216. static void USART1_RX_DMA_Init(void)
     
217. {
     $ A3 m6 T9 R" h8 h1 B
218.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
     ! I' D: n& F" p
219.    
     1 }0 I: M8 D2 u3 v/ n# Q' _
220.     DMA_DeInit(DMA1_Channel5);
     
221.    
     6 R  g9 }( b, V$ q% t
222.     DMA_InitTypeDef DMA_InitStruct;
     ; `' a- i* w" {' t7 z, F) ?
223.     DMA_StructInit(&DMA_InitStruct);
     6 Q4 A5 Y: l* N! o2 [2 R
224.     DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);
     , W9 c% s4 h# `4 z
225.     DMA_InitStruct.DMA_MemoryBaseAddr = (u32)USART1_RX_DMA_Buff;
     ! W  U7 E1 t8 a; s" Z8 O8 y
226.     DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
     
227.     DMA_InitStruct.DMA_BufferSize = sizeof(USART1_RX_DMA_Buff);
     & X+ O8 h* l5 U) _  m
228.     DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
     
229.     DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
     
230.     DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
     2 h" ?4 w4 M+ f% O* I7 t
231.     DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
     
232.     DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
     
233.     DMA_InitStruct.DMA_Priority = DMA_Priority_High;
     
234.     DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
     
235.    
     
236.     DMA_Init(DMA1_Channel5,&DMA_InitStruct);
     4 n: y9 i* g2 W& i2 S- \% O) d
237.    
     & R# J1 c# l7 L
238.     DMA_ITConfig(DMA1_Channel5,DMA_IT_TC,DISABLE);
     
239.     DMA_ITConfig(DMA1_Channel5,DMA_IT_HT,DISABLE);
     7 D7 U3 q: n' q% t( t
240.     DMA_ITConfig(DMA1_Channel5,DMA_IT_TE,DISABLE);
     
241.    
     
242.     NVIC_InitTypeDef NVIC_InitStruct;
     0 k- Z! y2 y. N
243.     NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel5_IRQn;
     
244.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
     * T0 u( c& a! a6 ^$ a  [9 @' k
245.     NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
     
246.     NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
     + ?- H. t5 @! Y" \
247.     NVIC_Init(&NVIC_InitStruct);
     
248. 
       x7 d) ]6 |/ O& G) J
249.     USART1->CR3 |= (1<<6);    //???DMA????
     
250.     DMA_Cmd(DMA1_Channel5,ENABLE);    //????DMA????
     3 ^) P0 T* A0 o+ k1 o
251. 
     
252. }
       _: c; d, M5 f8 t  A/ M: B6 k; e- f
253. 
     + b( q. _; @# `8 ]$ R6 l, b
254. // void DMA1_Channel5_IRQHandler()
     
255. // {
     & m# u, r$ L9 |( n
256. //     DMA_ClearFlag(DMA1_FLAG_TC5);
     
257. //     int i;
     7 S+ R; K5 I! B' q) R. ~
258. //     for(i=0;i<sizeof(USART1_RX_DMA_Buff);i++)
     
259. //         printf("%c",USART1_RX_DMA_Buff[i]);
     
260. //     printf("\r\n");
     ( L8 V2 K2 R& J
261. // }
     
262. 
     
263. static void read_uart_input_buff(void)
     
264. {
     
265.         static int LastDataCount = 0;
     
266.         
     
267.         //????????DMA��???.????DMA_GetCurrDataCounter?????????????????????.
     
268.         int CurrDataCount = USART1_RX_DMA_BUFF_SIZE - DMA_GetCurrDataCounter(DMA1_Channel5);
     
269.         
       |; `! {: |1 k$ f+ g' i, x1 u( c1 S
270.         if(LastDataCount != CurrDataCount)
     5 o( [9 n6 T# p0 n  y
271.         {
     
272.             int i;
     
273.             if(LastDataCount < CurrDataCount)
     
274.             {
     
275. //                 printf("1:%d %d,",LastDataCount,CurrDataCount);
     
276.                 for(i = LastDataCount;i<CurrDataCount;i++) {
     
277. //                    MasterFrameInput(USART2_RX_DMA_Buff[i]);
     # S* v3 I1 f0 B6 S' l! u
278.                      printf("%c",USART1_RX_DMA_Buff[i]);
     + Q! M) m% Z& C3 m; o0 w' s6 L
279.                 }
     , ~. L% J" X4 c) X
280. //                 printf("\r\n");
     * Z+ @  ~9 [* a$ w& D; a% q
281.             }
     
282.             else
     * g4 z" e) f* q3 Q( O
283.             {
     ; B  i: e6 v. B# s% l* Y; e
284. //                 printf("2:%d %d,",LastDataCount,CurrDataCount);
     8 M/ J5 D) [- i7 h8 g; D$ }. d
285.                 for(i = LastDataCount;i<USART1_RX_DMA_BUFF_SIZE;i++) {
     
286. //                    MasterFrameInput(USART2_RX_DMA_Buff[i]);
     ( n* e9 k9 k7 S; D( q
287.                      printf("%c",USART1_RX_DMA_Buff[i]);
     : h/ m8 \' ^) Z# \( |8 R4 ^, f
288.                 }
     
289.                 for(i = 0;i<CurrDataCount;i++) {
     : ^0 C! \5 B' u8 P, Z
290. //                    MasterFrameInput(USART2_RX_DMA_Buff[i]);
     
291.                      printf("%c",USART1_RX_DMA_Buff[i]);
     # S5 _2 {* T& ]2 r  j2 m7 f( k
292.                 }
     
293. //                 printf("\r\n");
     
294.             }
     3 E7 c. w3 M) m; b
295.         }
     ( T' G9 I; x" G# [
296. 
     & H2 d/ J4 C8 x. k$ Z: o; P' z
297.         LastDataCount = CurrDataCount;
     3 d' P8 D! ~( _# w" W+ ^! A
298. }
     ; m* E) j5 p: Y
299. 
     
300. static void SPI1_init(void)
     
301. {
     2 `: M6 B( D. z0 U1 Y
302.     GPIO_InitTypeDef GPIO_InitStructure;                    //定义一个GPIO结构体变量
     
303.     SPI_InitTypeDef SPI_InitStructure;
     
304. 
     ' h. {% e2 n( R3 Z( ?5 m# \7 \+ t
305.     //初始化片选引脚
     
306.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);   
     - d+ T9 \/ T4 E) G' v; u( l9 x
307. 
     & Q% J8 Z' Z% v( u% v$ Z/ q
308.     //chip select/reset pin init
     ! ]% F% N: F! Z
309.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_11;
     7 u9 L2 [+ m  s3 R' u: n
310.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     " Y1 m. ~2 ~* d5 b& i
311.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     / `" O8 N+ q, m- {& Q0 P* ?
312.       GPIO_Init(GPIOA, &GPIO_InitStructure);
     
313.     // SPI_CS = 1;
     
314.     // SPI_RST = 1;
     ! F: D/ [6 s$ `( p! M
315. 
     1 s( x' b+ u- u# @; |
316.     //初始化SPI引脚
     
317.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
     
318.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
     
319.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
320.       GPIO_Init(GPIOA, &GPIO_InitStructure);
     
321. 
     
322.     //初始化SPI1
     
323.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
     
324.     RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);//复位SPI1
     8 l& `& @0 H: G# n  {, e" d
325.     RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
     
326.    
     
327.       SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
     
328.       SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
     , u) R# S7 l4 {# }; ~
329.       SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
     4 w' }8 H& V' o+ W7 p+ r+ ]) a6 ]
330.       SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
     
331.       SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
     0 A  q# ~  A' l
332.       SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
     ) m0 A' ^8 }$ A( P3 r* l; Y
333.       SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
     
334.       SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     # ?/ h, B  S0 T3 k
335.       SPI_InitStructure.SPI_CRCPolynomial = 7;
     
336.     SPI_Init(SPI1,&SPI_InitStructure);
     
337. 
     
338.     SPI_SSOutputCmd(SPI1, ENABLE);
     & S" E0 A$ s3 F
339.     // SPI_Cmd(SPI1, DISABLE);    //Enable SPI1  
     6 c4 A( @( i" v# F9 V5 g. m
340. 
     
341.     SPI_Cmd(SPI1, ENABLE);    //Enable SPI1  
     & O* u' r9 _+ e
342.     // SPIx_ReadWriteByte(0xff);    //启动传输
     
343.     // SPI_Cmd(SPI1, DISABLE);    //Enable SPI1  
     
344. }
     
345. 
     
346. static void SPI2_init(void)
     
347. {
     
348.     GPIO_InitTypeDef GPIO_InitStructure;                    //定义一个GPIO结构体变量
     
349.     SPI_InitTypeDef SPI_InitStructure;
     9 }, R# t4 y* j, C0 ]
350. 
     $ p: F4 _% R2 k, L, m6 t! P* B& ]9 P
351.     //初始化片选引脚
     
352.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);   
     
353. 
     ( _! i3 s0 c9 ]6 V1 \5 S/ r
354.     //chip select/reset pin init
     
355.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
     & c* s! J* E$ ?& q6 `0 b
356.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
357.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     5 I) _* x& s0 `" c
358.     GPIO_Init(GPIOB, &GPIO_InitStructure);
     4 @9 \, I1 S  Z# ?) ~- k. D7 g
359.     // SPI_CS = 1;
     3 c! G. X6 j3 C. k. x
360.     // SPI_RST = 1;
     
361. 
     
362.     //初始化SPI引脚
     ) s! _, ~! r+ }$ S, ?
363.     GPIO_InitStructure.GPIO_Pin =   GPIO_Pin_12 |   // note that NSS pin of the SPI slave is use to select the
     
364.                                                     // device, if it is pulled up, SPI slave will not shift
     : o4 C1 i+ Q: D% V; X
365.                                                     // any byte to its shift register
     . g0 I; l9 X1 P, `1 ^% n
366.                                     GPIO_Pin_13 |
     4 V: W4 F$ c; x: ?8 u; S% H, w
367.                                     GPIO_Pin_14 |
     
368.                                     GPIO_Pin_15;
     8 ~% y" q2 g& L6 p0 p1 F
369.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
     ! W" O- b0 F- ]
370.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
371.     GPIO_Init(GPIOB, &GPIO_InitStructure);
     4 T* |6 Z' X# e/ \$ Z
372. 
     - Q1 J' G/ z' P2 h9 V+ x
373.     //初始化SPI2
     
374.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
     
375.     RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,ENABLE);//复位SPI2
     2 }  p3 @2 f( t1 Z' q5 E1 v* c/ P
376.     RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);//停止复位SPI2
     
377. 
     
378.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
     
379.     SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
     ( W1 d  f+ ^% D) J, c
380.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
     / t6 W: o9 \0 L# e) D$ g4 E
381.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
     % U6 }" G9 G' \7 s
382.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
     
383.     SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
     
384.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
     & `2 B4 @' P; U, W. @+ O6 T
385.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     ; J/ L6 e8 [* J) {
386.     SPI_InitStructure.SPI_CRCPolynomial = 7;
     
387.     SPI_Init(SPI2,&SPI_InitStructure);
     ; u1 |. v- ^0 P* X, V3 V- w
388. 
     8 V/ b) V* A7 }0 a+ A4 E+ m
389.     SPI_SSOutputCmd(SPI2, DISABLE);
     
390.     // SPI_Cmd(SPI2, DISABLE);    //Enable SPI2  
     
391. 
     ( |, i& q3 z6 e  r* b1 r6 e
392.     SPI_Cmd(SPI2, ENABLE);    //Enable SPI2  
     % f% N3 g) e* z4 K) p1 D' P6 j
393.     // SPIx_ReadWriteByte(0xff);    //启动传输
     
394.     // SPI_Cmd(SPI2, DISABLE);    //Enable SPI2
     ( H6 c3 m$ o8 k/ D. n" r
395.    
     
396.     // SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_RXNE, ENABLE);
     
397.     SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_ERR, ENABLE);
     ) H" c8 ]5 i9 I
398. 
     ) F% \1 O# ?7 M" i
399.     NVIC_InitTypeDef NVIC_InitStruct;
     ' [* K! S3 _( S+ D+ n# c6 T3 e
400.     NVIC_InitStruct.NVIC_IRQChannel = SPI2_IRQn;
     
401.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
     
402.     NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
     
403.     NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
     
404.     NVIC_Init(&NVIC_InitStruct);
     ' a7 B" Y+ U* A# J* A
405.    
     3 c- b' W& C: m
406. }
     4 z7 X- a- A* \4 T$ Q
407. 
     
408. void SPI2_IRQHandler()
     
409. {
     
410.     if (SPI_I2S_GetITStatus(SPI2, SPI_I2S_IT_RXNE) == SET) {
     4 q2 k5 ?' L& K
411.         // SPI_I2S_ClearITPendingBit(SPI2, SPI_I2S_IT_RXNE);
     8 }2 ?0 P" X& n6 q' @8 `
412.         LOGI("IRQ:%.2X\r\n", SPI2->DR);
     7 y+ r0 N0 A5 w2 X
413.     } else if (SPI_I2S_GetITStatus(SPI2, SPI_I2S_IT_ERR) == SET) {
     6 d0 H" X6 A5 M1 S
414.         LOGE("SPI2 Error\r\n");
     3 w  C, t9 q9 m/ I5 \
415.         while (1);
     
416.     } else {
     
417.         LOGE("Unknown SPI2 interrupt\r\n");
     
418.         while (1);
     
419.     }
     ( ?: `# b: |  s  g
420. }
     ; a& E9 ~0 Q' }, B
421. 
     
422. static void SPI2_RX_DMA_Init(void)
     % V+ ^# u5 s0 e. q- x& h
423. {
     7 N. p% `2 W3 J  y+ [. t4 J
424.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
     
425.    
     
426.     DMA_DeInit(DMA1_Channel4);
       I$ h$ k0 v% A. B1 o
427.    
     
428.     DMA_InitTypeDef DMA_InitStruct;
     
429.     DMA_StructInit(&DMA_InitStruct);
     
430.     DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&SPI2->DR);
     
431.     DMA_InitStruct.DMA_MemoryBaseAddr = (u32)SPI2_RX_DMA_Buff;
     
432.     DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
     3 A6 W: |( }( J2 I  q* c# R  Z! c
433.     DMA_InitStruct.DMA_BufferSize = sizeof(SPI2_RX_DMA_Buff);
     
434.     DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
     * x% i7 n/ g4 a
435.     DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
     
436.     DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
     
437.     DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
     : A. L" m* S" N
438.     DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
     & [6 o3 m5 W/ u2 |
439.     DMA_InitStruct.DMA_Priority = DMA_Priority_High;
       }0 X4 k0 j7 q9 v
440.     DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
     
441.    
     * E1 g( Y, t9 ]8 r
442.     DMA_Init(DMA1_Channel4,&DMA_InitStruct);
     2 H6 ^. Z& D2 ^% e) V* {3 s
443.    
     : P" O4 C7 T! w0 {% v/ s: K% B6 ?# I
444.     DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,DISABLE);
     
445.     DMA_ITConfig(DMA1_Channel4,DMA_IT_HT,DISABLE);
     - D9 O0 n3 s9 v' k- s
446.     DMA_ITConfig(DMA1_Channel4,DMA_IT_TE,DISABLE);
     : W8 o7 G8 r! u+ K/ F3 R
447.    
     
448.     NVIC_InitTypeDef NVIC_InitStruct;
     
449.     NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel4_IRQn;
     / d5 z9 k: M1 Y- l0 D% F
450.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
     
451.     NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
     
452.     NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
     
453.     NVIC_Init(&NVIC_InitStruct);
     , e6 y9 C) e) E" B$ ~
454. 
     ' ^, J4 n" z* b7 a2 W4 a% ?
455.     SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
     ! E" F* q( Z, w5 ]7 v1 R
456. 
     
457.     DMA_Cmd(DMA1_Channel4,ENABLE);    //????DMA????
     4 [6 j) {; A% u
458. 
     8 m$ J" l' m5 F( D" w
459. 
     
460. }
     
461. 
     1 E/ G' k) ~9 o7 D  G3 a
462. void DMA1_Channel4_IRQHandler()
     ' M( q/ c5 _4 k& W3 t* P; D
463. {
     
464.     DMA_ClearFlag(DMA1_FLAG_TC4);
     , U5 y9 R4 I7 R$ `# X( k6 R
465.     int i;
     
466.     for(i=0;i<sizeof(SPI2_RX_DMA_Buff);i++)
     + Y0 f" J# Y8 F6 p+ B0 w; z# _7 }
467.         printf("%c",SPI2_RX_DMA_Buff[i]);
     7 R! R; B- X% C: L: g' S7 m6 V
468.     printf("\r\n");
     
469. }
     + t9 p! u( x" Q9 f$ O# u- L0 c
470. 
     * P' A' p' |% s0 P, y9 x) ]4 K2 K0 S
471. static void read_spi2_input_buff(void)
     & p* N* Y* n  J/ g
472. {
     6 H- M- _' U9 f+ k
473.         static int LastDataCount = 0;
     
474.         
     
475.         int CurrDataCount = SPI2_RX_DMA_BUFF_SIZE - DMA_GetCurrDataCounter(DMA1_Channel4);
     
476.         
     
477.         if(LastDataCount != CurrDataCount)
     0 T$ D  z7 r  I( L- b( D- Z
478.         {
     9 M. L* b" J4 s, U; i" N. }) K& M
479.             int i;
     : Q/ {1 S  {' ?( Z& W8 O
480.             if(LastDataCount < CurrDataCount)
     
481.             {
     
482. //              printf("1:%d %d,",LastDataCount,CurrDataCount);
     
483.                 for(i = LastDataCount;i<CurrDataCount;i++) {
     
484.                      // printf("%.2X ",SPI2_RX_DMA_Buff[i]);
     & y% U! \; I8 X) ^0 ~
485.                     SPI2_frame_handler(SPI2_RX_DMA_Buff[i]);
     . i! c. w) R# D3 h8 S$ J7 D& f; v) f
486.                 }
     % K) b$ B4 u* U* Z3 O
487. //              printf("\r\n");
     
488.             }
     ( r7 N) M# z7 y$ s7 S  b3 M
489.             else
     
490.             {
     7 o# g! E  _/ ?) `$ h( C
491. //              printf("2:%d %d,",LastDataCount,CurrDataCount);
     # H% `0 t' N8 W6 _/ t/ Q
492.                 for(i = LastDataCount;i<SPI2_RX_DMA_BUFF_SIZE;i++) {
     7 }! `; d) A/ e7 ?2 U, u: B0 z
493.                     // printf("%.2X ",SPI2_RX_DMA_Buff[i]);
     
494.                     SPI2_frame_handler(SPI2_RX_DMA_Buff[i]);
     ! p- a% Q7 _# N2 O
495.                 }
     $ v9 ?, n; p7 P+ d. q( M6 L6 j( Y, c
496.                 for(i = 0;i<CurrDataCount;i++) {
     
497.                     // printf("%.2X ",SPI2_RX_DMA_Buff[i]);
     : y# y3 S, b4 s% p5 C* W
498.                     SPI2_frame_handler(SPI2_RX_DMA_Buff[i]);
     ( l  {* j, B: g, y
499.                 }
     4 k  H3 h2 t+ v7 L; f
500. //              printf("\r\n");
     ( k2 B; ?# U7 V+ P% L9 ?
501.             }
     
502.         }
     
503. 
     
504.         LastDataCount = CurrDataCount;
     7 [' k! z: Q  p+ J& ]" y
505. }
     
506. 
     5 a: b+ z" w0 q( V* P6 H) ?
507. static void SPI2_frame_handler(uint8_t data)
     ) d$ Y8 g- r4 _% V
508. {
     
509.     // printf("%.2X\r\n", data);
     5 ?7 P( L' S2 Z7 Z/ U1 f; |
510. 
     
511.     static int state = 0;
     
512. 
     , q0 @7 B. l& T( }$ Q; `: B5 M
513.     // 0xA5 5A 55 AA
     / \( l9 j: k. q4 p" n
514.     if (state == 0) {
     
515.         if (data == 0xA5) {
     
516.             state = 1;
     
517.         }
     * |  A5 V- A% b: @
518.     } else if (state == 1) {
     ) P0 S  V8 D2 \5 a: s# A+ N; z1 B
519.         if (data == 0x5A) {
     # d+ H' j) {* m1 h$ q
520.             state = 2;
     
521.         } else if (data == 0xA5) {
     
522. 
     
523.         } else {
     
524.             LOGE("Frame err\r\n");
     
525.             // while (1);
     * u- j% b) s9 S1 i" l% D/ [1 Q7 e
526.             state = 0;
     : G8 h5 B9 X# K; r
527.         }
     
528.     } else if (state == 2) {
     
529.         if (data == 0x55) {
     $ V' f% a  v6 D
530.             state = 3;
     ; y" o# }' A% Z1 f3 g
531.         } else if (data == 0xA5) {
     
532.             state = 1;
     / @, o4 Z" [8 m
533.         } else {
     
534.             LOGE("Frame err\r\n");
     # c: t, E& G) {/ Z
535.             // while (1);
     1 n0 k2 }& R0 j: F! r$ H+ n
536.             state = 0;
     
537.         }
     
538.     } else if (state == 3) {
       x0 w$ m1 `$ t5 S  i
539.         if (data == 0xAA) {
     
540.             state = 4;
     6 _( }: v2 D# i- G0 h
541.         } else if (data == 0xA5) {
     
542.             state = 1;
     
543.         } else {
     
544.             LOGE("Frame err\r\n");
     
545.             // while (1);
     
546.             state = 0;
     
547.         }
     - N% |  `+ v+ L$ F, J! {
548.     } else if (state == 4) {
     1 I! h( N, V2 \" t* z3 M6 [/ R
549.         // printf("ADDR:%.2X\r\n", data);
     : U6 R( Z4 ?# M' ]0 z! m
550.         state = 5;
     / D% H# t, \5 ?# l
551.     } else if (state == 5) {
     
552.         // printf("CMD:%.2X\r\n", data);
     ) F( k. x% E; y/ C
553.         // SPI2->DR = 0x33;
     
554. 
     
555.         DMA_Cmd(DMA1_Channel5, DISABLE);     // disable DMA before starting a new DMA transaction
     2 i6 _* [2 W/ s3 G
556. 
     , g) w" z* O, l+ D
557.         DMA_InitTypeDef DMA_InitStruct;
     $ P' ]1 a: S! N# `# M" v
558.         DMA_StructInit(&DMA_InitStruct);
     ( Q; D2 m' C( @8 |+ u
559.         DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&SPI2->DR);
     
560.         DMA_InitStruct.DMA_MemoryBaseAddr = (u32)SPI2_TX_DMA_Buff;
     
561.         DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
     
562.         DMA_InitStruct.DMA_BufferSize = sizeof(SPI2_TX_DMA_Buff);
     + I  j2 L: w2 M  g
563.         DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
     3 O1 o' d0 S* @9 y9 Y/ I
564.         DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
     9 E+ [: p% S! f+ c& z' H
565.         DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
     9 ^! W' o3 q( v3 Y0 l
566.         DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
     7 S# z" {, w5 ]* f9 S0 c/ f9 D
567.         DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
     , T# q1 j: W. Z7 n5 _0 f
568.         DMA_InitStruct.DMA_Priority = DMA_Priority_High;
     
569.         DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
     0 s5 Y5 \; g) f1 u. z
570.         
     % l8 ~. X6 X# u4 Z( ^- n# f
571.         DMA_Init(DMA1_Channel5,&DMA_InitStruct);
     1 K% A/ P1 ~) g6 w" e
572. 
     " u9 I9 [2 A& N
573.         DMA_Cmd(DMA1_Channel5, ENABLE);
     
574.         
     3 x# V0 A1 U! V7 ?1 `
575.         state = 0;
     
576.     } else if (state == 6) {
     4 C* v: [! u6 F# Y7 ~) H
577. 
     7 R9 J, m+ m  [" P# Z- u3 j
578.     } else if (state == 7) {
     * k; ^! j6 m- _( Y9 l
579. 
     5 I6 U5 ~# ?1 G, M" A- R
580.     } else if (state == 8) {
     
581. 
     2 P/ L4 d$ i# O% X
582.     } else if (state == 9) {
     1 g; g# B2 Z  T8 G% S
583. 
     
584.     } else if (state == 10) {
     # y" u/ v6 v% B1 J
585. 
     - C9 V2 j0 S# w% Y. x& }2 {# y
586.     } else {
     - p; s8 `+ D; J6 D
587. 
     
588.     }
     4 U  P1 J& z0 y" W9 D9 }8 n+ d- d
589. }
     
590. 
     2 I! p# j  p1 r; N
591. static void SPI2_TX_DMA_Init(void)
     0 V: _! o) ]; b
592. {
     $ a; X8 }" [% ?$ W" E5 q
593.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
     ) R7 D# w3 D( x/ f* l/ U. ~- b
594.    
     8 B4 L! Z2 u% |; K  d4 B- A
595.     DMA_DeInit(DMA1_Channel5);
     
596.    
     , {+ F) Y# E4 w+ o0 q  V
597.     DMA_InitTypeDef DMA_InitStruct;
     3 j" }- e! j- A$ E+ W3 H
598.     DMA_StructInit(&DMA_InitStruct);
     
599.     DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&SPI2->DR);
     
600.     DMA_InitStruct.DMA_MemoryBaseAddr = (u32)SPI2_TX_DMA_Buff;
     ( @* S: l- L" N* ]4 N: S4 ^2 B
601.     DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
     
602.     DMA_InitStruct.DMA_BufferSize = sizeof(SPI2_TX_DMA_Buff);
     0 K4 j" C' B: V( _7 H; `
603.     DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
     # d6 P& s+ \, X5 e- a/ m# s
604.     DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
     6 n4 w7 s: G2 i% H8 x
605.     DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
     
606.     DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
     % i1 w. R, N* P2 o
607.     DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
     
608.     DMA_InitStruct.DMA_Priority = DMA_Priority_High;
     
609.     DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
     6 K; z/ p% s# ?# ~  }- ^
610.    
     
611.     DMA_Init(DMA1_Channel5,&DMA_InitStruct);
     5 j$ `) B8 \& ~- Z+ n- T" k: K  e# D
612.    
     
613.     DMA_ITConfig(DMA1_Channel5,DMA_IT_TC,DISABLE);
     
614.     DMA_ITConfig(DMA1_Channel5,DMA_IT_HT,DISABLE);
     
615.     DMA_ITConfig(DMA1_Channel5,DMA_IT_TE,DISABLE);
     ( [( E4 @9 F# M2 z; B1 v% @
616.    
     
617.     NVIC_InitTypeDef NVIC_InitStruct;
     
618.     NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel5_IRQn;
     
619.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
     4 X! h5 k8 g% o6 @; T
620.     NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
     
621.     NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
     8 J% i, ^+ g4 X( F7 f& `
622.     NVIC_Init(&NVIC_InitStruct);
     * [/ S6 z5 \7 T- a9 I
623. 
     # y' c/ e" O. G& u$ L
624.     SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
     
625. 
     
626.     DMA_Cmd(DMA1_Channel5,DISABLE);    //????DMA????
     
627. 
     
628.     // note: the last byte moved from RAM to SPI2->DR is seen as the end of DMA transmission
     / j. u; d/ R* L8 @% M+ _
629.     // but the last byte still not been transferred out from the shift register which means
     8 _( J$ N9 }2 c4 E! `
630.     // the SPI master might not received the last byte when the SPI slave finishing the DMA
     + X" a6 ]' F5 b& s& T, R
631.     // transfer.
     1 c/ |8 @5 s+ ?. r1 \, z5 |2 P
632. }
     + H' Z& t8 d7 _  q
633. 
     ! `  u9 e1 }- x7 h) E6 u
634. void DMA1_Channel5_IRQHandler()
     - |" t" P0 T$ p- }6 M2 g# ?* J
635. {
     - Q. X* ~) T1 ^& H  a( v+ D
636.     DMA_ClearFlag(DMA1_FLAG_TC5);
     
637.     // LOGI("Sent done\r\n");
     
638.     DMA_Cmd(DMA1_Channel5, DISABLE);
     
639.     // SPI2->DR = 0x00;     // set the shift register to 0x00 other wise SPI master will get the previous byte
     
640.     //                      // which might be 0xA0 and causes error.
     
641.                             // update: don't do it like this, due to the last byte still in the shift register
     3 A2 ~: ?# Q' s& k* P  ^/ N  ~9 W
642.                             // and waiting to be shifted out from MISO. We can add a byte of 0x00 int the last
     5 S$ U' e$ U% z8 t( d
643.                             // byte of the DMA buffer if the last byte is 0xA0.
     2 l# E* F; L8 D" ]" r
644. }
     - K& F/ Z6 R. v( t1 n

复制代码

转载自：哐哐哐 Quan
如有侵权请联系删除
* [% \; F. {% [
1 \0 E, \  x$ \7 U' c2 ~