一、开发板平台简介：
1、开发板资源简介
（1）开发板主芯片型号：STM32L431RCT6
% j/ ?8 _. t2 \! J% `9 A
) I+ Y/ |$ ]' D（2）开发板主芯片封装：LQFP-64_10x10x05P
! w: }) z# [* ]: Q7 p
（3）开发板主芯片内核：ARM® Cortex®-M4
( S- n( l7 _+ d/ a0 a4 C
（4）开发板主芯片主频：80MHz
& z6 ^5 y& q2 T
（5）开发板主芯片Flash大小：256KB
. L9 L' g6 l2 ?, @, W
7 I+ J8 Y, I* T- O（6）开发板主芯片RAM大小：64KB
+ ]" b( B- H. \, A9 Z
0 x" B: n, i8 Q& M$ e, ]



0 F( B4 a. ]0 @  ^- h9 d3 ]2、LED灯资源
/ \$ w6 [4 Q; y7 f3 o) k+ |, L（1） STM32L431RCT6开发板共5个LED灯资源，其中一个红色LED为系统指示灯，指示开发板供电系统是否正常，如供电系统正常，红色LED为上电常亮状态，硬件原理图如下图所示：

* F, [5 [: i( A0 j  Q4 O% F1 k
0 \0 u( K8 w+ ]0 \6 d
（2）其他四个LED灯为黄绿色可控LED，高电平点亮、低电平熄灭，计划用LED常亮验证看门狗的作用，硬件原理图如下图所示：



+ h, H9 _; O+ c1 _​3、串口printf打印工作原理
 串口全称为串行通讯接口，即数据在通信线上一次传输一位，按先后一定顺序传输。我们通常所说的单片机串口准确来说应该是串行异步收发传输器（Universal Asynchronous Receiver/Transmitter，UART），使用TTL电平，串口需要RXD、TXD、GND三根线进行通信。
9 M8 U) |: G' q! H, S/ L
     （1）我们选用的STM32L431RCT6开发板串口1已通过USB转TLL串口芯片CH340G引出，使用时，只需要用公对公USB线连接电脑即可（注意也得需要安装CH340G驱动），后期验证试验也可使用该串口作为debug串口。

5 O! c+ K/ C4 L( n  Y4 Q( d: N; D  i     （2）开发板上的其他串口已通过排针引出，为TTL电平，通信的时候需要注意选择对应的电平模块，如USB转TTL串口模块等。
! F9 \; l3 |# ~
TTL转CH340串口，硬件原理图如下所示：
$ r, P2 T9 I( k( t


4、SPI Flash简介
（1）SPI总线介绍
; g8 W5 u4 N+ u4 t& r( `1 tSPI分为主从工作模式，通常有一个主设备和一个或多个从设备，本文中MCU为主机，W25Q16为从机。
! ~& ?! b( ], \4 n. i4 [$ ^
- G! Y) L3 l. |SPI通信有以下四根线：
MISO：主设备数据输入，从设备数据输出。
7 ]2 p! Z) y" J  t4 ^) xMOSI：主设备数据输出，从设备数据输入。
SCLK：时钟信号，由主设备产生。

CS：从设备片选信号，由主设备控制，低电平为选中。

& r8 K" f1 _. s' m0 x6 U% i' I0 \1 e; y（2）SPI的特点：
高位先发送，共有四种工作模式。
, R* C" L' D2 ?* r6 F6 r6 TCPOL(时钟极性)：规定了SCK时钟信号空闲状态的电平(0-低电平,1-高电平)
CPHA(时钟相位)：规定了数据是在SCK时钟的上升沿还是下降沿被采样(0-第一个时钟边沿开始采样,1-第二个时钟边沿开始采样)
$ Q4 d3 L5 I3 J* Q
+ ?. @6 o1 |( _5 y) L8 r# _8 ^4 B+ v模式0：CPOL=0，CPHA =0  SCK空闲为低电平，数据在SCK的上升沿被采样(提取数据)
模式1：CPOL=0，CPHA =1  SCK空闲为低电平，数据在SCK的下降沿被采样(提取数据)
  g; Y/ g- h; y. B7 g# t( ?$ V$ o模式2：CPOL=1，CPHA =0  SCK空闲为高电平，数据在SCK的下降沿被采样(提取数据)
模式3：CPOL=1，CPHA =1  SCK空闲为高电平，数据在SCK的上升沿被采样(提取数据)

（3）开发板 SPI Flash原理图如下：
) A' B4 {& X' L% S3 Q/ t4 o% \
7 K. j( p* L) B5 s( C

/ y& K1 d0 I2 e' @$ S8 S- j
  二、串口printf实验过程
8 Q7 \* S9 O3 {9 G2 W( G: U1、新建STM32CubeMX基础工程
（1）打开STM32CubeMX，点击“File”-->"New Project"


3 W7 A9 {8 b' ~0 d, X) u! E$ S' o9 W
（2）等待打开主芯片选项界面（大约1分钟时间）。
; x0 o, C7 N/ I. {. i! d- }# Z
# \4 W" K8 ]# X

! }" q0 P+ U, }) b1 k( b( t, R（3）昨天搜索框中输入（或选择）所需的主芯片型号（因为我们用的是STM32L431RCT6开发板，所以此处选择STM32L431RC），然后在右下角选择STM32L431RCTx（因为开发板主芯片是STM32L431RCT6），左键双击即可打开新建的项目。
" r. j' O# M8 @  `; y  {3 ]" `- t

: w& b! _! m5 o8 N: y* u- V
（4）选择时钟源。
（1）因为开发板上有8M外部时钟，硬件原理图如下所示，所以此处选择使用外部高速时钟（HSE）。



( _& _9 k6 _1 }- M（2）因为我们没有用到外部低速时钟（LSE），此处不做处理，如下图所示。
# C, ~" v# ~# q$ M( ^

5 K& s( v3 O6 Q2 i
2、配置GPIO控制LED
（1）查开发板原理图得，LED1、LED2、LED3、LED4的控制引脚分别为：
- K0 c- o( e3 V, U* O* q/ m& sLED1——PC0
LED2——PC1
LED3——PC2
! T; ^. D; \0 kLED4——PC3

0 U6 k$ N3 X# H$ x# s3 Z（2）配置LED的控制引脚为输出，输出频率、输出方式默认即可。
! L9 b9 W. p: _9 _& t鼠标左键点击PC0,选择“GPIO_Output”,表示设置该引脚为输出模式。
鼠标左键点击PC1,选择“GPIO_Output”,表示设置该引脚为输出模式。
鼠标左键点击PC2,选择“GPIO_Output”,表示设置该引脚为输出模式。
鼠标左键点击PC3,选择“GPIO_Output”,表示设置该引脚为输出模式。



6 u# c( q2 x1 f' c% s, D7 E
% R/ j/ H$ B$ y* r1 o2 K
8 [: d; W0 e  u- M5 E' L（3）也根据自己的需求配置GPIO的参数，如输出方式、输出频率、上拉下拉等。因为GPIO控制LED的要求比较低，此处采用默认参数即可，不用修改。

  R) c4 P0 u  ^! {$ y4 i, L
( R/ X5 b+ i; @' Y- d3 J
​​3、配置PA9、PA10为串口
查原理图得知，串口1使用STM32L431RCT6引脚为PA9-USART1_TX,PA10-USART1_RX,引脚设置如下：
; n, F6 q2 A4 d3 E0 A: g3 n
& q  C; K1 G" q) v; N) S

（1）序号1用来设置串口收发引脚的选择。
（2）序号2-3-4-5-6设置串口参数，如波特率115200、8位、NONE无奇偶校验等。

( u( ]+ P* s! ^7 N; \ 4、配置SPI Flash接口
5 q' y, L4 I  p9 w" p8 z（1）查看STM32L431RCT6开发板原理图得知，芯片原理图如下：
) b$ G, L1 B9 ?9 g


) e, {" C# S/ }7 Y （2）SPI Flash接口对应芯片的PB12、 PB13、 PB14  PB15，芯片引脚配置如下：
PB12：SPI2_NSS，此处设置普通输出IO即可。不能配置成NSS
9 {) V  `/ T3 X, dPB13：SPI2_SCK
; C) B2 b' {2 u3 Q. XPB14：SPI2_MISO
  V" E; R% z% U& W1 x; G7 Y3 R* v$ ~9 PPB15：SPI_MOSI

% Z$ D8 p. @* u6 e3 e- |5 Y1 x- z
# @7 R# t& |) r% |$ |1 Q1 o* d6 c
（3）设置SPI引脚参数，并选择 Full-Duplex Master 全双工主模式，此处不开启 NSS 即不使用硬件片选信号。

- I3 |" ]' t8 t% N$ j

0 z$ A; f% L: Y* c（4）设置SPI基础参数以及时钟。
0 g7 T) M! G* x8 m1 I8 u# N
' q0 Y1 d# i- w  h5 X  H
' }# z, s6 f, q


* a  q9 e$ k0 w# L( ] 5、配置项目工程参数
（1）配置时钟树，用于系统内部时钟，以及各个外设时钟等。此处选择外部8M晶振作为主时钟频率，内部最大倍频80MHz。
9 ^* K2 f. k! x9 m) m. p
6 H  R5 a- r7 g- A: K5 R$ |5 [

（2）完成配置工程。
; G; M- T/ c( V( m- t9 v备注：需要注意代码生成过程中的继承关系，如图所示：需要保留开发者自己编写的代码时，请根据配置设置，不然生成代码后会删除自己编写的代码（从这个方面也可以看出开发者备份自己的代码是多么的重要。）

" t3 Q' S; r8 K2 B) ?+ L
​​
- h" _$ I3 ]; ]% ~1 E1 b

( A7 f/ A& s3 R4 \, J$ j7 {（3）生成代码。
备注：使用Generate CODE生成工程代码前，请确保文件路径无中文，否则会生成项目失败。


! o' V$ `1 ~5 K+ K$ H2 E
（4）工程代码生成成功。

  J/ u  \- I7 J4 M, v6 y$ P1 y% {
8 g; A' K, Z* D2 u8 B( a
" c1 {/ n  I- ^; o3 k2 n4 _
! f, Z0 ]3 l" w3 g" U 三、在KEIL 5中编写代码
: g- B* c8 ]1 _; l% F; V7 s1、使用KEIL 5（MDK）打开项目工程文件
, r& {3 [' F# g源码使用说明：使用前必须把项目工程复制到无中文路径的文件夹下使用。
（1）找到刚才新建工程的存储路径，安装项目名称，打开项目工程.uvprojx。
% |! B+ n% z- d

: Z- I4 g% N- m- Q
2、添加SPI Flash读写验证程序
（1）main.c文件中，初始化LED1、LED2、LED3、LED4默认为点亮，并在while循环中添加控制程序，如下所示：实现每隔500ms后LED1、LED2、LED3、LED4点亮和熄灭之间反转切换，并且串口每隔500ms打印一次。
. d5 B3 {5 _/ n) X4 Y1 d% ?: U
. ~& c" y; @3 V+ j8 u3 c4 ]4 @备注：自己添加的代码需要在 /* USER CODE BEGIN 3 */和 /* USER CODE END 3 */之间添加，否则STM32CubeMX更新代码时，会造成自己添加的代码丢失。

' |0 p6 [+ X8 u2 A




/ I9 _% o' \; n( h' n6 D
（2）main.c函数添加初始化代码和读取flash的代码，如下所示：

1. int main(void)
   " C9 S# J4 w1 H# h* {% f
2. {
   3 a' [+ M) u( w6 @
3.     /* USER CODE BEGIN 1 */
   - Q. }. O1 t+ M- _$ j* K
4.     uint32_t w25q_chip_id=0;                                                                                //读取芯片ID
   % p( h- `* q9 M: p6 d2 p
5.     uint8_t  onebyte_read[8]= {0};                                                                                //读取的字节内容
   , ]3 w  a- N- \. D) Y' i4 e: h4 P. C
6.     uint8_t  onebyte_write[8]= {0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80};                                //写入的字节内容
   0 A+ U2 B. f" b2 a( @" Y$ n- G
7.     /* USER CODE END 1 */
   2 i+ f# ^' X# R4 p( X4 B+ w
8. 
   
9.     /* MCU Configuration--------------------------------------------------------*/
   
10. 
    ; e) {! f+ V' z; m  h& {/ {
11.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    ' l7 ~% T( x- j7 G
12.     HAL_Init();
    
13. 
    
14.     /* USER CODE BEGIN Init */
    & x- p% a5 u2 A- ?" J
15. 
    1 u0 W  p! P2 g. i
16.     /* USER CODE END Init */
    
17. 
    4 w# R7 _8 Q# [, b# F% ~
18.     /* Configure the system clock */
    
19.     SystemClock_Config();
    3 Z% v8 P5 P) w( ?! g
20. 
    2 @1 ]9 B6 ~2 V% {
21.     /* USER CODE BEGIN SysInit */
    
22. 
    % [7 {1 Y; |. V# T
23.     /* USER CODE END SysInit */
    
24. 
    9 R& k' F: a: K' J+ I& j# ]7 p
25.     /* Initialize all configured peripherals */
    
26.     MX_GPIO_Init();
    8 E- c3 x  z6 Z
27.     MX_DMA_Init();
    
28.     MX_USART1_UART_Init();
    
29.     MX_SPI2_Init();
    
30.     /* USER CODE BEGIN 2 */
    % A1 Q' ~7 L$ x7 ]1 |8 b
31.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_0,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    
32.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_1,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    # ]( s+ b+ B8 ], t! B
33.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_2,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    6 K' Y! q$ V5 i0 i+ P. |3 p
34.     HAL_GPIO_WritePin(GPIOC,GPIO_PIN_3,GPIO_PIN_SET);                                                                    //初始化默认LED灯为点亮
    
35.     w25q_chip_id=spi_flash_read_ID();                                                                                                        //读取flash芯片ID
    & b) }) G8 Y- F* V
36.     HAL_Delay(100);
    4 r- D4 m' @+ ?" h: _  Y
37.     printf("hello world,spi_flash_read_ID==0x%0x!\r\n",w25q_chip_id);                    //printf 芯片ID
    
38.     spi2_flash_sector_erase(0x0);                                                                                                                 //写之前需要先擦除扇区
    
39.     spi2_flash_write(0x0,onebyte_write,8);                                                                                                 //写八个字节
    
40.     spi2_flash_read(0x00,onebyte_read,8);                                                                                                 //读取写入的字节
    
41.     /* USER CODE END 2 */
    / m- V! q+ [9 u1 b
42. 
    
43.     /* Infinite loop */
    # H3 _! }  [  O5 S) ^" u* m5 }
44.     /* USER CODE BEGIN WHILE */
    
45.     while (1)
    
46.     {
    
47.         /* USER CODE END WHILE */
    7 o% B& R! ~: W4 j4 \/ P
48. 
    
49.         /* USER CODE BEGIN 3 */
    . F( w% E" ^8 H- m3 N
50.         HAL_Delay(500);
    
51.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_0);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    ' E; w. y! H) a7 ~* D
52.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_1);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    
53.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_2);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    # U3 `8 _% o3 }. n, l
54.         HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_3);                                                                                 //每隔500ms闪烁一次，并打印flash区域的值
    
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],\
    2 R( ^' t6 A4 \9 f  z
56.         onebyte_read[2],onebyte_read[3],onebyte_read[4],onebyte_read[5],onebyte_read[6],onebyte_read[7]);   //printf打印flash区域的值
    % l, W+ J  [" g) Z) `2 V% ~
57. 
    ! W4 e1 }9 h9 _! V3 Z
58.     }
    
59.     /* USER CODE END 3 */
    
60. }

复制代码

（3）新建w25qxx.c文件，并添加驱动层函数，如下所示：

1. #include "main.h"
   4 @: D6 x' U, b4 \( }5 q5 _
2. #include "spi.h"
   
3. #include "w25qxx.h"
   2 W( i3 j6 g* [/ k& I: U
4. /**
   3 r, ^0 y% Y% ^' q2 I- \
5.   * @brief SPI1 读一个字节
   
6.   * @param None
   5 X& J" t& ?: X$ H, Q! g) Z! M
7.   * @retval None
     @& n- D8 f* k+ Y$ s% o- m# I
8.   */
   
9. static uint8_t spi2_flash_read_byte(void)
   8 y  c4 h$ y" G6 k2 l; ~# R  A7 W
10. {
    
11.     uint8_t t_data, r_data;
    
12. 
    
13.     if(HAL_SPI_TransmitReceive(&hspi2, &t_data, &r_data, 1, 0xFFFFFF) != HAL_OK)
    7 {8 D8 j( n! X5 a/ E
14.     {
    
15.         r_data = 0xff;
    
16.     }
    + j6 f7 x3 G' t/ s
17.     return r_data;
    
18. }
    # ?& \4 {8 c) j1 W
19. /**
    
20.   * @brief SPI1 写一个字节
    + ?5 T* G! Q! e' |2 X! b  o4 w* L
21.   * @param byte 写入的字节
    
22.   * @retval 写状态 0成功 1失败
    
23.   */
    
24. static uint8_t spi2_flash_send_byte(uint8_t byte)
    
25. {
    . d7 l9 @5 b" ]9 L  T
26.     uint8_t r_data;
    2 {5 x5 V) f3 K- q5 w, s4 n0 ~
27. 
    ) I9 b& }- _' z, g. G( J0 y. `
28.     if(HAL_SPI_TransmitReceive(&hspi2, &byte, &r_data, 1, 0xFFFFFF) != HAL_OK)
    
29.     {
    
30.         return 1;
      O( P. z$ T/ t6 ]% T9 x: t- n; J
31.     }
    , o$ m: Z/ g9 t
32.     return 0;
    1 W8 O# S/ I' i) v4 |- T
33. }
    
34. /**
    
35.   * @brief FLASH 写使能
    9 `$ Y4 f' B5 G# b' {
36.   * @param None
    ' C% L' F& k" k0 D$ X
37.   * @retval None
    . O. C. u1 a" b; m3 ?$ Z* s, Y( \
38.   */
    8 u) o& k7 B9 T! z( R3 |0 i: U# `) Q
39. static void spi2_flash_write_enable(void)
    
40. {
    
41.     SPI_FLASH_CS_LOW();
    
42.     spi2_flash_send_byte(W25X_WriteEnable);
    " g  e/ O: m- S' ~5 C9 `8 E2 {
43.     SPI_FLASH_CS_HIGH();
    
44. }
    
45. /**
      h" ]( a0 I5 G
46.   * @brief FLASH 等待写结束
    
47.   * @param None
    
48.   * @retval None
    1 f( E- S; A- o+ s0 N7 _* ?/ L/ b1 D& ]# D1 k
49.   */
    
50. static void spi2_flash_wait_for_write_end(void)
    
51. {
    
52.     uint8_t state = 0;
    . l8 A# L1 J/ _% L) N6 F  s
53. 
    
54.     SPI_FLASH_CS_LOW();
    
55. 
    
56.     spi2_flash_send_byte(W25X_ReadStatusReg);
    
57. 
    # Z, }1 O, j" N
58.     do
    
59.     {
    " n! J0 ^( Z0 g# s/ D, F8 F
60.         state = spi2_flash_read_byte();
    
61.     }
    
62.     while((state & 0x01) == SET);
      X; M, n+ E) Q9 b$ l1 b0 y% }
63. 
    & r0 r; u* ^: ~
64.     SPI_FLASH_CS_HIGH();
    7 q7 o9 Q! l0 V/ J# m( r1 W
65. }
    
66. /**
    
67.   * @brief FLASH 读ID
    
68.   * @param None
    
69.   * @retval None
    , w/ e8 V, M5 [, S; J1 |
70.   */
    ( w, f7 t5 s" P( l2 f5 N
71. uint32_t spi_flash_read_ID(void)
    
72. {
    
73.     uint32_t temp, temp0, temp1, temp2;
    
74. 
    
75.     SPI_FLASH_CS_LOW();
    
76.     spi2_flash_send_byte(W25X_JedecDeviceID);
    
77. 
    
78.     temp0 = spi2_flash_read_byte();
    * G2 B( [: b) k. N) o! O. W- E& \
79.     temp1 = spi2_flash_read_byte();
    - w0 z) [& j& k* ?/ W- {+ m
80.     temp2 = spi2_flash_read_byte();
    % N5 w& c) C5 }
81. 
    
82.     SPI_FLASH_CS_HIGH();
    
83. 
    7 ?- n# v# G; Q/ ?) a4 W, q; ?& U
84.     temp = (temp0 << 16) | (temp1 << 8) | temp2;
    8 K, O8 k1 ^, q; A* [# B
85. 
    
86.     return temp;
    " y* Z6 Q5 A$ R; c! b6 i
87. }
    
88. /**
    & B: s; w/ [) N9 t+ E  Y
89.   * @brief 读FLASH
    
90.   * @param addr 读flash的起始地址
    
91.   * @param pdata 读到的数据存放起始地址
    * W. a4 ]9 G/ [: U# x# N7 P: c6 x
92.   * pdata size 读数据大小
    9 @1 d& S+ m( ~9 w1 y# `6 f
93.   * @retval None
    " N! r# |8 o# ^* W. e8 a$ v" Z/ C
94.   */
    
95. void spi2_flash_read(uint32_t addr,uint8_t *pdata, uint16_t size)
    : A( y* v/ ~2 D! h4 w7 e
96. {
    
97.     SPI_FLASH_CS_LOW();
    
98. 
    
99.     spi2_flash_send_byte(W25X_ReadData);
    
100. 
     
101.     spi2_flash_send_byte((addr & 0xFF0000) >> 16);
     ( r- v1 `! w9 l- C: z1 Y
102.     spi2_flash_send_byte((addr & 0xFF00) >> 8);
       ]8 I9 \; e* d, j# I) m7 f6 ^
103.     spi2_flash_send_byte(addr  & 0xFF);
     
104. 
     ' [7 i6 m6 U+ b
105.     while (size--)
     
106.     {
     $ {6 R2 ^% {# z* @) x
107.         *pdata = spi2_flash_read_byte();
     
108.         pdata++;
     
109.     }
     
110. 
     
111.     SPI_FLASH_CS_HIGH();
     ( M- m! r- a5 K( z, T% _0 U& E
112. }
     
113. /**
     : E4 b/ w$ z  O( l# `1 A0 L
114.   * @brief 按页写FLASH
     " V  s2 m+ |1 O+ s' s
115.   * @param addr 写入flash的起始地址
     2 A( b5 b- {/ D& F' B0 ?
116.   * @param pdata 写入数据的起始地址
     
117.   * pdata size 写数据大小
     % y' ]/ Y& d' R( C
118.   * @retval None
     
119.   */
     
120. void spi2_flash_page_write(uint32_t addr, uint8_t *pdata, uint16_t size)
     
121. {
     9 o6 s+ O9 y: I% w. Z/ `2 j
122.     uint16_t i;
     . f) O- }& \& y! `
123. 
     
124.     spi2_flash_write_enable();
     ( E: D) h$ }! b# R+ [# M$ L: O# v
125. 
     
126.     SPI_FLASH_CS_LOW();
     
127. 
     , \4 w' q) [+ @5 ]6 J
128.     spi2_flash_send_byte(W25X_PageProgram);
     : k% |: q% P% v' S
129.     spi2_flash_send_byte((uint8_t)((addr)>>16));
     4 [$ M- x% e: W) W8 V/ A. K
130.     spi2_flash_send_byte((uint8_t)((addr)>>8));
     
131.     spi2_flash_send_byte((uint8_t)addr);
     7 b' O" C* z: y7 ~& Q
132. 
     
133.     for(i = 0; i < size; i++)
     
134.     {
     6 O7 s3 d9 u4 F- c* L) r; U
135.         spi2_flash_send_byte(pdata[i]);
     7 G$ ]' V2 g  X! d0 ?4 K" m
136.     }
     
137. 
     
138.     SPI_FLASH_CS_HIGH();
     ! N; E9 P7 }) u/ u0 Q' ?6 h
139.     spi2_flash_wait_for_write_end();
     % |7 Y9 Q4 P) G# E4 ~' T* t& e
140. }
     
141. /**
     
142.   * @brief 写FLASH
     ) s9 h' z/ H. E3 x; b" U- }
143.   * @param addr 写入flash的起始地址
     
144.   * @param pdata 写入数据的起始地址
     ' b# Y+ }% m& o4 H0 l) w! b/ `3 s
145.   * pdata size 写数据大小
     % d. B6 G9 r. n  {7 ]9 [
146.   * @retval None
     6 L4 k7 X# z* g- c# z, R
147.   */
     
148. void spi2_flash_write(uint32_t addr, uint8_t *pdata, uint32_t size)
     
149. {
     
150.     uint32_t page_remain;
     
151. 
     
152.     page_remain = 256 - addr%256;
     
153. 
     
154.     if(size <= page_remain)
     $ X) q: A$ f% ~! S. r2 T
155.     {
     4 r8 A" B9 ^0 R) T
156.         page_remain = size;
     
157.     }
     * B" i8 m  ?8 z
158.     while(1)
     6 Z4 T$ h, G3 j  W( R+ B5 C
159.     {
     % W5 E. H, l4 k
160.         spi2_flash_page_write(addr, pdata, page_remain);
     
161. 
     
162.         if(size == page_remain)
     
163.             break;
     ( ?" i+ P) q% M" ~' L& u/ e( q/ D/ Q
164.         else
     
165.         {
     
166.             pdata += page_remain;
     
167.             addr += page_remain;
     
168. 
     " |2 \, W, b, N* w3 b: Z( }
169.             size -= page_remain;
     : {3 Z6 J1 E0 a  e8 K  X! `1 n
170.             if(size > 256)
     " _0 o" l3 w) v+ u" Q
171.                 page_remain = 256;
     9 ]0 K9 R% E: E- w( j1 R" c- I, T; [( T
172.             else
     : R* Y. n, I5 D' k' {- ^- L! l
173.                 page_remain = size;
     9 c6 X' S& W: G# h+ {( c; J$ `' J
174.         }
     
175.     }
     $ l& P- L! j6 D0 p& H
176. }
     
177. /**
     2 N  D: _% V) W! y5 y
178.   * @brief 擦除FLASH扇区
     
179.   * @param sector_addr 扇区的起始地址
     7 l0 R7 y, N  _
180.   * @retval None
     
181.   */
     
182. void spi2_flash_sector_erase(uint32_t sector_addr)
     
183. {
     
184.     spi2_flash_write_enable();
     4 d, g3 N: Z/ O# q/ b# Q
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);
       Q! r$ _& m0 H1 c+ q* j
190.     spi2_flash_send_byte((sector_addr & 0xFF00) >> 8);
     * E( z1 t; J; U" ^/ [& P
191.     spi2_flash_send_byte(sector_addr & 0xFF);
     
192. 
     
193.     SPI_FLASH_CS_HIGH();
     
194. 
     
195.     spi2_flash_wait_for_write_end();
     
196. }
     # G! o) n0 c! k. _! b. e1 B2 J9 ?
197. 
     
198. /**
     
199.   * @brief 擦除FLASH块
     8 b$ N" E% b) i
200.   * @param None
     & i  P" {9 f/ ]( h  g/ t0 g
201.   * @retval None
     . B, N9 z/ \- b/ [- P8 }9 }
202.   */
     * @* `( h% x4 @7 o6 X
203. void spi2_flash_block_erase(void)
     ) c6 b" c7 p" U
204. {
     
205.     spi2_flash_write_enable();
     3 r% b. U6 `- ?  o: h0 t, H
206. 
     
207.     SPI_FLASH_CS_LOW();
     ) s* j1 j) o# F; G7 \) M
208.     spi2_flash_send_byte(W25X_ChipErase);
     
209.     SPI_FLASH_CS_HIGH();
     
210. 
     
211.     spi2_flash_wait_for_write_end();
     # [# A3 P/ j7 ^* Y5 }) G
212. }
     3 D6 E5 B4 p; ^& ], ]0 H2 j- s

复制代码

3、设置编程仿真下载模式
（1）选择Options for target ...>>Debug>>J-Link/J-JTRACE Cortex,点击Settings>>选择Port（SW），可以看到搜索成功SW Device，表示芯片可用，可以下载。
1 ^  K* C* R7 N2 z+ [6 f: }
9 j& H0 i4 ?0 N
  {: ?. R4 \( J) r' K5 I​​
1 v. z  e( D. M; x+ i2 s# `+ `（2）点击编译，完成后提示“0 error（s），0 warning（s）”。



8 D' m$ r, x, B! X% y（3）点击Download（或者快捷键F8），即可下载程序。
* L3 \6 y: }* k

! c  I1 `0 R# M3 y* D​​

（4） 如果下载程序后，没有看到LED1、LED2、LED3、LED4闪烁，可以按下述方式设置一下（Reset and run表示下载后自动复位和重启运行）。或者重新彻底断电再次上电（或按开发板的Reset按键复位MCU即可）。


9 c! W, k8 u0 X6 I( V1 X0 I ​

: v( v& e* D- f/ ?6 ]5 s; Y) ^# m; x& _4、SPI Flash实验效果展示
& f9 ]- t. [' d1 u" b% J& M6 _      （1）  程序烧录到开发板后，即可看到LED1、LED2、LED3、LED4初始化后每隔500ms闪烁一次，并且打开串口助手后（串口参数：波特率115200、N、8、1），可以看到printf每隔500ms打印一次log数据。

) W  R8 j* h5 {; s

6 ^1 T- j2 ]8 s+ S （2）屏蔽写入flash的语句，可以看到此时串口log打印的全为FF，则证明SPI Flash读写有效。

% g2 \: \9 A" A. I$ r3 [. n" X$ b
+ j2 Y1 w1 I1 N8 W; x  a


————————————————
  k: _/ C1 E9 v3 C3 _; b! F/ P版权声明：智能小屋ZYXC
4 J7 s8 l3 s" z* P5 M# Q# {; B