你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32(ARM)开发经验分享

[复制链接]
攻城狮Melo 发布时间:2023-4-12 16:18

3 d" Z# d8 {7 l0 W
微信图片_20230412161833.jpg

0 |. z3 z2 @$ Z
本系列为ARM开发的进阶知识,讲解与ARM芯片进行通信的大部分高级外设的原理及使用方法,不局限于ARM芯片内部,实操性较强且晦涩,需要一定的读者具备一定代码阅读和理解能力。
" T& D+ z4 _5 G
  • STM32 I2C总线通信专题讲解

    % c! i6 j5 }0 q5 d3 h
( e4 L4 h3 n0 a/ P, o, b& _4 g
  • 总线介绍:I2C(Inter-Integrated Circuit)总线(也称IIC或I2C)是由PHILIPS公司开发的两线式串行总线(单双工),用于连接微控制器及其外围设备,在这两根线上可以挂很多设备,同一时刻只能有一个节点处于主机模式,其他节点处于从机模式,总线上数据的传送都由主机发起。I2C总线没有片选信号线,所以需要通过协议来找到对应操作的芯片。是微电子通信控制领域广泛采用的一种总线标准。它是同步通信的一种特殊形式,具有接口线少,控制方式简单,期间封装形式少,通信速率高等优点。* A& \/ E' n3 p+ E0 I# i
    8 b4 s7 z1 X; x1 Z. J8 p; g1 Y6 P

6 c( f0 j/ J9 g2 [9 b
  • 总线特征:

    ) f7 q7 H0 ?3 P4 I2 t, e7 S
1.两条总线线路:一条串行数据SDA,一条串行时钟线SCL(主从设备使用同一时钟,属于同步通信)来完成数据的传输及外围器件的扩展

2 i3 k9 W3 {8 F+ `: b* @
2.I2C总线上的每一个设备都可以作为主设备或者从设备,而且每一个设备都会对应一个唯一的地址,通常是7位,有时候是10位
' V3 Q! ^9 \$ N
3.I2C总线数据传输速率在标准模式下可达100kbit/s,快速模式下可达400kbit/s,高速模式下可达3.4Mbit/s。在开发配置的时候,最好检查从设备的传输速率从而对主设备(一般是MCU)进行相应的配置。一般通过I2C总线接口可编程时钟来实现传输速率的调整,同时也跟所接的上拉电阻的阻值有关。
7 f4 m. ?% p$ r' [# P+ j
4.I2C总线上的主设备与从设备之间以字节(8位)为单位进行单双工的数据传输。

3 j, M; z' S( o- Y
  • 拓扑结构——总线型

    ! c6 ]* y5 [. {# c; }
I2C 总线在物理连接上分别由SDA(串行数据线)和SCL(串行时钟线)及上拉电阻组成,SCL由主机发出,SCL越快,通讯速率越快。通信原理是通过对SCL和SDA线高低电平时序的控制来产生I2C总线协议所需要的信号进行数据的传递。在总线空闲状态时,这两根线一般被上面所接的上拉电阻拉高,保持着高电平。
# c$ W) a  C9 l9 {6 a
微信图片_20230412161906.png
. P: L( C9 |+ b  L
  • I2C总线协议
    - B3 y& g( s6 R5 _8 a+ ?, W
1.I2C协议规定:  总线上数据的传输必须以一个起始信号作为开始条件,以一个结束信号作为传输的停止条件。起始和结束信号总是由主设备产生。
2 e3 q+ o' z) h  r
2.空闲状态:SCL和SDA都保持着高电平。

8 `( v7 X% H1 C- U" {3 j
3.起始信号:  当SCL为高电平而SDA由高到低的跳变,表示产生一个起始条件,所有的从设备都能感受到这个跳变,做好准备等待被选择。

% @& M8 L# x) Z9 s) E
4.结束信号:当SCL为高而SDA由低到高的跳变,表示产生一个 停止条件
" i6 o- h7 s# g7 _# r# U
微信图片_20230412161928.png

# l2 Q4 H2 K$ O3 g6 p, S
5.数据传输:数据传输以字节为单位 , 主设备在SCL线上产生每个时钟脉冲的过程中将在SDA线上传输一个数据位,数据在时钟的高电平被采样这时候采集到是1就是1,是0就是0,所以在传输数据时,当时钟处于高电平时一定要保持稳定,时钟处于低电平时可以变换数据。(高电平采样,低电平变换)一个字节按数据位从高位到低位的顺序进行传输。主设备在传输有效数据之前 要先指定从设备的地址,一般为7位,然后再发生数据传输的方向位, 0表示主设备向从设备写数据,1表示主设备向从设备读数据。主从设备以字节为单位(8位)进行数据传输,开始传输数据时把从设备地址加上方向位组成一个8位的字节进行发送并接收一个应答。
# d& \8 u3 Y8 G# r7 a; w
6.应答信号:接收数据的器件在接收到 8bit 数据后,向发送数据的器件发出低电平的应答信号,表示已收到数据。这个信号可以是主控器件发出,也可以是从动器件发出。总之,由接收数据的器件发出。
. G. y! J- ~9 p
微信图片_20230412161941.png

# A/ R) |2 z# t& W4 j7 M3 B
a.主设备向从设备写数据:

7 ~+ {! s. S4 ~; c
微信图片_20230412161956.png

! {2 n. X% q! y* h& |" S( {
b.主设备读从设备的数据:

; D8 r4 L4 X" B2 ]& F0 f5 [; M. P
1.png
% U% d: P1 D/ N1 m! V' u
c.主设备读从设备的某个寄存器:读设备的寄存器首先应该对该设备发送写命令,很多设备都可以看成是一段内存,所以写命令写给从设备,指明要读取哪个地址(寄存器)的数据,接下来才是真正的读数据。不同的从设备是由区别的,在驱动I2C从设备时应当查明设备的时序图,又怎样的要求,不同的时序对应了不同的命令。

! b/ M1 H! _7 ]* ^, ~+ w1 y! M
2.png
4 N% b8 X9 y1 K! R- A: ~) i. e
% P6 Z6 B- h& Y0 Q- r
  • STM32F4-I2C控制器特性
    . ~# ^1 e3 f" ], t; S
软件模拟I2C时序:由于直接控制 GPIO 引脚电平产生通讯时序时,需要由 CPU 控制每个时刻的引脚状态,所以称之为“软件模拟协议”方式。我们知道,驱动I2C设备只需要两根管脚,即使单片机上没有I2C控制器,根据协议控制每根管脚每一时刻的电平状态,一根模拟数据线,一根模拟时钟线,就可以驱动从设备,相对而言效率低,但是可以实现控制驱动。STM32内部具备专门的I2C控制器,使用时只需对其进行相应的配置即可。

. q8 k  ~0 d+ B* M6 F+ t* ]( f
硬件控制产生I2C时序:STM32 的 I2C 片上外设专门负责实现 I2C 通讯协议,只要配置好该外设,它就会自动根据协议要求产生通讯信号,收发数据并缓存起来,CPU只要检测该外设的状态和访问数据寄存器,就能完成数据收发。这种由硬件外设处理I2C协议的方式减轻了 CPU 的工作,且使软件设计更加简单。
$ S( x; E3 D6 @
控制器功能:配置主从模式(一般都把STM32当作主机使用,作为从机时应当对其赋一个地址),通过配置其内部的寄存器产生一些中断和错误信号,配置通信速率位标准模式、快速模式、超快速模式等
8 f3 D2 o: w6 H! x$ e8 w
STM32芯片有3组I2C外设,可以同时进行3组I2C传输。它们的I2C通讯信号引出到不同的GPIO引脚上,使用时必须配置到这些指定的引脚。
6 J& h. o3 ]6 n% Z  n- k1 q
微信图片_20230412162110.png

% @! n  y3 l8 C& Y' E# r4 Z* Y
  • EEPROM(AT24CXX)存储芯片介绍
    9 x9 H4 h3 M6 e" H0 H4 w) Q
一个典型的I2C接口的从设备,专门用于存储数据的芯片。EEPROM (Electrically ErasableProgrammable read only memory),带电可擦可编程只读存储器,一种掉电后数据不丢失的存储芯片。EEPROM可以在电脑上或专用设备上擦除已有信息,重新编程。

8 P1 a8 S4 R! H1 U# |1 B
EEPROM常用来存储一些配置信息,以便系统重新上电的时候加载之,容量不会很高。EEPOM 芯片最常用的通讯方式就是I2C协议。XX表示容量,常用值为01、02、04、16、32、64等,单位Kbit。一般的存储芯片都具有写保护功能,对WP管脚加一个高电平就开启了写保护功能,就无法往芯片内写数据了。在开发中通常将该管脚接地,确保能够写数据
典型24CXX芯片引脚如下:
4 F# \* v7 k% q( b& l; Y) b
微信图片_20230412162134.png
! F+ j2 X: E6 j0 V9 I8 A) H
例:24C65的设备地址为7位,高4位恒定为1010,低3位取决于A0-A2的电平状态,般主机在读写24CXX都是把设备地址连同读写位组合成一个字节一起发送。
! [$ C& p; A6 d+ H3 G0 R: K
3.png

2 r0 M! c( L, k- v
24C65的电气连线如下,根据电气连线可知,A0-A2均接地,因此读地址为1010 0001,即0xA1;写地址为10100000,即0xA0 ,且WP接地,用户随时可向芯片内部写入数据。
# R* C+ X+ u2 s  _+ z. ?2 s
4.png

; h$ P9 @  {! }8 x
24C65写时序:首先发送一个起始信号,接着发送从设备地址以及方向位,收到应答后,向从设备发送要写的存储区域的首地址,24C65的存储地址是16位,先发送高8位,收到应答后再发送低8位,再次收到应答后开始写数据。64Kbit大小位8K字节,需要13位即可表示,所以高3位固定定为0,如下图。
5 L/ R+ c- t5 |1 p2 ^
这里是BYTE WRITE,一次写一个字节,此芯片还支持PAGE WRITE,一次写一页,也就是8个字节,如果想写更多,可设置一个for循环实现。
7 U5 i) d, r( w8 m; t- |
5.png
: ~( s& k' B, A* N$ A% ]
24C65 读时序与写时序基本相同,只不过在读之前要发送再发送重复开始位进行读操作。
; ^* s# D, Q# _5 a
6.png
) o! @# M1 T$ K; e. y
  • I2C读写EEPROM实例

    + k$ m& o1 z4 U$ L

( L! p1 S& x2 @: {' U8 x
由电气原理图可知SCL和SDA分别接入了PB6和PB7管脚,读地址为1010 0001,即0xA1;写地址为10100000,即0xA0
5 m3 c6 @' m9 q  B' _) E
步骤:
1.配置RCC

9 ?2 F- J5 \+ B0 [! i2 \# _4 B
2.配置PB6和PB7管脚

& o6 C7 j1 d1 k. T& {
7.jpg
- D# v) }  R" E7 ^. p  l$ t
3.配置I2C协议参数

$ R( `  m: m% N" j
8.png
/ X. Z' c, G8 s( Y3 n1 W- p
4.编写代码
  1. " _9 B) Z9 ]9 p2 l% A
  2. //mian.c* H0 s: n! k* w# z& U
  3. 6 t4 d: h: y7 G5 _3 s6 h
  4. #include "main.h", x! L0 }3 ^. H( K  C+ j+ A
  5. #include "stm32f4xx_hal.h"4 J; D* G- \) s' P) s8 O3 {
  6. #include "i2c.h"( \+ |0 Q( ^; o6 K0 K
  7. #include "usart.h"9 C! Y3 c$ \0 ?, e5 ^' [( t( o6 C
  8. #include "gpio.h"
      A7 y4 Z1 ^! j: ]* F0 ~$ q

  9. 6 ]7 K5 G" K0 A$ W
  10. #define ReadAddr   0xA19 Z  {3 Y, M, g2 y& f/ c0 j
  11. #define WriteAddr  0xA0
      w- h  y& i4 f
  12. " m" n8 O2 h4 B1 D
  13. uint8_t Wbuf[20] = "EEPROM TEST OK!";, ^  @9 _) p- a0 D; N  h3 I
  14. uint8_t Rbuf[20] = {0};
    & W  v* J/ l! L7 f( R3 T- g

  15. / s+ s. g+ s+ V9 A- Y" U& H
  16. /*********  24C65写数据函数*****************************/- [; y( I. @5 c4 m/ J2 l

  17. ) M/ Y' `; k) A& Q  l0 _7 X$ |
  18. void  Eeprom_Write(uint16_t MemAddr, uint8_t *Wbuf, uint16_t len ){) Y3 X; Q  p$ V1 l, J, b5 K9 C
  19.         while(len--){3 k. l, y8 j2 N* O
  20.         //I2C_MEMADD_SIZE_16BIT表示存储单元大小9 T( u  R$ K: f5 ~1 L9 `
  21.         //默认为两个参数,分别是I2C_MEMADD_SIZE_16BIT和I2C_MEMADD_SIZE_8BIT
    + b* ^. f2 l. Z! g/ X
  22.         //由于24C65的存储地址是16位的
    9 x6 k- `: j) b- F
  23.         //所以我们选择I2C_MEMADD_SIZE_16BIT9 Y, w% z) n" p  e* g" [
  24.         //1表示一次写一个字节  ^4 L3 u* o' b( I' g  f& O
  25.                 while(HAL_I2C_Mem_Write(&hi2c1, WriteAddr, MemAddr, I2C_MEMADD_SIZE_16BIT, Wbuf, 1, 100) != HAL_OK){};
    7 C# N1 I0 V. O5 Y0 H9 c& z
  26. MemAddr++;) y- S* _9 b  U4 H/ v. V) }" }/ u+ Q* @5 F
  27. Wbuf++;
    % Q6 ^: x4 P! A& i$ r0 }9 }- a
  28. }
    ( ]- m  o6 l% X  |$ m
  29. }
      X9 ~& q3 |, j: r, H

  30. # s7 O: K+ _- O0 n, k* B& a5 `+ {

  31. % a8 l" k/ m8 N) Z. z1 n. _: T
  32. /*********  24C65读数据函数*****************************/
    0 L! y9 n  C$ S7 U
  33. , i7 `5 p. Q4 d6 O) t- M  U
  34. void  Eeprom_Read(uint16_t MemAddr, uint8_t *Rbuf, uint16_t len ){, S4 T8 \7 E6 G& R3 U9 E4 A0 Y  L
  35.         //可以连续读,所以无需循环! S2 j) n1 R: |  j9 r, F9 ?
  36.         while(HAL_I2C_Mem_Read(&hi2c1, ReadAddr, MemAddr, I2C_MEMADD_SIZE_16BIT, Rbuf, len, 100) != HAL_OK );
    4 \/ d" C) C. j, a
  37. }1 e! ]1 ?0 W0 k$ {! ~# ^
  38. int mian(){% m4 s% x$ ?  j( \3 ~. p
  39.       MX_GPIO_Init();) x4 v, }/ B7 f1 b) l2 y9 L) {
  40.       MX_I2C1_Init();
    3 }+ w3 q3 Q* ]8 p: ]
  41.       MX_USART1_UART_Init();
      B( {! F! y5 b; R0 _! ~$ F
  42.       printf("this is i2c eeprom test\n");
    ( {+ T; k/ E6 ^& _/ z
  43. " |9 T  m2 B- U
  44.       Eeprom_Write(0, Wbuf, sizeof(Wbuf) );8 [- r- W7 g4 I0 g# ]" T$ N
  45.       HAL_Delay(500);
    " R: P* V* u  S4 _! h( ~, b/ [$ _
  46.       Eeprom_Read(0 , Rbuf, sizeof(Rbuf));
    ' R9 c5 v9 Z. W4 x9 \! F$ d7 S
  47.       printf("READ:  %s\n", Rbuf);' Y. v5 l! v6 }2 y: u% b1 T0 ~
  48. 1 k: U% p9 D" h) C; L
  49.       while(){2 G7 ^8 e  Q- Q
  50. - E% I) J6 E) }; a* S. @* F
  51.       }, z& _  l- E. `. _3 C7 p8 [
  52. }
复制代码

" Y' {- s% t. _7 U
  • STM32 SPI总线通信专题讲解

    # f2 ?2 ]# g- f1 ^5 q* K2 @
SPI接口是Motorola 首先提出的全双工三线同步串行外围接口,采用主从模式(Master Slave)架构;支持多slave模式应用,一般仅支持单Master。时钟由Master控制,在时钟移位脉冲下,数据按位传输,是高位在前还是低位在前是可以配置的,配置时根据从设备的通信进行相应配置,一般是高位在前,低位在后(MSB first)。SPI接口有2根单向数据线,为全双工通信,目前应用中的数据速率可达几Mbps的水平。
SPI总线被广泛地使用在FLASH、ADC、LCD等设备与MCU间,要求通讯速率较高的场合。

) d: Q* C2 {) x0 V: V+ _3 q
微信图片_20230412162643.png

/ a: c7 G# Q- ~% |
SPI接口共有4根信号线,分别是:设备选择线、时钟线、串行输出数据线、串行输入数据线。

% B6 d5 l2 J9 e; `; O1 X7 s
微信图片_20230412162658.png

9 r: H7 n1 h, V# |0 ^( T
(1)MOSI:主器件数据输出,从器件数据输入,连接从机的MOSI,与串口不同,串口需要反着连接(Rx-----Tx)
(2)MISO:主器件数据输入,从器件数据输出,连接从机的MISO
(3)SCLK :时钟信号,由主器件产生
(4)/SS:从器件使能信号,由主器件控制(片选),一般情况下为地电平选中设备,高电平释放设备。
* H- R! _& t+ C) k4 R$ J: K
  • SPI总线协议
    3 C& R# Z- j: @1 M  T3 N; F
% F* J4 c+ J% E, L" F$ c, q
1.数据交换逻辑:主机和从机都包含一个串行移位寄存器,主机通过向它的SPI串行寄存器写入一个字节发起一次传输。寄存器通过MOSI信号线将字节传送给从机,从机也将自己的移位寄存器中的内容通过MISO信号线返回给主机。这样两个移位寄存器中的内容就被交换了。从机的写操作和读操作时同步完成的,因此SPI成为一个很有效的协议。
" [% P; [0 \! Y! s+ T& t! P" E
如果主机只想写不想读,只需把数据放在数据寄存器,SPI控制器会自动传给外设,同时忽略掉外设传过来的数据即可;如果主机只想读不想写,主机写给外设一个空字符或者随便写一个数据,外设就会把数据传过来,不管是只读还是只写,主机与外设的读和写都h会发生且同时进行。

: l) A6 V1 e  ]5 q
微信图片_20230412162734.png

( _7 F$ y- q+ K, D) _
2.起始信号:  NSS信号线由高变低,是SPI通讯的起始信号。

% Q  @9 r  c. u. U" ^# L3 F' _
3.结束信号:NSS信号由低变高,是SPI通讯的停止信号。
3 X0 _& q+ R' _9 G# o$ ^# E0 F2 Z' q
4.数据传输:SPI使用MOSI及MISO信号线来传输数据,使用SCK信号线进行数据同步。MOSI及MISO数据线在SCK的每个时钟周期传输一位数据,按位传输,且数据输入输出是同时进行的。SPI每次数据传输可以 8 位或 16 位为单位,每次传输的单位数不受限制,要么是8位,要么是16位,可以配置。

$ R8 A  t) o, J: |
微信图片_20230412162755.png

; A* B9 y& o& F+ i1 C8 I* o  R. r1 n
  • SPI的4种通信模式
    : @4 ]: X, w, |1 C+ d% c/ W

, m* }0 J: e1 V8 Z
在SPI操作中,最重要的两项设置就是时钟极性(CPOL)和时钟相位(CPHA)这两项即是主从设备间数据采样的约定方式。由CPOL及CPHA的不同状态,SPI分成了四种模式,主机与从机需要工作在相同的模式下才可以正常通讯,因此通常主机要按照从机支持的模式去设置。同样在配置时一定要弄明白从机支持什么通信模式进行相应的配置。

/ @) \2 {& X. K% u! y% i' m
13.png

1 W- m" D0 w0 \/ _/ i+ Q( {
1.时钟极性CPOL : 设置时钟空闲时的电平:
a.当CPOL= 0 ,SCK引脚在空闲状态保持低电平;
b.当CPOL= 1 ,SCK引脚在空闲状态保持高电平。

0 J7 p, Y5 x- S* ~4 Z
2.时钟相位CPHA :设置数据采样时的时钟沿:
a.当 CPHA=0时,MOSI或 MISO 数据线上的信号将会在 SCK时钟线的奇数边沿被采样
b.当 CPHA=1时, MOSI或 MISO 数据线上的信号将会在 SCK时钟线的偶数边沿被采样

; \8 P+ Z* x5 P3 W7 T1 s
微信图片_20230412162837.png

7 v  ~5 m* N7 I
11.png
  • STM32F4-SPI控制器特性

    ' N" e6 n: n- K& E' f
12.png
- E% e7 Z, b1 y( E/ i$ ^3 |/ z
1.通讯引脚:
STM32F4芯片最多支持6个SPI外设控制器,它们的SPI通讯信号引出到不同的GPIO引脚上,使用时必须配置到这些指定的引脚,以《STM32F4xx规格书》为准。f407只有SPI1、SPI2、SPI3。
8 n, c5 V% y" ~6 c0 j
微信图片_20230412163014.png

* O) }  U# j) o/ Z; [& B- C. L& A
其中SPI1、SPI4、SPI5、SPI6是APB2上的设备,最高通信速率达42Mbtis/s,SPI2、SPI3是APB1上的设备,最高通信速率为21Mbits/s。其它功能上没有差异。

9 a4 i; c! X+ p+ I2 I+ e" c2 L
2.时钟控制逻辑:
SCK线的时钟信号,由波特率发生器根据“控制寄存器CR1”中的BR[0:2]位控制,该位是对f pclk 时钟的分频因子,对f pclk 的分频结果就是SCK引脚的输出时钟频率。
- |( {) L, p, a  M3 w
微信图片_20230412161739.png

' M3 Y) o1 v- `, U5 B% I9 K1 N
其中的fpclk 频率是指SPI所在的APB总线频率,APB1为fpclk1 ,APB2为fpckl2
, P8 n0 @  D$ b7 @1 C$ @
3.数据控制逻辑:
STM32F4的MOSI及MISO都连接到数据移位寄存器上,数据移位寄存器的数据来源来源于接收缓冲区及发送缓冲区。
5 y: ^( [- X) v
a.通过写SPI的“数据寄存器DR”把数据填充到发送缓冲区中。

2 [& T+ N4 [5 ^3 {4 `# `
b.通过读“数据寄存器DR”,可以获取接收缓冲区中的内容。

4 b8 B" i8 e- Q# C
c.其中数据帧长度可以通过“控制寄存器CR1”的“DFF位”配置成8位及16位模式;配置“LSBFIRST位”可选择MSB先行(高位在前)还是LSB先行(低位在前)。
) k+ P) b4 t8 S5 j* Q5 Z6 N) B
4.整体控制逻辑:
a.整体控制逻辑负责协调整个SPI外设,控制逻辑的工作模式根据“控制寄存器(CR1/CR2)”的参数而改变,基本的控制参数包括前面提到的SPI模式、波特率、LSB先行、主从模式、单双向模式(同时发送和接收、只发送关掉接收、只接收关掉发送)等等。

2 I; k7 N3 n0 G3 R8 V# j
b.在外设工作时,控制逻辑会根据外设的工作状态修改“状态寄存器(SR)”,只要读取状态寄存器相关的寄存器位,就可以了解SPI的工作状态了。除此之外,控制逻辑还根据要求,负责控制产生SPI中断信号、DMA请求及控制NSS信号线。

7 Q3 G$ Z# a( d' i. a: u- P$ o
c.实际应用中,一般不使用STM32 SPI外设的标准NSS信号线,而是更简单地使用普通的GPIO,软件控制它的电平输出,从而产生通讯起始和停止信号。
  • 串行FLASH_W25X16简介

    9 v2 K" o* v' S/ D' m5 c$ H- ^" C& _. X4 G
* j; v) ~1 T" x% Y, `
FLSAH 存储器又称闪存,它与EEPROM都是掉电后数据不丢失的存储器,但FLASH存储器容量普遍大于 EEPROM,现在基本取代了它的地位。我们生活中常用的 U盘、SD卡、SSD 固态硬盘以及我们 STM32 芯片内部用于存储程序的设备,都是 FLASH 类型的存储器。在存储控制上,最主要的区别是FLASH 芯片只能一大片一大片地擦写,而EEPROM可以单个字节擦写。
- A7 f$ H! v5 g4 B7 r; |3 C* R
W25X16有8192个可编程页,每页256字节。用“页编程指令”每次就可以编程256个字节。用扇区擦除指令每次可以擦除16页,即一个扇区包含16页,用块擦除指令每次可以擦除256页,用整片擦除指令即可以擦除整个芯片。W25X16有512个可擦除扇区或32个可擦除块。
+ T4 D0 F# s. X+ i3 S
微信图片_20230412161735.png

. Q9 t/ O" J8 [8 s. p# S# W% \
1.W25X16的硬件连线如下:

7 x  a- f6 \; [( L* Y( W! v
微信图片_20230412161643.png
  o; |$ l9 G4 R( Y4 y* m1 E
CS:    片选引脚,低电平有效,连接到STM32-PH2管脚
SO:   连接到STM32-PB4管脚(MISO)
SI:    连接到STM32-PB5管脚(MOSI)
CLK:  连接到STM32-PA5管脚(CLK)
WP:   写保护管脚,低电平有效,有效时禁止写入数据。接电源未使用
HOLD: HOLD 引脚可用于暂停通讯,该引脚为低电平时,通讯暂停,未使用
, l1 {* o- I# g# R& K4 a% k, r
2.W25X16控制指令:
我们需要了解如何对FLASH芯片进行读写。FLASH 芯片自定义了很多指令,我们通过控制 STM32利用 SPI总线向 FLASH 芯片发送指令,FLASH芯片收到后就会执行相应的操作。
而这些指令,对主机端(STM32)来说,只是它遵守最基本的 SPI通讯协议发送出的数据,但在设备端(FLASH 芯片)把这些数据解释成不同的意义,所以才成为指令。
" u3 f2 h2 t  P+ i) F; m. _2 x% i" ]
微信图片_20230412161719.png
5 P  n. Y" ?" o) M
a.读制造商/设备ID(90):该指令通常在调试程序的时候用到,判断SPI通信是否正常。该指令通过主器件拉低/CS片选使能器件开始传输,首先通过DI线传输“90H”指令,接着传输000000H的24位地址(A23-A0),之后从器件会通过DO线返回制造商ID(EFH)和设备ID。(注:SPI为数据交换通信,主器件在发送“90H”指令时也会接收到一个字节FFH,但此数据为无效数据)
! f% e# A% K& U1 T" p3 W# {
微信图片_20230412161715.png
  v8 \, H) ]9 ^
b.写使能命令(06H):在向 FLASH 芯片存储矩阵写入数据前,首先要使能写操作,通过“Write Enable”命令即可写使能。
2 l" m) F3 s& v. m2 B
微信图片_20230412161711.png

2 W4 {% |# D8 l* N0 l) B
c.扇区擦除(20H):由于 FLASH 存储器的特性决定了它只能把原来为“1”的数据位改写成“0”,而原来为“0”的数据位不能直接改写为“1”。所以这里涉及到数据“擦除”的概念。
7 s- G6 i; L! U
在写入前,必须要对目标存储矩阵进行擦除操作,把矩阵中的数据位擦除为“1”,在数据写入的时候,如果要存储数据“1”,那就不修改存储矩阵 ,在要存储数据“0”时,才更改该位。
# I4 s& Q/ Z* p( @; _
微信图片_20230412161707.png
微信图片_20230412161704.png
7 x+ e: A  b7 v$ f
d.读状态寄存器(05H):FLASH 芯片向内部存储矩阵写入数据需要消耗一定的时间,并不是在总线通讯结束的一瞬间完成的,所以在写操作后需要确认FLASH芯片“空闲”。我们只需要读取FLASH芯片内部的状态寄存器SRP的S0即可(当这个位为“1”时,表明 FLASH芯片处于忙碌状态,它可能正在对内部的存储矩阵进行“擦除”或“数据写入”的操作)
  u" }9 p/ p5 t. U8 p# ]6 n9 h
微信图片_20230412161658.png

1 F- u# O. n  I& ?2 q0 P
微信图片_20230412161654.png
# t' I" \( G7 {" L: \' u/ a4 P% T: }
e.读数据(03H):读数据指令可从存储器依次一个或多个数据字节,该指令通过主器件拉低/CS电平使能设备开始传输,然后传输“03H”指令,接着通过DI管脚传输24位芯片存储地址,从器件接到地址后,寻址存储器中的数据通过DO引脚输出。每传输一个字节地址自动递增,所以只要时钟继续传输,可以不断读取存储器中的数据。
/ T! r' x) \& G/ F
微信图片_20230412161650.png

2 _( k6 S$ R5 C6 K+ L/ E
f.写数据——页编程(02H):页编程指令可以在已擦除的存储单元中写入256个字节。该指令先拉低/CS引脚电平,接着传输“02H”指令和24位地址。后面接着传输至少一个数据字节,最多256字节。
8 c* r+ w% z6 ~
注:当数据写到一个新的扇区的时候,需要重新发起一个页编程信号才能继续写入数据。
/ b* g& u8 W3 x1 ?4 ~
微信图片_20230412161646.png
' B- q' o* p( C, K
  • STM32 SPI_FLASH基本配置和操作

    . R2 W, O: S: Y; n
" W* _. \  B4 U6 f/ `. h
根据如下的硬件连线图进行配置

  Q. N% W) G9 y6 e4 J& P  z
微信图片_20230412161729.png

; p* |  O0 d4 Y# |
步骤:
1.使能时钟RCC

" i' W+ j2 c! A  k* Z' ^
2.使能SPI1,配置相应管脚
) d/ I; _7 ~: l6 Q; r) r
微信图片_20230412161640.png
" _  K1 L# O: Q6 @: b1 d. c
微信图片_20230412161637.png
9 B9 r, Q2 `5 z; Y! A0 H0 x" C
3.配置SPI协议

$ X4 _* ~% V$ W0 ^, A# |0 P3 D3 P
微信图片_20230412161632.png
. I+ w3 _) X+ X3 ?0 u* @
) E" j1 ~; ^7 f2 N
4.编码
  1. //main.c
    1 i- A& j( Z# E2 b8 x2 @
  2. & J* ?9 ?" \5 u
  3. #include "w25x16.h"7 f. s- P& A' b/ G2 f1 r. D
  4. , N$ B& Y5 E+ ~; J$ b  m" h
  5. uint8_t RD_Buffer[5000] = {0};
    8 q  ]9 F/ U8 o$ o. ]9 _
  6. uint8_t WR_Buffer[5000] = "SPI FLASH WRITE TEST\n";5 F8 v4 j- n6 ~- k* L
  7. 3 n6 s+ f0 w# G/ |1 w) f+ f1 E
  8. int main(){3 n: }& I% c% [3 u- ?: L! _
  9.     uint16_t FLASH_ID = 0;$ A' J- }- r! Y/ c- R5 ^% F4 @& _
  10.     uint32_t i;
    ' G; z$ B. d3 Y
  11.     , K' l+ v% p5 ~: L" I  L. `6 V
  12.     MX_GPIO_Init();( W4 ]. C& U5 R+ d* t
  13.     MX_SPI1_Init();
    / ]2 U& K5 `5 E' [( U1 L+ u/ v5 X
  14.     FLASH_ID = sFLASH_ReadID();- v3 t+ e& t8 b3 C; f3 i
  15.     ' }) C/ m7 u# `7 e" ]
  16.     /******测试擦除******/( @; u# t/ r' K" O3 U, l6 f
  17.     sFLASH_EraseSector(4096*0);
    ) Z8 X# t) l5 B. W% S
  18.     //sFLASH_EraseSector(4096*1);
    0 p( b' s9 w' y  n0 ^% ^: i/ w9 s
  19.     sFLASH_ReadBuffer(RD_Buffer,0,4096);
    . C- B6 D) e* ]) N3 \( t! `  |
  20.     printf("读数据开始\n");1 g8 e5 d  b5 ]$ m5 w
  21.     for(i=0; i<4096; i++)
      x: P% @; w. f0 H7 M( R* ]6 b
  22.     {# d$ X/ b! M- P1 r  j
  23.     printf("%x ",RD_Buffer[i]);/ w( n: e$ w* B. n$ v/ u
  24.     }
    $ k3 R" `6 G- m
  25.     printf("读数据结束\n");
    : ^& k9 M( H; L
  26. : C% }. |# u* ^4 X* d
  27. + P4 Q" G! a" ?) w
  28.     /******测试写操作1*****/$ N3 B7 ]& K0 [' N
  29.     //写之前都需要擦除扇区" ^) `4 S! d9 G2 p
  30.     sFLASH_EraseSector(4096*0);
    7 G& {+ H" p' o/ G
  31.     sFLASH_WritePage(WR_Buffer,0, 20);
    * T& ?! z( m; V+ X) s0 ]
  32.     sFLASH_ReadBuffer(RD_Buffer,0,20);7 p' v1 V! g; @1 F5 p# r
  33.     printf("READ DATA: %s\n",RD_Buffer);
    ) w0 x2 X/ e( B; Q/ L3 u2 F
  34.     $ J% U5 [2 \: w( u# M
  35.     /******测试写操作2*****/# O" d0 S, E, Y0 G, G3 Y
  36.     //写之前都需要擦除扇区
    % g, |1 k6 b1 ?- t9 @6 q. K% M
  37.     sFLASH_EraseSector(4096*0);
    ! G" }" |" G- |- G
  38.     sFLASH_EraseSector(4096*1);                            8 x6 O$ C4 e' b
  39.     for(i=0; i<4096; i++)/ [3 @& `& H! L0 r6 i
  40.     {5 r5 t8 I9 n5 N
  41.     WR_Buffer[i] = 0x55;
    ) R& D) E1 A8 U' p* }
  42.     }0 C+ c9 {4 H  g! X9 j
  43.     sFLASH_WriteBuffer(WR_Buffer,4090, 1000);/ H/ o9 L: C! s
  44.     sFLASH_ReadBuffer(RD_Buffer,4090,1000);' |/ ]7 h8 n/ n+ u
  45.     for(i=0; i<1000; i++)9 z% E% C: i) q; |6 l
  46.     {  |$ u" `+ J$ P- @& d1 I( c
  47.     printf("%x ",RD_Buffer[i]);; v$ I' {- m; ^4 v; q& Z0 I" r
  48.     }
    9 w# H4 d/ `! A! B
  49.     /*****************/5 s2 y: S7 s& a$ D4 Q" B
  50.     while(){}
    , Q  V4 k& u8 G2 j1 H; d
  51. }
复制代码
  1. //w25x16.h. I/ y2 [+ }; F4 u! X9 j) D$ G

  2. ' x2 j1 B0 V; |  k
  3. #ifndef __W25X16_H
    ( w) V4 A, _* W+ V5 m
  4. #define __W25X16_H. ]7 j. n1 u3 I2 [

  5. # W# Y$ ^0 J+ q4 j+ B
  6. #include "stm32f4xx_hal.h"$ ~8 Y9 y; v0 R

  7. 9 U: X9 ?" e7 h# i. N2 g
  8. //使用宏定义芯片指令3 ?. y; I8 g" q, d/ O" \
  9. #define W25X_ManufactDeviceID  0x90  /* Read identification */
    ' @+ i2 v1 M9 F& r
  10. #define sFLASH_CMD_WREN        0x06/* Write enable instruction */
    & U2 Y+ [9 U: C. p+ k4 y, u$ s* C; G
  11. #define sFLASH_CMD_RDSR        0x05/* Read Status Register instruction  */% ?! h% R, Y' ]' b
  12. #define sFLASH_CMD_SE          0x20/* Sector Erase instruction */% h) I, k: t9 g/ z+ V% Y8 ^
  13. #define sFLASH_CMD_WRITE       0x02  /* Write to Memory instruction */, d6 K' s! e. k. h9 [+ M8 f
  14. #define sFLASH_CMD_READ        0x03/* Read from Memory instruction */, D% \  q( q; s9 f! a1 b* f
  15. #define sFLASH_DUMMY_BYTE      0x00 //空字节,用于只读传回来的数据
    # Y) o2 S: w. g3 b- X4 c
  16. #define sFLASH_BUSY_FLAG       0x019 j) M0 b- [) b( P8 @9 T; Z; p
  17. #define sFLASH_SPI_PAGESIZE    0x100$ F8 J. c1 M; \
  18. 9 y, ~* J* i7 J) d+ b9 p+ q) K
  19. /* 选中芯片,拉低信号 */5 u& u1 O8 W, x
  20. #define sFLASH_CS_LOW()       HAL_GPIO_WritePin(GPIOH,GPIO_PIN_2,GPIO_PIN_RESET)6 ~6 L! n6 `. u5 s
  21. /* 释放芯片,拉高信号 */# Y7 }+ J" Z, P7 D. `" x
  22. #define sFLASH_CS_HIGH()      HAL_GPIO_WritePin(GPIOH,GPIO_PIN_2,GPIO_PIN_SET)
    . @. Q- O4 \9 I) d3 s9 `
  23. : z: ]0 _1 x  p1 S: c! E) E
  24. //定义函数7 @1 r! T$ z8 M7 `
  25. uint8_t sFLASH_SendByte(uint8_t byte);
    - x* h3 h0 S$ M, e
  26. uint16_t sFLASH_ReadID(void);& @  Z5 H# M% A( t3 o
  27. void sFLASH_EraseSector(uint32_t SectorAddr);! k9 E* ]& G, I- ^) g
  28. void sFLASH_WriteBuffer(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite);
    $ }- W" p3 C5 `& R0 _: ^' M" U
  29. void sFLASH_WritePage(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite);
    $ ]' }  X7 A( c+ q; w) _8 O
  30. void sFLASH_ReadBuffer(uint8_t* pBuffer, uint32_t ReadAddr, uint32_t NumByteToRead);
      y/ w2 t" y5 w, q, D% g
  31. #endif
复制代码

  1. 7 S3 @1 r% C& t1 ]% h7 o4 f
  2. //w25x16.c& d$ D$ r/ L9 Q" k& W* k
  3. 9 s8 Y7 z- N& q+ o
  4. #include "w25x16.h"# i3 _$ J. `+ n. {# N
  5. 3 L% c/ h: |% V  ~5 G# f7 @
  6. extern SPI_HandleTypeDef hspi1;6 B! t4 f3 U# |3 g# E" K5 h! H# X
  7. " H# G. l* P: C; J
  8. /*读写一个字节函数,因为SPI读和写同时完成*/
    ( D0 p4 y( h2 y7 T5 I% f. p. A
  9. /*发送数据一定会接收到一个数据*/% y" v5 X- O3 H# u& {
  10. uint8_t sFLASH_SendByte(uint8_t byte)4 j5 ]6 t# k! q* i9 u
  11. {0 _! T- r) g( S9 w; ^5 i; s
  12.     uint8_t TX_DATA = byte;3 K( R  }8 i0 Y: [3 @' R1 i$ m
  13.     uint8_t RX_DATA = 0;
    " B6 z2 ~- b# S% {5 F
  14.     HAL_SPI_TransmitReceive(&hspi1, &TX_DATA ,&RX_DATA , 1, 1000);  k& b2 R" V' H5 G8 v
  15.     return RX_DATA;3 n3 z( ?! A; ]6 x8 t& s9 X4 u
  16. }
    / G, ]4 K( J% f

  17. % [* v7 A1 l; L3 k, c+ t7 _
  18. /*等待擦除或者写数据完成*/
    * Y+ B; f. C5 B3 F4 p
  19. void sFLASH_WaitForEnd(void)
    + U5 E6 M, E$ x, L2 n$ V
  20. {
    1 [5 r0 O1 w8 A; }, `3 o' b
  21.     uint8_t sr_value = 0;) L6 c% u& F# P3 E
  22.     sFLASH_CS_LOW();- a8 |3 `, b. l% X
  23.     sFLASH_SendByte(sFLASH_CMD_RDSR);& t" C$ l, m5 x6 r5 W- f0 q
  24.             //读S0的值,为1表示忙碌,为0表示停止         
    8 F) ^& @5 x% S. d
  25.     do{4 T0 [* S: e/ b4 A  L
  26.                 //发一个空字节,得到S0的值            
    7 I5 f# a1 {3 p$ h! H+ e$ f
  27.                 sr_value = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
    / y0 D5 s( |+ s, X7 P1 q
  28.     }while( sr_value & sFLASH_BUSY_FLAG);
    " j! I4 r# f  C# \4 ~- Z0 z; o
  29. ( S: R# U( I2 z& _; ~
  30.     sFLASH_CS_HIGH();
    * U: x% w$ ]: t7 |' h( f6 w
  31. }- _- N: o1 D2 J9 v8 \

  32. ( i5 u9 ~8 u1 d, I8 I  A4 F
  33. void sFLASH_WriteEnable(void)
    ( J1 k5 ^, @$ j+ R
  34. {6 A& L( X* o. C) K, z
  35.     sFLASH_CS_LOW();
    ; o5 t- a3 V. F
  36.    
    1 \& `9 s1 C$ U8 L1 s3 U2 ^0 v$ g! c
  37.     sFLASH_SendByte(sFLASH_CMD_WREN);
    1 s7 B6 V9 q# ]. Y. M( W
  38.     $ J% O! h7 l# \
  39.     sFLASH_CS_HIGH();
    5 b1 o0 L* s8 M, h# H: f( M) q
  40. }3 ?2 A- {# B6 n5 O0 P# z

  41. 6 n1 ~- j8 j: d4 f  N4 @8 S
  42. 1 p  M0 W$ ^9 J
  43. /*读设备ID*/ . ~9 Y8 F1 Q" p; H* [5 i
  44. uint16_t sFLASH_ReadID(void)/ j* h6 @! z: V4 y& _5 b
  45. {
    0 |& y: G# J. Y: ^
  46.     uint16_t FLASH_ID;2 s  f, n1 u5 j, P4 h& l, v, ~
  47.     uint8_t temp0,temp1;1 V- ^& k' ]0 c% P2 `, G& \9 f5 V
  48.    
    ' Z$ T! M! ^; A7 b& t
  49.     ! U7 ?$ ]) {7 z! c2 i
  50.     sFLASH_CS_LOW();9 p: m# c. u) S( R+ V
  51.     ' F. @4 G3 a. T# h  J
  52.     sFLASH_SendByte(W25X_ManufactDeviceID);1 A+ G& X$ D: S3 n
  53.     //读设备指令后要发24位地址,所以要发三次7 l  ?- |4 E0 q! x; V% L- U2 B
  54.     sFLASH_SendByte(sFLASH_DUMMY_BYTE);' K: j6 ~. @5 M
  55.     sFLASH_SendByte(sFLASH_DUMMY_BYTE);" Z& X  p+ M7 n
  56.     sFLASH_SendByte(sFLASH_DUMMY_BYTE);
    " H$ A$ e4 y2 E0 s9 t
  57.     //制造商ID( Y6 b! D; m& ~% K* C
  58.     temp0 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);. m3 ]! S7 y1 h, _7 c5 Z3 j& `; n
  59.     //设备商ID
    $ t2 ^; P7 ~# J
  60.             temp1 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
    " y2 y6 G# {, [6 a
  61.     ) Q: [# @, G) T- U1 a% e% a4 f
  62.     sFLASH_CS_HIGH();" T5 l2 T. N, C2 p' x
  63.    
    - q( A7 C$ _6 ~% S8 d6 L& ?
  64.     FLASH_ID = (temp0 << 8) | temp1;+ H: U/ X0 u& f7 p; r; t
  65.     $ J- H# f+ p5 l- M' k) k* `
  66.     return FLASH_ID;
    6 G% r# L& `0 \  u+ t0 z$ I
  67. }6 x0 k! X' e9 v* p0 I$ l
  68. * V, i0 |" K, z+ j2 ]& n
  69. //擦除扇区,擦除为1,因为只能由1变为0 ,不能0变1
    3 c$ N" l+ e$ ~  o- i) L, z
  70. void sFLASH_EraseSector(uint32_t SectorAddr)
    0 \* f' V; f3 c( M0 p
  71. {" ~3 [4 m! t# r  Y$ z3 W& P& @9 n5 W5 M
  72.     //SectorAddr表示擦除第几个扇区
    " J5 M- a9 {( v6 u& E4 Z5 r
  73.     sFLASH_WriteEnable();  //开启写使能2 y  {$ x6 E  s" M4 g) K' h
  74.     sFLASH_CS_LOW();//拉低,片选' B# W! b$ U  W
  75.     //擦除命令
    9 \, X1 l9 j, K& U1 |, P
  76.     sFLASH_SendByte(sFLASH_CMD_SE);& D8 B8 d" [9 a0 r3 y, d
  77.             //传24位地址$ W3 G% p: F+ T
  78.             //传送高8位,将中8位和低8位一共16位移出去,得到高8位                  
    ( I( S$ y* H$ R; R
  79.     sFLASH_SendByte( (SectorAddr>>16) & 0xff);   3 Z5 C" z& M" I" ?. A+ y
  80.     sFLASH_SendByte( (SectorAddr>>8) & 0xff);    //传送中8位
    . }; v0 N: v  C, I/ }  Z" X
  81.     sFLASH_SendByte( (SectorAddr>>0) & 0xff);    //传送低8位" @1 g4 P2 g/ @( w- e: v  N) b" u
  82.      ) {- n7 b3 E  W- F
  83.     sFLASH_CS_HIGH();; N3 {. K8 G9 ~. X" r+ K' M+ R
  84.    
    2 M3 Z' j7 A- M2 `2 B2 Q* m# S% S
  85.     /*读状态寄存器,等待擦除完成*/! I! r% _- s' u
  86.     sFLASH_WaitForEnd();
    & R6 `. W# N8 h# Z4 Q& n
  87. }
      s1 p) |, ^4 y" O. F* j
  88. ) g7 Q* l4 e% v$ U6 O' b
  89. //读数据4 G' @1 C8 P" A! f2 u
  90. //读命令和读地址发送后,芯片内部会自动不断递增读数据/ \  E/ I: m  y2 p* z6 y5 Q* @, [8 }
  91. void sFLASH_ReadBuffer(uint8_t* pBuffer, uint32_t ReadAddr, uint32_t NumByteToRead)0 C: ~/ {/ A- K& j  Y) M* z$ `
  92. {
    : `' l9 ]/ N1 B7 i: U& a
  93.     sFLASH_CS_LOW();- c7 A/ R& p4 P. z5 O* h& |, }3 w
  94.     2 {" W, M, V! p( N8 l+ U8 n! N3 @8 n
  95.     sFLASH_SendByte(sFLASH_CMD_READ);
    9 p6 G7 o1 u& K# Q
  96.     sFLASH_SendByte( (ReadAddr>>16) & 0xff);   //传送高8位
    2 P4 T) [9 i+ d4 b4 P& @) U: Z
  97.     sFLASH_SendByte( (ReadAddr>>8) & 0xff);    //传送中8位' z9 F0 @% O" e9 i
  98.     sFLASH_SendByte( (ReadAddr>>0) & 0xff);    //传送低8位. X% H+ Z5 u& R' L' I: b; B! m8 K
  99.     9 A& j* m% ]: T3 `5 l9 Y' ?
  100.     while(NumByteToRead--)
    ; H! t1 M0 @  ^' {8 B- [% Q0 y
  101.     {8 \' x4 @+ m2 r' j
  102.     * pBuffer = sFLASH_SendByte(sFLASH_DUMMY_BYTE);8 L1 V9 j8 P" ~, K+ ]
  103.     pBuffer++;5 j0 p% `  V. r& l/ g; r
  104.     }/ N& z* p+ Q1 P  n
  105.    
    * q) {# d, e& u& G
  106.     sFLASH_CS_HIGH();7 e% s3 G/ F0 ^1 j8 J
  107. }1 w7 ~" k; M! f3 ^/ v

  108.   u) g/ s) v1 H+ @
  109. //写一页最多只能写256个字节,一个扇区16页,一个块16个扇区                               3 E2 y* W9 o, l6 z: c/ G0 g
  110. void sFLASH_WritePage(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite)
    6 J% O/ s4 U$ q) k1 q# R0 b+ t
  111. {7 w5 x  I! _  j+ P
  112.     if(NumByteToWrite > sFLASH_SPI_PAGESIZE ). _; \: s- c! K  H
  113.     {
    % m8 |; w9 v' K3 x* l
  114.     NumByteToWrite = sFLASH_SPI_PAGESIZE;
    8 W% m0 ^2 a( H& Q1 R4 {
  115.     3 |, D7 B$ G3 N! C
  116.     printf("写数据量过大,超过一页大小\n");
    " [) h/ o8 b( J2 l1 v1 K1 j. X
  117.     }2 \7 X4 l5 K. y$ P  Z; D& ?
  118.    
    4 D2 S% R+ `0 v6 `, _
  119.     sFLASH_WriteEnable();  //开启写使能
    0 s  G3 C4 ^! f3 o' ?
  120.    
    " N+ y/ Y2 m. ~. G" x4 `8 _
  121.     sFLASH_CS_LOW();) `4 q, _: Q" M6 `( z' y
  122.     % w0 I7 w! \' r$ k# Y0 u: S) L' h
  123.     sFLASH_SendByte(sFLASH_CMD_WRITE);
    2 R* m4 C, v+ w0 R9 r
  124.     sFLASH_SendByte( (WriteAddr>>16) & 0xff);   //传送高8位
    2 h( @2 F+ m3 S/ R6 H- r
  125.     sFLASH_SendByte( (WriteAddr>>8) & 0xff);     //传送中8位
    1 k- [: s. S3 y; H3 Y; y- z0 [
  126.     sFLASH_SendByte( (WriteAddr>>0) & 0xff);      //传送低8位
    + d: x& C& b0 n" E& _
  127.     6 H5 M2 g, o& q+ g/ k1 E
  128.     while(NumByteToWrite--)0 U- i1 {$ R6 _
  129.     {8 _4 B/ X  W9 w& Y; `
  130.     sFLASH_SendByte(* pBuffer);1 j8 `- l/ u; X& a; i
  131.     pBuffer++;8 ~  q  H% p7 }
  132.     }8 z" O% c) k7 ~" J
  133.     ; B5 g$ q2 P4 K' v8 B5 N
  134.     sFLASH_CS_HIGH();6 Z' }% v* i9 \+ v
  135.     8 U$ Z( K7 _$ C8 o  `) E8 ?( o7 Q2 p
  136.     /*擦除和写数据都涉及到写动作,一定要等待完成*/9 v8 S' h2 ?5 ~& X9 B- K
  137.     sFLASH_WaitForEnd();
    & j7 Y  E6 f; z4 x5 m
  138. }
    3 z: n! X* V7 W1 n6 p+ n" t

  139. % a8 @0 s( o, `
  140. //写任意地址、任意长度9 K3 x# P5 d6 R) E- r
  141. void sFLASH_WriteBuffer(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite)
    ' F1 \0 m; N, Z& E; [; C
  142. {/ ^( `2 y1 o6 z4 G, G( x4 M
  143.     uint16_t NumOfPage, NumOfBytes, count, offset;7 N  L  x  G, p
  144.     //求WriteAddr在某一页的位置        
    / Z8 r# j6 D5 r# @& k
  145.     offset = WriteAddr % sFLASH_SPI_PAGESIZE;
    / [% `, Y. ]' I7 W: k/ i( X$ L
  146.     //求某一页剩余的大小 & m% ?& O- B7 x" z
  147.     count = sFLASH_SPI_PAGESIZE - offset;
    $ W' p! L+ X* i* F
  148.     8 Y( [2 D) J+ j
  149.     /*处理页不对齐的情况,防止页内覆盖*/' W' {/ e3 D, d6 {4 v7 K3 ~! E
  150.     //先把某一页剩下的部分写掉,之后的就能新页的起始处开始写        /*offset有值表示需要页对齐,如果要写的字节数小于某一页剩余的部分,那就无需对齐*/                  
    ( G3 _0 _* O  s/ d
  151.     /*这两个条件必须同时满足*/  Q' `3 U# V* Z( v( G
  152.     if(offset && (NumByteToWrite > count ))# ]$ O1 Z3 f, U
  153.     {0 P9 C2 e5 h( S
  154.     sFLASH_WritePage(pBuffer,WriteAddr,count);
    ; U( z0 r' G7 X* f; k
  155.     NumByteToWrite -= count;//去掉已经写了的,从新页开始& w# d+ D% a5 l- _$ o0 W# l2 g) G7 f# ]
  156.     pBuffer += count;& b. T4 O2 A. o  M8 _
  157.     WriteAddr += count;, H$ t; f/ I: p; W8 ?' u1 Q
  158.     }
    6 j( n9 e5 J- K7 w6 c" I/ w
  159.     1 w( s& j$ k. u& L
  160.     /*最多可分多少页*/; o7 ^0 o2 X9 I
  161.     NumOfPage = NumByteToWrite / sFLASH_SPI_PAGESIZE;+ `) r1 u; O' u! }
  162.     /*剩余多少字节*/
    2 f3 B( r% C/ R2 b
  163.     NumOfBytes = NumByteToWrite % sFLASH_SPI_PAGESIZE;
    ) ~2 R1 d0 b$ i! G: ~: o8 j
  164.     1 c" L* m0 {; K2 Y3 l6 D
  165.     if(NumOfPage)& l5 z3 Q9 L1 _$ U) S  j
  166.     {
    ' F* ]6 e3 @8 M: n' {( `
  167.         while(NumOfPage--)
    % H% o1 t4 L1 i1 N1 o. Z0 \
  168.         {, Q( t$ Z; G$ `( d9 ]( F3 x% y4 M
  169.              //每一页都发起页编程
    - g: i! Y6 M+ E
  170.              sFLASH_WritePage(pBuffer,WriteAddr,sFLASH_SPI_PAGESIZE);4 h4 `3 P% @( `# O( ]0 e) k7 \
  171.              pBuffer += sFLASH_SPI_PAGESIZE;
    8 v) I' t. }1 g; y* O5 U
  172.      WriteAddr += sFLASH_SPI_PAGESIZE;
    4 f/ c2 P) Z! E( _; t( E& v0 g4 |
  173.          }
    4 n# J) W5 _6 `9 c% g; C7 O
  174.     }
    0 L1 f% g: m0 Z3 ], d
  175.     2 ?# a/ i$ q& F% s. g, R$ `! _8 A& v
  176.     if(NumOfBytes)# J9 G6 T9 o7 T$ M/ h1 M
  177.     {
      a) A" R/ D" h% E, ?2 G  u
  178.     sFLASH_WritePage(pBuffer,WriteAddr,NumOfBytes);
    . W- g4 M! D4 G, p# B! r1 h
  179.     }
    ( w8 V, c) i6 C* ^
  180. }
复制代码

$ B* L, X1 c& g7 C# |+ ]5 W
  • 为什么会有两种写操作函数,是因为这里的写操作有两个特点:
      L8 p( R3 v7 O; @! l7 \% g
    , g5 Z" H* d4 A( }
" l0 N+ \/ r# S. Z0 V# ?
1.无法突破页限制,超过一页需要重新发起页编程信号。另外如果要写的数据大于剩余一页剩余的容量,那么超出的数据会写到当前页起始地址出。例如,初始输入的写地址为200,而要写的数据大小为100,那么要写的前56个字节会从地址200开始依次写入,剩下的44个字节会从当前页的0地址开始依次写入,这很有可能覆盖之前的数据。
" X6 x) ~  g4 d) k. G5 t$ @
2.无法突破扇区的限制,当数据写到一个新的扇区的时候,需要重新发起一个页编程信号才能继续写入数据。
# Z; c* e( I. G
转载自: 骆驼听海6 }6 s4 Z/ |! `" O2 m5 i7 }
如有侵权请联系删除( [% I) }- Y5 F  D6 i8 N; o; X6 M+ G
) q  K3 }9 }& Q- M* K* o( n
赞 收藏 评论0 发布时间:2023-4-12 16:18

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版