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

【经验分享】STM32掉电时存数据到FLASH

[复制链接]
STMCU小助手 发布时间:2022-1-30 01:00
一、STM32FLASH简介
  不同的STM32它的FLASH大小也是不一样的,分为大、中、小容量,容量由16K到1024K不等。这次实验用的开发板FLASH容量大小为128K。
  STM32的闪存模块由:主存储器、信息块和闪存存储器接口寄存器三部分组成。
  主存储器:该部分主要是用来存放代码和数据常数,被划分为128页,每页1K字节(小容量产品也是每页1K字节,大容量为每页2K字节)。主存储器的起始地址就是0X08000000, B0、B1都接GND的时候,就是从0X08000000开始运行代码的。
  信息块:该部分分为2个小部分,其中启动程序代码,是用来存储ST自带的启动程序,用于串口下载代码,当B0接V3.3,B1接GND的时候,运行的就是这部分代码。用户选择字节,则一般用于配置写保护、读保护等功能。
  闪存存储器接口寄存器:该部分用于控制闪存读写等,是整个闪存模块的控制机构。 
  对主存储器和信息块的写入由内嵌的闪存编程/擦除控制器(FPEC)管理;编程与擦除的高电压由内部产生。
  在执行闪存写操作时,任何对闪存的读操作都会锁住总线,在写操作完成后读操作才能正确地进行;既在进行写或擦除操作时,不能进行代码或数据的读取操作
闪存的读取
  内置闪存模块可以在通用地址空间直接寻址,任何32位数据的读操作都能访问闪存模块的内容并得到相应的数据。读接口在闪存端包含一个读控制器,还包含一个AHB接口与CPU衔接。这个接口的主要工作是产生读闪存的控制信号并预取CPU要求的指令块,预取指令块仅用于在I-Code总线上的取指操作,数据常量是通过D-Code总线访问的。这两条总线的访问目标是相同的闪存模块,访问D-Code将比预取指令优先级高。
  这里要特别留意一个闪存等待时间,因为CPU运行速度比FLASH快得多,STM32F103的FLASH最快访问速度≤24Mhz,如果CPU频率超过这个速度,那么必须加入等待时间,比如我们一般使用72Mhz的主频,那么FLASH等待周期就必须设置为2,该设置通过FLASH_ACR寄存器设置。
闪存的编程和擦除
  编程过程:
  ·检查FLASH_CR的LOCK是否解锁,如果没有则先解锁
  ·检查FLASH_SR寄存器的BSY位,以确认没有其他正在进行的编程操作
  ·设置FLASH_CR寄存器的PG位为’1’
  ·在指定的地址写入要编程的半字
  ·等待BSY位变为’0’
  ·读出写入的地址并验证数据
  擦除过程(页擦除)
  ·检查FLASH_CR的LOCK是否解锁,如果没有则先解锁
  ·检查FLASH_SR寄存器的BSY位,以确认没有其他正在进行的闪存操作
  ·设置FLASH_CR寄存器的PER位为’1’
  ·用FLASH_AR寄存器选择要擦除的页
  ·设置FLASH_CR寄存器的STRT位为’1’
  ·等待BSY位变为’0’
  ·读出被擦除的页并做验证
二、软件实现
  flash.c文件
  1. #include "flash.h"
    + ^* Y# V, Y7 M2 P" P: j+ j
  2. #include "delay.h"
    7 Z6 L0 S9 C4 }8 q4 G6 c
  3. #include "usart.h"
    1 V* s) Z& x# F7 I! z7 V

  4. % L& W+ J) f& w
  5. /***flash解锁*****/. q1 E$ W. {0 C2 `
  6. void STMFLASH_Unlock(void)$ y: }* V6 I, j0 _
  7. {
    + [7 x) I2 ~. E: \& w( S
  8.   FLASH->KEYR=FLASH_KEY1;                                        //写入解锁序列
    ( G1 |0 _  r  h% i' }7 v
  9.   FLASH->KEYR=FLASH_KEY2;
      X8 o' o3 H6 |, b1 J5 z
  10. }
    0 D4 N% R9 y) l; i) J

  11. ! X4 k' ^# W  B; W
  12. //flash上锁# z7 L+ `0 P3 \$ z
  13. void STMFLASH_Lock(void)5 F1 R2 d8 l- k7 Y
  14. {4 L- x9 ^( I6 x) l& m5 K) a
  15.   FLASH->CR|=1<<7;                                              //上锁
    4 t0 m9 g  a: Y' C6 k
  16. }
    ! M: [. D/ a* R

  17. " C4 l8 R4 Z& d% I* T
  18. //得到FLASH状态
    , d6 W1 N) J& e! C
  19. u8 STMFLASH_GetStatus(void)
    4 m! q" D# d" c0 j0 ~2 i2 m
  20. {    5 g  ^3 K. Y9 |0 e3 R
  21.    u32 res;         
    1 x. T: x, Z, G, `; b
  22. 3 T$ `' E2 @4 A
  23.    res=FLASH->SR;5 K9 d& {1 P' T: v) V* w5 B4 p5 B
  24.    if(res&(1<<0))return 1;                                          //忙
    ( E4 ?) y: G; o; g2 o% K9 C& m& W
  25.    else if(res&(1<<2))return 2;                                     //编程错误
    ! |4 x( R6 _/ S" r8 U4 Y
  26.    else if(res&(1<<4))return 3;                                     //写保护错误4 m: `& S  m- ?
  27.    return 0;                                                        //操作完成! e6 l  `/ M& g2 _: @
  28. }7 t, H% L" ~' a4 g
  29. " r/ K7 Q; f0 w% g- {# {* J: y
  30. //等待操作完成
      g! q4 k% \# [' c; h  P  L
  31. //time:延时长短
    - h* K2 U6 N% E' e
  32. //返回值:状态.
    & m( B  @& h9 z
  33. u8 STMFLASH_WaitDone(u16 time)
    6 A% }  T) t+ o* y* k3 L
  34. {* q% n- L: N! j7 E* |% `
  35.    u8 res;
    ) f5 C' M! J9 t

  36. ; o  y* V0 j4 X; E, g
  37.    do
    + {( M6 D% }% Z! `& h2 \2 T. m
  38.    {
    - N! G+ N5 q( v1 r
  39.       res=STMFLASH_GetStatus();
    / c- [: n9 ^7 V6 R% X4 L
  40.       if(res!=1)break;                                            //非忙,无需等待,直接退出.1 g. Q; \% G" P
  41.       Delay_us(1); time--;            
    ; `9 i. Y' b, P! t
  42.     }while(time);" ]& P# W4 \. A: p4 D' i0 M$ U& y
  43.     if(time==0)res=0xff;                                           //TIMEOUT
    / \* r% V6 u$ r0 c  k- q
  44.     return res;  q  ?3 z1 _0 t( \
  45. }
    4 r  b& e) s5 X! P3 d, R

  46. . Q5 |' g/ b5 k0 N
  47. //擦除页. X0 O0 u  W- r7 ]" E9 y
  48. //paddr:页地址! `# _1 `9 V' ~+ |
  49. //返回值:执行情况
    7 |0 J+ e/ z0 ]2 G: b) K0 p6 m5 S" @9 @
  50. u8 STMFLASH_ErasePage(u32 paddr)
    - B" F1 V# x  ?3 p; p: h/ c

  51. 6 O. H+ K  E7 O! i- @0 _; q
  52. {5 V* I7 ?4 q6 E! S$ P8 z2 I( a1 F
  53.        u8 res=0;
    9 ?0 w8 I. S! S
  54. - g8 |( X# [+ r& _
  55.        res=STMFLASH_WaitDone(0X5FFF);                              //等待上次操作结束,>20ms   
    & i7 V; p* a) e! Q1 y
  56.        if(res==0)/ |8 @7 }+ A  @0 h) ^
  57.        {; Q& h, s- f' x
  58.               FLASH->CR|=1<<1;                                      //页擦除
    ( {  b- e7 B" E2 O$ J% R4 X6 R
  59.               FLASH->AR=paddr;                                      //设置页地址. q2 n4 O  u+ }, o+ O7 F. D
  60.               FLASH->CR|=1<<6;                                      //开始擦除           
    3 j! O: a/ L* W
  61.               res=STMFLASH_WaitDone(0X5FFF);                       //等待操作结束,>20ms
    % m" ^7 O. E! `$ ?$ [7 E! y
  62.               if(res!=1)                                             //非忙! o0 |% d% U: G" A6 u! d
  63.               {
    / {  f4 W- ?( b* C
  64.                      FLASH->CR&=~(1<<1);                           //清除页擦除标志.% ^3 Y* h& f7 G0 r  F3 \# W" E
  65.               }  p4 j" J3 p3 `% D) m9 V) F( `/ n
  66.        }
    / C' F+ q9 D7 m6 Z2 a1 u5 r
  67.        return res;
    & ~4 U4 ]% f' z; f/ ~! M
  68. }; ?9 S# M, w7 D& b

  69. , n" c. N% L+ P% U
  70. //读出指定地址的半字(16位数据); f% g# B& t% t, G/ H" T+ T; X
  71. //faddr:读地址(此地址必须为2的倍数!!)
    5 Z) @1 K  l8 G; A7 l3 v
  72. //返回值:对应数据.
    7 N. l, [- _2 p3 H2 |
  73. u16 STMFLASH_ReadHalfWord(u32 faddr)
    ( ~& d" M# d3 E1 T, k
  74. {
    7 r$ i0 ~3 X! R" q4 S$ J
  75.     return *(vu16*)faddr; 3 J& b) |" v" F2 f$ ~* N) r- v8 h
  76. }4 \# q4 V# [( a8 d
  77. #if STM32_FLASH_WREN                                               //如果使能了写   
    6 ?) G! E  m0 x7 l
  78. //不检查的写入) ^% v4 Y) l" e
  79. //WriteAddr:起始地址
    ) q" E3 C5 f9 _) \
  80. //pBuffer:数据指针
    8 ?  u- L4 K% R1 O) d
  81. //NumToWrite:半字(16位)数     D  j* {9 @9 U$ ^, t" `
  82. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   5 K# d5 Z8 E+ F- b* P
  83. {                       
      H' Z/ Q, C( z$ `
  84.     u16 i;5 V, [- a! I1 L  ~+ K
  85.     for(i=0;i<NumToWrite;i++)
    / H# Q" A9 ]9 z9 J2 M; D* }
  86.     {
    ; k/ \/ a0 I3 @$ O$ a3 v8 X) u# y% B
  87.         FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);6 O7 r2 C/ \- O- d3 G7 z" m9 d/ r
  88.         WriteAddr+=2;                                           //地址增加2.
    9 U/ M7 h3 k) N( O, t  j1 N
  89.     }  ! |6 z+ @  N( ?* n6 V# g0 x' ]+ x
  90. } - o4 X; R8 G9 G! R
  91. //从指定地址开始写入指定长度的数据
    2 F3 y( m) W4 L
  92. //WriteAddr:起始地址(此地址必须为2的倍数!!)
    7 a3 ?* q6 l& W/ t
  93. //pBuffer:数据指针
    8 m5 A& }: u  d! u2 {. s, f
  94. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)% S2 P6 E3 r' h: j4 d
  95. #if STM32_FLASH_SIZE<256
    ! ^* [; V* J7 `: I3 k# M1 k
  96. #define STM_SECTOR_SIZE 1024                                       //字节
    * [' e8 z; k2 P& }1 \8 U+ J
  97. #else
    ; E5 Z' ~7 v, V$ B) p
  98. #define STM_SECTOR_SIZE    2048
    & e( D+ c& L- c$ p$ F" O. j
  99. #endif         
    # |, v3 q6 w9 m* Q
  100. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];                               //最多是2K字节
    * W, O  z% O4 y: ~

  101. 1 h5 i8 o8 S$ e6 M+ B: M
  102. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)& z$ x3 [. E9 b8 q/ h* A$ R. Y
  103. {
    3 {+ s* V% |+ T) }
  104.     u32 secpos;                                                     //扇区地址9 n- H* [3 ]& c& T* I7 K
  105.     u16 secoff;                                                     //扇区内偏移地址(16位字计算)% X9 [* k' b6 Q- C$ L! I
  106.     u16 secremain;                                                  //扇区内剩余地址(16位字计算)       ! R0 ]2 u2 s- o, v8 a( y
  107.      u16 i;   
    7 B1 h, y: i4 u* d# n1 F% v
  108.     u32 offaddr;                                                    //去掉0X08000000后的地址3 d+ `# h* E1 m9 C. g' z; l
  109.    
    9 q7 u) |) t  D9 u/ G
  110.     if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
    2 V$ g) `' y7 j" D0 Z
  111.     FLASH_Unlock();                                                 //解锁
      R, L; d' H9 l% ~9 P/ Y
  112.     offaddr=WriteAddr-STM32_FLASH_BASE;                             //实际偏移地址.2 y' \9 A* a* x9 H# B9 }3 }: n
  113.     secpos=offaddr/STM_SECTOR_SIZE;                                 //扇区地址  0~127 for STM32F103RBT6, m. b3 ?2 J. G8 Z* O/ b7 `: v6 J' ?% L
  114.     secoff=(offaddr%STM_SECTOR_SIZE)/2;                             //在扇区内的偏移(2个字节为基本单位.)
    , B) }0 j, c7 w( d3 Y- |: V$ g( w
  115.     secremain=STM_SECTOR_SIZE/2-secoff;                             //扇区剩余空间大小  3 E4 m6 d' S3 U3 z* l
  116.     if(NumToWrite<=secremain)secremain=NumToWrite;                 //不大于该扇区范围. A& F/ E9 X# r& x
  117.     while(1)
    8 u* ?3 }7 L" E5 h1 _
  118.     {   
    , K3 ]5 N: x6 {: b
  119.         STMFLASH_Read(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容& z$ w" b2 s0 n: L
  120.         for(i=0;i<secremain;i++)                                   //校验数据( k2 }6 s4 P5 D6 B; |
  121.         {
    0 E& Z5 ]" m( v& f$ M% Z
  122.             if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;              //需要擦除      
    5 J. f* @; a% T, e9 [: ^$ j
  123.         }, I4 n- G( L6 f1 Y
  124.         if(i<secremain)                                            //需要擦除
    " p; T# e  Y5 Y; }, G
  125.         {
    ! S8 a# {) t" T5 n! u" U. a7 g
  126.             FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);               //擦除这个扇区( x4 N  W- ~6 @3 h/ F
  127.             for(i=0;i<secremain;i++)                              //复制
    9 M* s; X% G$ i
  128.             {& [2 B  o6 f/ R1 O
  129.                 STMFLASH_BUF[i+secoff]=pBuffer[i];      6 I! y0 a0 d0 }: R7 \
  130.             }' k4 N& {- g0 d: C' m) D; I& A
  131.             STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区9 i( z0 y6 R; n1 \
  132.         }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain); //写已经擦除了的,直接写入扇区剩余区间.                    
    8 T: c& R8 N1 ], c$ r' c
  133.         if(NumToWrite==secremain)break;                            //写入结束了2 i- j/ }% N3 N
  134.         else                                                       //写入未结束
    3 {! j. J1 g$ o3 i1 \$ F
  135.         {
    ) H5 V+ H$ `5 L9 s! I
  136.             secpos++;                                              //扇区地址增1
    3 F* C0 Y* f. m" K1 j0 D
  137.             secoff=0;                                              //偏移位置为0      
    1 z  m* l3 G( m% Y
  138.                pBuffer+=secremain;                                 //指针偏移9 q: L) @! I$ ^/ [! A. s
  139.             WriteAddr+=secremain;                                  //写地址偏移       ! T* O4 l6 Q6 P3 m$ ^/ @  y
  140.                NumToWrite-=secremain;                              //字节(16位)数递减
    $ ?: R* q- S$ L8 S- I/ g
  141.             if(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
    5 l- L. P; m* d9 v# {
  142.             else secremain=NumToWrite;                             //下一个扇区可以写完了
    ; [3 ]- v' p8 h
  143.         }     
    . Z% n+ x! n* q8 s, e' x! K
  144.     };    : h8 {) z  d( M4 E; L# H6 s
  145.     FLASH_Lock();                                                  //上锁
    & h# d; S7 B3 `7 F6 `5 g, t6 O
  146. }+ N3 o. p7 c2 H
  147. #endif$ c& |+ E: Q1 x5 u3 R5 ]

  148. # x$ |7 B% B: Z
  149. //从指定地址开始读取指定长度的数据2 g0 a0 g8 j) D, Q: i+ B6 u4 A
  150. //ReadAddr:起始地址
    2 E$ B- `! W4 k: n' }6 [, z: N- T
  151. //pBuffer:数据指针
    & b' w7 y& W% z" k; @
  152. //NumToWrite:半字(16位)数
    " U- ~, Q8 I+ p2 a; l( e
  153. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)
    1 G5 W" Z$ j, i1 F" e4 N/ j* k
  154. {
    1 b% k! s* F/ C2 ~6 i" P
  155.     u16 i;
    # ]: R8 a2 k; F6 w3 H
  156.     for(i=0;i<NumToRead;i++)+ u, w  Q7 @, F$ M2 r) H: `
  157.     {
    8 a( h  k1 P% p$ q+ i; n9 r
  158.         pBuffer[i]=STMFLASH_ReadHalfWord(ReadAddr);               //读取2个字节.4 a/ q& P9 e/ z: {8 M" I
  159.         ReadAddr+=2;                                              //偏移2个字节6 h. h8 m+ N, S: O, V
  160.     }7 d, R# S# @9 H( N8 U/ W* `# t8 ~
  161. }& \. x6 H& G  U: Z6 ]
  162. 1 |% q! z. A. B  }0 P( W1 O
  163. //////////////////////////////////////////////////////////////////////////////////////////////////////& l! k7 m2 b1 R+ [5 q9 V
  164. //WriteAddr:起始地址
    ; M& E& V+ M) G# ]  \1 L
  165. //WriteData:要写入的数据" R6 d+ }6 _  f2 n
  166. void Test_Write(u32 WriteAddr,u16 WriteData)       0 t/ y' S( P6 h+ B0 E3 b
  167. {
    8 I' R$ n% i/ S
  168.     STMFLASH_Write(WriteAddr,&WriteData,1);                       //写入一个字 & m; ~% x, r2 a3 v* v  u
  169. }
复制代码

9 B* s7 J5 x& }! Q% u9 F1 G" J
  flash.h文件
  1. #ifndef __FLASH_H__1 E5 t" z' p# E/ J7 m4 C/ c. Q
  2. #define __FLASH_H__
    1 a% P2 g9 m1 r3 \& O5 s  U2 Q
  3. #include <stm32f10x.h>% S) p. x/ O  F& J) V7 a- |" T
  4. # Q* s1 p6 l' k' R
  5. #define FLASH_KEY1               0X45670123
    " X$ c; w! A0 q' Q# T7 I
  6. #define FLASH_KEY2               0XCDEF89AB3 }2 P! v; n& ~
  7. 0 i  C. @" I$ g
  8. #define STM32_FLASH_SIZE 128                                 //所选STM32的FLASH容量大小(单位为K)
    7 W" [& A  L4 v* V; {
  9. #define STM32_FLASH_WREN 1                                       //使能FLASH写入(0,不使能;1,使能)
    - `7 Q. {8 ?) D- v( ~" l  E
  10. //////////////////////////////////////////////////////////////////////////////////////////////////////
    ' h' }  j+ e7 ?  s: U8 j- S! y

  11. 9 ^$ A% s4 C! q2 t8 k9 R6 L* P
  12. //FLASH起始地址
    , g1 g6 Y4 z+ I4 q! `' E
  13. #define STM32_FLASH_BASE 0x08000000                         //STM32 FLASH的起始地址2 T( u2 M, c* S% d
  14.   J9 x) U9 V2 R+ v* N! a
  15. . I  k/ d$ z4 ]1 I+ i7 y2 y
  16. void STMFLASH_Unlock(void);                                        //解锁
    9 Y* w0 t" J7 h  `
  17. void STMFLASH_Lock(void);                                       //上锁
    5 V5 _0 G. C* U
  18. u8 STMFLASH_GetStatus(void);                                       //获得状态: R6 B8 l- C' D
  19. u8 STMFLASH_WaitDone(u16 time);                                  //等待操作结束! j/ w  o2 h5 D: d
  20. u8 STMFLASH_ErasePage(u32 paddr);                                  //擦除页) L( g1 x- B  P1 h, b7 L# m9 J) H+ F
  21. u16 STMFLASH_ReadHalfWord(u32 faddr);                               //读出半字  1 h6 I; ~; x' Q  o1 A' F. M0 R
  22. void STMFLASH_WriteLenByte(u32 WriteAddr,u32 DataToWrite,u16 Len);       //指定地址开始写入指定长度的数据
    9 E. O/ G4 x) B: Z. B# n
  23. u32 STMFLASH_ReadLenByte(u32 ReadAddr,u16 Len);                       //指定地址开始读取指定长度的数据) q0 B) Y% W! E) ]" x
  24. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite);          //从指定地址开始写入指定长度的数据) T7 ^1 A7 }- t: _5 J
  25. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead);             //从指定地址开始读取指定长度的数据
    2 g- \# |! u: ?6 V  N9 z# e

  26. % c5 K" N, P9 \; t8 r2 x
  27. //测试写入
    6 g; t9 N+ e, o3 a: a
  28. void Test_Write(u32 WriteAddr,u16 WriteData);                                   
    0 L" Z/ P6 I" c+ u1 {1 X; B. [
  29. #endif
复制代码
/ z: w/ `7 K/ E& \

2 T6 P, ~5 G5 R  K( H
  main.c文件
  1. #include "flash.h": s0 F0 H* Y- n/ q- o! |8 p6 ?- \) p
  2. ! u, N7 J* n8 J& |7 m+ \
  3. #define SIZE sizeof(TEXT_Buffer)                  ///数组长度" a; [/ E0 z. @/ Y5 C
  4. #define FLASH_SAVE_ADDR  0X08070000   //设置FLASH 保存地址(必须为偶数,且其值要大于本代码所占用FLASH的大小+0X08000000)1 K* l+ c4 h& q. O
  5. ! A, _" G* y4 y! o% b! y4 g
  6. const u8 TEXT_Buffer[]={"STM32 FLASH TEST"};2 Z! Y/ @" k9 ^3 _
  7. u8 datatemp[SIZE];
    4 l1 n7 b) s# W9 \

  8. 9 B* M  }/ E/ n8 l- l3 J% i$ m
  9. int main(void)
    / @5 f' U  X, S7 O( z" A0 M9 N
  10. {
    : H" W% q/ r* j" G' L  P! N/ V
  11.      while(1)8 W/ `# o  C0 z. ^- i+ Q8 \
  12.     {& Q7 n. \8 n8 {* e
  13.         if(掉电)
    . s) z+ k5 Q0 {  u' W
  14.      {, Q1 n$ i- ]2 R
  15.           STMFLASH_Write(FLASH_SAVE_ADDR,(u16*)TEXT_Buffer,SIZE);//flash写函数
    . F+ _0 H% v* a+ @. a9 \$ M$ A
  16.      }  
    2 p; l  s5 l, ?5 q( A7 U) v
  17.            STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)datatemp,SIZE);     //flash读函数   
    ) W: d) ?$ z' [" K
  18.    }
    ( d& v5 @) v6 [  T5 Z) z
  19. }
复制代码

$ q4 Z* ?' J2 d! _# v5 s) S) I
) y& _' G' q9 m8 F8 k) d1 {+ z- C
  以上就是flash在掉电的时候进行读写的程序,项目用到了就记录一下,方便以后查阅学习。其中的大部分代码在库函数中都能够找到参考。
# s: [+ C7 W% U0 m- ~8 ]
赞 收藏 评论0 发布时间:2022-1-30 01:00

举报

0个回答

所属标签

相似技术帖

官网相关资源

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