一、关于时间

　　在计算机应用上，2038年问题可能会导致某些软件在2038年无法正常工作。所有使用UNIX时间表示时间的程序都将将受其影响，因为它们以自1970年1月1日经过的秒数（忽略闰秒）来表示时间。这种时间表示法在类Unix（Unix-like）操作系统上是一个标准，并会影响以其C编程语言开发给其他大部份操作系统使用的软件。

　　在大部份的32位操作系统上，此“time_t”数据模式使用一个有正负号的32位元整数（signedint32)存储计算的秒数。也就是说最大可以计数的秒数为 2^31次方 可以算得：

                2^31/3600/24/365 ≈ 68年
　　所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
/ r3 u1 E2 b5 }- c6 ~( q                 2^32/3600/24/365 ≈ 136年
/ T+ A1 \. z* Z. E, H　　到2116年，这个整数将溢出。
　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
' l' K" W# ~9 k8 g
二、RTC使用说明

　　"RTC"是Real Time Clock 的简称，意为实时时钟。stm32提供了一个秒中断源和一个闹钟中断源，修改计数器的值可以重新设置系统当前的时间和日期。

　　RTC模块之所以具有实时时钟功能，是因为它内部维持了一个独立的定时器，通过配置，可以让它准确地每秒钟中断一次。但实际上，RTC就只是一个定时器而已，掉电之后所有信息都会丢失，因此我们需要找一个地方来存储这些信息，于是就找到了备份寄存器。其在掉电后仍然可以通过纽扣电池供电，所以能时刻保存这些数据。

　　配置RTC前须知：

　　BKP：

　　RTC模块和时钟配置系统的寄存器是在后备区域的（即BKP），通过BKP后备区域来存储RTC配置的数据可以让其在系统复位或待机模式下唤醒后，RTC里面配置的数据维持不变。

　　PWR：

　　PWR为电源的寄存器，我们需要用到的是电源控制寄存器（PWR_CR），通过使能PWR_CR的DBP位来取消后备区域BKP的写保护。

　　RTC：

　　由一组可编程计数器组成，分成两个模块。第一个模块是RTC的预分频模块，它可编程产生最长为1秒的RTC时间基准TR_CLK。RTC的预分频模块包含了一个20位的可编程分频器（RTC）TR_CLK 周期中RTC产生一个中断（秒中断）。第二个模块是一个32位的可编程计数器，可被初始化为当前的系统时间。系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比较，如果RTC_CR控制寄存器中设置了相应允许位，比较匹配时，将产生一个闹钟中断。

　　

( \# J1 y+ K; J

　　下面讲解下配置整体过程：

　　　第一步： 通过设置寄存器 RCC_APB1ENR 的 PWREN 和 BKPEN 位来打开电源和后备接口的时钟
; K! L/ C2 @8 e% |8 t6 R8 R3 n　　　调用库函数：

　　　　RCC_APB1PeriphClockCmd (RCC_APB1Periph_PWR | RCC_APB1Periph_BKP,ENABLE );

　　　第二步：电源控制寄存器(PWR_CR) 的 DBP 位来使能对后备寄存器和 RTC 的访问

　　　调用库函数：

　　　　PWR_BackupAccessCmd(ENABLE );

　　　第三步：初始化复位 BKP 寄存器

　　　调用库函数：

　　　BKP_DeInit ();

　　　第四步：设置 RTCCLK，如下图：

　　

# t; Z8 i; f; O, o; N4 d  I% \2 t- ?

　　　我们需要将 RTCCLK 设置为 LSE OSC  这个 32.768KHZ 的晶振。

　　　调用的库函数：　　

　　　RCC_LSEConfig (RCC_LSE_ON);

　　　While(!RCC_GetFlagStatus (RCC_FLAG_HSERDY));//设置后需要等待启动

8 r  y0 _; Y. K" x# T) Y

　　　第五步：将 RTC 输入时钟 选择为 LSE 时钟输入并使能 RTC，等待 RTC 和 APB 时钟同步

　　　调用库函数：

　　　RCC_RTCCLKConfig (RCC_RTCCLKSource_LSE);//选择 LSE 为 RTC 设备的时钟

　　　RCC_RTCCLKCmd (ENABLE );//使能

　　　RTC RTC_WaitForSynchro();//等待同步

　　第六步：配置 RTC 时钟参数。

• 查询 RTOFF 位，直到 RTOFF 的值变为’1’
• 置 CNF 值为 1 ，进入配置模式
• 对一个或多个 RTC 寄存器进行写操作
• 清除 CNF 标志位，退出配置模式
• 查询 RTOFF，直至 RTOFF 位变为’1’ 以确认写操作已经完成。仅当 CNF 标志位被清除时，写操作才能进行，这个过程至少需要 3 个 RTCCLK 周期。
  

　　按照上述步骤用库函数来配置：

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   4 c- k8 v2 P8 i  Y) L( z
2. 
   # A& }6 ]3 q$ V' H
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   2 f- Z1 M3 z, [6 M% U
4. 
   
5. /*
   4 U  V: K) D! y- j7 s" @
6. 
   * z0 R, V) l- c4 e
7. 2.置 CNF 值为 1 ，进入配置模式
   5 W: y6 q- ^! V( [" q
8. 
   , b* S$ _5 }1 I- p; V) N
9. 3.对一个或多个 RTC 寄存器进行写操作
   
10. 
    
11. 4.清除 CNF 标志位，退出配置模式
    5 A  l, s' P% J+ _3 m
12. 
    
13. */
    
14. 
    # l! z2 }) i" l: ?
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    
16. 
    
17. /*
    
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    
19. */
    ) v' c. ~5 T: f
20. RTC_WaitForLastTask();//等待更新结束
    2 @* B, L! ?2 ?* s9 \; I- r
21. 
    
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    6 [+ H1 S0 n7 U. \
23. 
    ( s- \( d/ n5 w) V, a
24. RTC_WaitForLastTask();//等待更新结束

复制代码

三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   , H8 u" j/ j3 ~& U& w
2. #define __RTC_H
   / m5 g) b; o/ q* C
3. #include "stm32f10x.h"
   
4. 
   
5. //时间结构体
   
6. typedef struct
   ( R: k, s5 r+ h
7. {
   * q9 i: j& P% i# i: y. P4 f# u
8.     vu8 hour;
   7 f; q, h9 y: u/ \. G. Q
9.     vu8 min;
   3 D# C4 k7 z1 L0 |( f* ^
10.     vu8 sec;            
    
11.     //公历年月日周
      K8 q3 C& w  Q1 `6 S
12.     vu16 w_year;
    " [+ x$ F8 O, s& q
13.     vu8  w_month;
    
14.     vu8  w_date;
    
15.     vu8  week;     
    8 |5 m) o* H- K" Y% F6 c5 P
16. }_calendar_obj;                     
    $ j9 f0 x! N+ d# g" x4 Q$ w
17. extern _calendar_obj calendar;
    7 J* u" |$ v* o0 a0 J' I7 e! q4 P
18. void RCC_Configuration(void);
    5 f/ p# K; L: b* M3 e- ~+ k
19. void RTC_Init(void);
    
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    
21. u8 RTC_Get(void);
      u0 @: z: Q& T0 Q: |; M; B6 g
22. #endif

复制代码

　　rtc.c

1. #include "rtc.h"
   0 Q- ?( |- R. w6 ^5 Z) m0 o
2. _calendar_obj calendar;    //时钟结构体
   
3. //平均的月份日期表
   
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   ; a! m' N4 W) L) |
5. /*rtc中断向量配置*/
   
6. void NVIC_Configuration(void)
   
7. {
   
8.     NVIC_InitTypeDef NVIC_InitStructure;
   
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    ( {4 I" G2 z( [3 \9 ?( e/ K
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
14.     NVIC_Init(&NVIC_InitStructure);
    
15. }
    , R; W* h* H, P9 C4 n; ]
16. 
    
17. void RTC_Configuration(void)
    % M4 W- j) M5 z, ]& ^' s. B
18. 
    + e. A: j: k& f7 K
19. {
    
20.     /* 使能PWR和BKP时钟 */
    6 i7 i6 c0 f4 N0 ?  U1 [' R
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    ( D1 S) `* \, E/ @# I
22.     /* 使能对后备寄存器的访问 */
    
23.     PWR_BackupAccessCmd(ENABLE);
    
24.     /* 复位BKP寄存器 */
    
25.     BKP_DeInit();
    6 z" l, Y% o: R# v2 H; R+ ?$ A
26.     /* 使能LSE */
    
27.     RCC_LSEConfig(RCC_LSE_ON);
    
28.     /*等待启动完成 */
    
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    $ ~( j, c. L- r6 }: C. A2 |" A
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    * }! T4 Y7 S: m1 x
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    
32.     /* 使能RTC Clock */
    1 x' O$ `2 Q5 t* K5 e& f0 W+ ~
33.     RCC_RTCCLKCmd(ENABLE);
    : k" Y" C. c" o: o8 ?2 @/ F
34.     /* 等待同步 */
    " G. t$ k6 ]  |2 C, N/ @. w9 X
35.     RTC_WaitForSynchro();
    
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    7 g8 q  t& d1 r# s1 K
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    ) K/ ?7 e4 R7 u
40.     /* 等待对RTC寄存器最后的写操作完成 */
    
41.     RTC_WaitForLastTask();
    
42.     /* 使能RTC秒中断 */
    
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    
45.     RTC_WaitForLastTask();
    
46. 
    - @- S4 S# K0 e9 {+ v1 \4 o; Y
47. void RTC_Init(void)
    6 S( |  ]; {. U/ P4 A2 v3 E
48. {
    ' F1 L; h3 }7 v7 A- T
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    & Z. o# y. U, R5 T) I0 P
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    
51.     {
    3 S* ~& v% a. _! B
52.             RCC_Configuration();
    
53.             RTC_Set(2016,5,11,9,7,55);
    
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    # E* l& f7 e* J
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    8 z& D2 w" u7 [0 l' `/ [
56.     }
    ! E& ?6 a' m9 I- @- W1 V3 C
57.     else
    + L. d( g2 r5 E$ |( C  B9 B* |3 a! l
58.     {
    . m& G4 Z- H7 C+ z5 y
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    9 s! ?3 \2 t6 ~, L& l& t4 }
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    * H/ W3 p% M2 A6 e$ ]
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    : ?3 }# _1 g) }( G! {( K6 h
63.     }
    
64.     NVIC_Configuration();
    
65.     RTC_Get();//更新时间
    
66. }
    
67. u8 Is_Leap_Year(u16 pyear)
    . Q" d8 C' R0 U2 D
68. {
    
69.     if(pyear%4==0)//首先需能被4整除
      @) z( d9 h6 y0 Q0 H* T' k
70.     {
    
71.         if(pyear%100==0)
    # Q5 F( U" i! r$ F* `1 C2 @
72.         {
    
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    : b+ Y- J5 o. Q! e
74.             else    return 0;
    
75.         }
      l. O; P4 B: [/ O. t
76.         else
    : e) r! A3 z/ p
77.             return 1;
    
78.     }
    
79.     else
    
80.         return 0;
    
81. }
    
82. /*
    3 @- C1 p) D' S4 U/ c, u+ o
83. *设置时钟
    ' k( G% c2 v8 H( h! E( V" V* V
84. *把输入的时钟转换为秒钟
    
85. *以1970年1月1日为基准
    
86. *1970~2099年为合法年份
    2 K/ b: K  w% e! N2 W
87. 返回值：0，成功；其它：错误
    7 b) J2 t) i4 }3 T! C* C
88. */
    2 J0 k/ i  j2 W& ]5 o. _8 H9 r% v
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    
90. {
    
91.     u16 t;
    ! N% Q9 H- @0 v# J) \; j# G
92.     u32 secCount=0;
    $ `" e- G! Q; t% |8 y5 m9 [
93.     if(year<1970||year>2099)
    
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    ( s& z9 ^5 ?6 s
96.     {
    * N; L* J; W4 e% t; c; p; O& w
97.         if(Is_Leap_Year(t))//闰年
    # Y& E' ]0 r. O6 d& @# ?; [
98.             secCount+=31622400;//闰年的秒钟数
    
99.         else
    ! ?9 w6 P) p* m; b" X( [. O
100.             secCount+=31536000;   
     
101.     }
     5 n3 h+ U1 T: p$ P: {
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     - U- Z* ^1 C- v7 _) S+ c" x
103.     for(t=0;t<mon;t++)
     
104.     {
     
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     ' c" k& f1 c# o2 L
106.         if(Is_Leap_Year(year)&&t==1)
     3 z0 Q) u3 X; J
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     
108.     }
     ) g; v* E" F" p) @0 c9 A6 J
109.    
     ! ]# z$ t" }4 T9 S3 i3 {* w7 U% @
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     & B* X1 L2 X* m6 p' C# N4 T: U% d
111.     secCount+=(u32)hour*3600;//小时秒钟数
     
112.     secCount+=(u32)min*60;//分钟秒钟数
     ! f; b2 E7 n- T  R0 L( G. m; I
113.     secCount+=sec;
     
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     
115. //    PWR_BackupAccessCmd(ENABLE);
     
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     * i4 C& [3 D3 {
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     
118.     RTC_Get();//更新时间
     ! b6 z$ y5 X4 k  H0 e
119.     return 0;
     4 U  k  _% g% A% q2 e# z$ U2 O
120. }
     
121. 
     6 @$ y& D" o  Z& z8 A- }
122. /*
     % m: U1 `" @: i  ?9 s/ q6 W9 I, M1 ^
123. 得到当前的时间
     
124. 成功返回0，错误返回其它
     # T- M) U9 M# D0 }4 Q2 U- u
125. */
     / f" l% E# O' c4 h" J9 R
126. u8 RTC_Get(void)
     9 G/ O+ F1 V2 n6 m# E; O) b! b
127. {
     . d1 O7 ]' M" u# f& M" ^
128.         static u16 dayCount=0;
     : O# [8 N: @6 J+ i# v: k- r
129.         u32 secCount=0;
     ) Q" _# L& E: ^/ Y" u1 s# z
130.         u32 tmp=0;
     
131.         u16 tmp1=0;
     
132.         secCount=RTC_GetCounter();
     , P8 G  W' N" j( e# U
133.         tmp=secCount/86400;//得到天数
     ! r5 t' C2 Q7 f) ^  w, e
134.         if(dayCount!=tmp)//超过一天
     # x4 b9 U: L) ~6 d
135.         {
     
136.             dayCount=tmp;
       [9 f4 Z2 ^. x5 G4 i2 M
137.             tmp1=1970;//从1970年开始
     / k. L$ S- S- A/ H" @" ~
138.             while(tmp>=365)
     % n: b8 \) f! Y
139.             {
     
140.                 if(Is_Leap_Year(tmp1))//是闰年
     
141.                 {
     5 M' R( x/ U$ N! n4 s8 D
142.                     if(tmp>=366)   
     
143.                         tmp-=366;//减掉闰年的天数
     
144.                     else
     6 ?. L: {! s, E
145.                     {
     
146.                     //    tmp1++;
     - S( \: e, l" |. a& [
147.                         break;
     3 B" h6 U* N# b3 F5 {
148.                     }
     
149.                 }
     5 F9 L  V0 B7 X8 ^0 p2 w
150.                 else
     ' T8 @4 g; k2 D$ p8 Q& P
151.                     tmp-=365;//平年
     
152.                 tmp1++;
     
153.             }
     
154.             calendar.w_year=tmp1;//得到年份
     8 Z) }+ F% p: c8 B- ^0 C
155.             tmp1=0;
     
156.             while(tmp>=28)//超过一个月
     
157.             {
     
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     3 R" W* F% R& |5 B
159.                 {
     : ?+ m* l9 Y+ y
160.                     if(tmp>=29)   
     0 j2 h! Y% n+ {  D3 [7 I
161.                         tmp-=29;
     
162.                     else
     
163.                         break;
     
164.                 }
     
165.                 else
     
166.                 {
     ; n9 P/ m6 x! q' j' L, u
167.                     if(tmp>=mon_table[tmp1])//平年
     
168.                         tmp-=mon_table[tmp1];
     ' [* I1 G+ T, E2 T8 H; u! {
169.                     else
     
170.                         break;
     
171.                 }
     # l9 p+ ?- U" K4 ^; c  t. q* ~
172.                 tmp1++;
     . z( h( a; ~( m: i$ C
173.             }
     
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     , ]& X7 l' p6 C
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     % r; j; n5 U( N1 e9 K7 }6 a
176.         }
     , `+ t8 C3 q, W
177.         tmp=secCount%86400;//得到秒钟数
     
178.         calendar.hour=tmp/3600;//小时
     ; {) z1 F# A/ A' a9 g$ ~: M
179.         calendar.min=(tmp%3600)/60;//分钟
     
180.         calendar.sec=(tmp%3600)%60;//秒
     + @: O/ U$ o- Y9 V% P
181.         return 0;
     
182. }
     ; C% M- }+ w1 l8 }
183. /*
     
184. RTC时钟中断
     ) ^9 R/ }% d( v* f0 U1 N1 B
185. 每秒触发一次
     1 U8 c3 Y& d' u0 ?4 O
186. */
     ( G+ j6 l( C* Q) d+ d3 m
187. void RTC_IRQHandler(void)
     ! O+ b( d: f' w, t0 T
188. {         
     
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     
190.     {                           
     
191.         RTC_Get();//更新时间
     
192.       
     4 }! X& p0 g6 W  I# }
193.      }
     
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     0 N7 R+ L1 ^1 O* B3 M% `, o4 p
195.     {
     
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     4 r: v* B1 y: a  W  R" v1 l
197.   }                                                   
       @; ]# H0 Q" Q5 K% E6 V& }5 `) A! a
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     ( n* _9 L, b) m( z
199.     RTC_WaitForLastTask();                                                   
     
200. }

复制代码

# @# D; H3 _* T" c

　　main.c

1. #include "stm32f10x.h"
   ! m( f/ n6 \3 w: `( R' X
2. #include "usart1.h"
   , w# w. C3 Y4 q4 l
3. #include "LED.h"
   
4. #include "delay.h"
   5 E2 Q, ]% {! Z7 A& z7 D; _
5. #include "flash.h"
   4 ^$ [& E: }9 E( J+ D& O
6. #include "rtc.h"
   
7. #include "stdio.h"
   2 Y7 J4 m# t6 }
8. int main(void)
   
9. {
   1 ]$ ^0 y# n( n) i. L1 L  |/ L
10.     u8 t=0;
    ' \, h+ q: u0 \) @
11.     USART1_Config();
    ' u9 u8 n& B, m) n8 F
12.     GPIO_Configuration();
    
13.     RTC_Init();
    
14.     while(1)
    8 L( t) T1 B; i9 a/ P, ^! y: u4 }" }
15.     {
    
16.         if(t!=calendar.sec)
      T* o9 [/ q: ^4 J9 s- N
17.         {
    
18.             t=calendar.sec;
    * |" }% j" ~/ S
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    % F+ n$ C4 ?) y% T! t1 m3 M
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    + L" |; O' H! J1 O
21.         }
    
22.         Delay(0x02FFFF);
    / m  x5 u1 s  C. F: G9 O* P. U, f
23.     }
    
24.    
    ) m2 J! ]4 l7 q* E0 {' ~' f+ i
25.    
    
26. }   

复制代码