STM32F4 SPI DMA

自己整理（存储器到外设模式）
SPI结构体
4 s. T" {3 @3 U  F: s6 k

1. typedef struct
   ' R- s" _, U  }# D
2. {
   
3. uint16_t SPI_Direction; /*设置SPI 的单双向模式 */
   
4. uint16_t SPI_Mode; /*设置SPI 的主/从机端模式 */
   
5. uint16_t SPI_DataSize; /*设置SPI 的数据帧长度，可选8/16 位 */
   
6. uint16_t SPI_CPOL; /*设置时钟极性CPOL，可选高/低电平*/
   & H5 d' y7 C4 c) a! l
7. uint16_t SPI_CPHA; /*设置时钟相位，可选奇/偶数边沿采样 */
   6 Y; t( Q6 Z; v
8. uint16_t SPI_NSS; /*设置NSS 引脚由SPI 硬件控制还是软件控制*/
   $ w/ _( y2 \- w% v4 ]
9. uint16_t SPI_BaudRatePrescaler; /*设置时钟分频因子，fpclk/分频数=fSCK */
   5 B' N% d8 s& F4 m5 i" M* n2 r
10. uint16_t SPI_FirstBit; /*设置MSB/LSB 先行 */
    
11. uint16_t SPI_CRCPolynomial; /*设置CRC 校验的表达式 */
    
12. }SPI_InitTypeDef;
    0 v' m( \$ ]+ [6 Z; `

复制代码

SPI引脚编号
# S1 c) [0 m5 T

SPI配置

1. void SPI_Config(void)
   
2. {
   8 J  Z* I8 V/ A6 N: K
3. GPIO_InitTypeDef GPIO_InitStructure;
   0 I: W. j$ v$ U& O* _& H6 z
4. SPI_InitTypeDef SPI_InitStructure;
   
5. 
   & q( K3 K0 Y( d, S9 G
6. //1.初始化GPIO
   7 q1 {0 C+ A1 @
7. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOB,ENABLE);
   
8. /* 连接 引脚源*/
   ! y8 v( b6 d3 V; Z7 g
9. GPIO_PinAFConfig(GPIOA,GPIO_PinSource15,GPIO_AF_SPI1);
   
10. GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1);
    
11. GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1);
    
12. 
    
13. /* 使能 SPI 时钟 */
    
14. RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    
15. 
    
16. /* GPIO初始化 */
    
17. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;       
    
18. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
19. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    % O" O$ R0 _9 L, ~6 a$ Z
20. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
21. 
    
22. /* 配置SCK引脚为复用功能 */
    ; R1 @5 z4 A. F- Z: W
23. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;
    ( W3 ~* ^$ R0 D) Q! x( r' r
24. GPIO_Init(GPIOB, &GPIO_InitStructure);
    ; h/ O6 S% i# u2 {( C
25. 
    3 W9 y1 v9 v; S0 D1 M' }
26. /* 配置MISO引脚为复用功能 */
    
27. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    - i7 P% q# P' U' x9 s5 j7 L' R
28. GPIO_Init(GPIOB, &GPIO_InitStructure);
    
29. 
    
30. /* 配置MOSI引脚为复用功能 */
    
31. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    
32. GPIO_Init(GPIOA, &GPIO_InitStructure);
    
33. 
    
34. /*CS引脚 */
    5 n) ?& ]2 T9 ~1 E/ D( W' q5 j3 J
35. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    3 m% ~, K1 U" w3 Y3 A2 c
36. 
    
37. /* 配置CS(NSS,自动控制SPI的片选信号)引脚为复用功能 */
    
38. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 ;
    ' z, `0 P9 }: \5 P4 E
39. GPIO_Init(GPIOA, &GPIO_InitStructure);
    / {: H) s4 ^( v1 O
40. 
    
41. /* 停止信号: CS 引脚高电平 */
    6 Q# q( d! R+ e# @9 {5 O& K& ~/ Z- j  q
42. GPIO_SetBits(GPIOA, GPIO_Pin_15);
    2 b% L7 S: l- b3 N4 d
43. 
    # v/ Q7 `0 V' C1 E) ?; h% l, w
44. //2.配置SPI工作模式
    1 t+ M5 e& r$ R+ ?0 j( \# P
45. // 分频
    0 Z8 ?9 n: E6 J# j! w& s; T
46. SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
    
47. // 数据捕获于第二个时钟沿
    
48. SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    
49. // 时钟空闲idle时是低电平
    
50. SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    
51. // 不需要使用CRC校验
    & U1 }! K( t& v2 v  l! C
52. SPI_InitStructure.SPI_CRCPolynomial = 0;
    
53. // 数据帧长度为8位
    
54. SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    
55. // 双线全双工模式
    2 ?7 M; D3 a3 U- H, u; e$ Z1 c! v5 B
56. SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    
57. //数据传输从 MSB 位开始
    8 H# K' l- C, k' v
58. SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    
59. //NSS 信号由软件管理
    5 L, C4 f8 C2 p. N' q1 N* J/ r
60. SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    
61. //设置为主设备
    
62. SPI_InitStructure.SPI_Mode = SPI_Mode_Master;       
    . c9 z+ w  N4 [, T$ t
63. SPI_Init(SPI1,&SPI_InitStructure);
    
64. 
    
65. /* 使能 FLASH_SPI */       
    8 p! D1 p5 T. K: {( m' W' N( b$ N# I
66. SPI_Cmd(SPI1, ENABLE);
    # A- }9 Q1 G! B, r& X
67. }
    

复制代码

DMA结构体
$ X4 r9 [; a) w: V! ]

1. typedef struct {
   
2.     uint32_t DMA_Channel;                                 //通道选择
   
3.     uint32_t DMA_PeripheralBaseAddr;         //外设地址
   / P, h5 r* {1 p% d% l
4.     uint32_t DMA_Memory0BaseAddr;                 //存储器0 地址
   0 R# c! R2 N7 I3 q5 O1 e  h- k7 }  s
5.     uint32_t DMA_DIR;                                         //传输方向
   * [, ?; H! S) U) f* d
6.     uint32_t DMA_BufferSize;                         //数据数目
   
7.     uint32_t DMA_PeripheralInc;                 //外设递增
   
8.     uint32_t DMA_MemoryInc;                         //存储器递增
   . a; \: d" [9 N; w0 n3 r* B
9.     uint32_t DMA_PeripheralDataSize;         //外设数据宽度
   ; x: z! ~" c' R9 q  d/ x- Y4 ~
10.     uint32_t DMA_MemoryDataSize;                 //存储器数据宽度
    1 w* U8 F8 E. j6 r
11.     uint32_t DMA_Mode;                                         //模式选择
    $ |6 r* P, I# |
12.     uint32_t DMA_Priority;                                 //优先级
    & v# G( h" Z8 r/ G& o5 o8 m
13.     uint32_t DMA_FIFOMode;                                 //FIFO 模式
    2 l; B7 U3 v" |. L& y" q
14.     uint32_t DMA_FIFOThreshold;                 //FIFO 阈值
    6 a0 g% s6 }9 I% W
15.     uint32_t DMA_MemoryBurst;                         //存储器突发传输
    
16.     uint32_t DMA_PeripheralBurst;                 //外设突发传输
    ! N" O, I" c6 T4 }6 K3 ^
17. } DMA_InitTypeDef;
    

复制代码

/ Q8 x; ^; Q& _- }; E  KDMA请求映射
7 R8 i9 m7 ]  _  V

DMA传输模式

SPI 发送DMA配置
7 n3 R- z9 K& v/ E$ O0 S# v

1. #define SENDBUFF_SIZE (1024*20)            // 一次发送的数据       
   
2. uint8_t TX_Buff[SENDBUFF_SIZE];                // 发送缓存
   $ v. `- _8 J) K# Q6 ?
3. void SPI2_TX_DMA_Config(void)
   
4. {
   * P4 J4 ?, W" \& O
5.     // 中断结构体
   + p, e- H" Z/ Y# w/ l- |
6.     NVIC_InitTypeDef NVIC_InitStructure;               
   ( y, W% |2 v+ Z7 z, E
7.     // DMA结构体
   
8.     DMA_InitTypeDef DMA_InitStructure;                 
   
9.     /* 使能DMA时钟 */                 
   5 Y/ I( l1 o1 {' G! a' x
10.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);       
    ) ^( F: V7 `$ @. a
11.     /* 复位初始化DMA数据流 */  
      }" L* D4 ]0 ^8 Z$ _! Q! T6 H# Y7 w
12.     DMA_DeInit(DMA2_Stream5);                                                               
    : i( n6 t9 u  c6 I2 m( _
13.     /* 确保DMA数据流复位完成 */  
    6 F' a2 G; }5 s, h( x
14.     while (DMA_GetCmdStatus(DMA2_Stream5) != DISABLE);       
    4 [/ M/ S5 j0 c) Q" x! K
15. 
    ; [. L4 H3 w7 c7 h. c
16.     /* 配置 DMA Stream */
    ! d( y0 O2 U, j: n
17.     /* 通道3，数据流5 */          
    + @5 F# j: s' ?1 l0 J' F
18.     DMA_InitStructure.DMA_Channel = DMA_Channel_3;
    
19.     /* 外设地址 */  
    , G$ o! C$ ~7 g& p/ T" e) h1 f
20.     DMA_InitStructure.DMA_PeripheralBaseAddr = (SPI1_BASE+0x0C);       
    
21.     /* 内存地址(要传输的变量的指针) ,DMA存储器0地址*/         
    
22.     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)TX_Buff;       
    
23.     /* 方向：存储器到外设 */                       
    & u4 `$ c# ^3 l8 J
24.     DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
    
25.     /* 数据传输量 ,可设置为0， 实际发送时会重新设置*/            
    * r( y9 o" p) G9 p  b+ Q
26.     DMA_InitStructure.DMA_BufferSize = (uint32_t)SENDBUFF_SIZE;               
    ! Z4 ~0 }: Z4 I% I) G& s
27.     /* 外设非增量模式 */               
    8 n! N! `, w; ~( ?- g
28.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    
29.     /* 存储器增量模式 */         
    
30.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    
31.     /* 外设数据长度:8位 */         
    
32.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    5 c$ n. ?3 ~& U; z
33.     /* 内存数据长度:8位 */
    : [1 N& [! C  E3 d
34.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    1 c. G- s) I" |- H
35.     /* DMA模式：正常模式 */                 
    
36.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    * ]8 `0 V: `2 L9 D( S! W9 p
37.     /* 优先级：高 */                        
    
38.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    , {$ K5 ]  S" T
39.     /* 禁用FIFO */
    3 h( y4 V7 @* @& S
40.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;                       
    
41.     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;   
    
42.     /* 外设突发单次传输 */  
    6 O! a0 Q2 ]; Q' D, n3 w& ?
43.     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;                   
    
44.     /* 存储器突发单次传输 */  
    0 g  i. O5 |$ Q
45.     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    
46. 
    ) T* H, B9 D( _+ l0 s/ [
47.     /* 初始化DMA Stream */               
    ' V% h$ L; O' a, B" X6 ^0 _
48.     DMA_Init(DMA2_Stream5, &DMA_InitStructure);
    
49.     /* 开启传输完成中断  */               
    1 c( f" A/ E9 E3 l
50.     DMA_ITConfig(DMA2_Stream5,DMA_IT_TC,ENABLE);
    ' t3 w4 \8 @5 c* w& `
51. 
    
52.     // 中断初始化
    3 d6 R9 V8 {; ^& H0 {2 ^
53.     /* DMA发送中断源 */  
    8 a. T3 R+ {, v( m
54.     NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream5_IRQn;       
    
55.     /* 抢断优先级 */  
    % N& u( @/ s; S5 \
56.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
57.     /* 响应优先级 */  
    
58.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                               
    
59.     /* 使能外部中断通道 */
    
60.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                 
    
61.     /* 配置NVIC */               
    
62.     NVIC_Init(&NVIC_InitStructure);
    
63. }
    

复制代码

DMA发送中断服务函数
! F( C; S! i5 H/ e, i6 r( m" n

1. void DMA2_Stream5_IRQHandler(void)
   ; U5 o, {# H- u) w& ^7 n
2. {
   
3.     // DMA 发送完成
   
4.     if(DMA_GetITStatus(DMA2_Stream5, DMA_IT_TCIF5))       
   
5.     {
   
6.         // 清除DMA发送完成标志
   
7.         DMA_ClearITPendingBit(DMA2_Stream5, DMA_IT_TCIF5);       
   
8.         // 片选拉高，数据发送完毕       
   
9.         GPIO_SetBits(GPIOA, GPIO_Pin_15);       
   1 L8 X/ S! O" [; l2 B% ~( {
10.     }
    
11. }
    ' h- I* a" G+ \( X4 f! L7 Q# o

复制代码

SPI 接收DMA 配置
* A& ]! |; j6 q" {8 V. N

1. #define RECEIVE_SIZE                  800          // 接收大小
   
2. uint8_t RX_Buff[RECEIVE_SIZE];                // 接收到缓存
   * F$ W: j3 k# l6 t0 I* D
3. void SPI2_RX_DMA_Config(void)
   ( G1 Q% M3 V; q0 @) M
4. {
   
5.     // 中断结构体
   4 }) F' j4 w& k2 R$ }3 R
6.     NVIC_InitTypeDef NVIC_InitStructure;       
   
7.     // DMA结构体  
   
8.     DMA_InitTypeDef DMA_InitStructure;               
   
9.     /* 使能DMA时钟*/  
   
10.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);                                        /* 复位初始化DMA数据流 */
    % C2 ?( g/ _% s# U/ ^
11.     DMA_DeInit(DMA2_Stream2);                                                                                                /* 确保DMA数据流复位完成 */
    $ x# @6 {7 x) R9 Y. h! {5 A) v
12.     while(DMA_GetCmdStatus(DMA2_Stream2)!=DISABLE);
    
13. 
      _  q* w2 L# ~6 ]
14.     /* 配置 DMA Stream */
    
15.     /* 通道3，数据流2*/          
    
16.     DMA_InitStructure.DMA_Channel = DMA_Channel_3;                         
    
17.     /* 设置DMA源：串口数据寄存器地址*/  
    
18.     DMA_InitStructure.DMA_PeripheralBaseAddr = (SPI1_BASE+0x0C)                ;
    1 T6 T% \2 W9 t4 M
19.     /* 内存地址(要传输的变量的指针)*/  
    
20.     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)RX_Buff;                       
    
21.     /* 方向：存储器到外设模式 */                       
    
22.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
    
23.     /* 数据传输量 ,需要最大可能接受的数据量[不能为0],实际发送时会重新设置*/          
    
24.     DMA_InitStructure.DMA_BufferSize = (uint32_t)RECEIVE_SIZE;
    
25.     /* 外设非增量模式 */          
    
26.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;           
      B6 A+ k" k) N9 @0 t# d  b
27.     /* 存储器增量模式 */   
    " d) D; \- T0 u* v) i
28.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    ' M4 E! n. O% T+ c' m
29.     /* 外设数据长度:8位 */          
    
30.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    
31.     /* 内存数据长度:8位 */
    7 u& |! ~8 w0 G, h, C: L# \4 Z+ l
32.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;               
    , i+ I5 F& ]/ ?- [/ R$ y4 b
33.     /* DMA模式：正常模式 */  
    
34.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    % j7 I( E+ s' K: U% E
35.     /* 优先级：高 */          
    ( b7 O! L; s5 A- N% x; h: A
36.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    
37.     /*禁用FIFO*/   
    
38.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
    
39.     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
    
40.     /* 外设突发单次传输 */  
    
41.     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    
42.     /* 存储器突发单次传输 */  
    ; r. w. q) Y+ B) M
43.     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    
44.     /* 初始化DMA Stream */               
    
45.     DMA_Init(DMA2_Stream2, &DMA_InitStructure);                                                          
    
46.     /* 开启传输完成中断  */
    - T  T" |% F( H9 f. [
47.     DMA_ITConfig(DMA2_Stream2,DMA_IT_TC,ENABLE);                                         
    + l1 S& [1 w# Q0 v3 S
48. 
    
49.     // 中断初始化
    
50.     /* 配置 DMA接收为中断源 */
    8 V% t1 Z: V$ f* m8 }
51.     NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream2_IRQn;         
    
52.     /* 抢断优先级 */  
    
53.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;               
    
54.     /* 响应优先级 */  
    
55.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                               
    4 ?! n! L; W- ?( `5 z" a
56.     /* 使能外部中断通道 */  
    ; W5 K$ u6 v3 L
57.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    , s. M9 C' }3 p; L" |) K
58.     /* 配置NVIC */       
    
59.     NVIC_Init(&NVIC_InitStructure);
    & R+ n, a7 d3 ?* U" j. d
60. }
    

复制代码

DMA接收中断服务函数

1. void DMA2_Stream2_IRQHandler(void)
   
2. {                               
   $ k1 `, I9 B7 T- v
3.     // DMA接收完成
   
4.     if(DMA_GetITStatus(DMA2_Stream2, DMA_IT_TCIF2))       
   
5.     {               
   
6.         // 数据接收完成 拉高片选
   ; T0 D7 K+ Z5 {) {# R% S
7.         GPIO_SetBits(GPIOA, GPIO_Pin_15);       
   
8.         // 清除DMA接收完成标志位               
   
9.         DMA_ClearITPendingBit(DMA2_Stream2, DMA_IT_TCIF2);       
   % F; N  l6 x4 D/ X+ H
10.     }
    . K( p0 d6 W# L- b  ]
11. }
    0 G/ `9 T5 O: t. o9 A

复制代码

DMA请求使能

1. //SPI2 TX DMA请求使能
   
2. SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);       
   
3. //SPI2 RX DMA请求使能
   
4. SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);       

复制代码

SPI_DMA 读写一个buf
. ~* F, U+ P4 c

1. #define BufSize                800
   : @; ~7 l# I! w7 |+ Q( m
2. void SPI_DMA_WRITE_READ_BUF(void)
   
3. {   
   & X$ X( \" _5 j5 k
4.     // 关闭发送 DMA       
   
5.     DMA_Cmd(DMA2_Stream5, DISABLE);       
   $ P- L7 \! O$ N9 A
6.     // 关闭接收 DMA       
   
7.     DMA_Cmd(DMA2_Stream2, DISABLE);
   / S7 D% b( p& ~# ^
8.     // 设置发送的数据量
   % H( [! \1 e7 b* L2 p3 p; l
9.     DMA_SetCurrDataCounter(DMA2_Stream5, BufSize);       
   
10.     // 设置接收的数据量
    
11.     DMA_SetCurrDataCounter(DMA2_Stream2, BufSize);
    
12.         // 清空数据
    
13.     SPI1->DR;                                 
    
14.     // 擦除DMA标志位
    
15.     DMA_ClearFlag(DMA2_Stream5, DMA_IT_TCIF5);       
    
16.     DMA_ClearFlag(DMA2_Stream2, DMA_IT_TCIF5);
    
17. 
    
18.     // 片选拉低,接收数据
    
19.     GPIO_ResetBits(GPIOA, GPIO_Pin_15);       
    
20.     // 开启接收 DMA
    4 i3 ?# ], E4 Z& o1 Q/ l
21.     DMA_Cmd(DMA2_Stream5, ENABLE);       
    3 v3 b, |$ L/ w7 f2 }, @- b  T
22.     DMA_Cmd(DMA2_Stream2, ENABLE);
    
23. }
    ( e1 D6 E7 K0 s2 Y' _

复制代码

SPI_DMA 发送一个buf

1. void DMA_Write_buf(uint32_t SizeLen)
   
2. {   
   
3.     // 关闭发送 DMA               
   
4.     DMA_Cmd(DMA2_Stream5, DISABLE);       
   # p; S& ~1 t  N7 q8 Q# O, X6 N+ c
5.     // 设置发送的数据量   
   - H- C) N1 i( [3 M0 o2 e3 |9 M
6.     DMA_SetCurrDataCounter(DMA2_Stream5,SizeLen);
   : ]; |, h0 r7 J3 e% V5 y7 R
7.     // 清空数据
   - C! Q8 a. Q. ]% w% a1 t
8.     SPI1->DR;               
   
9.     // 擦除DMA标志位       
   $ {0 V. i; @, _  Q7 {/ a
10.     DMA_ClearFlag(DMA2_Stream5,DMA_IT_TCIF5);
    7 Z% X# t* g4 B8 P
11.     // 片选拉低,接收数据
    
12.     GPIO_ResetBits(GPIOA, GPIO_Pin_15);       
    
13.     // 开启发送 DMA
    ; v9 i0 D3 N% u' J1 B6 V' Q, i( i) V8 x
14.     DMA_Cmd(DMA2_Stream5, ENABLE);       
    - \. `5 @7 }) p
15. }
      S4 G3 A( }1 \; H9 i  i8 j

复制代码

张贴的代码显示如何配置我的GPIO，定时器，SPI, DMA和NVIC模块，以及一些系统如何工作的解释。
注意，我使用的是STM32F4标准外设库。


  ]  P2 b9 `5 H% J6 B( |网上内容
( @, C' E2 x0 X# U* @通过RCC(复位和时钟控制)模块使时钟信号到达所需模块:
8 h  Y% g) Y& G9 Y- z! s0 C1 X
& V# O; B8 V  }7 ]
: n" N2 F; |" v' ?& Q! P: t% iRCC

1. // 为所需模块配置时钟
   $ s: |5 g: I0 h
2.     // 启用GPIO外围时钟
   + k- I6 e; n( r4 \8 ]- T: E' @+ V
3.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
   ) \2 A7 ]- E6 k* }/ Z5 Q
4.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
   ( U" l' Q: [1 [9 \) b
5.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
   , k) b" O6 k7 E0 u) v2 k7 M
6.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   ; G/ H* m* F" K8 S1 {
7. 
   
8.     // 启用串行外围接口外围时钟
   " F) \7 ~, T0 C8 H  r/ {
9.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
   
10. 
    
11.     // 启用直接内存访问外围时钟
    
12.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    
13. 
    % Q- L8 x' J7 ^
14.    // 启用计时器外围时钟
    
15.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
    3 M6 F3 p, `. e6 n+ `0 {
16.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
    * C) i/ H5 I* ]

复制代码

GPIO
" A0 X# j8 U2 `: n接下来，配置所需的GPIO引脚:
' n9 X7 O5 K, K9 S( R  f# o

1. #define GPIO_SCAN_PORT            GPIOB
   
2.   #define GPIO_SCAN_PIN                GPIO_Pin_7
   
3.   #define GPIO_XLAT_PORT              GPIOA
   
4.   #define GPIO_XLAT_PIN                 GPIO_Pin_5
   
5.   #define GPIO_BLANK_PORT           GPIOB
   
6.   #define GPIO_BLANK_PIN              GPIO_Pin_6
   
7. 
     H0 j* I6 e+ d: l" {9 P. ^
8. // 配置GPIO引脚
     w0 G; d7 g8 F$ Y1 I
9.     GPIO_InitTypeDef GPIO_InitStructure;
   
10. 
    0 I& s$ T4 \- z* v$ F9 x
11.     // Timer3&4 输出 (TLC5940 GSCLK and BLANK)
    
12.     GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_4 | GPIO_Pin_6);
    ! f7 F/ ?0 @6 R8 L2 O6 g
13.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
14.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    1 N0 u; s) T" K5 ~( E- [' y% e+ j
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
16.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
17.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    & C8 o8 R5 J: d$ i
18.     // 连接计时器到GPIO引脚
    
19.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_TIM3);   // 将TIM3 OC1输出连接到PortB Pin4 (GSCLK)
    
20.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_TIM4);   // 将TIM4 OC1输出连接到PortB Pin6(BLANK)
    6 g& i( E- f7 b  d4 U
21. 
    
22.     // TLC5940 XLAT 引脚
    
23.     GPIO_InitStructure.GPIO_Pin = GPIO_XLAT_PIN;
    
24.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    
25.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
26.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
27.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
28.     GPIO_Init(GPIO_XLAT_PORT, &GPIO_InitStructure);
    ! ]  j* ]5 b6 f0 p
29. 
    : A. `7 U: ^* F) ?" S
30.     // 显示扫描 引脚
    
31.     GPIO_InitStructure.GPIO_Pin = GPIO_SCAN_PIN;
    
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      Z* V4 w) M, F' _+ w+ R4 X
33.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    $ i/ N2 S; H1 d/ o# L
34.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    ! \* b* Q0 K0 h/ Q5 `) c0 B. p
35.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    ; `' i8 Y0 p* l# _4 e0 u+ o
36.     GPIO_Init(GPIO_SCAN_PORT, &GPIO_InitStructure);
    
37. 
    
38.     // SPI2 引脚
    
39.     //    SCLK =    PB10
    , L3 r6 |: f  H3 N+ P
40.     //    NSS =     PB9
    
41.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
    % ^- x8 m4 _/ A* _1 g" g9 Z$ m5 w
42.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
43.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
44.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    * z0 |! P# a8 ^) ]4 Z; H- L! z
45.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
46.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    0 w/ `: l) N2 U- E7 w/ E3 [& B
47.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_SPI2);
    
48.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_SPI2);
    , C0 |& G: Z: c, `4 }
49. 
    
50.     //    MISO =    PC2
    
51.     //    MOSI =    PC3
    
52.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
    & _2 a+ a8 u" r. |# o3 f7 U. \1 s& S
53.     GPIO_Init(GPIOC, &GPIO_InitStructure);
    . J0 l+ |2 k8 f, W4 h
54.     GPIO_PinAFConfig(GPIOC, GPIO_PinSource2, GPIO_AF_SPI2);
    
55.     GPIO_PinAFConfig(GPIOC, GPIO_PinSource3, GPIO_AF_SPI2);
    
56. ————————————————
    * J- k4 d4 V# o& m1 X0 ^7 l: ?4 }

复制代码

这里的要点是，我将把TIM3的OC1输出直接连接到GPIO引脚(用于GSCLK)，把TIM4的OC1输出连接到BLANK信号。
" r9 G' V( e# s: o9 S: O
$ L" V$ I, [$ T% O- a  h: B
SPI
现在SPI模块可以初始化:
: V+ t/ S* w2 U- Y

1. // 初始化SPI模块
   
2.     SPI_InitTypeDef SPI_InitStructure;
   : U9 U4 f- z7 c' Q( N) A7 G6 K
3.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;       // SPI总线设置使用两条线，一条用于Rx，另一条用于Tx
   * L1 W! {* q" b  Q. c
4.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                // STM32是主服务，tlc5940作为从服务
   : O  F# v$ v8 Z: m' v0 }
5.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                             // 使用8位数据传输
   
6.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;                                    // TLC5940时钟空闲时低
   
7.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;                                // TLC5940使用第一个时钟过渡作为“捕获边缘”
   
8.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                        // 软件slave-select操作
   
9.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; // 设置预定标器
   8 E: `: e0 L6 B: B2 d, ]
10.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                             // TLC5940数据先从MSB传输
    
11.     SPI_InitStructure.SPI_CRCPolynomial = 0;                                          // 没有使用CRC
    ( l# Y+ w7 N: Q$ S
12. 
    
13.     SPI_Init(SPI2, &SPI_InitStructure);                                                    // 初始化SPI2外围设备
    
14.     SPI_SSOutputCmd(SPI2, ENABLE);                                                 // 将SS Pin设置为输出(主模式)
    7 j! ?, b' L1 H" ]2 u5 s& U6 F
15.     SPI_Cmd(SPI2, ENABLE);
    

复制代码

我选择的SPI时钟分频器是相当随意的，但这里的关键点是，我已经配置了时钟相位和极性，根据TLC5940数据表，所有传输都将是8位(稍后详细介绍)。


- \( s% W' c% D* dDMA
/ a7 c! ~7 _* H8 D; H& |用于SPI传输的DMA模块如下:

1. // 初始化用于SPI2_TX DMA访问的DMA1流4通道0
   
2. 
   
3.     #define DISP_SCAN_DATA_CNT     (24 * 3 * 2)    // 初始化用于SPI2_TX DMA访问的DMA1流4通道0
   
4.     volatile uint8_t dispData0[DISP_SCAN_DATA_CNT];
   
5.     volatile uint8_t dispData1[DISP_SCAN_DATA_CNT];
   
6. 
   
7.     DMA_InitTypeDef DMA_InitStructure;
   
8. 
     W8 I# h$ Y8 h/ k! L; _
9.     DMA_InitStructure.DMA_Channel = DMA_Channel_0;                   // SPI2 Tx DMA是DMA1/Stream4/Channel0
   ( o' @0 x- y9 j
10.     DMA_InitStructure.DMA_PeripheralBaseAddr  = (uint32_t)&(SPI2->DR);                // 设置SPI2 Tx
    
11.     DMA_InitStructure.DMA_Memory0BaseAddr  = (uint32_t)&dispData0;                   // 设置内存位置
    : B9 E  v- u$ Z+ n: L
12.     DMA_InitStructure.DMA_DIR  = DMA_DIR_MemoryToPeripheral;                          // 从内存发送数据到外设的Tx寄存器
    # w6 C! R% P% N) l: ]
13.     DMA_InitStructure.DMA_BufferSize  = DISP_SCAN_DATA_CNT;                          // 定义要发送的字节数
    + c3 D, `# i/ N4 a
14.     DMA_InitStructure.DMA_PeripheralInc  = DMA_PeripheralInc_Disable;                  // 不要增加外围“内存”
    % g4 ~9 ?7 }: I
15.     DMA_InitStructure.DMA_MemoryInc  = DMA_MemoryInc_Enable;                        // 增加内存位置
    % h5 v- q% |; \7 M+ h
16.     DMA_InitStructure.DMA_PeripheralDataSize  = DMA_PeripheralDataSize_Byte;    // 字节大小内存传输
    $ i. C; r& A# U
17.     DMA_InitStructure.DMA_MemoryDataSize  = DMA_MemoryDataSize_Byte;         // 字节大小内存传输
    
18.     DMA_InitStructure.DMA_Mode  = DMA_Mode_Normal;                           // 正常模式(非循环)
    8 S2 Z* H& ^; R3 i1 n) g) f/ Z" ]
19.     DMA_InitStructure.DMA_Priority  = DMA_Priority_High;                // 优先级高，以避免使FIFO饱和，因为我们是在直接模式
    ! H( p$ S! C1 y* W, @
20.     DMA_InitStructure.DMA_FIFOMode  = DMA_FIFOMode_Disable;                 // 操作在“直接模式”没有FIFO
    ' i% h! s$ d0 F$ w
21.     DMA_Init(DMA1_Stream4, &DMA_InitStructure);
    % F  N4 f& I: [+ o+ X4 z- }: s3 m
22. 
    8 T) Y) m3 m# }5 \
23.     // 操作在“直接模式”没有FIFO
    " B8 `' X( }, \& }' H% t) l
24.     DMA_ITConfig(DMA1_Stream4, DMA_IT_TC, ENABLE);
    

复制代码

NVIC
接下来，我已经为两个中断服务例程触发器配置了NVIC(嵌套矢量中断控制器):
0 z) a* R9 X6 M4 [3 H

1. // 初始化嵌套矢量中断控制器
   
2.     NVIC_InitTypeDef NVIC_InitStructure;
   
3. 
   
4.     // 启用TIM4(BLANK)中断
   ; y/ y3 z% l' h
5.     NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
   1 }5 x/ C. v& e0 K
6.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
   
7.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
   
8.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   1 Z& H6 I( e9 ?2 s
9.     NVIC_Init(&NVIC_InitStructure);
   
10. 
    
11.     // 启用DMA1 Stream4 (SPI2_TX)中断
    6 H8 A3 \7 S4 u6 h9 G4 {
12.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream4_IRQn;
    7 \& k% M" |& z3 r
13.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
14.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    * ?5 r# \1 U3 z6 s9 @* r( |
15.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    : C' T3 c  w/ v( _0 |% c
16.     NVIC_Init(&NVIC_InitStructure);
    / K" U( n! r& x; ~2 Z* ]& s1 T$ N

复制代码

BLANK中断用于产生空白脉冲，初始化DMA传输，并在每个扫描周期后锁定先前传输的数据。

2 M9 n  E6 _7 g& d, j' V
Timers
最后，定时器模块配置:
2 A! D) K+ x. O% Z2 d

1.    #define TLC5940_GSCLK_COUNTS    256                   // GSCLK在BLANK 脉冲之间进行计数
   $ `& a% _, U% n# g/ n
2.    #define TLC5940_GSCLK_FREQ        1000000            // GSCLK频率
   
3.    #define TLC5940_BLANK_COUNT      50                     // 在切换到下一列之前，允许前一扫描列的正电源轨道关闭的填充
   
4.    #define TIM_APB1_FREQ                  84000000          // 内部时钟频率(CK_INT)
   
5. 
   # g' Z* {$ A( i* C  w' j; j# t7 ^- A
6. // 启动计时器模块
   
7.     TIM_TimeBaseInitTypeDef TIM_BaseInitStructure;
   9 E  I1 q# T/ L* Y- K) F2 n8 n
8.     TIM_OCInitTypeDef TIM_OCInitStructure;
   8 G/ w7 _) ^$ I3 D
9. 
   
10.     // 反初始化计时器模块和初始化结构
      e5 d8 S! a* l: @4 C* Z( b
11.     TIM_DeInit(TIM3);
    ' I( ]6 {. e/ {* _) L$ K4 }
12.     TIM_DeInit(TIM4);
    / ]' c" ^  M( F( O1 E$ S
13.     TIM_TimeBaseStructInit(&TIM_BaseInitStructure);
    
14.     TIM_OCStructInit(&TIM_OCInitStructure);
    
15. 
    
16.     // 设置TIM3来生成“主时钟”
    
17.     TIM_BaseInitStructure.TIM_Period = 1;
    
18.     TIM_BaseInitStructure.TIM_Prescaler = (uint16_t) (((TIM_APB1_FREQ / TLC5940_GSCLK_FREQ)/4) - 1);    // 请注意，4的除法因子是由OC1频率vs CK_INT频率引起的
    
19.     TIM_BaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    / J1 x, B8 S/ o* Y. m" z
20.     TIM_BaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    8 e/ S4 E; I3 ]
21.     TIM_TimeBaseInit(TIM3, &TIM_BaseInitStructure);
      d8 D. q9 u7 Q4 ^4 N* K
22.     // 配置通道1输出比较作为触发器输出(用于生成‘GSCLK’信号)
    + O3 u1 M* Y0 x
23.     TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
    & y. z( w, h6 z
24.     TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    " c  V8 D' R" u* I/ }2 \
25.     TIM_OCInitStructure.TIM_Pulse = 1;
      W" z8 [  }% v* |
26.     TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    
27.     TIM_OC1Init(TIM3, &TIM_OCInitStructure);
    " D3 {& I5 v% U: Z( T
28.     TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);
    
29. 
    
30.    // 为对称计数器设置TIM4基准，最大计数指定为“GSCLK计数”(实际上是TLC5940的灰度分辨率)
    7 `4 }/ s& H$ D; ]; |- h/ I0 x
31.     TIM_BaseInitStructure.TIM_Period = TLC5940_GSCLK_COUNTS + TLC5940_BLANK_COUNT;                   // GSCLK溢出计数(对“阻塞”的空白信号额外加1)
    
32.     TIM_BaseInitStructure.TIM_Prescaler = 0;
    % |9 i+ v: }% R
33.     TIM_BaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    - B# A& B4 F0 D$ C+ x( X# {( c
34.     TIM_BaseInitStructure.TIM_CounterMode = TIM_CounterMode_CenterAligned1;
    
35.     TIM_TimeBaseInit(TIM4, &TIM_BaseInitStructure);
    
36.     // 将Channel 1输出Compare配置为触发输出(TIM4用作时钟信号来生成'BLANK')
    / I9 @( _8 P" p0 r7 b( g$ D" a5 |
37.     TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
    / b; ], t/ D1 ~8 a: F) F0 E
38.     TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    , b/ G# I  G4 t
39.     TIM_OCInitStructure.TIM_Pulse = TLC5940_BLANK_COUNT;
    
40.     TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    7 ]; Y2 \  }4 s
41.     TIM_OC1Init(TIM4, &TIM_OCInitStructure);
    / ^+ q4 p4 e& v
42.     TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);
    
43. 
    
44.     // 将TIM3配置为主计时器
    5 k0 X- R4 F+ \3 t
45.     TIM_SelectOutputTrigger(TIM3, TIM_TRGOSource_Update);                 // TRGO与TIM3的更新绑定
    
46.     TIM_SelectMasterSlaveMode(TIM3, TIM_MasterSlaveMode_Enable);    // TIM3作为master启用
    " M8 B. D0 W$ `5 Q
47. 
    6 @  q/ u' v- J- E1 B
48.    // 将TIM4配置为从属
    
49.     TIM_SelectInputTrigger(TIM4, TIM_TS_ITR2);                                     // 设置TIM4(从)触发TIM3(主)
    , ^9 U% l$ k2 M! m. R
50.     TIM_SelectSlaveMode(TIM4, TIM_SlaveMode_External1);                   // 使用主信号输入作为一个“外部时钟”
    
51. 
    9 b& W; l# X( O: p& m/ E  \4 J6 K
52.     // 将TIM4模块配置为在捕获/比较1个事件时中断(向上计数和向下计数都匹配)
    2 N1 D# S' q8 l* N7 {" k# b0 C
53.     TIM_ITConfig(TIM4, TIM_IT_CC1, ENABLE);
    ! R# k4 W# \( n1 O" e
54. 
    
55.     // 启用计时器3和4
    
56.     TIM_Cmd(TIM4, ENABLE);
    
57.     TIM_Cmd(TIM3, ENABLE);
    : v7 l5 \1 }' ~" k$ R
58. ————————————————
    & M8 ?- t2 u4 Y8 y7 }5 {

复制代码

在这里，定时器3被用作主时钟，在它的输出比较1线上产生GSCLK信号，和驱动定时器4被配置为一个中心对齐的PWM输出在OC1上。
BLANK计数是有效的填充脉冲，允许:

( I/ y( c- o1 I8 r: r1 w
最小空白脉冲时间
. Z) W4 A. j/ V$ f7 o$ B- XXLAT和DMA传输触发
3 G5 h- `# e, j! V4 i, O) yMOSFET输出在之前的扫描列完全放电(我已经通过观察放电时间在我的示波器调谐)
设置了GSCLK频率，并且在下降和上升的空白信号边缘之间的GSCLK脉冲数设置为256，因为我使用的是8位的颜色，而不是TLC5940芯片(12位)的全部功能。这意味着在空白脉冲之间将有256个GSCLK周期。
外围设备现在已经完全配置好了，所以最后要做的是查看中断服务例程，并调查结果:
" }+ f0 T) d  M0 G
9 I% q! w- r* a  P$ b9 n0 u, `
ISRs
8 T3 L7 p- a2 a: W4 q

1. #define DISP_SCAN_FREQ                 200                                                                                                                                                                           // 扫描信号的频率
   # H2 i; u6 m0 {. t
2. #define DISP_BLANK_CYCLE_LIMIT    ((((TLC5940_GSCLK_FREQ / (TLC5940_GSCLK_COUNTS + TLC5940_BLANK_COUNT)) / DISP_SCAN_FREQ) / 2) - 1)   // 扫描前要计数的BLANK循环数
   $ i+ X0 z. I9 C& C2 V
3. 
   ! X" i4 X2 R1 e) V
4.    void TIM4_IRQHandler(void)
   + N0 A7 m3 K+ v! k6 a
5.     {
   5 A, f& |  W7 I8 k
6.         // TIM4 IRQ处理程序有几个任务:
   + u7 S3 K) ~3 r7 U' W
7.         //    - 切换扫描信号
   
8.        //    - 锁定新选择('扫描')列的先前传输的数据
   ( s* {' z' S  J4 I
9.         //    - 设置并启动SPI2 DMA流来传输下一列的数据
   : F' W2 n$ b8 Y7 I. j2 o" F; L5 @
10.         // 所有这些都应该在BLANK信号(TIM4 OC1)高的窗口内执行(而不是完整的SPI传输)。
    
11. 
    
12.         // 检查所生成的中断是否为OC1更新
    
13.         if(TIM_GetFlagStatus(TIM4,TIM_IT_CC1))
    4 n1 ?% G  r. N- Q$ i0 S# S/ J0 O1 D6 i
14.         {
    
15.             // 清除TIM4 CC1中断位
    & H; M( D2 l% l  q9 z
16.             TIM_ClearITPendingBit(TIM4, TIM_IT_CC1);
    
17. 
    : k( v5 g8 F. Q( p/ i; E5 J$ h
18.             // 仅在向下计数时执行事件(这确保在空白脉冲内触发XLAT脉冲、扫描更新和SPI传输)
    " b# p- d: K' V" f" s" T$ ~5 f* d
19.             if(TIM4->CR1 & TIM_CR1_DIR)
    
20.             {
    
21.                 // 检查是否需要'SCAN'更新(XLAT脉冲，扫描切换，下一次传输触发)
    8 u% k% l; K* o  a; `
22.                 if(dispBlankCycleCnt++ >= DISP_BLANK_CYCLE_LIMIT)
    
23.                 {
    $ z0 R4 t: A+ V% Y$ w% L. A
24.                     GPIO_SetBits(GPIO_XLAT_PORT, GPIO_XLAT_PIN);                  // 设置XLAT引脚
    ) x, a# t2 P1 ~' k$ J' U) m5 J
25.                     dispBlankCycleCnt = 0;                                        // 重置计数器
    * W) o" F4 A& u* ?: M0 M
26. 
    % U0 Q, ?5 ~8 Y) h% b4 U
27.                     // 确定当前列，并相应地移动
    
28.                     if(dispCurrentCol)
    
29.                     {
    
30.                         dispCurrentCol = 0;                              // 更改为“0”列
    
31.                        GPIO_SetBits(GPIO_SCAN_PORT, GPIO_SCAN_PIN);      // 设置扫描引脚(注意列0是逻辑高位，列1是逻辑低位)
    9 s+ w: S+ n/ O2 W, r
32.                         DMA1_Stream4->M0AR = (uint32_t)&dispData1;       // Send *next*列的数据(由于当前列现在是'0'，因此将发送(针对下一个循环)
      W9 E( e4 _1 F" V) l0 D
33.                    }
      K; e: a$ I. p3 |7 c
34.                    else
    . ^$ k2 N; m, b; I. ~/ p8 `4 [! }
35.                     {
    
36.                         dispCurrentCol = 1;                                    // 更改为“1”列
    # z' f+ P* w  N$ Q! t! J2 i
37.                         GPIO_ResetBits(GPIO_SCAN_PORT, GPIO_SCAN_PIN);      // 重置扫描引脚(注意列0是逻辑高位，列1是逻辑低位)
    
38.                         DMA1_Stream4->M0AR = (uint32_t)&dispData0;         // Send *next*列的数据(由于当前列现在是'1'，因此发送了(对于下一个循环)
    
39.                     }
    
40. 
    1 Z4 F8 U  I9 |9 G6 x
41.                     GPIO_ResetBits(GPIO_XLAT_PORT, GPIO_XLAT_PIN);             // 清除XLAT引脚
    : o9 M$ r; P$ C
42. 
    9 g; M0 k# p, z9 H
43.                     //Trigger the next transfer
    ' s1 J: i& Z! M6 j. ^
44.                     SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);        // 启用DMA传输请求
    
45.                     DMA_Cmd(DMA1_Stream4, ENABLE);                         // 启用分配给SPI2的DMA流
    # Q* ?0 R" X+ J% M3 l
46.                 }
    
47.             }
    
48.         }
    + @9 t3 t- s" n2 O8 `
49.     }
    ! w$ b/ v- C" j
50. 
    + Z. p4 R2 M2 N
51.     void DMA1_Stream4_IRQHandler(void)
    
52.     {
    , S- G6 l$ J6 W& l% _
53.         // 检查是否设置了传输完成中断标志
    $ B* i. t' j( J5 I' a8 J2 e0 k
54.         if(DMA_GetITStatus(DMA1_Stream4, DMA_IT_TCIF4) == SET)
    / ]- \9 Q+ R  ]; u7 n
55.         {
    
56.             // 清除DMA1 Stream4传输完成标志
    
57.             DMA_ClearITPendingBit(DMA1_Stream4, DMA_IT_TCIF4);
    7 K# O7 L1 ^; e5 B8 q& L6 G8 t
58.         }
    ' o& h* E( W, ?% X6 d
59.     }
    

复制代码

DMA ISR目前没有被使用(我确实打算用它做一些无关的事情)，但TIM4 ISR基本上控制了整个显示。
空白脉冲的上升边缘(有效地)触发中断。在确定正确的ISR触发了事件之后，使用TIM_CR1_DIR位检查计数器是否正在减少计数。这确保了我们只在BLANK脉冲的上升边缘执行以下任务。
* O7 C6 Z) Z, M3 F1 D  P" Q1 s每当ISR运行时，我们增加一个计数器，如果这个计数器超过扫描显示所需的数量，我们就使用XLAT信号锁存前面的数据，切换扫描信号，并传输下一个数据(在disdata0[]或disdata1[]数组中找到)。
在dis_blank_cycle_limit中计算扫描前等待的空循环数，其中考虑到:


TLC5940_GSCLK_FREQ -灰度时钟频率
, q1 L. G- y$ Z7 p& V& wTLC5940_GSCLK_COUNTS + TLC5940_BLANK_COUNT——上升的空白边之间的GSCLK脉冲数
expec_scan_freq -我们希望扫描数组的频率(此处设置为200Hz)
7 Z, H$ l" Q' |6 X现在，更新disdatax[]数组中的数据将改变led上显示的内容。
+ `3 H+ o* Y( B% d6 Z4 B$ i  J4 BGSCLK频率为1MHz，扫描频率为200Hz，我没有明显的LED闪烁，即使我听到人们谈论使用>5MHz来避免它与他们的设置。


. Y5 x, B; }0 V3 m! lLogic Analysis
我在STM32F407输出和TLC5940显示板输入之间附加了一个逻辑分析器，如下所示:
; J4 A& k* y: C! n/ z4 {/ A1 s

现在我们知道GSCLK周期是预期的，我们可以研究空白时间来确定正在以8位分辨率记录的灰度数据。
- z* q, y2 N3 }& T1 t) {1 U; G下降和上升空白边之间的时间是305.6 - 49.6 = 256us，这是预期的。
我还调查了一个更接近的水平，以检查信号的相位是正确的2^8计数。
4 T8 \) ^3 q$ O5 p9 g3 g0 J

最后，检查扫描宽度，我们可以看到一个列启用了2.445ms。
即扫描速率为409Hz;考虑到2。5us =不能被256us整除，这很好。
% \' u1 o1 T) M上面的捕获还显示，当空白计数达到极限时，相关的ISR锁存前面的数据，
切换扫描行，然后触发SPI传输。
) E) x" M3 w0 E然后在锁定该数据之前计算所需的空白周期数(XLAT信号在2445ms光标所在的蓝色箭头右侧几乎不可见)。

# I: N7 F/ a( k- b! m3 v7 d

* E- E5 `; {0 [8 d8 e. w: a