一、原理图
" K/ o5 v- L/ a' i# n* l


! g# T3 N; l' a二、 CubeMX配置
' ^8 f4 M# \$ d0 |% ?. {! j
Step1.打开 STM32CubeMX，点击“New Project”，选择芯片型号，STM32F103VETx。
$ b3 o3 H, K: S8 j. y) s. P


' A% Y1 y" }& ]* u! J/ S Step2.选择时钟源，并配置时钟树。选择Crystal/Ceramic Resonator，并配置系统时钟为72M。
, t5 G  t& p! C! }
( y' w, V* i; c6 i: @' n
9 p7 _9 \9 |% C3 L
" I) P8 m, u, ^0 n

Step3.配置SYS，我们这里选择的是Serial Wire。（正常情况配置不配置不影响，debug可以使用。但是你不可以把这两个引脚用于其他复用功能，如果用于其他复用功能，debug就不起作用了。）
. _+ i: [; @# Y7 e) y* O; L


  Step4.串口配置（主要为了在串口调试助手显示读写数据），因为没有用到中断和DMA所以我们就不过多讲解。
( L( w4 @/ d* l6 m
/ T  H3 s" O+ i2 B2 h9 s% R% p' i

8 r2 I' ?9 B5 K& a step5.SPI外设配置，这里选用的SPI1。因为没有使用到中断和DMA所以只需要把硬件SPI基本参数配置好就行。

& e; H& j2 ]3 M0 ^

step6.因为是采用软件NSS，所以还需要配置相应的IO口。

% p! [8 f* q3 ~' E( I. b" C
  L% z3 V; z+ Q* S& t7 Q! G
) G! H# D0 u/ A) b* l 到这里关于硬件IIC参数配置基本已经完成，只需要根据之前文章《STM32Cube HAL:GPIO输入/输出（一）》Step4-Step8，设置相关工程参数和生成代码。
0 B: Q( C9 A( q4 ~1 ^! A
三、添加功能代码
. _) W1 I9 C4 y8 e
* q! a, I5 U) d1、我们等会会向串口调试助手发送数据，进行实验结果的验证。 发送数据我们采用printf函数，所有需要重定向c库函数printf到串口。注意使用时需要在keil设置中勾选微库(use mircolib)，同时需要添加头文件#include <stdio.h>。
0 \" m) z$ P9 [0 ^

1. //重定向c库函数printf到串口DEBUG_USART，重定向后可使用printf函数
   
2. int fputc(int ch, FILE *f)
   - D$ v) U; F# i" U- s4 t
3. {
   ! @% l9 g! _/ Y3 d2 w& l; U( F
4.         /* 发送一个字节数据到串口DEBUG_USART */
   - X3 U; i1 Z! o( F. a+ a6 D
5.         HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 1000);        
   - P3 v2 a% S' O, j( M
6.         
   & K" s. a+ D. C7 l
7.         return (ch);
   3 D. `' }  ?: H: g
8. }
   ' V, s. t! O& a4 X) m9 |$ S
9. 
   
10. //重定向c库函数scanf到串口DEBUG_USART，重写向后可使用scanf、getchar等函数
    8 l; `, N" ^1 j- |
11. int fgetc(FILE *f)
    
12. {               
    + E5 @# Q2 \, A% U8 |& N% [# ^
13.         int ch;
    6 h4 o9 R4 C; x' M  \0 ]
14.         HAL_UART_Receive(&huart1, (uint8_t *)&ch, 1, 1000);        
    
15.         return (ch);
    # ?! h: z5 a! y/ f! s1 K9 @9 }
16. }

复制代码

2 d5 A1 Y' ~& K& k2、在gpio.h文件中添加相关的宏定义。因为是使用软件控制NSS，下面宏定义通过IO口模拟NSS信号。（NSS低电平控制，NSS高电平释放）
# S* C7 N" b1 A* Z

1. #define NSS_HIGH() HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET)
   - \4 x( H/ U' c, m0 g4 u+ b& j
2. #define NSS_LOW()  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET)

复制代码

3、在spi.h添加宏定义，和函数的声明。方便移植和提高可读性。

1. #define FLASH_PAGESIZE         256                          //W25Q64的页面大小
   
2. #define _Flash_ID        0xEF4017

复制代码

1. extern SPI_HandleTypeDef hspi1;
   . o$ j% _4 l- G7 B: c
2. void MX_SPI1_Init(void);
   $ c8 @% M( x2 [% t! L8 U* e
3. uint32_t SPI_FLASH_ReadID(void);
   ) X' e. Y9 ?& V5 W8 R
4. void SPI_FLASH_WriteEnable(void);
   
5. void SPI_FLASH_WaitForWriteEnd(void);
   2 p4 {& C: N7 k& P  y; Y
6. void SPI_FLASH_SectorErase(uint32_t SectorAddr);
   ; V' X7 h" _" p8 U6 A: z
7. void SPI_FLASH_PageWrite(uint8_t * pBuffer, uint32_t WriteAddr,uint16_t NumByteToWrite);
   
8. void SPI_FLASH_BufferWrite(uint8_t * pBuffer, uint32_t WriteAddr,uint16_t NumByteToWrite);
     b! s6 ~5 `' n- s, F
9. void SPI_FLASH_BufferRead(uint8_t * pBuffer, uint32_t  ReadAddr,uint16_t NumByteToWrite);

复制代码

$ {& b% t! @! Y, }9 I6 z 然后在spi.c中实现声明函数的具体功能。
; f, f9 W0 f" W9 h, t3 T
5 y( I. U* t- V) M0 h

1. /*读取制造商和设备ID*/
   9 T7 ]# g2 M4 N  }) H
2. uint32_t SPI_FLASH_ReadID(void)
   
3. {
   6 a! n1 B* c) ]7 W$ v/ _" W
4.         uint8_t W25X_JEDEC_ID=0X9F;
   , u# j; f4 E7 g: S7 ]1 e: A$ Q% o; h
5.         uint8_t temp0[3];
   
6.         uint32_t temp;
   9 L, H+ w% A+ h. D6 G
7.         
   
8.         NSS_LOW();//选择FLASH:NSS低电平
   4 k8 c( a1 s/ L/ L
9.         
   
10.         HAL_SPI_Transmit(&hspi1,&W25X_JEDEC_ID,1,10);//发送指令
    
11.         
    
12.         HAL_SPI_Receive(&hspi1,temp0,3, 10);//读取制造商和设备ID
    
13.         
    / W. A8 \2 z& [& q) o1 [
14.         NSS_HIGH();//停止信号 FLASH:NSS高电平
    + h- f1 }4 d( x! f
15.         
    3 G6 h* e$ c$ T8 z. a. T# X
16.         temp=(temp0[0])<<16|(temp0[1]<<8)|temp0[2];//把数据组合起来，作为函数的返回值
    ' a# ?9 H6 d/ [6 E$ {; _' J6 ]$ }' ~& c
17. 
    5 Q4 ~4 x, B& ]& l" k7 S# ]. t
18.         return temp;
    
19. }
    
20. 
    
21. /*写使能*/
    # B/ g; f  V. k- }+ F1 C
22. void SPI_FLASH_WriteEnable(void)
    & m2 k; T, J: K& R! p
23. {
    7 v! }* l' s  I+ m& l
24.         uint8_t W25X_WriteEnable=0x06;
    8 x1 U8 L# l9 T# r
25.         
    , }/ G% L. L- G: C3 X& n8 p
26.         NSS_LOW();//选择FLASH:NSS低电平
    
27.         
    
28.         HAL_SPI_Transmit(&hspi1,&W25X_WriteEnable,1,10);//发送指令
    
29.         
    ; M4 E% C6 E. k" o+ n
30.         NSS_HIGH();//停止信号 FLASH:NSS高电平
    
31. }
      B/ h3 |* V0 F, n7 X
32. 
    
33. /*扇区擦除*/
    % q) A- Y( ]) Y) M3 X1 X: v& A
34. void SPI_FLASH_SectorErase(uint32_t SectorAddr)
      V+ i) a) w1 m' l' m
35. {
    ; G0 B- z0 _$ g' v8 S7 d# m2 P
36.         uint8_t W25X_SectorErase=0x20;
    7 J% e- q$ b9 i2 g. _; h
37.         uint8_t temp1,temp2,temp3;
    
38.         
    6 `% c. g: I5 j! R9 F* E( ?
39.         SPI_FLASH_WriteEnable();//写使能
    3 y" J; C4 X+ `& @5 W. Y
40. 
    
41.         NSS_LOW();//选择FLASH:NSS低电平
    
42.         
    ( ?. Y* w3 F" u3 O- N) z5 [
43.         HAL_SPI_Transmit(&hspi1,&W25X_SectorErase,1,10);//发送指令
    # d% @6 x  r+ `( _
44.         
    * f5 v1 J; R6 l6 r, @
45.         temp1=(SectorAddr&(0xFF0000))>>16;//发送地址
    
46.         HAL_SPI_Transmit(&hspi1,&temp1,1,10);
    * L& b* Q  M- [# _
47.         temp2=(SectorAddr&(0x00FF00))>>8;
    4 l' L" u5 ], L! N( S" x  G8 W
48.         HAL_SPI_Transmit(&hspi1,&temp2,1,10);
    
49.         temp3=(SectorAddr&(0x0000FF));
    : z! E6 M7 L. M7 l
50.         HAL_SPI_Transmit(&hspi1,&temp3,1,10);
    : E& {, u: s2 x0 J; F( q4 i
51.         NSS_HIGH();//停止信号 FLASH:NSS高电平
    * n& O! u7 s$ T( W
52.         
    
53.         SPI_FLASH_WaitForWriteEnd();//等待擦除完毕
    
54. }
    
55. 
    & r# ~* \: _3 B2 v8 {9 A8 J
56. /*等待 WIP(BUSY) 标志被置 0，即等待到 FLASH 内部数据写入完毕*/
    + j+ s! {  L$ \4 T8 c- x/ ]# @
57. void SPI_FLASH_WaitForWriteEnd(void)
    ; l/ X' e- l; n4 G4 I+ |7 O5 w
58. {
    : n& V' P/ t7 t# g1 |$ E. B9 _
59.         uint8_t W25X_ReadStatusReg=0x05;
    + B0 P: A: O% \1 b0 ]  Y/ s8 b
60.         uint8_t temp;
    % Q' [4 L2 g- b# E
61.         
    : G& @) X$ `$ \, w6 b
62.         NSS_LOW();//选择FLASH:NSS低电平
    
63.         
    " e& r( S& O% ~5 v& s
64.         HAL_SPI_Transmit(&hspi1,&W25X_ReadStatusReg,1,10);//发送指令
    , I9 {8 t# F( D) Y( N
65.         do
    5 j5 V# o6 o1 v% q
66.         {
    
67.                 HAL_SPI_Receive(&hspi1,&temp,1,10);// 读取 FLASH 芯片的状态寄存器
    
68.         }
    
69.         while((temp&0x01)==1);
    
70.         
    ) G+ q+ l1 \- m
71.         NSS_HIGH();//停止信号 FLASH:NSS高电平
    
72. }
    
73. 
    " a* E9 l0 h  A4 h9 Z7 D
74. /*在FLASH的一个写循环中可以写多个字节，但一次写入
    7 Z4 D7 x2 G/ h. \% X* J
75. 的字节数不能超过FLASH页的大小，W25Q64每页有256个字节*/
    
76. void SPI_FLASH_PageWrite(uint8_t * pBuffer, uint32_t WriteAddr,uint16_t NumByteToWrite)
    
77. {
    " a7 e9 ], c7 a( }
78.         uint8_t W25X_PageProgram=0x02;
    
79.         uint8_t temp1,temp2,temp3;
    ( [  `, k' M0 o' t' I* Q  n
80.         
    
81.         SPI_FLASH_WriteEnable();//写使能
    - I; L* B# g# h9 i0 ^
82.         
    
83.         NSS_LOW();//选择FLASH:NSS低电平
    
84.         
    
85.         HAL_SPI_Transmit(&hspi1,&W25X_PageProgram,1,10);//发送指令
    
86.         
    
87.         temp1=(WriteAddr&(0xFF0000))>>16;//发送地址
    0 I# ]% m6 k; h2 y6 Z9 t
88.         HAL_SPI_Transmit(&hspi1,&temp1,1,10);
    % V( m" \5 a* C
89.         
    , V5 A* [$ X9 |7 t) x
90.         temp2=(WriteAddr&(0x00FF00))>>8;
    
91.         HAL_SPI_Transmit(&hspi1,&temp2,1,10);
    
92.         
    4 T; E5 `0 h. U$ A
93.         temp3=(WriteAddr&(0x0000FF));
    ) a2 m# ^& I- [; C5 y% b
94.         HAL_SPI_Transmit(&hspi1,&temp3,1,10);
    / k7 S7 y2 m/ F) x. `) R" _
95.         
    0 f+ {; u1 b) D. R, w# @
96.         HAL_SPI_Transmit(&hspi1,pBuffer,NumByteToWrite,10);//发送数据
    
97.         
    ( y1 l8 [8 ]: ^
98.         NSS_HIGH();//停止信号 FLASH:NSS高电平
    ) z% q2 V1 e. ]
99.         
    
100.         SPI_FLASH_WaitForWriteEnd();//等待写入完毕
     ) G5 w1 e# i( }% @8 i9 n- i6 }/ N, E
101. }
     
102. 
     3 A% ?% Y. L/ Y' Q" O* u/ M
103. /*不定量数据写入*/
     
104. void SPI_FLASH_BufferWrite(uint8_t * pBuffer, uint32_t WriteAddr,uint16_t NumByteToWrite)
     
105. {
     
106.   uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;
     
107. 
     9 Q' `  {4 R3 V. \
108.   Addr = WriteAddr % FLASH_PAGESIZE;//判断写入的首地址是否与EEPROM页的首地址对齐，0为对齐
     : d7 s4 ]* S( B8 A9 E
109.   count = FLASH_PAGESIZE - Addr;//计算从写入的首地址需要写多少数据才能填满当前页
     
110.   NumOfPage =  NumByteToWrite / FLASH_PAGESIZE;//计算写入数据需要写几个完整页（地址对齐的情况）
     5 X) g, v, r4 }0 e/ R8 b2 n: t
111.   NumOfSingle = NumByteToWrite % FLASH_PAGESIZE;//计算写完完整页剩下的数据个数（地址对齐的情况）
     ) O, y* t# i/ Z" V0 L: X/ _. Q
112. 
     . s) n* W. A. |" S* B: m9 b
113.   if(Addr == 0) //判断写入的首地址是否与页地址对齐
     
114.   {
     
115.     if(NumOfPage == 0) //如果页对齐，判断数据是否不满一页
     3 |+ g  z8 y$ e
116.     {
     ; G2 O/ Q$ ~6 y* a; z
117.       SPI_FLASH_PageWrite(pBuffer,WriteAddr,NumOfSingle);//如果不满一页，直接写入数据
     
118.     }
     
119.     else  //在数据满一页的情况下，通过地址自增方式，循环写入数据（页写入的形式）
     * S6 c; ~5 G: R% _. T; B2 m
120.     {
     
121.       while(NumOfPage--)//循环写入数据：先写入完整页
     
122.       {
     , X' Y+ o8 n% O
123.                                 SPI_FLASH_PageWrite(pBuffer, WriteAddr, FLASH_PAGESIZE);
     : Y0 |% ?; O4 M) l% f
124.         WriteAddr +=  FLASH_PAGESIZE;
     , C  u5 [) P# V' U
125.         pBuffer += FLASH_PAGESIZE;
     % u1 c, R0 d4 P* m/ F+ e9 N" E
126.       }
     ' b$ {* @& e) s4 ?. q0 G7 v
127. 
     : S" @& p: t2 P# b- _
128.       if(NumOfSingle!=0)//循环写入数据：再写入不满一页的数据
     . h7 q/ ~4 Y6 Y" S: W) m( C1 `5 C
129.       {
     6 R" t; h3 H% O
130.                                 SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
131.       }
     * k7 {7 C' ^7 B8 |" j2 `
132.     }
     
133.   }
     
134.   else
     . A* ^- N& h! ?8 X7 r; U/ [( z
135.   {
     
136.     if(NumOfPage== 0) //如果页不对齐，判断数据是否不满一页
     % o1 d6 p6 G1 |  x* q6 V5 E3 a
137.     {
     ' W+ Q1 S5 p; Y1 ^
138.                         if(NumOfSingle<=count)//如果不满一页，判断数据是否跨页
     9 E3 L# ]5 a3 q9 K
139.                         {         
     
140.                                 SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);//如果不跨页，直接写入数据
     
141.                         }
     . i& X7 b' C) L' l5 @
142.                         else
     & X1 l) {* _# R' X( E& W
143.                         {
     9 u4 b& \7 U' m7 }8 H' R5 l
144.                                 SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);//如果跨页，先写首页数据，再写次页数据
     
145.                                 SPI_FLASH_PageWrite(pBuffer+count, WriteAddr+count, NumOfSingle-count);
     
146.                         }
     
147.     }
     - [" L+ A# U' L( s
148. 
     
149.     else
     
150.     {
     
151.                         /*如果数据满一页，对数据进行分离*/
     3 Z- V0 Q" G" p! U( x& b6 Y
152.       NumByteToWrite -= count;//扣除第一页数据个数
     * b9 V) ]- o) W& S0 M( @
153.       NumOfPage =  NumByteToWrite / FLASH_PAGESIZE;//计算写入数据需要写几个完整页
     
154.       NumOfSingle = NumByteToWrite % FLASH_PAGESIZE;        //计算写完完整页剩下的数据个数
     6 R2 y% f5 P5 o" b9 t' N
155. 
     
156.       if(count != 0)
     + r2 W3 P0 p: V7 U5 r8 Q- P% O: @
157.       {  
     
158.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);//写入首页数据
     
159.         WriteAddr += count;//写地址自增
     
160.         pBuffer += count;//缓冲区指针自增
     # o. J( R. q/ v# _$ K. B
161.       }
     2 W: ]0 `' ^$ ?- t' O$ B$ I1 r. K
162. 
     ; H; v' P3 Q: v- \
163.       while(NumOfPage--)//依次写入完整页的数据
     ! S# ^) ^( q- X
164.       {
     + P. `! {( b3 B9 `/ {& ^( b- O0 n. W4 Y
165.                                 SPI_FLASH_PageWrite(pBuffer, WriteAddr, FLASH_PAGESIZE);
     3 c: x& j& b- M' e
166.         WriteAddr +=  FLASH_PAGESIZE;//写地址自增
     
167.         pBuffer += FLASH_PAGESIZE; //缓冲区指针自增
     / {8 Y, m. q/ T4 n  k
168.       }
     0 k( k, m0 k) B! M2 r- S1 c
169.       if(NumOfSingle != 0)//判断最后一页的数据是否是填满完整一页的
     
170.       {
     
171.                                 SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);//写入最后一页的数据
     
172.       }
     
173.     }
     + s0 E( F. x/ W
174.   }  
     
175. }
     
176. 
     
177. /*读取FLASH数据,读取的数据量没有限制*/
     9 C$ F" j! c/ ]$ q/ ]
178. void SPI_FLASH_BufferRead(uint8_t * pBuffer, uint32_t  ReadAddr,uint16_t NumByteToWrite)
     
179. {
     
180.         uint8_t W25X_ReadData=0x03;
     , _; p" U' l( i3 Z# F4 L( B8 d
181.         uint8_t temp1,temp2,temp3;
     - S7 `1 L$ `2 y6 f1 M1 C% M
182.         
     
183.         SPI_FLASH_WriteEnable();//写使能
     
184.         
     ( B- `) l: r9 m+ s" k2 Z- T/ T
185.         NSS_LOW();//选择FLASH:NSS低电平
     
186.         
     
187.         HAL_SPI_Transmit(&hspi1,&W25X_ReadData,1,10);//发送指令
     , x5 n6 \2 o' k/ K/ t9 D) g
188.         
     & [- D4 W0 Z. K$ i6 q
189.         temp1=(ReadAddr&(0xFF0000))>>16;//发送地址
     
190.         HAL_SPI_Transmit(&hspi1,&temp1,1,10);
     
191.         
     
192.         temp2=(ReadAddr&(0x00FF00))>>8;
     
193.         HAL_SPI_Transmit(&hspi1,&temp2,1,10);
     
194.         
     $ u. K6 q  d" Q( Y
195.         temp3=(ReadAddr&(0x0000FF));
     / N: h( O! H: Q" H% {
196.         HAL_SPI_Transmit(&hspi1,&temp3,1,10);
     1 h0 O( L  n3 X! T2 }' Y& v. }# r) d
197.         
     
198.         HAL_SPI_Receive(&hspi1,pBuffer,NumByteToWrite, 10);//这里超时时间不能设置为1，否则会读取错误
     ' z" z) k. \" P: j* l- A
199.         
     9 w$ i4 |" ?9 V+ M4 z! I
200.         NSS_HIGH();//停止信号 FLASH:NSS高电平
     2 y; c1 }) m* q; u$ n
201. }
     

复制代码

4 n6 H: ~+ ^& E5 z. q 3、最后在main.c文件中，编写测试代码进行验证。

% c1 U# M* B  U1 o9 _

1. /*测试代码涉及到变量，宏定义*/
   - F2 }1 m- B* |. e! _3 V
2. /* 获取缓冲区的长度 */
   
3. 
   * S# P% K" \) e0 L# p
4. /*sizeof（）：数组占用字节除以数组类型所占字节，结果为数组元素个数*/
   
5. /*使用方法：sizeof（数组名）/ sizeof（数组类型名） */
   ! J; V1 B3 E: a1 u1 g2 G0 ?
6. #define countof(a)      (sizeof(a) / sizeof(*(a)))
   
7. #define  BufferSize (countof(Tx_Buffer)-1)
   + h6 H2 S1 D8 M8 `
8. 
   ) A. b8 ~  G& G
9. #define  FLASH_WriteAddress     0x000006
   
10. #define  FLASH_ReadAddress      FLASH_WriteAddress
    , [  t9 R; ?& A& W; J
11. #define  FLASH_SectorToErase    FLASH_WriteAddress
    
12. 
    ; R. r" B$ t* m7 z0 q1 F0 w
13. uint8_t Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength);
    - {& i: ]0 N, n% C% s
14. 
    
15. uint32_t Flash_ID;
    , H- ]7 j( X  X' K" H: x  M
16. uint8_t CMP_RES;
    6 i5 u" J$ a! A4 G
17. uint8_t Tx_Buffer[] =
    # l4 X7 {# [* `/ {9 Z# o' R( u6 |
18. "采薇采薇，薇亦作止。曰归曰归，岁亦莫止。靡室靡家，猃狁之故。不遑启居，猃狁之故。\
    % q+ v& }1 l$ u/ n
19. 采薇采薇，薇亦柔止。曰归曰归，心亦忧止。忧心烈烈，载饥载渴。我戍未定，靡使归聘。\
    
20. 采薇采薇，薇亦刚止。曰归曰归，岁亦阳止。王事靡盬，不遑启处。忧心孔疚，我行不来！\
    
21. 彼尔维何？维常之华。彼路斯何？君子之车。戎车既驾，四牡业业。岂敢定居？一月三捷。\
    
22. 驾彼四牡，四牡骙骙。君子所依，小人所腓。四牡翼翼，象弭鱼服。岂不日戒？猃狁孔棘！\
    3 @' r8 u5 W7 p) J) e9 d
23. 昔我往矣，杨柳依依。今我来思，雨雪霏霏。行道迟迟，载渴载饥。我心伤悲，莫知我哀！";
    5 x# p! j6 a( q: V' c
24. uint8_t Rx_Buffer[BufferSize];
    ! h. s% h; q9 K7 C

复制代码

1. /*比较函数，用于比较写入和读取的数据是否一致*/
   / _! `9 m/ K) o# `
2. uint8_t Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
   
3. {
   
4.   while(BufferLength--)
   
5.   {
     o: X* X: w! j" x4 O$ e7 M
6.     if(*pBuffer1 != *pBuffer2)
   5 k" q9 c: S$ u" z; @& o0 y" {
7.     {
   . h: h( P5 q# S$ o- Z1 k/ }
8.       return 0;
   9 K% _( q  u$ d: {& n9 v5 |5 S
9.     }
   
10. 
    5 I0 V) w7 c0 C- L$ k+ [) f1 W
11.     pBuffer1++;
    
12.     pBuffer2++;
    
13.   }
    2 L+ u! h! Y; r. `' y0 n* B+ I
14.   return 1;
    4 t2 A- i4 Z# Z+ l& O
15. }
    ' m. N! G6 I2 ?2 r
16. /*在主函数编写测试代码：ID验证，读写比较*/
    6 E6 t# |: ?6 s
17. Flash_ID=SPI_FLASH_ReadID();//读取Flash ID
    7 m1 i' j0 m8 P. Q0 t
18.         if (Flash_ID == _Flash_ID) //判断读取的ID和数据手册的ID是否一致
    
19.         {        
    
20.                 printf("\r\n系统检测到SPI FLASH W25Q64 ! FlashID：0x%X\r\n",Flash_ID);
    3 g& I/ H. q; j6 n8 W! E3 _
21.                
    4 ]/ u- C5 N- k
22.                 /* 擦除将要写入的 SPI FLASH 扇区，FLASH写入前要先擦除 */
    " j1 E. x5 X# E. h- F: Q
23.                 SPI_FLASH_SectorErase(FLASH_SectorToErase);                  
    , T+ w0 c, m8 x
24.                
    
25.                 /* 将发送缓冲区的数据写到flash中 *///
    
26.                 SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);
    
27.                 printf("\r\n写入的数据为：\r\n%s", Tx_Buffer);
    7 Z7 p- U8 \2 k, _( \7 ^' L
28.                
    
29.                 /* 将刚刚写入的数据读出来放到接收缓冲区中 */
    
30.                 SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
    , R" N0 @4 @2 m5 R
31.                 printf("\r\n读出的数据为：\r\n%s", Rx_Buffer);
    1 v0 n2 j' i3 Z
32.                
    4 r7 Y% W! d; O$ V
33.                 /* 检查写入的数据与读出的数据是否相等 */
    
34.                 CMP_RES= Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
    
35.                
    
36.                 if(CMP_RES)
    
37.                 {   
    ; r% D  c+ ?. g# t
38.                         printf("\r\n16M串行flash(W25Q64)测试成功!\n\r");
      q  C: H) f5 s4 ^9 M* c! o; X
39.                 }
    5 Y& Y- n  \5 ~$ a
40.                 else
    . v$ ?" w& M5 j
41.                 {        
    
42.                         printf("\r\n16M串行flash(W25Q64)测试失败!\n\r");
    * a/ R$ h" m# k% e1 _% g- P+ d
43.                 }
    
44.         }// if (FlashID == sFLASH_ID)
    
45.         else
    
46.         {   
    
47.                 printf("\r\n获取不到 W25Q64 ID!\n\r");
    0 F" M8 D) d$ U( f, @9 F2 i
48.         }                        

复制代码

/ W+ j$ o  D! ?  ~调试过程碰到几个问题，也是比较无脑的。
1、编写页写入的时候，常规流程：写使能->NSS拉低->发送页编程指令->发送地址->写入数据。
我忘记写发送页编程指令，导致了每次读取的时候，数据前面总是多出一些空白。（数据内容：
空格（发送内容越多，空格越多）+数据）。刚开始在论坛看到了，一个网友也出现类似情况，评论区，都是说等待函数加个延时就可以了，试了下还是不行，后来才发现是指令忘记写了。

1. HAL_SPI_Transmit(&hspi1,&W25X_PageProgram,1,10);//发送指令

复制代码

2、还出现一个问题，读取大量数据的时候(超过一页)，后面的内容总是读不全。刚开始以为是自己本身写入就有问题，后来用了例程读取我写入的数据，可以正常读取。基本可以锁定是读取函数的问题，看了一下整个读取的流程没有问题，唯一需要更改就是库函数自带的接收函数的参数：超时时间的设置。果然把原先设置的1改成10就可以正常读写了。（因为这个原因，我索性把发送的超时时间也都设置为10，直接设置为1也会正常的就是了。）
9 I& T: T. b8 _7 @, v4 y
1 g2 b. y; k' ]" @6 k! W

1. HAL_SPI_Receive(&hspi1,pBuffer,NumByteToWrite, 10);

复制代码

# B3 N& j; T) O1 Q: X) J3 G# S