3 d" Z# d8 {7 l0 W
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
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
. 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
# 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
# A/ R) |2 z# t& W4 j7 M3 B
a.主设备向从设备写数据:
7 ~+ {! s. S4 ~; c
! {2 n. X% q! y* h& |" S( {
b.主设备读从设备的数据:
; D8 r4 L4 X" B2 ]& F0 f5 [; M. P
% U% d: P1 D/ N1 m! V' u
c.主设备读从设备的某个寄存器:读设备的寄存器首先应该对该设备发送写命令,很多设备都可以看成是一段内存,所以写命令写给从设备,指明要读取哪个地址(寄存器)的数据,接下来才是真正的读数据。不同的从设备是由区别的,在驱动I2C从设备时应当查明设备的时序图,又怎样的要求,不同的时序对应了不同的命令。
! b/ M1 H! _7 ]* ^, ~+ w1 y! M 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
% @! 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
! 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
2 r0 M! c( L, k- v
24C65的电气连线如下,根据电气连线可知,A0-A2均接地,因此读地址为1010 0001,即0xA1;写地址为10100000,即0xA0 ,且WP接地,用户随时可向芯片内部写入数据。 # R* C+ X+ u2 s _+ z. ?2 s
; 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- |
: ~( s& k' B, A* N$ A% ]
24C65 读时序与写时序基本相同,只不过在读之前要发送再发送重复开始位进行读操作。 ; ^* s# D, Q# _5 a
) 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& {
- D# v) } R" E7 ^. p l$ t
3.配置I2C协议参数
$ R( ` m: m% N" j
/ X. Z' c, G8 s( Y3 n1 W- p
4.编写代码 - " _9 B) Z9 ]9 p2 l% A
- //mian.c* H0 s: n! k* w# z& U
- 6 t4 d: h: y7 G5 _3 s6 h
- #include "main.h", x! L0 }3 ^. H( K C+ j+ A
- #include "stm32f4xx_hal.h"4 J; D* G- \) s' P) s8 O3 {
- #include "i2c.h"( \+ |0 Q( ^; o6 K0 K
- #include "usart.h"9 C! Y3 c$ \0 ?, e5 ^' [( t( o6 C
- #include "gpio.h"
A7 y4 Z1 ^! j: ]* F0 ~$ q
6 ]7 K5 G" K0 A$ W- #define ReadAddr 0xA19 Z {3 Y, M, g2 y& f/ c0 j
- #define WriteAddr 0xA0
w- h y& i4 f - " m" n8 O2 h4 B1 D
- uint8_t Wbuf[20] = "EEPROM TEST OK!";, ^ @9 _) p- a0 D; N h3 I
- uint8_t Rbuf[20] = {0};
& W v* J/ l! L7 f( R3 T- g
/ s+ s. g+ s+ V9 A- Y" U& H- /********* 24C65写数据函数*****************************/- [; y( I. @5 c4 m/ J2 l
) M/ Y' `; k) A& Q l0 _7 X$ |- void Eeprom_Write(uint16_t MemAddr, uint8_t *Wbuf, uint16_t len ){) Y3 X; Q p$ V1 l, J, b5 K9 C
- while(len--){3 k. l, y8 j2 N* O
- //I2C_MEMADD_SIZE_16BIT表示存储单元大小9 T( u R$ K: f5 ~1 L9 `
- //默认为两个参数,分别是I2C_MEMADD_SIZE_16BIT和I2C_MEMADD_SIZE_8BIT
+ b* ^. f2 l. Z! g/ X - //由于24C65的存储地址是16位的
9 x6 k- `: j) b- F - //所以我们选择I2C_MEMADD_SIZE_16BIT9 Y, w% z) n" p e* g" [
- //1表示一次写一个字节 ^4 L3 u* o' b( I' g f& O
- 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 - MemAddr++;) y- S* _9 b U4 H/ v. V) }" }/ u+ Q* @5 F
- Wbuf++;
% Q6 ^: x4 P! A& i$ r0 }9 }- a - }
( ]- m o6 l% X |$ m - }
X9 ~& q3 |, j: r, H
# s7 O: K+ _- O0 n, k* B& a5 `+ {
% a8 l" k/ m8 N) Z. z1 n. _: T- /********* 24C65读数据函数*****************************/
0 L! y9 n C$ S7 U - , i7 `5 p. Q4 d6 O) t- M U
- void Eeprom_Read(uint16_t MemAddr, uint8_t *Rbuf, uint16_t len ){, S4 T8 \7 E6 G& R3 U9 E4 A0 Y L
- //可以连续读,所以无需循环! S2 j) n1 R: | j9 r, F9 ?
- while(HAL_I2C_Mem_Read(&hi2c1, ReadAddr, MemAddr, I2C_MEMADD_SIZE_16BIT, Rbuf, len, 100) != HAL_OK );
4 \/ d" C) C. j, a - }1 e! ]1 ?0 W0 k$ {! ~# ^
- int mian(){% m4 s% x$ ? j( \3 ~. p
- MX_GPIO_Init();) x4 v, }/ B7 f1 b) l2 y9 L) {
- MX_I2C1_Init();
3 }+ w3 q3 Q* ]8 p: ] - MX_USART1_UART_Init();
B( {! F! y5 b; R0 _! ~$ F - printf("this is i2c eeprom test\n");
( {+ T; k/ E6 ^& _/ z - " |9 T m2 B- U
- Eeprom_Write(0, Wbuf, sizeof(Wbuf) );8 [- r- W7 g4 I0 g# ]" T$ N
- HAL_Delay(500);
" R: P* V* u S4 _! h( ~, b/ [$ _ - Eeprom_Read(0 , Rbuf, sizeof(Rbuf));
' R9 c5 v9 Z. W4 x9 \! F$ d7 S - printf("READ: %s\n", Rbuf);' Y. v5 l! v6 }2 y: u% b1 T0 ~
- 1 k: U% p9 D" h) C; L
- while(){2 G7 ^8 e Q- Q
- - E% I) J6 E) }; a* S. @* F
- }, z& _ l- E. `. _3 C7 p8 [
- }
复制代码
" 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
/ a: c7 G# Q- ~% |
SPI接口共有4根信号线,分别是:设备选择线、时钟线、串行输出数据线、串行输入数据线。
% B6 d5 l2 J9 e; `; O1 X7 s
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
( _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: |
; 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
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
7 v ~5 m* N7 I
STM32F4-SPI控制器特性
' N" e6 n: n- K& E' f
- 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
* 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
' 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
. Q9 t/ O" J8 [8 s. p# S# W% \
1.W25X16的硬件连线如下:
7 x a- f6 \; [( L* Y( W! v 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" ]
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# {
v8 \, H) ]9 ^
b.写使能命令(06H):在向 FLASH 芯片存储矩阵写入数据前,首先要使能写操作,通过“Write Enable”命令即可写使能。 2 l" m) F3 s& v. m2 B
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( @; _
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
1 F- u# O. n I& ?2 q0 P# t' I" \( G7 {" L: \' u/ a4 P% T: }
e.读数据(03H):读数据指令可从存储器依次一个或多个数据字节,该指令通过主器件拉低/CS电平使能设备开始传输,然后传输“03H”指令,接着通过DI管脚传输24位芯片存储地址,从器件接到地址后,寻址存储器中的数据通过DO引脚输出。每传输一个字节地址自动递增,所以只要时钟继续传输,可以不断读取存储器中的数据。 / T! r' x) \& G/ F
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 ~
' 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
; p* | O0 d4 Y# |
步骤: 1.使能时钟RCC
" i' W+ j2 c! A k* Z' ^
2.使能SPI1,配置相应管脚 ) d/ I; _7 ~: l6 Q; r) r
" _ K1 L# O: Q6 @: b1 d. c
9 B9 r, Q2 `5 z; Y! A0 H0 x" C
3.配置SPI协议
$ X4 _* ~% V$ W0 ^, A# |0 P3 D3 P. I+ w3 _) X+ X3 ?0 u* @
- //main.c
1 i- A& j( Z# E2 b8 x2 @ - & J* ?9 ?" \5 u
- #include "w25x16.h"7 f. s- P& A' b/ G2 f1 r. D
- , N$ B& Y5 E+ ~; J$ b m" h
- uint8_t RD_Buffer[5000] = {0};
8 q ]9 F/ U8 o$ o. ]9 _ - uint8_t WR_Buffer[5000] = "SPI FLASH WRITE TEST\n";5 F8 v4 j- n6 ~- k* L
- 3 n6 s+ f0 w# G/ |1 w) f+ f1 E
- int main(){3 n: }& I% c% [3 u- ?: L! _
- uint16_t FLASH_ID = 0;$ A' J- }- r! Y/ c- R5 ^% F4 @& _
- uint32_t i;
' G; z$ B. d3 Y - , K' l+ v% p5 ~: L" I L. `6 V
- MX_GPIO_Init();( W4 ]. C& U5 R+ d* t
- MX_SPI1_Init();
/ ]2 U& K5 `5 E' [( U1 L+ u/ v5 X - FLASH_ID = sFLASH_ReadID();- v3 t+ e& t8 b3 C; f3 i
- ' }) C/ m7 u# `7 e" ]
- /******测试擦除******/( @; u# t/ r' K" O3 U, l6 f
- sFLASH_EraseSector(4096*0);
) Z8 X# t) l5 B. W% S - //sFLASH_EraseSector(4096*1);
0 p( b' s9 w' y n0 ^% ^: i/ w9 s - sFLASH_ReadBuffer(RD_Buffer,0,4096);
. C- B6 D) e* ]) N3 \( t! ` | - printf("读数据开始\n");1 g8 e5 d b5 ]$ m5 w
- for(i=0; i<4096; i++)
x: P% @; w. f0 H7 M( R* ]6 b - {# d$ X/ b! M- P1 r j
- printf("%x ",RD_Buffer[i]);/ w( n: e$ w* B. n$ v/ u
- }
$ k3 R" `6 G- m - printf("读数据结束\n");
: ^& k9 M( H; L - : C% }. |# u* ^4 X* d
- + P4 Q" G! a" ?) w
- /******测试写操作1*****/$ N3 B7 ]& K0 [' N
- //写之前都需要擦除扇区" ^) `4 S! d9 G2 p
- sFLASH_EraseSector(4096*0);
7 G& {+ H" p' o/ G - sFLASH_WritePage(WR_Buffer,0, 20);
* T& ?! z( m; V+ X) s0 ] - sFLASH_ReadBuffer(RD_Buffer,0,20);7 p' v1 V! g; @1 F5 p# r
- printf("READ DATA: %s\n",RD_Buffer);
) w0 x2 X/ e( B; Q/ L3 u2 F - $ J% U5 [2 \: w( u# M
- /******测试写操作2*****/# O" d0 S, E, Y0 G, G3 Y
- //写之前都需要擦除扇区
% g, |1 k6 b1 ?- t9 @6 q. K% M - sFLASH_EraseSector(4096*0);
! G" }" |" G- |- G - sFLASH_EraseSector(4096*1); 8 x6 O$ C4 e' b
- for(i=0; i<4096; i++)/ [3 @& `& H! L0 r6 i
- {5 r5 t8 I9 n5 N
- WR_Buffer[i] = 0x55;
) R& D) E1 A8 U' p* } - }0 C+ c9 {4 H g! X9 j
- sFLASH_WriteBuffer(WR_Buffer,4090, 1000);/ H/ o9 L: C! s
- sFLASH_ReadBuffer(RD_Buffer,4090,1000);' |/ ]7 h8 n/ n+ u
- for(i=0; i<1000; i++)9 z% E% C: i) q; |6 l
- { |$ u" `+ J$ P- @& d1 I( c
- printf("%x ",RD_Buffer[i]);; v$ I' {- m; ^4 v; q& Z0 I" r
- }
9 w# H4 d/ `! A! B - /*****************/5 s2 y: S7 s& a$ D4 Q" B
- while(){}
, Q V4 k& u8 G2 j1 H; d - }
复制代码- //w25x16.h. I/ y2 [+ }; F4 u! X9 j) D$ G
' x2 j1 B0 V; | k- #ifndef __W25X16_H
( w) V4 A, _* W+ V5 m - #define __W25X16_H. ]7 j. n1 u3 I2 [
# W# Y$ ^0 J+ q4 j+ B- #include "stm32f4xx_hal.h"$ ~8 Y9 y; v0 R
9 U: X9 ?" e7 h# i. N2 g- //使用宏定义芯片指令3 ?. y; I8 g" q, d/ O" \
- #define W25X_ManufactDeviceID 0x90 /* Read identification */
' @+ i2 v1 M9 F& r - #define sFLASH_CMD_WREN 0x06/* Write enable instruction */
& U2 Y+ [9 U: C. p+ k4 y, u$ s* C; G - #define sFLASH_CMD_RDSR 0x05/* Read Status Register instruction */% ?! h% R, Y' ]' b
- #define sFLASH_CMD_SE 0x20/* Sector Erase instruction */% h) I, k: t9 g/ z+ V% Y8 ^
- #define sFLASH_CMD_WRITE 0x02 /* Write to Memory instruction */, d6 K' s! e. k. h9 [+ M8 f
- #define sFLASH_CMD_READ 0x03/* Read from Memory instruction */, D% \ q( q; s9 f! a1 b* f
- #define sFLASH_DUMMY_BYTE 0x00 //空字节,用于只读传回来的数据
# Y) o2 S: w. g3 b- X4 c - #define sFLASH_BUSY_FLAG 0x019 j) M0 b- [) b( P8 @9 T; Z; p
- #define sFLASH_SPI_PAGESIZE 0x100$ F8 J. c1 M; \
- 9 y, ~* J* i7 J) d+ b9 p+ q) K
- /* 选中芯片,拉低信号 */5 u& u1 O8 W, x
- #define sFLASH_CS_LOW() HAL_GPIO_WritePin(GPIOH,GPIO_PIN_2,GPIO_PIN_RESET)6 ~6 L! n6 `. u5 s
- /* 释放芯片,拉高信号 */# Y7 }+ J" Z, P7 D. `" x
- #define sFLASH_CS_HIGH() HAL_GPIO_WritePin(GPIOH,GPIO_PIN_2,GPIO_PIN_SET)
. @. Q- O4 \9 I) d3 s9 ` - : z: ]0 _1 x p1 S: c! E) E
- //定义函数7 @1 r! T$ z8 M7 `
- uint8_t sFLASH_SendByte(uint8_t byte);
- x* h3 h0 S$ M, e - uint16_t sFLASH_ReadID(void);& @ Z5 H# M% A( t3 o
- void sFLASH_EraseSector(uint32_t SectorAddr);! k9 E* ]& G, I- ^) g
- void sFLASH_WriteBuffer(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite);
$ }- W" p3 C5 `& R0 _: ^' M" U - void sFLASH_WritePage(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite);
$ ]' } X7 A( c+ q; w) _8 O - void sFLASH_ReadBuffer(uint8_t* pBuffer, uint32_t ReadAddr, uint32_t NumByteToRead);
y/ w2 t" y5 w, q, D% g - #endif
复制代码
7 S3 @1 r% C& t1 ]% h7 o4 f- //w25x16.c& d$ D$ r/ L9 Q" k& W* k
- 9 s8 Y7 z- N& q+ o
- #include "w25x16.h"# i3 _$ J. `+ n. {# N
- 3 L% c/ h: |% V ~5 G# f7 @
- extern SPI_HandleTypeDef hspi1;6 B! t4 f3 U# |3 g# E" K5 h! H# X
- " H# G. l* P: C; J
- /*读写一个字节函数,因为SPI读和写同时完成*/
( D0 p4 y( h2 y7 T5 I% f. p. A - /*发送数据一定会接收到一个数据*/% y" v5 X- O3 H# u& {
- uint8_t sFLASH_SendByte(uint8_t byte)4 j5 ]6 t# k! q* i9 u
- {0 _! T- r) g( S9 w; ^5 i; s
- uint8_t TX_DATA = byte;3 K( R }8 i0 Y: [3 @' R1 i$ m
- uint8_t RX_DATA = 0;
" B6 z2 ~- b# S% {5 F - HAL_SPI_TransmitReceive(&hspi1, &TX_DATA ,&RX_DATA , 1, 1000); k& b2 R" V' H5 G8 v
- return RX_DATA;3 n3 z( ?! A; ]6 x8 t& s9 X4 u
- }
/ G, ]4 K( J% f
% [* v7 A1 l; L3 k, c+ t7 _- /*等待擦除或者写数据完成*/
* Y+ B; f. C5 B3 F4 p - void sFLASH_WaitForEnd(void)
+ U5 E6 M, E$ x, L2 n$ V - {
1 [5 r0 O1 w8 A; }, `3 o' b - uint8_t sr_value = 0;) L6 c% u& F# P3 E
- sFLASH_CS_LOW();- a8 |3 `, b. l% X
- sFLASH_SendByte(sFLASH_CMD_RDSR);& t" C$ l, m5 x6 r5 W- f0 q
- //读S0的值,为1表示忙碌,为0表示停止
8 F) ^& @5 x% S. d - do{4 T0 [* S: e/ b4 A L
- //发一个空字节,得到S0的值
7 I5 f# a1 {3 p$ h! H+ e$ f - sr_value = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
/ y0 D5 s( |+ s, X7 P1 q - }while( sr_value & sFLASH_BUSY_FLAG);
" j! I4 r# f C# \4 ~- Z0 z; o - ( S: R# U( I2 z& _; ~
- sFLASH_CS_HIGH();
* U: x% w$ ]: t7 |' h( f6 w - }- _- N: o1 D2 J9 v8 \
( i5 u9 ~8 u1 d, I8 I A4 F- void sFLASH_WriteEnable(void)
( J1 k5 ^, @$ j+ R - {6 A& L( X* o. C) K, z
- sFLASH_CS_LOW();
; o5 t- a3 V. F -
1 \& `9 s1 C$ U8 L1 s3 U2 ^0 v$ g! c - sFLASH_SendByte(sFLASH_CMD_WREN);
1 s7 B6 V9 q# ]. Y. M( W - $ J% O! h7 l# \
- sFLASH_CS_HIGH();
5 b1 o0 L* s8 M, h# H: f( M) q - }3 ?2 A- {# B6 n5 O0 P# z
6 n1 ~- j8 j: d4 f N4 @8 S- 1 p M0 W$ ^9 J
- /*读设备ID*/ . ~9 Y8 F1 Q" p; H* [5 i
- uint16_t sFLASH_ReadID(void)/ j* h6 @! z: V4 y& _5 b
- {
0 |& y: G# J. Y: ^ - uint16_t FLASH_ID;2 s f, n1 u5 j, P4 h& l, v, ~
- uint8_t temp0,temp1;1 V- ^& k' ]0 c% P2 `, G& \9 f5 V
-
' Z$ T! M! ^; A7 b& t - ! U7 ?$ ]) {7 z! c2 i
- sFLASH_CS_LOW();9 p: m# c. u) S( R+ V
- ' F. @4 G3 a. T# h J
- sFLASH_SendByte(W25X_ManufactDeviceID);1 A+ G& X$ D: S3 n
- //读设备指令后要发24位地址,所以要发三次7 l ?- |4 E0 q! x; V% L- U2 B
- sFLASH_SendByte(sFLASH_DUMMY_BYTE);' K: j6 ~. @5 M
- sFLASH_SendByte(sFLASH_DUMMY_BYTE);" Z& X p+ M7 n
- sFLASH_SendByte(sFLASH_DUMMY_BYTE);
" H$ A$ e4 y2 E0 s9 t - //制造商ID( Y6 b! D; m& ~% K* C
- temp0 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);. m3 ]! S7 y1 h, _7 c5 Z3 j& `; n
- //设备商ID
$ t2 ^; P7 ~# J - temp1 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
" y2 y6 G# {, [6 a - ) Q: [# @, G) T- U1 a% e% a4 f
- sFLASH_CS_HIGH();" T5 l2 T. N, C2 p' x
-
- q( A7 C$ _6 ~% S8 d6 L& ? - FLASH_ID = (temp0 << 8) | temp1;+ H: U/ X0 u& f7 p; r; t
- $ J- H# f+ p5 l- M' k) k* `
- return FLASH_ID;
6 G% r# L& `0 \ u+ t0 z$ I - }6 x0 k! X' e9 v* p0 I$ l
- * V, i0 |" K, z+ j2 ]& n
- //擦除扇区,擦除为1,因为只能由1变为0 ,不能0变1
3 c$ N" l+ e$ ~ o- i) L, z - void sFLASH_EraseSector(uint32_t SectorAddr)
0 \* f' V; f3 c( M0 p - {" ~3 [4 m! t# r Y$ z3 W& P& @9 n5 W5 M
- //SectorAddr表示擦除第几个扇区
" J5 M- a9 {( v6 u& E4 Z5 r - sFLASH_WriteEnable(); //开启写使能2 y {$ x6 E s" M4 g) K' h
- sFLASH_CS_LOW();//拉低,片选' B# W! b$ U W
- //擦除命令
9 \, X1 l9 j, K& U1 |, P - sFLASH_SendByte(sFLASH_CMD_SE);& D8 B8 d" [9 a0 r3 y, d
- //传24位地址$ W3 G% p: F+ T
- //传送高8位,将中8位和低8位一共16位移出去,得到高8位
( I( S$ y* H$ R; R - sFLASH_SendByte( (SectorAddr>>16) & 0xff); 3 Z5 C" z& M" I" ?. A+ y
- sFLASH_SendByte( (SectorAddr>>8) & 0xff); //传送中8位
. }; v0 N: v C, I/ } Z" X - sFLASH_SendByte( (SectorAddr>>0) & 0xff); //传送低8位" @1 g4 P2 g/ @( w- e: v N) b" u
- ) {- n7 b3 E W- F
- sFLASH_CS_HIGH();; N3 {. K8 G9 ~. X" r+ K' M+ R
-
2 M3 Z' j7 A- M2 `2 B2 Q* m# S% S - /*读状态寄存器,等待擦除完成*/! I! r% _- s' u
- sFLASH_WaitForEnd();
& R6 `. W# N8 h# Z4 Q& n - }
s1 p) |, ^4 y" O. F* j - ) g7 Q* l4 e% v$ U6 O' b
- //读数据4 G' @1 C8 P" A! f2 u
- //读命令和读地址发送后,芯片内部会自动不断递增读数据/ \ E/ I: m y2 p* z6 y5 Q* @, [8 }
- void sFLASH_ReadBuffer(uint8_t* pBuffer, uint32_t ReadAddr, uint32_t NumByteToRead)0 C: ~/ {/ A- K& j Y) M* z$ `
- {
: `' l9 ]/ N1 B7 i: U& a - sFLASH_CS_LOW();- c7 A/ R& p4 P. z5 O* h& |, }3 w
- 2 {" W, M, V! p( N8 l+ U8 n! N3 @8 n
- sFLASH_SendByte(sFLASH_CMD_READ);
9 p6 G7 o1 u& K# Q - sFLASH_SendByte( (ReadAddr>>16) & 0xff); //传送高8位
2 P4 T) [9 i+ d4 b4 P& @) U: Z - sFLASH_SendByte( (ReadAddr>>8) & 0xff); //传送中8位' z9 F0 @% O" e9 i
- sFLASH_SendByte( (ReadAddr>>0) & 0xff); //传送低8位. X% H+ Z5 u& R' L' I: b; B! m8 K
- 9 A& j* m% ]: T3 `5 l9 Y' ?
- while(NumByteToRead--)
; H! t1 M0 @ ^' {8 B- [% Q0 y - {8 \' x4 @+ m2 r' j
- * pBuffer = sFLASH_SendByte(sFLASH_DUMMY_BYTE);8 L1 V9 j8 P" ~, K+ ]
- pBuffer++;5 j0 p% ` V. r& l/ g; r
- }/ N& z* p+ Q1 P n
-
* q) {# d, e& u& G - sFLASH_CS_HIGH();7 e% s3 G/ F0 ^1 j8 J
- }1 w7 ~" k; M! f3 ^/ v
u) g/ s) v1 H+ @- //写一页最多只能写256个字节,一个扇区16页,一个块16个扇区 3 E2 y* W9 o, l6 z: c/ G0 g
- void sFLASH_WritePage(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite)
6 J% O/ s4 U$ q) k1 q# R0 b+ t - {7 w5 x I! _ j+ P
- if(NumByteToWrite > sFLASH_SPI_PAGESIZE ). _; \: s- c! K H
- {
% m8 |; w9 v' K3 x* l - NumByteToWrite = sFLASH_SPI_PAGESIZE;
8 W% m0 ^2 a( H& Q1 R4 { - 3 |, D7 B$ G3 N! C
- printf("写数据量过大,超过一页大小\n");
" [) h/ o8 b( J2 l1 v1 K1 j. X - }2 \7 X4 l5 K. y$ P Z; D& ?
-
4 D2 S% R+ `0 v6 `, _ - sFLASH_WriteEnable(); //开启写使能
0 s G3 C4 ^! f3 o' ? -
" N+ y/ Y2 m. ~. G" x4 `8 _ - sFLASH_CS_LOW();) `4 q, _: Q" M6 `( z' y
- % w0 I7 w! \' r$ k# Y0 u: S) L' h
- sFLASH_SendByte(sFLASH_CMD_WRITE);
2 R* m4 C, v+ w0 R9 r - sFLASH_SendByte( (WriteAddr>>16) & 0xff); //传送高8位
2 h( @2 F+ m3 S/ R6 H- r - sFLASH_SendByte( (WriteAddr>>8) & 0xff); //传送中8位
1 k- [: s. S3 y; H3 Y; y- z0 [ - sFLASH_SendByte( (WriteAddr>>0) & 0xff); //传送低8位
+ d: x& C& b0 n" E& _ - 6 H5 M2 g, o& q+ g/ k1 E
- while(NumByteToWrite--)0 U- i1 {$ R6 _
- {8 _4 B/ X W9 w& Y; `
- sFLASH_SendByte(* pBuffer);1 j8 `- l/ u; X& a; i
- pBuffer++;8 ~ q H% p7 }
- }8 z" O% c) k7 ~" J
- ; B5 g$ q2 P4 K' v8 B5 N
- sFLASH_CS_HIGH();6 Z' }% v* i9 \+ v
- 8 U$ Z( K7 _$ C8 o `) E8 ?( o7 Q2 p
- /*擦除和写数据都涉及到写动作,一定要等待完成*/9 v8 S' h2 ?5 ~& X9 B- K
- sFLASH_WaitForEnd();
& j7 Y E6 f; z4 x5 m - }
3 z: n! X* V7 W1 n6 p+ n" t
% a8 @0 s( o, `- //写任意地址、任意长度9 K3 x# P5 d6 R) E- r
- void sFLASH_WriteBuffer(uint8_t* pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite)
' F1 \0 m; N, Z& E; [; C - {/ ^( `2 y1 o6 z4 G, G( x4 M
- uint16_t NumOfPage, NumOfBytes, count, offset;7 N L x G, p
- //求WriteAddr在某一页的位置
/ Z8 r# j6 D5 r# @& k - offset = WriteAddr % sFLASH_SPI_PAGESIZE;
/ [% `, Y. ]' I7 W: k/ i( X$ L - //求某一页剩余的大小 & m% ?& O- B7 x" z
- count = sFLASH_SPI_PAGESIZE - offset;
$ W' p! L+ X* i* F - 8 Y( [2 D) J+ j
- /*处理页不对齐的情况,防止页内覆盖*/' W' {/ e3 D, d6 {4 v7 K3 ~! E
- //先把某一页剩下的部分写掉,之后的就能新页的起始处开始写 /*offset有值表示需要页对齐,如果要写的字节数小于某一页剩余的部分,那就无需对齐*/
( G3 _0 _* O s/ d - /*这两个条件必须同时满足*/ Q' `3 U# V* Z( v( G
- if(offset && (NumByteToWrite > count ))# ]$ O1 Z3 f, U
- {0 P9 C2 e5 h( S
- sFLASH_WritePage(pBuffer,WriteAddr,count);
; U( z0 r' G7 X* f; k - NumByteToWrite -= count;//去掉已经写了的,从新页开始& w# d+ D% a5 l- _$ o0 W# l2 g) G7 f# ]
- pBuffer += count;& b. T4 O2 A. o M8 _
- WriteAddr += count;, H$ t; f/ I: p; W8 ?' u1 Q
- }
6 j( n9 e5 J- K7 w6 c" I/ w - 1 w( s& j$ k. u& L
- /*最多可分多少页*/; o7 ^0 o2 X9 I
- NumOfPage = NumByteToWrite / sFLASH_SPI_PAGESIZE;+ `) r1 u; O' u! }
- /*剩余多少字节*/
2 f3 B( r% C/ R2 b - NumOfBytes = NumByteToWrite % sFLASH_SPI_PAGESIZE;
) ~2 R1 d0 b$ i! G: ~: o8 j - 1 c" L* m0 {; K2 Y3 l6 D
- if(NumOfPage)& l5 z3 Q9 L1 _$ U) S j
- {
' F* ]6 e3 @8 M: n' {( ` - while(NumOfPage--)
% H% o1 t4 L1 i1 N1 o. Z0 \ - {, Q( t$ Z; G$ `( d9 ]( F3 x% y4 M
- //每一页都发起页编程
- g: i! Y6 M+ E - sFLASH_WritePage(pBuffer,WriteAddr,sFLASH_SPI_PAGESIZE);4 h4 `3 P% @( `# O( ]0 e) k7 \
- pBuffer += sFLASH_SPI_PAGESIZE;
8 v) I' t. }1 g; y* O5 U - WriteAddr += sFLASH_SPI_PAGESIZE;
4 f/ c2 P) Z! E( _; t( E& v0 g4 | - }
4 n# J) W5 _6 `9 c% g; C7 O - }
0 L1 f% g: m0 Z3 ], d - 2 ?# a/ i$ q& F% s. g, R$ `! _8 A& v
- if(NumOfBytes)# J9 G6 T9 o7 T$ M/ h1 M
- {
a) A" R/ D" h% E, ?2 G u - sFLASH_WritePage(pBuffer,WriteAddr,NumOfBytes);
. W- g4 M! D4 G, p# B! r1 h - }
( w8 V, c) i6 C* ^ - }
复制代码
$ B* L, X1 c& g7 C# |+ ]5 W" 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
|