【经验分享】HAL库 STM32CubeMX教程十四---SPI

[复制链接]

STMCU小助手发布时间：2022-3-23 14:00

文章
文章封面:
文章简介:	HAL库 STM32CubeMX---SPI

在我们的HAL库中，对硬件SPI函数做了很好的集成，使得之前SPI几百行代码，在HAL库中，只需要寥寥几行就可以完成那么这篇文章将带你去感受下它的优异之处，这些优异的函数，也正是HAL库的优点所在

所用工具：

1、芯片： STM32F103ZET6

2、STM32CubeMx软件

3、IDE： MDK-Keil软件

4、STM32F1xx/STM32F4xxHAL库

5、SPI：使用硬件SPI1

知识概括：

通过本篇博客您将学到：

SPI的基本原理

STM32CubeMX创建SPI例程

HAL库SPI函数库

什么是SPI
SPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola(摩托罗拉)首先在其MC68HCXX系列处理器上定义的。

SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。

SPI主从模式
SPI分为主、从两种模式，一个SPI通讯系统需要包含一个（且只能是一个）主设备，一个或多个从设备。提供时钟的为主设备（Master），接收时钟的设备为从设备（Slave），SPI接口的读写操作，都是由主设备发起。当存在多个从设备时，通过各自的片选信号进行管理。

SPI是全双工且SPI没有定义速度限制，一般的实现通常能达到甚至超过10 Mbps
( ~& G! d7 Q: F' {' y
r" w* N* Q H4 z/ p* ESPI信号线
SPI接口一般使用四条信号线通信：
SDI（数据输入），SDO（数据输出），SCK（时钟），CS（片选）

MISO：主设备输入/从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。
MOSI：主设备输出/从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。
SCLK：串行时钟信号，由主设备产生。
CS/SS：从设备片选信号，由主设备控制。它的功能是用来作为“片选引脚”，也就是选择指定的从设备，让主设备可以单独地与特定从设备通讯，避免数据线上的冲突。
硬件上为4根线。
" A8 O- B' s. B2 l/ ^5 Y9 \# y8 \" \. D; z/ H8 w8 c# d, T- I( q" a
SPI一对一
8 _- F9 A3 u) u) m0 ~$ |
' O6 ~. ?$ }3 r8 w U4AND{]Q35]1A2B[VX~{)$P.png

! U8 [, {% A/ ?$ l: F# S- [( p4 L+ L5 D" {; l6 P3 \4 [5 \0 a
SPI一对多5 U" U$ f: U7 {5 f# m

~EU(]W4UD{ZK@3[0U}6[WT5.png

SPI数据发送接收
SPI主机和从机都有一个串行移位寄存器，主机通过向它的SPI串行寄存器写入一个字节来发起一次传输。

1.首先拉低对应SS信号线，表示与该设备进行通信
2.主机通过发送SCLK时钟信号，来告诉从机写数据或者读数据
这里要注意，SCLK时钟信号可能是低电平有效，也可能是高电平有效，因为SPI有四种模式，这个我们在下面会介绍
3.主机(Master)将要发送的数据写到发送数据缓存区(Menory)，缓存区经过移位寄存器(0~7)，串行移位寄存器通过MOSI信号线将字节一位一位的移出去传送给从机，，同时MISO接口接收到的数据经过移位寄存器一位一位的移到接收缓存区。
4.从机(Slave)也将自己的串行移位寄存器(0~7)中的内容通过MISO信号线返回给主机。同时通过MOSI信号线接收主机发送的数据，这样，两个移位寄存器中的内容就被交换。

}9IPL%WBI(SXK~POT{1{A.png

SPI只有主模式和从模式之分，没有读和写的说法，外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。也就是说，你发一个数据必然会收到一个数据；你要收一个数据必须也要先发一个数据。

SPI工作模式
根据时钟极性（CPOL）及相位（CPHA）不同，SPI有四种工作模式。
时钟极性(CPOL)定义了时钟空闲状态电平：
CPOL=0为时钟空闲时为低电平
CPOL=1为时钟空闲时为高电平

时钟相位(CPHA)定义数据的采集时间。
CPHA=0:在时钟的第一个跳变沿（上升沿或下降沿）进行数据采样。
CPHA=1:在时钟的第二个跳变沿（上升沿或下降沿）进行数据采样。

WSKLH~CQVK{U~ENH5BE{QEP.png

1 V3 l& L @" x/ f; {
W25Q128 FLASH芯片介绍
W25Q128是一款SPI通信的FLASH芯片，可以通过标准/两线/四线SPI控制，其FLASH的大小为16M，分为 256 个块（Block），每个块大小为 64K 字节，每个块又分为 16个扇区（Sector），每个扇区 4K 个字节。通过SPI通信协议即可实现MCU(STM32)和 W25Q128 之间的通信。实现W25Q128的控制需要通过SPI协议发送相应的控制指令，并满足一定的时序。

0 Z/ M' v, I) C原理图连接

S65UQWR]EZ(@1G2M{E3~IV2.png

常用指令：
6 {; m h" _0 b5 {+ K/ M
写使能(Write Enable) (06h)

XPQX%GRHXNY))9_Z864R%SE.png

向FLASH发送0x06 写使能命令即可开启写使能，首先CS片选拉低，控制写入字节函数写入命令，CS片选拉高。

扇区擦除指令(Sector Erase) (0x20h)

$_%`E7{PK0@02IY3PO3~E1.png$
扇区擦除指令，数据写入前必须擦除对应的存储单元，该指令先拉低/CS引脚电平,接着传输“20H”指令和要24位要擦除扇区的地址。

读命令(Read Data) (03h)

读数据指令可从存储器依次一个或多个数据字节，该指令通过主器件拉低/CS电平使能设备开始传输，然后传输“03H”指令，接着通过DI管脚传输24位地址，从器件接到地址后，寻址存储器中的数据通过DO引脚输出。每传输一个字节地址自动递增，所以只要时钟继续传输，可以不断读取存储器中的数据。

7 c9 _+ J8 z, z- r0 t1 G. k9 ?" t状态读取命令(Read Status Register)

读状态寄存器1(05H)，状态寄存器2（35H）,状态寄存器3（15H）
写入命令0x05，即可读取状态寄存器的值。

`~_0F1_G[R2)T(M80VV1S8J.png

3 t5 J" i ~) [( {, ^写入命令(Page Program) (02h)

REU_LMITYA3M}MQZPO8G2T3.png

在对W25Q128 FLASH的写入数据的操作中一定要先擦出扇区，在进行写入，否则将会发生数据错误。
W25Q128 FLASH一次性最大写入只有256个字节。
在进行写操作之前，一定要开启写使能(Write Enable)。
当只接收数据时不但能只检测RXNE状态，必须同时向发送缓冲区发送数据才能驱动SCK时钟跳变。

基于CubeMx的讲解
: B6 v; ?" o, G+ ]" b1设置RCC时钟

A9XVC[L){CQYZLTRY6A]3~B.png

设置高速外部时钟HSE 选择外部时钟源

2 SPI设置
$ L; n6 y* M) H* Q7 O8 d: {( W9 K
; w: K) X' H0 T3 B9 |SPI2设置为全双工主模式，硬件NSS关闭，如下图：

$_OJ{EZE)BGBQ5P@`)0tLU.png$

08)B_EEMT$II8GC[19Y_K9K.png

模式设置:

有主机模式全双工/半双工
从机模式全双工/半双工
只接收主机模式/只接收从机模式
只发送主机模式
因为我们是和W25Q128V芯片闪存芯片进行通信，所以设置为主机全双工

5 |4 Y4 B: F2 \( R" I不使能硬件NSS

7OP}KVCLW_WDG@T$N9}Y`BJ.png

STM32有硬件NSS(片选信号)，可以选择使能，也可以使用其他IO口接到芯片的NSS上进行代替
" i8 f# S+ b+ t! S6 e8 f! T
其中SIP1的片选NSS ： SPI1_NSS（PA4）( c9 X% c* d0 b1 }
其中SIP2的片选NSS ： SPI2_NSS（PB12）

如果片选引脚没有连接 SPI1_NSS（PA4）或者SPI2_NSS（PB12），则需要选择软件片选

NSS管脚及我们熟知的片选信号，作为主设备NSS管脚为高电平，从设备NSS管脚为低电平。当NSS管脚为低电平时，该spi设备被选中，可以和主设备进行通信。在stm32中，每个spi控制器的NSS信号引脚都具有两种功能，即输入和输出。所谓的输入就是NSS管脚的信号给自己。所谓的输出就是将NSS的信号送出去，给从机。
对于NSS的输入，又分为软件输入和硬件输入。
软件输入：
NSS分为内部管脚和外部管脚，通过设置spi_cr1寄存器的ssm位和ssi位都为1可以设置NSS管脚为软件输入模式且内部管脚提供的电平为高电平，其中SSM位为使能软件输入位。SSI位为设置内部管脚电平位。同理通过设置SSM和SSI位1和0则此时的NSS管脚为软件输入模式但内部管脚提供的电平为0。若从设备是一个其他的带有spi接口的芯片，并不能选择NSS管脚的方式，则可以有两种办法，一种是将NSS管脚直接接低电平。另一种就是通过主设备的任何一个gpio口去输出低电平选中从设备。
硬件输入：
主机接高电平，从机接低电平。

左键对应的软件片选引脚，选择GPIO_Output(输出模式),然后点击GPIO，设置一下备注。

我这里虽然PB12是SPI2的硬件片选NSS，但是我想用软件片选，所以关闭了硬件NSS

~%UZ[)HI6C((0BNCD{K(H]7.png

; n3 D) \0 ~. w5 N1 r' F1 s& Q' Q
, N; R$ V- a. ?0 @& U
SPI配置默认如下：

SPI配置中设置数据长度为8bit,MSB先输出分频为64分频，则波特率为125KBits/s。其他为默认设置。
Motorla格式，CPOL设置为Low,CPHA设置为第一个边沿。不开启CRC检验，NSS为软件控制。

MNT@YEQZ`1}LDM0BBI05MGK.png

最后记得初始化一下串口，因为需要测试例程，发送数据到上位机。

$))_{$KKQG4]2X{X`R(XLEPT.png$

3时钟源设置

8Y(B0VG8[GH)O[VF06P0JCU.png

我的是外部晶振为8MHz

1选择外部时钟HSE 8MHz
2PLL锁相环倍频9倍
3系统时钟来源选择为PLL
4设置APB1分频器为 /2
5 使能CSS监视时钟

32的时钟树框图如果不懂的话请看《【STM32】系统时钟RCC详解(超详细，超全面)》

2 I5 b/ T) w* N8 a$ x. ~4项目文件设置

K[I448YQ}X]MOK]ZO1[6C.png

1 设置项目名称
2 设置存储路径
3 选择所用IDE

GPR)1~0V)H[YO(A)U2I]`LF.png

# ^( l0 r% S% V W9 w5创建工程文件

然后点击GENERATE CODE 创建工程

) X+ B6 y1 P: v2 Z5 p. _% e配置下载工具
新建的工程所有配置都是默认的我们需要自行选择下载模式，勾选上下载后复位运行

K)5%$]7K[06O]YRL~9QE)Y4.png

SPI函数详解

在stm32f1xx_hal_spi.h头文件中可以看到spi的操作函数。分别对应轮询，中断和DMA三种控制方式。

$KEO@HHK%AOM{_HUQ0H4FNWN.png$

轮询：最基本的发送接收函数，就是正常的发送数据和接收数据
中断：在SPI发送或者接收完成的时候，会进入SPI回调函数，用户可以编写回调函数，实现设定功能
DMA： DMA传输SPI数据

利用SPI接口发送和接收数据主要调用以下两个函数：

HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//发送数据5 m& D5 Q3 v/ j3 C6 Z3 l# [9 d) \
HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//接收数据

复制代码

SPI发送数据函数：

HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//发送数据

复制代码

参数:

*hspi: 选择SPI1/2，比如&hspi1，&hspi2
*pData ：需要发送的数据，可以为数组
Size：发送数据的字节数，1 就是发送一个字节数据
Timeout：超时时间，就是执行发送函数最长的时间，超过该时间自动退出发送函数

SPI接收数据函数：

HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//接收数据

复制代码

参数:
*hspi: 选择SPI1/2，比如&hspi1，&hspi2
*pData ：接收发送过来的数据的数组
Size：接收数据的字节数，1 就是接收一个字节数据
Timeout：超时时间，就是执行接收函数最长的时间，超过该时间自动退出接收函数

SPI接收回调函数：

　HAL_SPI_TransmitReceive_IT(&hspi1, TXbuf,RXbuf,CommSize);

复制代码

当SPI上接收出现了 CommSize个字节的数据后，中断函数会调用SPI回调函数：

　　　HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)

复制代码

用户可以重新定义回调函数，编写预定功能即可，在接收完成之后便会进入回调函数

片选引脚：

因为我们是软件使能片选，定义片选引脚，CS片选低电平为有效使能， CS片选高电平不使能

这里用两个宏定义来代替

5 t8 ^& s. g }; @在main.h中有宏定义命名，SPI2_CS_Pin 就是PB12

//以W25Q128为例2 o' p" G$ T1 L3 m
#define SPI_CS_Enable() HAL_GPIO_WritePin(GPIOB, SPI2_CS_Pin, GPIO_PIN_RESET)+ p8 g/ u& j8 C% X. I
#define SPI_CS_Disable() HAL_GPIO_WritePin(GPIOB, SPI2_CS_Pin, GPIO_PIN_SET)

复制代码

4 ~) ]3 v6 `6 W) q* g% ]3 T' g& ]6 e
SPI例程详解
因为不同的flash芯片通信协议以及方式都是不同的，所以这里介绍下具体的SPI的发送和接收应该怎么写，具体的请看芯片手册修改下即可，这里提供下W25QXX的驱动文件，以及测试例程，测试是正常没问题

挑几个函数讲解一下：

在w25Qxx.h钟可以修改CS片选引脚，W25Qx_Enable(),W25Qx_Disable()分别为使能和失能SPI设备，即拉低和拉高/CS电平

#define W25Qx_Enable() HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_RESET)) n- C- F% G& E4 s1 e. R
#define W25Qx_Disable() HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET)

复制代码

w25Qxx复位函数：
( j! ~* s5 K( w. n5 G+ I
函数开始先将要发送的数据（命令(0x66)和地址(0x99)）存储在cmd数组中，
拉低片选信号，开始SPI通信
然后后通过HAL_SPI_Transmit（）函数发送出去
拉高片选信号，关闭SPI通信

W25Qx_TIMEOUT_VALUE是最大超时时间，在w25Qxx.h中定义为1000，单位为us

FA)X9VQ]S3IY97FX]V8X1FW.png

/**
: v7 x$ Y7 G: R( _' e/ d! H" P) ^
* @brief This function reset the W25Qx.
' {# B: l2 e9 o+ o. C, \" L
* @retval None
9 g3 |1 q2 r3 Z
*/
' \- V6 U. I5 H5 G2 j) V- ^! m7 n
static void BSP_W25Qx_Reset(void)" q; p7 @4 `+ T' M% U8 T3 q! k
{
4 G; f+ X" Q8 r" J4 q2 P
uint8_t cmd[2] = {RESET_ENABLE_CMD,RESET_MEMORY_CMD};
: F9 p" i$ W7 V$ D! G5 ?
1 d. @8 i1 X; `# C& Q9 z# S/ O
W25Qx_Enable();* K% F* ]+ M- }
/* Send the reset command */4 j! g6 l, a8 R0 A! o( e! H {3 s9 c
HAL_SPI_Transmit(&hspi2, cmd, 2, W25Qx_TIMEOUT_VALUE); 1 {! ?" K9 O3 X
W25Qx_Disable();
5 c$ G+ { ]0 L
: g8 Q% Z9 {# Y- Y- }
}

复制代码

W25QXX读函数：
三个参数：
pData 存放读取到的数据的数组
ReadAddr 读取数据的地址
Size 读取数据的大小
…

函数开始先将要发送的数据（命令和地址）存储在cmd数组中，
拉低片选信号，开始SPI通信
然后后通过HAL_SPI_Transmit（）函数发送出去，首先发送写命令(0X03),上方有讲解，然后发送三个字节(24 Bit)的地址
接着通过HAL_SPI_Receive（）接收读取的数据。
拉高片选信号，关闭SPI通信

ESCEO7$I`2621{[NT1@4MFY.png

uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size); X! n2 D0 ^# g7 ^
{
* j _- S8 j. O$ K) u
uint8_t cmd[4];
$ W; ?1 X1 K& P2 ~# G( \
" L0 B1 u' c2 S' Q
/* Configure the command *// |/ C2 w+ b6 \$ Z# r
cmd[0] = READ_CMD;
8 }; W8 t2 n: l0 o
cmd[1] = (uint8_t)(ReadAddr >> 16);& {8 s2 ?3 }$ J- E- u# A
cmd[2] = (uint8_t)(ReadAddr >> 8);+ J2 x" M, D2 J* @7 r
cmd[3] = (uint8_t)(ReadAddr);
+ x2 M4 A' F0 K$ `0 p1 @+ |
! Y! N, A3 L5 m' I3 Y
W25Qx_Enable();5 u3 t/ l4 c, c
/* Send the read ID command */4 _+ X! Y- q2 J( _4 S
HAL_SPI_Transmit(&hspi2, cmd, 4, W25Qx_TIMEOUT_VALUE); " R8 `1 u- `7 a$ [
/* Reception of the data */9 ?& m% w$ a! W2 I8 O7 t
if (HAL_SPI_Receive(&hspi2, pData,Size,W25Qx_TIMEOUT_VALUE) != HAL_OK)$ \8 i1 L' Y$ f' _/ P3 |
{6 y8 [4 C9 U8 d
return W25Qx_ERROR;6 E% p0 `& X- D( |7 j$ z) W8 O
}
1 z% ]) q8 e9 r5 F" ?; }
W25Qx_Disable();. }( A- e F6 A" a9 D m
return W25Qx_OK;# A) w" b+ F& P* I. y% q3 O5 p
}# L4 V8 j/ B' t/ E$ l8 {, Q

复制代码

8 m" Z9 D8 z' d4 u写使能(Write Enable) (06h)

$_H${X10%GJ3V4NONTH0B1}7.png$

向FLASH发送0x06 写使能命令即可开启写使能，首先CS片选拉低，控制写入字节函数写入命令，CS片选拉高。

uint8_t BSP_W25Qx_WriteEnable(void)
" v# e, b- b/ N. C; d
{
% M6 b H) ~7 J# ~5 g! a
uint8_t cmd[] = {WRITE_ENABLE_CMD};
) L. O: k8 z, W+ O
uint32_t tickstart = HAL_GetTick();2 y9 h& i! D d. K( x z3 a
, A/ J" i0 o# `8 U
/*Select the FLASH: Chip Select low */
, s6 X/ ^" H# ^6 J' F% @( `9 _
W25Qx_Enable();5 q2 T( x* _. b
/* Send the read ID command */
* f2 D) r5 J |' ^8 |2 b
HAL_SPI_Transmit(&hspi2, cmd, 1, W25Qx_TIMEOUT_VALUE); 4 A$ p+ d% U5 d$ e$ u+ E9 x
/*Deselect the FLASH: Chip Select high */
( r" y: h' Y% o8 ]4 t7 F* Y4 u, j
W25Qx_Disable();3 [/ L4 |% D% b" J8 M' k2 P; D
1 k: }- n* J" X; E9 ~/ y, O$ r0 X
/* Wait the end of Flash writing */- c. ?, z9 T% a0 k% u5 ^! m5 b
while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
8 {' K$ o0 O" P3 \ E
{
/ U' J; M/ ?* I5 m+ [" D J* p; ]
/* Check for the Timeout */
: ~( s* m, B; |4 U2 P( O
if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
- B1 `2 V; ] M3 T) d" C Z
{ % N/ F) \; O" s8 Q, t
return W25Qx_TIMEOUT;* @2 b& B: e) s3 b
}& d; J* a8 T7 Z. t
}
; j4 }/ _+ |% |+ K, f8 W, ]- A$ n
3 `0 x/ h! x; B7 I% I7 X$ w
return W25Qx_OK;' v7 h5 i" v# H, \* C! Y% h# F3 d% P
}

复制代码

扇区擦除函数：
; @3 G( C/ y2 D" E" L$ ^) a( N3 z7 X# g" x: j
扇区擦除指令(Sector Erase) (0x20h)

EY@MZDOQ(DHAJFP0UNAWDTQ.png

扇区擦除指令，数据写入前必须擦除对应的存储单元，并且使能写操作，该指令先拉低/CS引脚电平,接着传输“20H”指令和要24位要擦除扇区的地址。判断flash是否为忙状态，如果不为忙则擦除操作完成。

uint8_t BSP_W25Qx_Erase_Block(uint32_t Address)
- e a) e0 i, M) H$ M7 p, @9 j
{& C1 L& @) U& X3 N/ O3 S( O9 E
uint8_t cmd[4];5 f/ ]3 G6 w: H( u9 g5 ~3 d1 k
uint32_t tickstart = HAL_GetTick();
" a" A7 Y8 {8 c$ M8 R
cmd[0] = SECTOR_ERASE_CMD;1 A: p* d7 y) U5 R
cmd[1] = (uint8_t)(Address >> 16);% l! S) ?5 q, G1 V: n+ R4 K
cmd[2] = (uint8_t)(Address >> 8);
: I2 r# g1 T _
cmd[3] = (uint8_t)(Address);. c; \* X8 C3 _1 v; s
8 M( g( E4 m. U0 \
/* Enable write operations */
& F4 z) I- k: ]2 W3 Y1 ~& b" b5 p+ T
BSP_W25Qx_WriteEnable();
4 u# ?- y' x. l8 U4 C) r5 d
/ O/ w$ `7 D, F7 E6 m( n! b
/*Select the FLASH: Chip Select low */, l, f! N) h7 H! X# S
W25Qx_Enable();
! Y6 U; y8 z4 h& w5 c# [
/* Send the read ID command */
4 {) m7 W& Y& u4 T1 f
HAL_SPI_Transmit(&hspi2, cmd, 4, W25Qx_TIMEOUT_VALUE);
P& X6 q- j6 j5 e* H, u
/*Deselect the FLASH: Chip Select high */" {; h+ g! r# K0 H3 X- v
W25Qx_Disable();
) s& Y3 @+ @" j3 ~& v) n
: T- Y# Q7 b" U5 w, Y; ^7 A `( w
/* Wait the end of Flash writing */
' ~- t/ P+ x. K6 ~- Y' P& h* c
while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);# o& b, a8 x1 M+ H
{
1 [5 o0 [* s4 L
/* Check for the Timeout */
$ V8 h) ]: L& \4 y
if((HAL_GetTick() - tickstart) > W25Q128FV_SECTOR_ERASE_MAX_TIME)9 U7 q. y# a4 z# t; e$ d
{
% p1 R- P' y. X0 j
return W25Qx_TIMEOUT;
4 d( g0 J+ V+ ]6 ?! }
}
7 z7 N" h, l+ {+ _. _
}' D2 M/ _* e) R1 L7 c. ^) t: R, Q! w
return W25Qx_OK;) ^4 A' v X. c% I" \
}

复制代码

例程测试
4 Q3 i) I( m$ q' I0 Y重新定义printf函数
在 stm32f1xx_hal.c中包含#include <stdio.h>

#include "stm32f4xx_hal.h"8 p, l# w* W( d
#include <stdio.h>
% N% P# y: K6 P5 Q4 b& q& N) l7 q' S2 A
extern UART_HandleTypeDef huart1; //声明串口

复制代码

在 stm32f1xx_hal.c 中重写fget和fput函数

/**
! R& U: u/ C) J3 b* N# V
* 函数功能: 重定向c库函数printf到DEBUG_USARTx9 K1 z$ Y& K2 Q& D5 k
* 输入参数: 无1 X6 ] l+ w# Z [7 a
* 返回值: 无% @4 P/ {0 g& }2 {% @
* 说明：无
: n1 F+ g e+ b& c' M
*/9 e$ Z* O0 O; U/ q1 m9 W
int fputc(int ch, FILE *f)2 `6 z T# p) g
{
1 C/ ^" Z4 F; w
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
8 J- e) @6 C" r
return ch;
0 `/ ?1 k8 _4 d# }
}' ~4 X: q6 ^6 x8 e: |' g0 e P
4 G4 Z) T: |0 }( Q3 {5 |
/**
7 F# W6 `; y% t# g7 K- l, u( v5 n8 h
* 函数功能: 重定向c库函数getchar,scanf到DEBUG_USARTx
" \- `; ]: ?5 F. ?' D' U$ c
* 输入参数: 无
2 y5 P$ V# x! A9 l; d. T. h
* 返回值: 无
* 说明：无& |% O3 d) o& t1 d9 a' a# M [( ?
*/( X% F- D" y, x6 V+ Q+ h
int fgetc(FILE *f)/ w( w4 ~) T& J, P% i, p6 o7 j
{/ r9 R# f$ R; O1 }* y
uint8_t ch = 0;' G9 i* a4 n- A! ^% v8 d6 G) m3 T
HAL_UART_Receive(&huart1, &ch, 1, 0xffff);, N0 U2 k D6 z/ V( O- ?: k
return ch;8 S k2 C# Y% c% t
}

复制代码

main.c
在main.c里添加以下代码：

#include <string.h>
0 `+ X% b0 U. O' z6 m) S
#include "W25QXX.h"
" q7 q* d! s$ ~
; d J( J/ c: D+ A
" L9 D, S2 _+ i. h i
& v& D: q9 S$ K, I
uint8_t wData[0x100];* |/ m" J; v' n k: p2 p2 J$ b% o
uint8_t rData[0x100];" X' q7 J& b$ w9 X, b& n0 v
uint32_t i;
, ~8 ]1 c8 f1 I& S! w. ?! P& G9 t
uint8_t ID[2];
: I: M$ a' i- ?) L' x

复制代码

printf("\r\n SPI-W25Qxxx Example \r\n\r\n");
' F: [: `: o; v/ G
/ a2 N5 V, O5 j* r2 B
/*##-1- Read the device ID ########################*/
- `% p7 G8 G5 ^0 A4 Y: k# A; o
3 u. U* i9 ]4 N `+ B6 A! g
BSP_W25Qx_Init();3 }! V+ n$ s$ E. \7 l ^6 ~
BSP_W25Qx_Read_ID(ID);
9 A, u7 x0 y% Y& n" G( ]
- O" }0 Q7 ]& R- g# V# v: T; R9 j
printf(" W25Qxxx ID is : 0x%02X 0x%02X \r\n\r\n",ID[0],ID[1]);5 C0 ~4 J. u- h- Y* {
/*##-2- Erase Block ##################################*/' ~5 `# r, ^: |9 \' I
if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
4 B# a" W: I4 i. \/ C- J" H: o
printf(" SPI Erase Block ok\r\n");8 X% s/ c* t0 w# K0 W1 P
else+ T8 q# G( o8 j8 r
Error_Handler();$ o9 k" o3 B7 j1 _( m4 C b
/*##-3- Written to the flash ########################*/0 I7 X" E4 v& K& b$ S
/* fill buffer */8 j4 z5 b) P$ A7 n: l
for(i =0;i<0x100;i ++)' D [! w2 v5 A. }
{( m5 b1 _ H L3 v7 R
wData = i;
* L$ [6 L* P$ L8 d7 M
rData = 0;
7 ], Z- a5 g* E$ p; o
}1 i% U" N/ K7 w7 q* { A
if(BSP_W25Qx_Write(wData,0x00,0x100)== W25Qx_OK)
6 j0 ?5 b5 s7 s7 _* v7 `
printf(" SPI Write ok\r\n");$ Q9 D, T/ J5 s' C* Z2 X
else4 u$ J0 i2 H& l7 ~% m( G
Error_Handler();
0 i: o$ R) L0 s1 ~/ r( z
/*##-4- Read the flash ########################*/
5 c, J. M6 A0 E' J" x
a3 }$ D* M4 T
if(BSP_W25Qx_Read(rData,0x00,0x100)== W25Qx_OK)
+ w% ^ D4 b1 h/ W
printf(" SPI Read ok\r\n\r\n");! i9 J& |/ `, T! I4 z$ `
else
6 D+ D# @" z1 }
Error_Handler();
! \6 C2 W% R# `* y" G8 Y" I
printf("SPI Read Data : \r\n");
! N$ w# J8 t6 J+ r3 V. L a
for(i =0;i<0x100;i++)
9 d3 y( w5 H( \6 Y* L
printf("0x%02X ",rData);
+ H; Y) x4 r5 m
printf("\r\n\r\n");' Q( y& Z/ }9 V- _9 V5 }1 u
/*##-5- check date ########################*/ 1 g. K8 b, C) a
if(memcmp(wData,rData,0x100) == 0 )& ?! @: {* q- v$ M8 O' I6 k
printf(" W25Q128FV SPI Test OK\r\n");$ }# v5 h) v% O# |
else
4 X7 Q. u$ b4 {2 E) o6 i+ W% D% O- q
printf(" W25Q128FV SPI Test False\r\n");; S, ~4 b9 ^9 H& ^9 A1 U9 Y