今日接手用stm32f100xx芯片开发的项目，以前用的是stm8s 和stm32f103xx芯片；因为在别人的项目代码的基础上做2次开发，但是发现那个代码main函数中没有对系统时钟的设置的相关函数，一直纳闷，但也没有深究，直至昨日 调试时出现串口收发数据出错，源代码在原项目的板子上串口发送、接收数据正常，同样程序在项目板子上收发的数据不正确， 两块板子芯片一样，串口收发管脚一样，最后发现原来板子外部晶振是8MHZ ,新板子外部晶振是12MHZ;  而在STM32固件库中，默认的外部晶振是8MHZ，由于时钟源不正确，导致波特率不正确，当然收发的数据也不正确了.....我勒个去！都怪自己平时看问题“不求甚解”。

（波特率与时钟源关系公式：IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate)))

为了深入思考，我提出了一些疑问，通过解答这些问题更深入的了解时钟；
, V# n8 L1 Z/ L% z
$ u& ?4 R$ |0 T) h& k/ S问题一：对系统时钟的设置的相关函数,在main函数中找不到，那在哪里？还是说根本没有对系统时钟进行配置？
2 e- H+ v3 N* q+ T# v2 N
8 e. C* m7 W/ r9 _' A6 n问题二：既然用了外部晶振做系统时钟，那为什么没看到启动外部晶振的操作？
8 c8 b- y3 [1 m( H+ r8 a( C
4 x: o* i8 s% y0 \& \3 b问题三：串口的时钟源是什么？串口时钟源跟系统时钟的关系？

0 V+ W7 n# {5 V; {8 P" r0 o问题四：程序中串口时钟源是怎样实现对波特率的关系的？

现附上我找到上面3个问题答案做的一张框架图：希望博友参考此图理解我后面的内容：

. T) s/ H" E5 f7 c. d, z

0 `- c" }* c8 d( h, m' m在进入主题之前我们先了解一些必要的基础知识----stm32系列芯片的种类和型号：

9 B7 I  k1 ^3 ystartup_stm32f10x_cl.s 互联型的器件，STM32F105xx，STM32F107xx
' M1 i; m0 ]% v2 ^1 [startup_stm32f10x_hd.s 大容量的STM32F101xx，STM32F102xx，STM32F103xx
! U  u7 P! _8 x% R8 ostartup_stm32f10x_hd_vl.s 大容量的STM32F100xx
startup_stm32f10x_ld.s 小容量的STM32F101xx，STM32F102xx，STM32F103xx
# V6 q( Z+ Q- x, ustartup_stm32f10x_ld_vl.s 小容量的STM32F100xx
startup_stm32f10x_md.s 中容量的STM32F101xx，STM32F102xx，STM32F103xx
startup_stm32f10x_md_vl.s 中容量的STM32F100xx  （我项目中用的是此款芯片 stm32f100CB）
startup_stm32f10x_xl.s FLASH在512K到1024K字节的STM32F101xx，STM32F102xx，STM32F103xx

4 M5 `, R% u7 Q3 d) u. Rcl：互联型产品，stm32f105/107系列
vl：超值型产品，stm32f100系列
& n. H0 m9 {$ Dxl：超高密度产品，stm32f101/103系列
ld：低密度产品，FLASH小于64K
4 O, I6 C$ l5 g( z5 emd：中等密度产品，FLASH=64 or 128
; a6 p9 ~/ }8 M+ t! V5 p- thd：高密度产品，FLASH大于128


（下图中的startup_stm32f10_ld.s应改为：startup_stm32f10x_md_vl.s）
7 U1 Z( c# T, w$ O: h8 l: g


问题一：对系统时钟的设置的相关函数,在main函数中找不到，那在哪里？还是说根本没有对系统时钟进行配置？

解答：高人指点，我看了一下启动文件startup_stm32f10x_md_vl.s，其中有一段汇编：
" p2 k7 ]+ O' f* N! W: n4 n$ p
  Y- }# Z& q/ S" A3 R% l! K: C6 L! K<strong>; Reset handler routine
Reset_Handler    PROC
                 EXPORT  Reset_Handler             [WEAK]
" g( K7 E! s) {5 E" h' k     IMPORT  __main
% {8 t1 A5 d4 Y7 @     IMPORT  SystemInit
                 LDR     R0, =<span style="color:#ff0000;">SystemInit
</span>                 BLX     R0
                 LDR     R0, =__main
3 b9 ~0 n/ }: Y1 j                 BX      R0
8 M8 E1 I% N0 z2 ]                 ENDP
</strong>
& U3 n* A) y, @; v& R2 N  Z1 h
- z6 a; L; F$ o* K: p8 }# a+ H( U; ^7 n其中,
- D8 c8 z+ b8 F! ^% a) x, _
1 k0 u2 p. N  g: f0 i( q( f7 a+ iIMPORT __main IMPORT SystemInit      //IMPORT 声明了需要引用C语言中的main函数、systeminit函数，
LDR R0, = systeminint       //把systeminit 函数地址放到r0 寄存器；
. ]: o8 T! A' ]
BLX   R0    //跳到到R0 寄存器中的地址执行；

所以，在跳到main函数执行前，已经在SystemInit 函数中把系统时钟给设置好了；

; N+ M( Q" ~0 [9 }$ J( D4 a. }
, H1 C9 `( I' @6 Q9 K3 F
问题二：既然用了外部晶振做系统时钟，那为什么没看到启动外部晶振的操作？
0 O  @( `1 H+ d. d
# _9 G. z) D* k我们在解答这个问题前，先到SystemInit函数里面做更深入的了解：

+ K. C9 H& u& l4 ^4 [$ d

1. <strong>void SystemInit (void)
   8 j7 B/ M. o% k9 v& x- T/ B- x
2. {
   
3.   /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
   * i- M8 _  x: E% Y. Z- l
4.   /* Set HSION bit */
   
5.   RCC->CR |= (uint32_t)0x00000001;
   ; W$ @% g+ o, A0 M. ~
6. 
   
7.   /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
   
8. #ifndef STM32F10X_CL
   
9.   RCC->CFGR &= (uint32_t)0xF8FF0000;
     g! D8 }! ~, h) K4 g9 P2 |; e5 k
10. #else
    9 H& K+ b8 k% O2 `( p
11.   RCC->CFGR &= (uint32_t)0xF0FF0000;
    
12. #endif /* STM32F10X_CL */   
    
13. 
    
14. <span style="color:#006600;"> /* Reset HSEON, CSSON and PLLON bits */
    
15.   RCC->CR &= (uint32_t)0xFEF6FFFF;
    
16. 
    
17.   /* Reset HSEBYP bit */
    : e9 ?6 P, p/ O
18.   RCC->CR &= (uint32_t)0xFFFBFFFF;
    0 g9 b2 s& ]7 q3 N, \
19. 
    . a: Z/ L' p2 R9 g+ s+ M4 D: e) b; w
20.   /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
    
21.   RCC->CFGR &= (uint32_t)0xFF80FFFF;
    
22. </span>
    
23. #ifdef STM32F10X_CL
    # d8 U9 ?- J. d4 a
24.   /* Reset PLL2ON and PLL3ON bits */
    
25.   RCC->CR &= (uint32_t)0xEBFFFFFF;
    
26. 
    0 P& d: c2 G! D. m& B6 f  o
27.   /* Disable all interrupts and clear pending bits  */
    
28.   RCC->CIR = 0x00FF0000;
    # S4 S4 k! y5 x/ r/ E
29. 
    
30.   /* Reset CFGR2 register */
    9 I1 y1 n% j' l- q- x/ p
31.   RCC->CFGR2 = 0x00000000;
    % @! s( `1 w0 Y
32. #elif defined (STM32F10X_LD_VL) || <span style="color:#006600;">defined (STM32F10X_MD_VL) </span>
    
33.   /* Disable all interrupts and clear pending bits  */
    
34.   RCC->CIR = 0x009F0000;
    0 Y5 p. p6 l8 e# u9 Z& {. Z7 s1 w/ C8 m
35. 
    
36.   /* Reset CFGR2 register */
    
37.   RCC->CFGR2 = 0x00000000;      
    $ T  L9 c. w9 q& K# F
38. #else
      ~3 D1 [* u8 _5 R) G
39.   /* Disable all interrupts and clear pending bits  */
    
40.   RCC->CIR = 0x009F0000;
    
41. #endif /* STM32F10X_CL */
    
42. 
    ) T1 i# v! F/ L( ~& q0 ^
43.   /* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
    4 v3 A0 F  g! K: a
44.   /* Configure the Flash Latency cycles and enable prefetch buffer */
    2 E, ~) l' v3 S9 b
45.   <span style="color:#ff0000;">SetSysClock();
    
46. </span>
    
47. #ifdef STM32F10X_HD
    & [) @& ^/ s. }# j( x  p/ O
48.   #ifdef DATA_IN_ExtSRAM
    
49.     SystemInit_ExtMemCtl();
    
50.   #endif /* DATA_IN_ExtSRAM */
    
51. #endif /* STM32F10X_HD */  
    ! P# B6 A, Z" w8 }5 W( n, H
52. 
    
53. }</strong>

复制代码

0 m: d5 e* ]8 h* R# I8 j/ D7 a4 ^我们进入setsysclock()函数，看其中作了哪些操作：

1. /**
   8 u7 B2 N, n" M
2.   * @brief  Configures the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers.
     ]8 ^8 Y; R8 v, F5 i
3.   * @param  None
   % [  v% [0 t7 X2 d
4.   * @retval None
   : S$ z* o2 y% T/ L
5.   */
   6 z+ C( U( N6 t
6. static void SetSysClock(void)
   
7. {
   3 Y  [1 W) L" K5 A# ~
8. #ifdef SYSCLK_FREQ_HSE
     [  i0 F5 L' S7 o
9.   SetSysClockToHSE();
   
10. #elif <span style="color:#ff0000;">defined SYSCLK_FREQ_24MHz</span>
    
11.   <span style="color:#ff0000;">SetSysClockTo24();
    
12. </span>#elif defined SYSCLK_FREQ_36MHz
    
13.   SetSysClockTo36();
    
14. #elif defined SYSCLK_FREQ_48MHz
    0 I3 |( S# m* U" F3 G  M
15.   SetSysClockTo48();
    7 S. M. m) A! X. f" J7 o- W
16. #elif defined SYSCLK_FREQ_56MHz
    " F0 d: I- \) u+ b
17.   SetSysClockTo56();  
    : Y# f0 q6 {) P
18. #elif defined SYSCLK_FREQ_72MHz
    
19.   SetSysClockTo72();
    : I5 ]% k  \% ~% _0 K( X/ q
20. #endif

复制代码

我项目中用的是此款芯片 stm32f100CB,内部晶振是24MHZ, 所以应进入执行SetSysClockTo24() 函数：
! A2 G: [9 n3 V3 x, S% M
* B# s) T2 \/ B  G

1. /**
   " ?5 ^% H0 y  ^9 t, ~2 a; g
2.   * @brief  Sets System clock frequency to 24MHz and configure HCLK, PCLK2
   # }! y5 H2 T) }  w# t; S
3.   *          and PCLK1 prescalers.
   6 e0 o- c; k( I0 x/ u. j+ ^
4.   * @note   This function should be used only after reset.
   # V' `2 D, W; S) L  k( v
5.   * @param  None
   1 L+ t' g- c( R: p! I
6.   * @retval None
   
7.   */
   9 a2 G' j, n  [
8. static void SetSysClockTo24(void)
   
9. {
   
10.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
    
11. 
    
12.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/   
    8 [7 `4 w3 d, I2 p1 U2 [
13.   /* Enable HSE */   
    
14. <span style="color:#ff0000;"> RCC->CR |= ((uint32_t)RCC_CR_HSEON); //开启外部晶振</span>
    # E! M+ C) e  b  c, m  z4 ^) N
15. 
    
16.   /* Wait till HSE is ready and if Time out is reached exit */
    
17.   do
    
18.   {
    * q1 U, D0 x8 b/ K, m3 @3 w
19.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
    2 j  w1 C& b4 l9 D( e3 L3 p
20.     StartUpCounter++;  
    8 w. @  b( b3 I! K+ A
21.   } while((HSEStatus == 0) && (StartUpCounter != HSEStartUp_TimeOut));
    
22. 
    
23.   <span style="color:#ff0000;">if ((RCC->CR & RCC_CR_HSERDY) != RESET)//等待外部晶振起振
    
24. </span>  {
    
25.     HSEStatus = (uint32_t)0x01;
    
26.   }
    
27.   else
    2 ~; X$ }5 g$ S  Y( O, S0 B
28.   {
    , e, s/ A7 I- t
29.     HSEStatus = (uint32_t)0x00;
    
30.   }  
    + w& y; L7 m4 m
31. 
    
32.   if (HSEStatus == (uint32_t)0x01)
    0 H3 J/ ?9 @7 L  |& {
33.   {
    " ^, \& W, V! O2 a
34. #if !defined STM32F10X_LD_VL && !defined STM32F10X_MD_VL
    
35.     /* Enable Prefetch Buffer */
    
36.     FLASH->ACR |= FLASH_ACR_PRFTBE;
    
37. 
    4 n2 S+ B& ?0 p- s# N: t: H9 N
38.     /* Flash 0 wait state */
    4 F: G& M9 u/ p, D# Y
39.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    / s( b  X; h/ p+ m/ ~& ~$ M* n
40.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;   
      z7 A0 v8 s: U& c% m
41. #endif
    
42. 
    
43.    <span style="color:#009900;"> /* HCLK = SYSCLK */
    8 P) q: v9 X5 ~+ H
44.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
    
45. 
    
46.     /* PCLK2 = HCLK */
    % n- t7 g( L% k  K
47.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
    
48. 
    
49.     /* PCLK1 = HCLK */
    
50.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
    
51. </span>   
    6 \; @' e  l; j5 Y# j* U' s
52. #ifdef STM32F10X_CL
    
53.     /* Configure PLLs ------------------------------------------------------*/
    ' a2 ^3 j/ p2 `! k7 d. o4 L, z
54.     /* PLL configuration: PLLCLK = PREDIV1 * 6 = 24 MHz */
    . A+ P2 A8 s4 F6 E) k& `
55.     RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
    
56.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
    
57.                             RCC_CFGR_PLLMULL6);
    
58. 
    
59.     /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
    / U# Y$ q# f9 q1 W2 ]. [
60.     /* PREDIV1 configuration: PREDIV1CLK = PLL2 / 10 = 4 MHz */      
    / J& W" m- U+ n' R1 l+ a' w* P: N
61.     RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
    ) U8 ^6 l% Y8 f. U/ M
62.                               RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
    ! q$ X$ ~! t# s* \: Z
63.     RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
    8 F/ i; ^, k5 J. t
64.                              RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV10);
    , R, {; ^0 \. g6 v# d. V7 ?+ R
65. 
    
66.     /* Enable PLL2 */
    
67.     RCC->CR |= RCC_CR_PLL2ON;
    5 ?2 G0 v1 F  @
68.     /* Wait till PLL2 is ready */
    
69.     while((RCC->CR & RCC_CR_PLL2RDY) == 0)
    
70.     {
    , Q2 J  X0 Q- s2 R& u
71.     }   
    
72. <span style="color:#3366ff;">#elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL)
    3 p$ d/ q/ O, S  _9 y, g
73.     /*  PLL configuration:  = (HSE / 2) * 6 = 24 MHz */
    
74.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
    " T7 Z/ K* W/ p
75.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_PREDIV1 | RCC_CFGR_PLLXTPRE_PREDIV1_Div2 | RCC_CFGR_PLLMULL6);
    / ~7 J0 ~- M2 p# S, g
76. </span>#else   
    
77.     /*  PLL configuration:  = (HSE / 2) * 6 = 24 MHz */
    
78.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
    
79.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLXTPRE_HSE_Div2 | RCC_CFGR_PLLMULL6);
    6 Y) s& \# T, T
80. #endif /* STM32F10X_CL */
    
81. 
    
82.     /* Enable PLL */
    + H! o# G# d# t  ^6 j, d) f
83.     RCC->CR |= RCC_CR_PLLON;
    ) @8 q7 q, s# f) b# }1 x
84. 
    
85.     /* Wait till PLL is ready */
    % P- W& E' T% p
86.     while((RCC->CR & RCC_CR_PLLRDY) == 0)
    & _+ [# f' Y3 y, G- T/ f
87.     {
    
88.     }
    
89. 
    
90.     /* Select PLL as system clock source */
    
91.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    
92.     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;   
    
93. 
    
94.     /* Wait till PLL is used as system clock source */
    
95.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
    
96.     {
    # w3 k* Z% `' O- I2 P! G( I
97.     }
    5 s6 ~( O$ T2 {! f9 K0 Y* H; X5 @2 K
98.   }
    ) Q0 L* E5 p# @$ a
99.   else
    
100.   { /* If HSE fails to start-up, the application will have wrong clock
     4 Q( r2 z; I* Z) L+ N
101.          configuration. User can add here some code to deal with this error */
     
102.   }
     + f4 i1 w  q; @2 l) ], N+ _
103. }
     
104. #elif defined SYSCLK_FREQ_36MHz

复制代码

, F' {7 W, r1 D: m# `
解析：
4 x: p% ^* q0 K, F) @# e! u
void SetSysClockTo24函数中主要做了下面几件事：（不同颜色功能分别对应上面对应颜色代码部分）

% H1 j" W) _) w! V* W, P; ~1.启动外部晶振作为系统时钟源；

  y; l1 A' w, Y9 {) n2.等待外部晶振起振；
$ Y3 ]; d  z% N" Y0 y4 n  n1 J: ]
2 U. Q* n+ g) {; g: J+ i) Z% n( B3.（起振后）对系统时钟源进行分频：（默认外部是HSE--8MHZ晶振）  PLL configuration: = (HSE / 2) * 6 = 24 MHz

6 s, g* }- ^& \4. 配置HCLK、PCLK1、PCLK2 与系统时钟源的关系；


$ r2 j8 ~  z, P* }  e5 f) n
问题三：串口的时钟源是什么？串口时钟源跟系统时钟的关系？

" B: E  ?5 Q$ D  {( r4 z) V; H回答这个问题前，我们先来看stm32f100芯片手册数据图（第12页）：
# |/ p) ^0 D: m0 k6 _5 F" e


& x& I( W, z7 T  F, A3 i从图里面我们可看出串口1的时钟源是PCLK1;

. V- K. G/ Z, c: ]2 ]1 `上面问题2的代码中我们看到PCLK1是时钟源24MHZ的1分频，即还是24MHZ;

: u' _0 c* J* @  g. z4 B4 u

( _: o4 Q+ p3 D. [% n- `) c/ T' n问题四：程序中串口时钟源是怎样实现对波特率的关系的？

由问题3我们知道串口时钟源是24mhz,依据公式：IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate)))

+ [* p+ ^: }1 k7 ^库中自动设置IntegerDivider 存入寄存器中；
, g' L3 J, @( ^& a
) r8 y4 a" l. _4 G6 |
& A& W8 o9 m0 T* H* ?$ r（1）
" O! k3 t5 w6 A& H4 M) p3 e
在KEIL下可以在项目的选项C/C++/PREPROMCESSOR symbols的Define栏里定义，比如STM32F10X_CL

也可以在STM32F10X.H里用宏定义
#if !defined (STM32F10X_LD) && !defined (STM32F10X_LD_VL) && !defined (STM32F10X_MD) && !defined (STM32F10X_MD_VL) && !defined (STM32F10X_HD) && !defined (STM32F10X_XL) && !defined (STM32F10X_CL)
! {  d5 m& V! W' R: D
    #define STM32F10X_HD         
/ h- u+ y6 Z2 S: P( m
#endif

' ^: o' l, H1 `: [- P(2)
如果芯片更换，除了做如上所述的更改外，还需以下几步
2 c( P7 U  J3 B/ ^第一步   system_stm32f10x.c的系统主频率，依实际情况修改
#if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL)

  #define SYSCLK_FREQ_24MHz  24000000
% `+ Y3 p; W  B: P  i#else
+ }$ Z' y- w5 A8 k' ?4 F#define SYSCLK_FREQ_72MHz  72000000
#endif
另外外部时钟在文件：stm32f10x.h 依实际修改
2 m! O$ a  `# k7 R6 Z( ?第二步 定时器的参数依系统主时钟做适当修改
7 Q! F) t$ n; Q, l3 E第三步 flash地址misc.h中的NVIC_VectTab_Flash 0x08000000 要与KEIL选项target的IROM1的地址一致，如果是IAP程序，依ISP程序占用大小，APP的FLASH地址向后延，比如0X8002000,那么KEIL选项target的IROM1的地址也要就0x8002000,SIZE因为ISP占用了2000，所以就为0x40000-0x2000,即只能填写0X3E000

1 `4 N( m5 z, t0 I ISP程序与APP程序连接
9 C) L8 O- d( L0 J. }8 e1 s  打开 User 选项卡  在 Run User Programs Before Build/Rebuild 中，勾选 Run#1，并在
其中填入
2 i  \, {2 _; T% r1 d6 T              D:\Keil\ARM\BIN40\fromelf.exe --bin -o ./obj/Project.bin ./obj/Project.axf
                          其中，Project.bin 和 Project.axf 要和 Output 选项卡中的 Name  of  Executable  的名字
" C! `! \) Y+ H: X/ {
IAP我的总结
" z8 ^, L. H% ?1 先FLASH_Unlock();
2 小于或等于128K的STM每页为1k bytes,大于128K的每页为2K BYTES,减去从地址0x8002000占用的0x2000后，算出页数，比如IAP占用8K,则64K的MD的STM32F系列用for(i=0;i<(64-8);i++) FLASH_ErasePage(0x8002000+0x400*i);循环按页擦除FLASH
3 按从外部串口获取到的数据，FLASH_ProgramWord(address,dat);//注意是按4字节方式写入的
5 w" f% f, N  W$ |  if (*(uint32_t*)address!= dat)//字编程后校验
% |. [& N/ p) F; T$ i0 k! z

# u2 P# X  I( l  r/ D