一、开发板平台简介：
1、开发板资源简介
. d1 A4 \" v5 i% r$ |* A（1）开发板主芯片型号：STM32L431RCT6
- g8 Q- }- y8 k1 S
（2）开发板主芯片封装：LQFP-64_10x10x05P

1 j5 g1 V% F1 A* `7 k（3）开发板主芯片内核：ARM® Cortex®-M4
% |2 ]7 L+ o  x8 Q  c1 O% S/ i4 M. x
（4）开发板主芯片主频：80MHz

（5）开发板主芯片Flash大小：256KB
- K( \$ H/ B; f, V+ m( L
, l. \' E3 T# ~. |% J0 g0 `" P（6）开发板主芯片RAM大小：64KB


6 s! R. q% t- }; `0 k
" q4 H( D1 R, D8 K' v

4 [/ i1 v( o# `& p" I/ }2、LED灯资源
, v) t/ Z# K* z0 d7 s（1） STM32L431RCT6开发板共5个LED灯资源，其中一个红色LED为系统指示灯，指示开发板供电系统是否正常，如供电系统正常，红色LED为上电常亮状态，硬件原理图如下图所示：

8 w) ]) P0 F( K9 S

（2）其他四个LED灯为黄绿色可控LED，高电平点亮、低电平熄灭，计划用LED常亮验证看门狗的作用，硬件原理图如下图所示：
$ X6 T' r7 @4 t) I; P8 C0 u

; j$ P3 }* L7 j# ~1 q+ L
​3、串口printf打印工作原理
& A4 c7 E) I6 B" l& H8 w5 o6 ^* s& m 串口全称为串行通讯接口，即数据在通信线上一次传输一位，按先后一定顺序传输。我们通常所说的单片机串口准确来说应该是串行异步收发传输器（Universal Asynchronous Receiver/Transmitter，UART），使用TTL电平，串口需要RXD、TXD、GND三根线进行通信。

     （1）我们选用的STM32L431RCT6开发板串口1已通过USB转TLL串口芯片CH340G引出，使用时，只需要用公对公USB线连接电脑即可（注意也得需要安装CH340G驱动），后期验证试验也可使用该串口作为debug串口。

% Y4 f. q1 J$ V! {9 z4 u! @     （2）开发板上的其他串口已通过排针引出，为TTL电平，通信的时候需要注意选择对应的电平模块，如USB转TTL串口模块等。

- b3 k& i# v( C5 yTTL转CH340串口，硬件原理图如下所示：
5 z7 [% F  C$ v" j

1 V! g8 |9 e) [4 |* l4 p
: S/ |# N& K& t1 b8 Y4、SPI Flash简介
6 K: i7 ^" _# d; {3 W! _（1）SPI总线介绍
* z+ ]: a- Q2 @& ESPI分为主从工作模式，通常有一个主设备和一个或多个从设备，本文中MCU为主机，W25Q16为从机。

% [* [+ D4 |  @# |# N2 jSPI通信有以下四根线：
MISO：主设备数据输入，从设备数据输出。
MOSI：主设备数据输出，从设备数据输入。
$ L3 Y2 R5 ]* O+ q2 q2 Z. FSCLK：时钟信号，由主设备产生。
4 B2 D; v$ N$ J
7 ]9 x4 o3 ?) B  `: RCS：从设备片选信号，由主设备控制，低电平为选中。

; j* G' H; }1 J- a! {5 C3 M6 o（2）SPI的特点：
高位先发送，共有四种工作模式。
CPOL(时钟极性)：规定了SCK时钟信号空闲状态的电平(0-低电平,1-高电平)
4 f. e% u2 T4 X. m8 Z: ECPHA(时钟相位)：规定了数据是在SCK时钟的上升沿还是下降沿被采样(0-第一个时钟边沿开始采样,1-第二个时钟边沿开始采样)

模式0：CPOL=0，CPHA =0  SCK空闲为低电平，数据在SCK的上升沿被采样(提取数据)
' r; F, M2 S  e, i模式1：CPOL=0，CPHA =1  SCK空闲为低电平，数据在SCK的下降沿被采样(提取数据)
/ W8 G6 m8 r9 C3 N模式2：CPOL=1，CPHA =0  SCK空闲为高电平，数据在SCK的下降沿被采样(提取数据)
模式3：CPOL=1，CPHA =1  SCK空闲为高电平，数据在SCK的上升沿被采样(提取数据)
& ]9 X7 N3 |/ P4 k6 ?" Z
（3）开发板 SPI Flash原理图如下：



/ a* e- ~" \- @5 R/ _7 I% B, A& z
9 J) r: N/ x9 x1 \* {$ h  二、串口printf实验过程
8 F; M9 f4 S( d, v6 U! j% }. L" Z7 U1、新建STM32CubeMX基础工程
7 X  `8 C; Y& h4 Q: q! N7 F（1）打开STM32CubeMX，点击“File”-->"New Project"
9 c! v* i, Q5 r
1 O3 B- t0 v' r$ z( \

（2）等待打开主芯片选项界面（大约1分钟时间）。
+ m7 i! s0 H- e
+ n% b0 \: A! ]: _
. C5 L$ r9 a2 R) |8 \& h$ R" g
7 H  z( o) @* i# r4 r（3）昨天搜索框中输入（或选择）所需的主芯片型号（因为我们用的是STM32L431RCT6开发板，所以此处选择STM32L431RC），然后在右下角选择STM32L431RCTx（因为开发板主芯片是STM32L431RCT6），左键双击即可打开新建的项目。


' c, X$ O. t' y" ?
' t3 W; `8 O0 T' o（4）选择时钟源。
（1）因为开发板上有8M外部时钟，硬件原理图如下所示，所以此处选择使用外部高速时钟（HSE）。


2 U! M- S6 b! e5 N
2 B. N3 d, e9 D6 S（2）因为我们没有用到外部低速时钟（LSE），此处不做处理，如下图所示。

/ o- j1 i. D3 t1 [, v4 X
( v2 `0 P) N: i8 ?5 f
2 u" j/ i6 U& B5 y, t2、配置GPIO控制LED
% F& W5 a- H# p. C) t+ Y0 x: f（1）查开发板原理图得，LED1、LED2、LED3、LED4的控制引脚分别为：
LED1——PC0
LED2——PC1
8 _  `( I7 H4 ?) r: j8 H# i* |# r, K. TLED3——PC2
LED4——PC3

+ A8 a% d1 N% n9 k（2）配置LED的控制引脚为输出，输出频率、输出方式默认即可。
9 m9 ^0 @: a& g/ @鼠标左键点击PC0,选择“GPIO_Output”,表示设置该引脚为输出模式。
鼠标左键点击PC1,选择“GPIO_Output”,表示设置该引脚为输出模式。
鼠标左键点击PC2,选择“GPIO_Output”,表示设置该引脚为输出模式。
+ i5 o' @9 N7 m2 y鼠标左键点击PC3,选择“GPIO_Output”,表示设置该引脚为输出模式。




3 P. T. j2 M. t: L' f% z: a6 \
5 _) L" M# d, k& ]（3）也根据自己的需求配置GPIO的参数，如输出方式、输出频率、上拉下拉等。因为GPIO控制LED的要求比较低，此处采用默认参数即可，不用修改。

/ B, i  i, `/ n: f/ V& Q
  k7 d  i0 o) o/ ^% l1 ~
* l8 C/ X  b* I& O​​3、配置PA9、PA10为串口
( V1 K- n' q; w查原理图得知，串口1使用STM32L431RCT6引脚为PA9-USART1_TX,PA10-USART1_RX,引脚设置如下：



（1）序号1用来设置串口收发引脚的选择。
（2）序号2-3-4-5-6设置串口参数，如波特率115200、8位、NONE无奇偶校验等。
7 U4 l, n3 v. s
  ?4 F4 e2 ]! w1 k$ s( S1 z/ n" C 4、配置SPI Flash接口
（1）查看STM32L431RCT6开发板原理图得知，芯片原理图如下：
" g5 I" _- T: l& s# Q


7 u5 G+ X$ l0 Y; x+ } （2）SPI Flash接口对应芯片的PB12、 PB13、 PB14  PB15，芯片引脚配置如下：
PB12：SPI2_NSS，此处设置普通输出IO即可。不能配置成NSS
PB13：SPI2_SCK
PB14：SPI2_MISO
- ~/ l8 c2 t! o3 xPB15：SPI_MOSI

' m5 J/ N& J) B7 F& M& }& C

（3）设置SPI引脚参数，并选择 Full-Duplex Master 全双工主模式，此处不开启 NSS 即不使用硬件片选信号。
4 C. c0 l. O4 R6 i* i% d
) E( }8 |9 K: X' H

) r1 d5 _7 ]- ?! I, ?0 v; @+ z（4）设置SPI基础参数以及时钟。
' q$ j1 G8 F$ h$ _3 y
0 n7 A( s$ `. K3 p1 Z

9 C/ J- [6 T3 T

+ R& t$ R+ e* ]+ [9 U2 i& {! G 5、配置项目工程参数
& m* G: f; A! }7 }2 f（1）配置时钟树，用于系统内部时钟，以及各个外设时钟等。此处选择外部8M晶振作为主时钟频率，内部最大倍频80MHz。
# F9 j$ s; C' X! M# k0 V


（2）完成配置工程。
备注：需要注意代码生成过程中的继承关系，如图所示：需要保留开发者自己编写的代码时，请根据配置设置，不然生成代码后会删除自己编写的代码（从这个方面也可以看出开发者备份自己的代码是多么的重要。）
( {7 Y& Y2 z  w8 I, i- K  t
. t# E1 ~# k/ p/ N
​​


（3）生成代码。
备注：使用Generate CODE生成工程代码前，请确保文件路径无中文，否则会生成项目失败。
6 o/ ?" ]" m) Z, F

2 e! `* q# ~' f! E8 K% d
( `) N+ @+ ?  ~- p7 J+ k; ?2 S（4）工程代码生成成功。
% B6 U& i7 _% i- s1 J  v4 n

. m6 K: K: L8 x+ g; j2 ^7 U& [/ k* Z; |

% X6 K' G' E6 C6 ^; k3 v: z 三、在KEIL 5中编写代码
1、使用KEIL 5（MDK）打开项目工程文件
9 u$ T% h3 I. f4 Z/ }6 h9 O源码使用说明：使用前必须把项目工程复制到无中文路径的文件夹下使用。
（1）找到刚才新建工程的存储路径，安装项目名称，打开项目工程.uvprojx。
4 j7 e( j& H" P
+ z$ D, V- b0 [3 r& T

' P/ ~" X; d3 s  \2、添加SPI Flash读写验证程序
: R! W6 i( ~1 S' r0 I（1）main.c文件中，初始化LED1、LED2、LED3、LED4默认为点亮，并在while循环中添加控制程序，如下所示：实现每隔500ms后LED1、LED2、LED3、LED4点亮和熄灭之间反转切换，并且串口每隔500ms打印一次。
) ?) r' O& f' j# ]$ v
3 V# p' G1 G$ s% Y4 {; Y4 N3 m备注：自己添加的代码需要在 /* USER CODE BEGIN 3 */和 /* USER CODE END 3 */之间添加，否则STM32CubeMX更新代码时，会造成自己添加的代码丢失。


5 f: h8 |; K+ @$ j7 b$ C: s- q+ _

' l% B% [' F: _4 v6 W. b% a
0 a# {- ~' m+ O, e. I# k# k
; f0 }8 Q7 @4 \3 v1 [; s- j+ c
9 _) P+ X1 D- X5 F5 T（2）main.c函数添加初始化代码和读取flash的代码，如下所示：
0 L! r9 f: y- B0 t# h

1. int main(void)
   
2. {
   0 L& ^. j5 Y6 A) r( q+ g& s
3.     /* USER CODE BEGIN 1 */
   
4.     uint32_t w25q_chip_id=0;                                                                                //读取芯片ID
   
5.     uint8_t  onebyte_read[8]= {0};                                                                                //读取的字节内容
     W9 Z: ^( E! v, b( `1 `; x
6.     uint8_t  onebyte_write[8]= {0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80};                                //写入的字节内容
   
7.     /* USER CODE END 1 */
   , w5 Y. |1 w6 x: s, g3 D
8. 
   
9.     /* MCU Configuration--------------------------------------------------------*/
   1 _; @: G, ^# A/ n- Y; }
10. 
    
11.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    8 X5 p8 P* `% b
12.     HAL_Init();
    + }, _% I5 `( l, C
13. 
    
14.     /* USER CODE BEGIN Init */
    
15. 
    / c7 C: S6 c, m* m
16.     /* USER CODE END Init */
    
17. 
    
18.     /* Configure the system clock */
    
19.     SystemClock_Config();
    
20. 
    7 k4 x% @8 \9 j4 W1 O8 h
21.     /* USER CODE BEGIN SysInit */
    % G3 S! w; z+ }0 w# n) y
22. 
    
23.     /* USER CODE END SysInit */
    
24. 
    0 s7 p9 n- y! y) r4 H% q5 K
25.     /* Initialize all configured peripherals */
    . f/ ~# j& t; T, L  v: F2 l' ?$ ?
26.     MX_GPIO_Init();
    : M8 j8 K% N5 [0 z  ]
27.     MX_DMA_Init();
    4 f5 a, F" w$ t; Q. |% f
28.     MX_USART1_UART_Init();
    
29.     MX_SPI2_Init();
    
30.     /* USER CODE BEGIN 2 */
    
31.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_0,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    ! d- l+ e: i- ^" f/ y' J; b& _. X
32.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_1,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    " x/ x, ?: \) q8 f3 W& X" a
33.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_2,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    $ |: H' C+ N+ {7 A6 T" |
34.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_3,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    
35.     w25q_chip_id=spi_flash_read_ID();                                                                                                        //读取flash芯片ID
    ! j3 B" c( K8 N% P) I5 j1 m
36.     HAL_Delay(100);
    , u# W" p- _5 O" [1 R4 E
37.     printf("hello world,spi_flash_read_ID==0x%0x!\r\n",w25q_chip_id);                    //printf 芯片ID
    
38.     spi2_flash_sector_erase(0x0);                                                                                                                 //写之前需要先擦除扇区
    # O* X; \/ h  J7 H0 v/ I$ O
39.     spi2_flash_write(0x0,onebyte_write,8);                                                                                                 //写八个字节
    1 u5 B' d' T! g  j/ w) J0 \# T
40.     spi2_flash_read(0x00,onebyte_read,8);                                                                                                 //读取写入的字节
    
41.     /* USER CODE END 2 */
    * Z" D# Z, Q8 r' g
42. 
    " e* F3 L) @/ O; I2 [) M9 O" u
43.     /* Infinite loop */
    
44.     /* USER CODE BEGIN WHILE */
    
45.     while (1)
    $ H, m2 H6 H* R
46.     {
    
47.         /* USER CODE END WHILE */
    7 N/ U  Q$ K$ F, J  @
48. 
    
49.         /* USER CODE BEGIN 3 */
    
50.         HAL_Delay(500);
    % c# O! ^6 d+ S9 K( q8 Z/ Q1 Z! E
51.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_0);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    * r0 U9 o3 s' r
52.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_1);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    
53.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_2);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    
54.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_3);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    & b* }; y+ l4 J1 g2 J) h$ @5 C
55.         printf("hello world,spi2_flash_read =0x%0x,0x%0x,0x%0x,0x%0x,0x%0x,0x%0x,0x%0x,0x%0x\r\n",onebyte_read[0],onebyte_read[1],\
    ( Z/ I& a; ], q, i. N
56.         onebyte_read[2],onebyte_read[3],onebyte_read[4],onebyte_read[5],onebyte_read[6],onebyte_read[7]);   //printf打印flash区域的值
    
57. 
    4 ^' Y8 u- O6 D9 E) o/ h$ g' R# p
58.     }
    , {+ R2 F7 a' s" P7 l6 z) K
59.     /* USER CODE END 3 */
    $ U7 v6 t! s( O0 o% W
60. }

复制代码

（3）新建w25qxx.c文件，并添加驱动层函数，如下所示：
4 H  f/ I: N+ W! w/ K; [6 M9 K. q& H# l

1. #include "main.h"
   - ^- O! v  S3 l% l2 d5 O* l
2. #include "spi.h"
   
3. #include "w25qxx.h"
   
4. /**
   
5.   * @brief SPI1 读一个字节
   ! y* ?1 y. ?% H& @. G/ R
6.   * @param None
   . d( }/ M+ W: {- t3 ]7 ?( _
7.   * @retval None
   ; {9 u( S8 S- W% y5 T. k
8.   */
   
9. static uint8_t spi2_flash_read_byte(void)
   
10. {
    
11.     uint8_t t_data, r_data;
    
12. 
    
13.     if(HAL_SPI_TransmitReceive(&hspi2, &t_data, &r_data, 1, 0xFFFFFF) != HAL_OK)
    8 l& m  e* d0 u5 ~3 O: J
14.     {
    
15.         r_data = 0xff;
    
16.     }
    
17.     return r_data;
    " x% i. B2 w4 Q, p
18. }
    
19. /**
    
20.   * @brief SPI1 写一个字节
    " V+ B3 N* l2 c
21.   * @param byte 写入的字节
    
22.   * @retval 写状态 0成功 1失败
    
23.   */
    * [  l2 o; B0 x3 y3 d2 }; S! z' G
24. static uint8_t spi2_flash_send_byte(uint8_t byte)
    . P! K3 n. C: Y; z
25. {
    
26.     uint8_t r_data;
    7 t/ x/ B% p  }5 p. Z& Y' T
27. 
    5 c+ i9 A  R; I. k
28.     if(HAL_SPI_TransmitReceive(&hspi2, &byte, &r_data, 1, 0xFFFFFF) != HAL_OK)
    + J# H1 ^+ E7 T  t, }
29.     {
    " y# H7 y1 M0 o7 \5 _6 X
30.         return 1;
    % l9 T; s, z7 v& q, C, U
31.     }
    ; w9 f# e( F9 D9 O8 ]
32.     return 0;
    
33. }
      e9 w0 A5 u7 {: ?4 Y) Z. @
34. /**
    $ Z& g4 L) ^0 r9 x' z+ A
35.   * @brief FLASH 写使能
    
36.   * @param None
    8 z2 ], B4 k. Z  {5 ?, o7 A
37.   * @retval None
    + }* F" x9 ?: C3 K3 o9 [' t" j
38.   */
    
39. static void spi2_flash_write_enable(void)
    - ~$ U* ~- b6 H) S) }7 p: u
40. {
    * L* j# V# x! y/ i+ ]
41.     SPI_FLASH_CS_LOW();
    
42.     spi2_flash_send_byte(W25X_WriteEnable);
    
43.     SPI_FLASH_CS_HIGH();
    
44. }
    . B* w5 A6 q1 X$ P) Y5 {+ Z
45. /**
    + D- h" X7 O* K0 O
46.   * @brief FLASH 等待写结束
    , z) e7 ^% H3 f
47.   * @param None
    
48.   * @retval None
    ! q+ T6 h5 n5 s& r+ x
49.   */
    / g/ [0 ?; B/ A) J! C4 G
50. static void spi2_flash_wait_for_write_end(void)
    
51. {
    1 I; Z' @& D" d' l
52.     uint8_t state = 0;
    ; n% \& h% E$ v; Z1 E' M0 a8 A
53. 
    & ]* a# g, r( Z9 Z3 G: Y7 [3 N
54.     SPI_FLASH_CS_LOW();
    3 f6 J0 |$ o3 H5 C% ~2 Z, }
55. 
    . d3 }6 M4 S8 w. [; L, L. C
56.     spi2_flash_send_byte(W25X_ReadStatusReg);
    
57. 
    - n! ^: r& V6 q: A
58.     do
    
59.     {
    + v8 y* G, V* @' Y! M* p6 c; H
60.         state = spi2_flash_read_byte();
    % N9 }( M) `9 @% p  ?" Q
61.     }
    / V* `% k) G" I1 w+ V- O
62.     while((state & 0x01) == SET);
    
63. 
    
64.     SPI_FLASH_CS_HIGH();
    
65. }
    ; s$ P/ k4 q1 i. V: r  [& K
66. /**
    
67.   * @brief FLASH 读ID
    , V. ]# j' }2 w; L( a
68.   * @param None
    
69.   * @retval None
    % a, ?! d/ w' b. \5 _
70.   */
    2 @6 a) g4 W0 i
71. uint32_t spi_flash_read_ID(void)
    
72. {
    ( S. I; u/ t$ d6 N- R
73.     uint32_t temp, temp0, temp1, temp2;
    
74. 
    , M) ^* M; A( Q1 `! W
75.     SPI_FLASH_CS_LOW();
    4 ?$ {# Y6 u8 {" ]" v5 ]  s
76.     spi2_flash_send_byte(W25X_JedecDeviceID);
    
77. 
    
78.     temp0 = spi2_flash_read_byte();
    % ^' A( Z* w6 Z
79.     temp1 = spi2_flash_read_byte();
    / R4 v0 q" M: Z7 j
80.     temp2 = spi2_flash_read_byte();
    7 }2 N" b! }8 t1 Q" I
81. 
    / r6 K. |7 {+ y  m6 K
82.     SPI_FLASH_CS_HIGH();
    0 z) S: N% l9 A
83. 
    , z1 W% s$ K% Z" R, r+ ~( W( K; n
84.     temp = (temp0 << 16) | (temp1 << 8) | temp2;
    2 L, |5 R/ |6 W4 J
85. 
    5 S, \4 M. b) {5 F1 _% {0 y$ U
86.     return temp;
    ; F7 b3 Y9 |4 }6 I
87. }
    
88. /**
    2 j6 ~8 \1 c5 x( c" R
89.   * @brief 读FLASH
    
90.   * @param addr 读flash的起始地址
    ; D& Y# n2 B" Z
91.   * @param pdata 读到的数据存放起始地址
    * g: s6 T7 I  e2 Q4 w
92.   * pdata size 读数据大小
    
93.   * @retval None
    : [/ i1 f- Z) Z( Q* E
94.   */
    
95. void spi2_flash_read(uint32_t addr,uint8_t *pdata, uint16_t size)
    
96. {
    
97.     SPI_FLASH_CS_LOW();
    
98. 
    0 d% a+ ?) C, ]* m* z
99.     spi2_flash_send_byte(W25X_ReadData);
    & S. ^- A0 a9 K2 e# B, u* E
100. 
     ' T0 _4 {8 D& |, [% O% `
101.     spi2_flash_send_byte((addr & 0xFF0000) >> 16);
     + v6 o* W3 q0 }' |: C+ z
102.     spi2_flash_send_byte((addr & 0xFF00) >> 8);
     * \  Z5 f- ]) n6 I) B& m* z: @% C
103.     spi2_flash_send_byte(addr  & 0xFF);
     3 S: a" Q- D- d6 ^5 b
104. 
     6 U% y1 K- e4 H6 e/ _: I8 V. o
105.     while (size--)
     & w1 N/ [* [8 m/ O5 v$ |+ ^( n
106.     {
     
107.         *pdata = spi2_flash_read_byte();
     
108.         pdata++;
     
109.     }
     + C3 q) e: V8 @& C6 a' ~
110. 
     
111.     SPI_FLASH_CS_HIGH();
     9 e6 K: H% C( o  m" D
112. }
     
113. /**
     
114.   * @brief 按页写FLASH
     
115.   * @param addr 写入flash的起始地址
     
116.   * @param pdata 写入数据的起始地址
     # s0 i9 k; v% D0 p- `. Z, m; j
117.   * pdata size 写数据大小
     & A! a0 s( E% [
118.   * @retval None
     
119.   */
     
120. void spi2_flash_page_write(uint32_t addr, uint8_t *pdata, uint16_t size)
     7 _9 o! E' \# j' c, j, }/ D
121. {
     
122.     uint16_t i;
     
123. 
     $ P" n/ O/ C+ b4 ~, B) z
124.     spi2_flash_write_enable();
     
125. 
     
126.     SPI_FLASH_CS_LOW();
     
127. 
     2 H6 ?. {7 X! h- B
128.     spi2_flash_send_byte(W25X_PageProgram);
     
129.     spi2_flash_send_byte((uint8_t)((addr)>>16));
     
130.     spi2_flash_send_byte((uint8_t)((addr)>>8));
     $ H, d6 [/ s# Y' e. K5 ]2 |
131.     spi2_flash_send_byte((uint8_t)addr);
     
132. 
     ) l- ]6 l4 L9 [' l
133.     for(i = 0; i < size; i++)
     
134.     {
     % E' S8 \6 Z, v5 T" Z+ T
135.         spi2_flash_send_byte(pdata[i]);
     : v4 Q+ A0 `: a( y% ?5 J/ u! y
136.     }
       o5 r. l6 r0 s/ n0 X
137. 
     9 y+ a( M, x- B- j! `. W) u
138.     SPI_FLASH_CS_HIGH();
     ( W- z* O$ ]$ Z( P: u; o
139.     spi2_flash_wait_for_write_end();
     4 X- I% F* c4 K" [. |- O1 `! U
140. }
     
141. /**
     2 C2 U+ h5 y. r; k% `: N
142.   * @brief 写FLASH
     ' c7 l( P$ j+ @; ]# \- N, b
143.   * @param addr 写入flash的起始地址
     
144.   * @param pdata 写入数据的起始地址
     
145.   * pdata size 写数据大小
     8 o1 u4 c; p  R, t
146.   * @retval None
     
147.   */
     + y9 c6 E' ~, O& ~) k2 E7 ^
148. void spi2_flash_write(uint32_t addr, uint8_t *pdata, uint32_t size)
     ( C/ ]# r) e' I, w  `5 h
149. {
     ; T# s0 j. Z; i- W+ ]' {8 P( D% I' I
150.     uint32_t page_remain;
     ' Y- B, s6 m) p: d- M% X5 D0 Q
151. 
     & w! n- H0 l0 B0 m; ^3 t: }6 W! D1 A2 w" s
152.     page_remain = 256 - addr%256;
     . Z# c5 d3 |0 l+ k
153. 
     
154.     if(size <= page_remain)
     6 x1 }9 @1 ~+ t6 m3 u1 k3 [
155.     {
     , O2 {" B8 p; P! k
156.         page_remain = size;
     
157.     }
     1 e  i5 F+ D' s. z; p
158.     while(1)
     
159.     {
     
160.         spi2_flash_page_write(addr, pdata, page_remain);
     
161. 
     
162.         if(size == page_remain)
     2 Z0 X2 |; b7 _: k" r
163.             break;
     8 K2 j1 a* j& A7 I& C
164.         else
     * @' S  o( U5 X7 g$ z; r
165.         {
     
166.             pdata += page_remain;
     
167.             addr += page_remain;
     
168. 
     
169.             size -= page_remain;
     1 X/ u9 m7 _, [4 A" _) V
170.             if(size > 256)
     
171.                 page_remain = 256;
     
172.             else
     
173.                 page_remain = size;
     * G, O/ |% ?  ^
174.         }
     + k% h! \, L# s# k, b7 e, q
175.     }
     + x% I: ~5 W1 V
176. }
     ' y0 r8 p# R/ N9 B. a
177. /**
     
178.   * @brief 擦除FLASH扇区
     
179.   * @param sector_addr 扇区的起始地址
     
180.   * @retval None
     % I3 M, I& n( J- Q! v2 S9 {
181.   */
     , O$ n# m9 q' F3 v: d
182. void spi2_flash_sector_erase(uint32_t sector_addr)
     
183. {
     
184.     spi2_flash_write_enable();
     ) E2 @$ a& N8 r* ]4 g; U: \2 M* D
185.     spi2_flash_wait_for_write_end();
     
186. 
     
187.     SPI_FLASH_CS_LOW();
     
188.     spi2_flash_send_byte(W25X_SectorErase);
     
189.     spi2_flash_send_byte((sector_addr & 0xFF0000) >> 16);
     ' n3 i8 f- y  ~, ~( D( l% z
190.     spi2_flash_send_byte((sector_addr & 0xFF00) >> 8);
     
191.     spi2_flash_send_byte(sector_addr & 0xFF);
     # Z- M; a1 t, o
192. 
     
193.     SPI_FLASH_CS_HIGH();
     
194. 
     
195.     spi2_flash_wait_for_write_end();
     
196. }
     * C- f5 Q3 ~' y
197. 
     4 [5 Q8 Q0 l* @3 ^; i
198. /**
     ! U! r; m4 T% @& H! L4 o4 J
199.   * @brief 擦除FLASH块
     4 j) v' x. g: t( a; \% f
200.   * @param None
     ( w& c5 H3 m& j5 e# g0 v
201.   * @retval None
     0 Q' y2 m# j4 l, _) S
202.   */
     
203. void spi2_flash_block_erase(void)
     
204. {
     
205.     spi2_flash_write_enable();
     
206. 
     
207.     SPI_FLASH_CS_LOW();
     
208.     spi2_flash_send_byte(W25X_ChipErase);
     6 {( T8 V' x. N& K- f- v& @5 @' Y
209.     SPI_FLASH_CS_HIGH();
     
210. 
     
211.     spi2_flash_wait_for_write_end();
     
212. }
     5 b( q& F; X2 ?, Q

复制代码

) B6 {4 ]) C% u* t2 \3 R8 G2 {; }3、设置编程仿真下载模式
（1）选择Options for target ...>>Debug>>J-Link/J-JTRACE Cortex,点击Settings>>选择Port（SW），可以看到搜索成功SW Device，表示芯片可用，可以下载。
  v" F  U: f( L6 U/ c  g' Y$ ~

7 X2 }8 w: M. M* R: I​​
9 G, j- z; j7 b- C7 u, v5 P（2）点击编译，完成后提示“0 error（s），0 warning（s）”。



  {9 G' c9 F% k1 W（3）点击Download（或者快捷键F8），即可下载程序。

5 U8 L; \2 C& u# T, r8 y# V" [
1 E# j$ f/ T: }6 O& M2 g  S​​
7 G2 @9 ~3 ^6 L% [3 |
（4） 如果下载程序后，没有看到LED1、LED2、LED3、LED4闪烁，可以按下述方式设置一下（Reset and run表示下载后自动复位和重启运行）。或者重新彻底断电再次上电（或按开发板的Reset按键复位MCU即可）。
6 |5 Q- W, M' ]9 {% B2 h

​

4 F% J4 F. N2 d: H: V% m( a# S4、SPI Flash实验效果展示
/ q- ?# D( ?2 n; \6 Z/ i      （1）  程序烧录到开发板后，即可看到LED1、LED2、LED3、LED4初始化后每隔500ms闪烁一次，并且打开串口助手后（串口参数：波特率115200、N、8、1），可以看到printf每隔500ms打印一次log数据。

' W  r; {$ X# F# e/ v. _

4 y5 t- t0 k5 x, D6 Y （2）屏蔽写入flash的语句，可以看到此时串口log打印的全为FF，则证明SPI Flash读写有效。
: B+ [9 Y% R  E
4 _, ]+ R2 u& p8 J, E. c7 L5 K' P
+ j2 Q. t8 A- L1 z* O7 t& S
) z& |1 a  _& w- r+ G  v5 M$ c8 M  O( \

————————————————
版权声明：智能小屋ZYXC
) W( H2 X8 u. R' A8 o

9 Y0 g# ]4 U& a$ k