一、开发板平台简介：
& t9 p+ {9 ]6 S1、开发板资源简介
（1）开发板主芯片型号：STM32L431RCT6
. N1 }* y: Z! C. H+ X* X（2）开发板主芯片封装：LQFP-64_10x10x05P
/ f" g& l" {  C! H0 M7 s（3）开发板主芯片内核：ARM® Cortex®-M4
3 t( M: s$ b* c  Q, a（4）开发板主芯片主频：80MHz
（5）开发板主芯片Flash大小：256KB
（6）开发板主芯片RAM大小：64KB
$ R) w9 y5 M( C9 p  z% u0 z （7）其他外设：请参考芯片手册
% r' J0 f( Z$ P6 `# x2 C6 R
& N" @8 i. P$ ~8 y1 {8 s2 W5 T# Q7 C

& q! u5 L' A- ^& U. [; [8 T
5 L6 O5 B0 B( X1 l. n8 t6 W! I
2 L; X6 ^3 _' ]2、串口简介
         串口全称为串行通讯接口，即数据在通信线上一次传输一位，按先后一定顺序传输。我们通常所说的单片机串口准确来说应该是串行异步收发传输器（Universal Asynchronous Receiver/Transmitter，UART），使用TTL电平，串口需要RXD、TXD、GND三根线进行通信。
& A& E" k) G2 c6 N& c) W+ a5 J        （1）我们选用的STM32L431RCT6开发板串口1已通过USB转TLL串口芯片CH340G引出，使用时，只需要用公对公USB线连接电脑即可（注意也得需要安装CH340G驱动），后期验证试验也试验该串口1进行。
5 h* C4 [1 O( w0 O        （2）开发板上的其他串口已通过排针引出，为TTL电平，通信的时候需要注意选择对应的电平模块，如USB转TTL串口模块等。

7 ^# M1 T: [/ W+ K. i0 Q  二、新建工程
1、新建STM32CubeMX基础工程
/ J; `) Q- o2 W, y; f5 O（1）打开STM32CubeMX，点击“File”-->"New Project"
' f7 X% x/ |3 m; e/ [7 E/ }2 w+ l


7 _' Y% H8 ?4 C( n' L7 z（2）等待打开主芯片选项界面（大约1分钟时间）。
& Y! T. K  E3 c% z
( ?0 u% E- g6 ^: x* r  m: l

（3）昨天搜索框中输入（或选择）所需的主芯片型号（因为我们用的是STM32L431RCT6开发板，所以此处现在STM32L431RC），然后在右下角选择STM32L431RCTx（因为开发板主芯片是STM32L431RCT6），左键双击即可打开新建的项目。

! @$ ~& f. m/ d6 p% j3 ?


（4）选择时钟源。
（1）因为开发板上有8M外部时钟，此处选择外部高速时钟（HSE）。
（2）因为我们没有用到外部低速时钟（LSE），此处不做处理。
4 b3 Y. i+ c, B  d& A( {

) n* t# ~: g/ U$ L) n, }
( D# X, a3 p4 Z+ g: \7 t2、配置GPIO控制LED
% x# \+ T; O+ B6 O4 |) i备注：LED灯用来指示系统是否正常工作。
（1）查STM32L431RCT6开发板原理图得LED1控制引脚为PC0，则配置GPIO的引脚PC0。
鼠标左键点击PC0,选择“GPIO_Output”,表示设置该引脚为输出模式。


/ ^; b/ |' N7 R: P, I2 H4 d0 h4 z
（2）根据自己的需求配置GPIO的参数，如输出方式、输出频率、上拉下拉等。因为GPIO控制LED的要求比较低，此处采用默认参数即可，不用修改。
3 h* ]  s/ ~0 X

2 g/ ~* |9 |' k* k9 ]8 T/ Z- ?
8 r8 W! Q& E+ V, g3、设置串口1参数
1、查原理图得知，串口0使用STM32L431RCT6引脚为PA9-USART1_TX,PA10-USART1_RX,引脚设置如下：
# ^5 f( E& A: F
: M/ d, u- B6 F" h+ `2 {2 X( O
1 c& F1 L. d* Q7 y: v( H! \
（1）序号1用来设置串口收发引脚的选择。
（2）序号2-3-4-5-6设置串口参数，如波特率115200、8位、NONE无奇偶校验等。
# B/ o; |. m( S* X7 |
4、配置SPI Flash接口
+ `3 E: t: ~: |8 A  |  t5 p（1）查看STM32L431RCT6开发板原理图得知，芯片原理图如下：


) }) k. f6 E$ L2 O3 o! P" U
（2）SPI Flash接口对应芯片的PB12、 PB13、 PB14  PB15，芯片引脚配置如下：
8 W+ w- m+ q2 ]. ?% O4 O8 kPB12：SPI2_NSS，此处设置普通输出IO即可。不能配置成NSS。
PB13：SPI2_SCK
" R4 E' `  S. z$ X/ iPB14：SPI2_MISO
PB15：SPI_MOSI


" a/ ^' R) Q5 c
（3）设置SPI引脚参数，并选择 Full-Duplex Master 全双工主模式，此处不开启 NSS 即不使用硬件片选信号。

- t& x4 c( A/ V
* Z, a+ ]2 ?" Q0 v5 ~, {/ U" m
（4）设置SPI基础参数以及时钟。
( |% ?' d! H8 Q! H3 X/ G) d+ s- ]



' V, R! Q. k8 O4 i0 J4 R! ^5 ~
4、配置项目工程参数
+ g- f! ~3 X$ N2 Q4 {# ]1 u（1）配置时钟树，用于系统内部时钟，以及各个外设时钟等。此处选择外部8M晶振作为主时钟频率，内部最大倍频80MHz。


1 z) a/ N& y/ Q( i8 _
# F) f5 j1 Q4 o: ?. `0 g" h% R（2）完成配置工程。
" c7 Y8 Q2 W! R) r8 i5 M备注：需要注意代码生成过程中的继承关系，如图所示：需要保留开发者自己编写的代码时，请根据配置设置，不然生成代码后会删除自己编写的代码（从这个方面也可以看出开发者备份自己的代码是多么的重要。）
2 v1 h. }5 o& f/ L, o. q% K
& a8 F9 W$ r( d) z7 `9 _
. s" k2 f, _1 I& T1 M" J" @9 M) [( O
2 m8 m' A$ J, T. c5 }; ]
  H1 ^# ?/ n6 J& p* Y) Q6 Y
; H9 G! A2 r2 V. M（3）生成代码。
4 ?1 F9 O  O8 W7 u7 ]
) o; H- t3 B+ E3 V% z

三、在KEIL 5中编写代码
1、使用KEIL 5（MDK）打开项目工程文件
! r/ t; x8 I  c1 `（1）找到刚才新建工程的存储路径，安装项目名称，打开项目工程。


  l2 y2 A& _" P# K; R0 Q7 R) E% Y
- k! B, u8 E' T2 H' F2 C" F0 R（2）添加每隔500ms，LED1闪烁一次的系统提示，用于提示程序运行正常。
9 Q3 T3 {/ h/ o" ]4 A
+ q; S; Y4 }! o( V0 V
9 e5 \1 n1 ]5 ^7 L) V
1 |; G" Y! M/ y( g2、添加使用printf函数打印log的代码
（1）在项目选项中勾选Use Micro LIB选项，勾选该项目后，可以正常使用基本的C语言库。
: d( N3 P4 F3 q1 i( u

3 A. A+ \7 b. a% A6 F1 }. u
（2）printf函数会调用fputs函数，fputs函数为弱定义函数，即使用__weak修饰符修饰的函数，可通过自己编写函数定义覆盖原定义，我们在此处重写fputs函数。在usart.c中添加如下代码。
+ y8 e! S- f8 O7 R备注：开发者自己的代码需要注意添加位置，一定要放置到一对《USER CODE BEGIN和USER CODE END》之间，避免重新生成工程后被覆盖。
. w/ M1 ]! F9 b% \# a1 e& Z
& g7 N4 C* c: J  z
: F' p$ J2 U: a& ~
4 r5 M) `- U$ |* x, { 代码段如下：可直接复制使用。
! g; `1 i( [1 K# ^) a# x" O

1. /* USER CODE BEGIN 1 */
   8 c. s0 m2 z2 x3 i4 s' z/ U
2. 
   
3. #include <stdio.h>
   
4. #ifdef __GNUC__
   
5.         #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   
6. #else
   ' A# @" l0 x2 g" V
7.         #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   
8. #endif
   ; O# R% i8 O. R$ @- A( e
9. PUTCHAR_PROTOTYPE
   
10. {
    4 t" K" l5 z9 h3 [
11.                 HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
    
12.                 return ch;
    , v, [/ r  @+ M0 X/ P
13. }
    
14. 
    9 B, F. C, M6 ?" D5 i- x
15. 
    
16. /* USER CODE END 1 */

复制代码

6 j1 U7 M8 c4 n7 f
+ i6 U, e0 e. B% ^% U（3）使用printf打印log数据。需要注意main.c位置添加"stdio.h"头文件（printf的函数声明头文件）。

" O" b+ T. d" d) R1 k0 c
, D  v9 R9 u- l! G. Y) ]- Y
) y- Z+ ?3 ?0 {

1. printf("hello world,this is printf function!\r\n");   //printf 打印函数
   2 {+ p5 k+ P! Z( [

复制代码

- a) ]. z/ L3 ]' Z 3、在w25qxx.c文件中添加SPI底层驱动函数

1. #include "main.h"
   : D/ F% J4 Z6 V+ L& @4 \* q& c% g
2. #include "spi.h"
   
3. #include "w25qxx.h"
   
4. /**
   
5.   * @brief SPI1 读一个字节
   
6.   * @param None
   + X' w" q5 R, P) K  a6 J& l1 u
7.   * @retval None
   / b/ f1 ~  `# D/ o
8.   */
   
9. static uint8_t spi2_flash_read_byte(void)
   9 L" F4 y+ [! _$ c4 l! E, x* ^# K
10. {
    
11.     uint8_t t_data, r_data;
    
12. 
    % x/ w# D1 G0 [8 I
13.     if(HAL_SPI_TransmitReceive(&hspi2, &t_data, &r_data, 1, 0xFFFFFF) != HAL_OK)
    
14.     {
    7 ?# r4 N( H9 d+ p' O+ u
15.         r_data = 0xff;
    4 I' I3 V( N8 Q' h
16.     }
    5 i) c! I; R: ?
17.     return r_data;
    * Z3 b- p* `8 l6 q$ ~5 T
18. }
    + u5 {' p# M9 `2 H9 D+ v5 c
19. /**
    3 A: W) z+ S& j
20.   * @brief SPI1 写一个字节
    
21.   * @param byte 写入的字节
    7 F0 L9 T+ X( Y' s7 a
22.   * @retval 写状态 0成功 1失败
    
23.   */
    $ W% O6 m1 I- a6 A0 H7 q
24. static uint8_t spi2_flash_send_byte(uint8_t byte)
    0 n. q9 Y% k; F8 s/ O0 S1 u' Y
25. {
    
26.     uint8_t r_data;
    
27. 
    
28.     if(HAL_SPI_TransmitReceive(&hspi2, &byte, &r_data, 1, 0xFFFFFF) != HAL_OK)
    ! y1 h0 g( M* @6 K) ^
29.     {
    
30.       return 1;
    ! S$ N* D4 L* o3 s$ L4 H
31.     }
    % X) p8 D3 B! b
32.     return 0;
    , J1 D2 N& r6 ^5 w6 W) N
33. }
    " _0 ~9 b* B( o/ m. k- X
34. /**
    
35.   * @brief FLASH 写使能
    + [+ g  G& m5 M, A* ~9 E" E
36.   * @param None
    : S$ }$ |3 m3 a! ?
37.   * @retval None
    
38.   */
    ( V8 U. Z9 V  n
39. static void spi2_flash_write_enable(void)
    
40. {
    : D& N. Z  g9 R% e5 M7 z6 \8 t9 v
41.     SPI_FLASH_CS_LOW();
    
42.     spi2_flash_send_byte(W25X_WriteEnable);
    7 W4 w9 d* V' y2 r4 f
43.     SPI_FLASH_CS_HIGH();
    ' v5 r7 e, E9 \' f- G5 e
44. }
    1 t6 T, C" z" }8 A# w1 U& c) K
45. /**
    
46.   * @brief FLASH 等待写结束
    
47.   * @param None
    ) |+ N0 ^, ?+ {5 W% G
48.   * @retval None
    
49.   */
    ( q$ S" Z! P$ x% R( L! F( q
50. static void spi2_flash_wait_for_write_end(void)
    
51. {
    
52.   uint8_t state = 0;
    
53. 
    
54.    SPI_FLASH_CS_LOW();
    0 Y! \) \0 G# j0 M5 k+ j# ^& N
55. 
    & R$ D+ k; R  V/ ~; M% D6 b2 L: M
56.                 spi2_flash_send_byte(W25X_ReadStatusReg);
    0 }! _2 L. ^2 Y' y
57. 
    
58.   do
    5 Z* ?: @( ^. q, A4 p1 [* U) Q
59.   {
    
60.       state = spi2_flash_read_byte();
    : a9 N  w' R3 d0 H) W6 H: e
61.   }
    9 V  {: v; l! L
62.   while((state & 0x01) == SET);
    9 r2 Z& ~0 f4 K+ g/ N( D
63. 
    
64.   SPI_FLASH_CS_HIGH();
    3 G. f. R3 I% Q& j& A3 C6 P3 S
65. }
    / P9 ~& B: I# p
66. /**
    
67.   * @brief FLASH 读ID
    + n/ N' o0 f: M( }
68.   * @param None
    
69.   * @retval None
    ' I# h( A. J; d# Z" C4 z
70.   */
    
71. uint32_t spi_flash_read_ID(void)
    
72. {
    
73.   uint32_t temp, temp0, temp1, temp2;
    
74. 
    9 j2 X# ^, q% h9 B, y
75.   SPI_FLASH_CS_LOW();
    
76.   spi2_flash_send_byte(W25X_JedecDeviceID);
    2 M8 S; q. ]& l( M1 j" w) m
77. 
    9 B2 u" Z- {  n8 O: M/ B
78.   temp0 = spi2_flash_read_byte();
    
79.   temp1 = spi2_flash_read_byte();
    ( o4 Y/ o: U9 @0 M+ g$ G- i! H
80.   temp2 = spi2_flash_read_byte();
    
81. 
    2 L' ^7 O3 x, T6 f6 g6 V3 t1 c, @1 ?
82.         SPI_FLASH_CS_HIGH();
    : N5 W  e7 K& k, e8 d  w
83. 
    2 o" ], \, {/ e& ?5 ]( [
84.   temp = (temp0 << 16) | (temp1 << 8) | temp2;
    + t% m& X& q" b& `* M' K1 O
85. 
    + Y4 w% u' t7 c8 ^" W1 L% e
86.   return temp;
    2 F1 D7 }  A1 E- q4 a
87. }
    
88. /**
      u1 B3 m" @, ~. Q5 Q# L
89.   * @brief 读FLASH
    
90.   * @param addr 读flash的起始地址
    : K, b* R7 m) |7 v
91.   * @param pdata 读到的数据存放起始地址
    
92.   * pdata size 读数据大小
    : E7 g9 r0 A' |  K8 G
93.   * @retval None
    # }) k# m, K5 o# r0 ~7 {
94.   */
    
95. void spi2_flash_read(uint32_t addr,uint8_t *pdata, uint16_t size)
    0 g5 \4 ~1 [/ n* v! \
96. {
    
97.    SPI_FLASH_CS_LOW();
    
98. 
    
99.   spi2_flash_send_byte(W25X_ReadData);
    & w, F: O( G7 ?# Q' i
100. 
     ' \4 R3 X5 L: T: u- p# l
101.   spi2_flash_send_byte((addr & 0xFF0000) >> 16);
     5 m6 s6 g$ ~$ i, J. y  p. M
102.   spi2_flash_send_byte((addr & 0xFF00) >> 8);
     
103.   spi2_flash_send_byte(addr  & 0xFF);
     9 V, O( ~" }- ~: @6 }7 f' Q
104. 
     
105.   while (size--)
     0 @4 u5 G9 O4 b  u; v
106.   {
     
107.     *pdata = spi2_flash_read_byte();
     " Z  n. ~+ V4 N; f; ^* i
108.     pdata++;
     
109.   }
     
110. 
     
111.         SPI_FLASH_CS_HIGH();
       v" N$ c+ L0 J
112. }
     4 Q, B9 B  h$ H! g6 r8 `
113. /**
     + ~# U1 G% u0 Y+ W$ B3 l7 F  T0 E
114.   * @brief 按页写FLASH
     
115.   * @param addr 写入flash的起始地址
     
116.   * @param pdata 写入数据的起始地址
     
117.   * pdata size 写数据大小
     
118.   * @retval None
     ; D  x! u4 d' I0 \' L
119.   */
     & O) F' ^$ O8 j5 t9 C( Y
120. void spi2_flash_page_write(uint32_t addr, uint8_t *pdata, uint16_t size)
     1 Q, ~% ~$ h: L  R3 }6 j: U
121. {
     4 u3 |% ?; r5 N  m% E- `* n
122.     uint16_t i;
     " ~9 G' X/ _6 n. H& K$ n$ X0 S0 c
123. 
     
124.      spi2_flash_write_enable();
     ) @9 o  b& J+ a/ b
125. 
     * u  _, b1 z0 H8 I  y
126.      SPI_FLASH_CS_LOW();
     
127. 
     
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));
     , `: u, i% k8 I0 i6 ?+ s
131.     spi2_flash_send_byte((uint8_t)addr);
     " p; ]0 a4 L& n9 ]
132. 
     
133.     for(i = 0; i < size; i++)
     % A, K' f+ m& x# {/ N2 A
134.     {
     
135.         spi2_flash_send_byte(pdata[i]);
     
136.     }
     
137. 
     4 L9 O* N  P- e3 u
138.     SPI_FLASH_CS_HIGH();
     
139.     spi2_flash_wait_for_write_end();
     6 H. q0 H" Q# P6 |2 q3 E/ Y" F4 w
140. }
     
141. /**
     : w9 q* }4 Z3 W" S" ?/ d4 P' g' @
142.   * @brief 写FLASH
     
143.   * @param addr 写入flash的起始地址
     
144.   * @param pdata 写入数据的起始地址
     1 D/ S4 m  [6 |
145.   * pdata size 写数据大小
     
146.   * @retval None
     
147.   */
     
148. void spi2_flash_write(uint32_t addr, uint8_t *pdata, uint32_t size)
     
149. {
     
150.     uint32_t page_remain;
     " L) V9 p( t# J/ I( L
151. 
     2 K/ }$ |0 Q; U! f7 v7 a
152.     page_remain = 256 - addr%256;
     & `5 |( T1 j/ w& x3 x! |9 l
153. 
     $ G$ r$ J/ L* f
154.     if(size <= page_remain)
     
155.     {
     : Z5 _/ o2 x6 P
156.         page_remain = size;
     + x- X  Y4 @; V& ~: }
157.     }
     
158.     while(1)
     
159.     {
     
160.         spi2_flash_page_write(addr, pdata, page_remain);
     : p4 ~- `/ m+ q9 D' C: F
161. 
     6 x& q' M. j$ g. ?! \
162.         if(size == page_remain)
     
163.             break;
     
164.          else
     . o, h7 u& M8 ^# {+ j5 v) ^5 D
165.         {
     ( n6 A. b! _8 ^/ y
166.              pdata += page_remain;
     
167.              addr += page_remain;
     
168. 
     
169.              size -= page_remain;
     : Z6 _' D! |( d
170.             if(size > 256)
     
171.                 page_remain = 256;
     
172.             else
     0 O1 b' }( }' D6 I/ Q# Z7 y: H; D
173.                 page_remain = size;
     
174.         }
     
175.     }
     $ I3 B- z. d" q$ f, u4 }
176. }
     
177. /**
     
178.   * @brief 擦除FLASH扇区
     ( k( \  |4 n' `6 f4 c1 k
179.   * @param sector_addr 扇区的起始地址
     
180.   * @retval None
     + `9 |7 X6 r* a2 i
181.   */
     
182. void spi2_flash_sector_erase(uint32_t sector_addr)
     " ]: s# b% p4 f3 k
183. {
     
184.     spi2_flash_write_enable();
     4 c$ ~- X' Q- }
185.     spi2_flash_wait_for_write_end();
     
186. 
     
187.     SPI_FLASH_CS_LOW();
     # @9 w# B. k; W" ~
188.     spi2_flash_send_byte(W25X_SectorErase);
     " h  U8 c( S9 j0 T
189.     spi2_flash_send_byte((sector_addr & 0xFF0000) >> 16);
     
190.     spi2_flash_send_byte((sector_addr & 0xFF00) >> 8);
     
191.     spi2_flash_send_byte(sector_addr & 0xFF);
     
192. 
     & C2 r' z: q# J  Z: T9 O
193.     SPI_FLASH_CS_HIGH();
     
194. 
     
195.     spi2_flash_wait_for_write_end();
     9 |+ B' ^3 m0 C9 @# B# H
196. }
     
197. 
     $ m& `& M2 K4 X7 }
198. /**
     8 W- u8 b5 c9 L+ m0 O0 x
199.   * @brief 擦除FLASH块
     
200.   * @param None
     
201.   * @retval None
     % W: h1 g0 q1 L' S; _5 p' h
202.   */
     
203. void spi2_flash_block_erase(void)
     
204. {
     
205.     spi2_flash_write_enable();
     , j1 `3 z6 _: X& i
206. 
     4 N0 K, }  g7 f6 f( S% e/ l
207.     SPI_FLASH_CS_LOW();
     3 e$ W; p6 C  S/ s; V4 {$ h
208.     spi2_flash_send_byte(W25X_ChipErase);
     
209.     SPI_FLASH_CS_HIGH();
     $ C* k" I% }+ K- D
210. 
     
211.     spi2_flash_wait_for_write_end();
     
212. }
     ) j$ h9 A: T! S9 Y' _, P* H; i

复制代码

  j( J# f9 e+ u; T. ~
$ A1 ?) |* S+ d) h4、在main.c中添加功能函数
7 o9 Q7 j: i- i2 W

1. /**
   
2.   * @brief  The application entry point.
   $ o9 O/ `+ ~. c1 K+ ?
3.   * @retval int
   , _$ X1 E* D: }
4.   */
   
5. int main(void)
   
6. {
     ^2 G! b1 ]/ z0 ?# O: V
7.   /* USER CODE BEGIN 1 */
   
8.         uint32_t w25q_chip_id=0;                                                                                        //读取芯片ID
   
9.         uint8_t  onebyte_read[8]={0};                                                                                    //读取的数据
   
10.         uint8_t  onebyte_write[8]={0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80};                                //写入的数据
    
11.   /* USER CODE END 1 */
    1 I2 K' ^* G* e
12.   
    
13. 
    
14.   /* MCU Configuration--------------------------------------------------------*/
    
15. 
    ) n; g. ^/ V( B5 D* a! D: X
16.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
17.   HAL_Init();
    
18. 
    
19.   /* USER CODE BEGIN Init */
    . V9 {, ~5 M1 _- e* T+ n5 x: X
20. 
    
21.   /* USER CODE END Init */
    + b% }4 _$ b! f$ C/ i% V9 m
22. 
    
23.   /* Configure the system clock */
    - M5 G) W" {: t1 H7 l
24.   SystemClock_Config();
    7 \' J+ ?6 h0 n+ q
25. 
    
26.   /* USER CODE BEGIN SysInit */
    ( t4 |. b  B: v4 {4 \3 a$ y7 l
27. 
    : q7 r" ~6 n2 F* k! P
28.   /* USER CODE END SysInit */
    
29. 
    
30.   /* Initialize all configured peripherals */
    ) W1 H& K+ a& I* b# D6 D  ?
31.   MX_GPIO_Init();
      {7 K  Q. x+ c8 e6 J7 M5 y
32.   MX_DMA_Init();
    ) N2 P8 s5 A* |
33.   MX_USART1_UART_Init();
    0 g6 ]3 F; `. c) m0 P; H( c# v
34.   MX_SPI2_Init();
    & \4 S* q) d" H8 g/ i! G
35.   /* USER CODE BEGIN 2 */
    
36.         HAL_GPIO_WritePin(GPIOC,GPIO_PIN_0,GPIO_PIN_SET);                                                                //初始化LED1
    
37.         w25q_chip_id=spi_flash_read_ID();                                                                                                                                //读取flash芯片ID
    . x( x5 J9 Q3 T: r# x
38.         HAL_Delay(100);
    . f+ d# H/ l7 ~7 I! A
39.         printf("hello world,spi_flash_read_ID==0x%0x!\r\n",w25q_chip_id); //printf 芯片ID
    4 o9 s6 B( _7 W, O5 c& K
40.         spi2_flash_sector_erase(0x0);                                                                                                                                                        //写之前需要先擦除扇区                                                                                                                                       
    2 g! `0 Y$ @; L& V0 C
41.         spi2_flash_write(0x0,onebyte_write,8);                                                                                                                //写八个字节
    
42.         spi2_flash_read(0x00,onebyte_read,8);                                                                                                                        //读取写入的字节
    % [: V  ~/ b; ]! G4 ^
43.   /* USER CODE END 2 */
    
44. 
    * w+ o# z5 p5 @" ?7 w
45.   /* Infinite loop */
    
46.   /* USER CODE BEGIN WHILE */
    0 s: J  m6 c. E1 J4 J  }
47.   while (1)
    
48.   {
      C5 y- n+ D! z/ q7 E
49.     /* USER CODE END WHILE */
    
50. 
    
51.     /* USER CODE BEGIN 3 */
    
52.                                 HAL_Delay(500);
    5 M3 r5 \% i. _% v7 p
53.                                 HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_0);                                                                        //每隔500ms闪烁一次LED1
    
54.                                 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],onebyte_read[2],onebyte_read[3],onebyte_read[4],onebyte_read[5],onebyte_read[6],onebyte_read[7]);   //printf
    
55.                                 
    6 n4 X+ h4 n. n, F4 |; A4 z# \
56.   }
    3 l" ~3 q! V7 |6 Z$ `$ m5 b
57.   /* USER CODE END 3 */
    + y) F3 F/ n6 r$ T  X. k3 L
58. }

复制代码

! V1 B, z! Z. z' I
* w% J8 x# P1 A1 P 5、设置编程仿真下载模式
（1）选择Options for target ...>>Debug>>J-Link/J-JTRACE Cortex,点击Settings>>选择Port（SW），可以看到搜索成功SW Device，表示芯片可用，可以下载。



（2）点击Download（或者快捷键F8），即可下载程序。
1 {+ J/ p: N  Z& o! X7 i


（3） 如果下载程序后，没有看到LED1灯闪烁，可以按下述方式设置一下（Reset and run表示下载后自动复位和重启运行）。或者重新彻底断电再次上电（或按开发板的Reset按键复位MCU即可）。
, b5 [1 D1 K- }% @" J# O: F
, t% |# K# }3 d

6、查看串口printf函数打印log效果
（1）设置串口助手参数为：115200、NONE、8、 1（和代码中串口初始化参数一致）。
（2）设置成功后，就可以看到串口打印的效果。每隔500ms闪烁LED1指示灯一次，且串口输出一个log。
* k& U' t' B) c5 z9 `0 _+ W% X+ m; C
% V1 T8 d: N. F7 v. `, u' {
' f$ V( d- h- y1 s
————————————————
版权声明：智能小屋ZYXC
0 u6 _' M1 v" S+ G3 {