一、关于时间

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

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

                2^31/3600/24/365 ≈ 68年
. X8 d6 v, y( Q　　所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
                 2^32/3600/24/365 ≈ 136年
　　到2116年，这个整数将溢出。
) T0 j( L( Q. k0 T; ^　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
9 c: B& C. ^. B# d　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
6 L( w, P/ b9 G- o5 j) \; K: [
二、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控制寄存器中设置了相应允许位，比较匹配时，将产生一个闹钟中断。

　　

" v8 H% ^. e8 y

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

　　　第一步： 通过设置寄存器 RCC_APB1ENR 的 PWREN 和 BKPEN 位来打开电源和后备接口的时钟
% P& G9 ~1 K9 [　　　调用库函数：

　　　　RCC_APB1PeriphClockCmd (RCC_APB1Periph_PWR | RCC_APB1Periph_BKP,ENABLE );

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

　　　调用库函数：

　　　　PWR_BackupAccessCmd(ENABLE );

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

　　　调用库函数：

　　　BKP_DeInit ();

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

　　

" O! `. }; l4 U* C

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

　　　调用的库函数：　　

$ v' _& ]+ X: |5 Z% M

　　　RCC_LSEConfig (RCC_LSE_ON);

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

$ U. _& y& S: ]8 q. Y* 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 周期。
  ( W* i* Q4 j7 K; S0 h2 d) k6 @

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

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   ; A; j7 Z0 I1 o4 y$ w4 @5 e
2. 
   
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   ! m, S6 R1 y- A* f/ x- e, v+ ]6 e! L, B
4. 
   ' e5 W* |8 w5 u7 P. ~
5. /*
   , U/ p. N' R6 U8 u9 ?5 w
6. 
   
7. 2.置 CNF 值为 1 ，进入配置模式
   . i: r( T0 I0 H+ ~
8. 
   , g+ c  f& W1 u/ X2 Q0 r& P* s5 V
9. 3.对一个或多个 RTC 寄存器进行写操作
   * f% i& ~+ k$ C8 Y% t
10. 
    $ _2 |0 p& i5 g$ t/ w
11. 4.清除 CNF 标志位，退出配置模式
    
12. 
    
13. */
    
14. 
    
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    
16. 
    . d+ m3 c5 Z" s1 ?, @$ M/ H
17. /*
    # i6 b& Y- f) x. z( L+ \, C+ D; R
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    
19. */
    
20. RTC_WaitForLastTask();//等待更新结束
    
21. 
    0 `0 f- y5 A6 m6 r
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    ) g  h% }5 R+ f" h1 }  C
23. 
    
24. RTC_WaitForLastTask();//等待更新结束

复制代码

三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   
2. #define __RTC_H
   
3. #include "stm32f10x.h"
   ' Y1 S# Z7 G5 m5 m4 }- W
4. 
   ' ?6 N: }$ x* m$ ?4 h
5. //时间结构体
   
6. typedef struct
   " |: H4 u* G& ?2 F9 U5 W$ e( S6 E
7. {
   
8.     vu8 hour;
   1 x& }/ U9 a2 H" \4 {
9.     vu8 min;
   ' q$ E6 j- M6 K) \# N( F
10.     vu8 sec;            
    
11.     //公历年月日周
    0 Q# Q2 i2 n  l8 d1 p, N& x
12.     vu16 w_year;
    
13.     vu8  w_month;
    
14.     vu8  w_date;
    
15.     vu8  week;     
    
16. }_calendar_obj;                     
    + U! h! v( J) @  E+ c2 ?, E( G% X
17. extern _calendar_obj calendar;
    7 m6 n7 z* L+ x. @" P$ i( d# I+ h: Y
18. void RCC_Configuration(void);
    2 |  x, V- o  h0 s% z) i
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);
    
22. #endif

复制代码

) C% |* `* l7 a4 h' {& {
% l5 V6 |& c! T1 w% N4 H

　　rtc.c

1. #include "rtc.h"
   
2. _calendar_obj calendar;    //时钟结构体
   
3. //平均的月份日期表
   : @6 h. A: ^- ]3 u8 c, m8 k) {
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   2 e7 K. ?% b) d1 O3 i
5. /*rtc中断向量配置*/
   7 H5 S& d% G2 D$ n  s& }9 i, ?( P' K
6. void NVIC_Configuration(void)
   
7. {
   , g! s" f1 s  ~5 a' F  T3 o
8.     NVIC_InitTypeDef NVIC_InitStructure;
   
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    . @) J$ f1 W1 j, s+ u# L
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
14.     NVIC_Init(&NVIC_InitStructure);
    
15. }
    . x0 f: z5 J" Z* h
16. 
    
17. void RTC_Configuration(void)
    4 N3 l% x8 q( N: n$ v2 ~6 o
18. 
    
19. {
    / |, K1 F5 U4 O; }9 U- T  A8 O
20.     /* 使能PWR和BKP时钟 */
    
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    
22.     /* 使能对后备寄存器的访问 */
    . n1 }" I. {5 m" a3 I9 `
23.     PWR_BackupAccessCmd(ENABLE);
    
24.     /* 复位BKP寄存器 */
    
25.     BKP_DeInit();
    
26.     /* 使能LSE */
    # b$ U3 l2 p; i- M
27.     RCC_LSEConfig(RCC_LSE_ON);
    
28.     /*等待启动完成 */
    + ]" B0 I0 A8 E5 b" ?
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    1 l, L! b: B; t; h- U
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    
32.     /* 使能RTC Clock */
    
33.     RCC_RTCCLKCmd(ENABLE);
    & e' @- X. F0 S( F8 p( G* w& E
34.     /* 等待同步 */
    0 L4 _' {" L  E1 a3 T$ B( g
35.     RTC_WaitForSynchro();
    
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    5 ?' I6 q5 p& y1 B5 J6 T* G
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    
40.     /* 等待对RTC寄存器最后的写操作完成 */
    
41.     RTC_WaitForLastTask();
    
42.     /* 使能RTC秒中断 */
    
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    ) m  K1 g$ L1 {' H4 e
45.     RTC_WaitForLastTask();
    3 U+ A6 j4 I; i) t4 P
46. 
    
47. void RTC_Init(void)
      q5 z9 u( U& T4 ^
48. {
    8 w! _- h; O3 j% _* e
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    
51.     {
    ( j+ v5 R+ w( i7 h2 l1 m2 H8 n/ r
52.             RCC_Configuration();
    : o/ k# M" d" O, i( {
53.             RTC_Set(2016,5,11,9,7,55);
    
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    & c0 @) K4 j# h- T
56.     }
    ) z$ @: t4 c* `" j6 C/ v$ q6 B
57.     else
    
58.     {
    ; [0 h0 I% ^- [8 F  C
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    ! n$ f7 [& q$ x/ J: X( L
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    ) z$ K3 o* @6 n5 ~8 D
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    7 A8 L: n8 E* b" n2 J
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    
63.     }
    3 c  c, S& m! {% ?& ^+ ?
64.     NVIC_Configuration();
    4 x. x* s, g8 R7 Q
65.     RTC_Get();//更新时间
    
66. }
    - r( R' v# h: T- a. T
67. u8 Is_Leap_Year(u16 pyear)
    7 R; L+ W( \  a, ]8 Y: v0 L
68. {
    ! m( Q6 o7 @: u
69.     if(pyear%4==0)//首先需能被4整除
    8 Q9 c1 D: E5 u! U9 _5 |: z% k
70.     {
    $ f9 j" H* D& b- X
71.         if(pyear%100==0)
    6 w2 R( W: N8 A& s
72.         {
    " Y9 R! ~2 _8 y$ q( M9 ?
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    : x3 z, K+ l; R
74.             else    return 0;
    ( g5 _6 m  i2 U
75.         }
    
76.         else
    . y$ B* I# ^9 z7 v8 l! O
77.             return 1;
    " [+ W9 q) l6 H/ T6 G3 \
78.     }
    
79.     else
    ) C% L5 }9 C2 e% H
80.         return 0;
    
81. }
    9 W, o7 H+ n6 I! y1 D5 A* s9 C
82. /*
    
83. *设置时钟
    
84. *把输入的时钟转换为秒钟
    
85. *以1970年1月1日为基准
    ' [! @, u0 b% o5 ^0 h6 \" c2 W
86. *1970~2099年为合法年份
    $ F1 _6 ?1 \% t' F. `5 P
87. 返回值：0，成功；其它：错误
    6 d8 e7 h/ U/ b  H8 @5 y: y
88. */
    
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    ) s7 e( O! X8 p7 {4 O8 h8 r
90. {
    * J/ c! s  Z, }, Q
91.     u16 t;
      U  O6 {1 o" ~, X3 G9 Y6 q# Z) n
92.     u32 secCount=0;
      y6 ^6 S! ]/ x4 E% {1 }: n( K2 t
93.     if(year<1970||year>2099)
    2 V5 f" i: H) G5 ?
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    
96.     {
      Y( L& k7 W( t9 i0 u( ~! X
97.         if(Is_Leap_Year(t))//闰年
    ! R3 \5 [3 d7 H2 K
98.             secCount+=31622400;//闰年的秒钟数
    
99.         else
    7 h; [3 F' C$ X' @2 E. Y
100.             secCount+=31536000;   
     
101.     }
     9 j( O- J+ @" d* ?' d! G, `  E5 F
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     ; }0 D# d0 p- @- I  }
103.     for(t=0;t<mon;t++)
     
104.     {
     6 b2 w" L5 K+ ]8 K1 Y5 ?- G
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     
106.         if(Is_Leap_Year(year)&&t==1)
     ! e# f/ N% y. h3 o6 ?) m
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     ( U- r% T2 X9 ]- ~
108.     }
     & ?. ^8 Z+ M8 {1 Q( l" l1 r
109.    
     
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     
111.     secCount+=(u32)hour*3600;//小时秒钟数
     . _( Y; \8 b1 T6 V* ?
112.     secCount+=(u32)min*60;//分钟秒钟数
     ! A& A% u  I0 z6 {
113.     secCount+=sec;
     
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     ' o2 Y4 @: n9 B* g5 ]9 N; v2 s6 g  \
115. //    PWR_BackupAccessCmd(ENABLE);
     
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     
118.     RTC_Get();//更新时间
     0 T% \' r7 p6 }
119.     return 0;
     5 @4 x* N; }( e  v1 a2 c$ p- A
120. }
     
121. 
     7 i) E/ |: Z+ u
122. /*
     , I' {7 ~- q% E$ _( n
123. 得到当前的时间
     ; e0 d. J; s9 r" w9 F7 F
124. 成功返回0，错误返回其它
     
125. */
     
126. u8 RTC_Get(void)
     * w2 T( G4 w( ]' [3 H  R
127. {
     
128.         static u16 dayCount=0;
     % P" G1 L+ ], Q& x* q
129.         u32 secCount=0;
     
130.         u32 tmp=0;
     . g5 c: i& B, }& P
131.         u16 tmp1=0;
     ( O4 e; p+ Z- j4 j* m. R8 V. o' r
132.         secCount=RTC_GetCounter();
     
133.         tmp=secCount/86400;//得到天数
     % R; Q- h+ ]) ^+ n
134.         if(dayCount!=tmp)//超过一天
     
135.         {
     9 u7 C% r) N6 U! }5 M
136.             dayCount=tmp;
     
137.             tmp1=1970;//从1970年开始
     * q4 i1 I% Z! d- \
138.             while(tmp>=365)
     * c: k; M* o+ W% e
139.             {
     - a' z) n8 W& t6 c5 I
140.                 if(Is_Leap_Year(tmp1))//是闰年
     $ R: B3 x0 a5 }9 {, n7 a7 M$ J8 T
141.                 {
     
142.                     if(tmp>=366)   
     
143.                         tmp-=366;//减掉闰年的天数
     / Q1 |& e2 ?- F7 \# [
144.                     else
     $ F  _' @4 {! ]$ g& g' l
145.                     {
     1 h# a& m  E% z3 r' ~( S0 v
146.                     //    tmp1++;
     
147.                         break;
     
148.                     }
     
149.                 }
     
150.                 else
     
151.                     tmp-=365;//平年
     
152.                 tmp1++;
     
153.             }
     * i/ w' g7 b% o  Q
154.             calendar.w_year=tmp1;//得到年份
     ! {1 j* ?9 ]/ D
155.             tmp1=0;
     ' G) \6 @" S/ p5 f
156.             while(tmp>=28)//超过一个月
     ; l; ~' o7 `; j1 ^$ |! l
157.             {
     
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     
159.                 {
     $ }! k; D3 W8 ~5 j& _2 o
160.                     if(tmp>=29)   
     " ^" t. N& d( Y  d' |. Z
161.                         tmp-=29;
     
162.                     else
     % U7 C& Q$ C1 T
163.                         break;
     7 g' s: i( s* x" t
164.                 }
     
165.                 else
     
166.                 {
     
167.                     if(tmp>=mon_table[tmp1])//平年
     
168.                         tmp-=mon_table[tmp1];
     ( J8 {' `) k/ ]% D
169.                     else
     # `" p- x9 P; t
170.                         break;
     
171.                 }
     ! \$ J- @* L  c9 D/ K2 o0 I# B
172.                 tmp1++;
     
173.             }
     1 A# E3 B: f1 P# v# |
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     # ^5 z& l9 K, k' M
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     # j6 P8 f; j7 O- `0 T
176.         }
     
177.         tmp=secCount%86400;//得到秒钟数
     , K& x+ s0 S: D; G1 w
178.         calendar.hour=tmp/3600;//小时
     
179.         calendar.min=(tmp%3600)/60;//分钟
     ; Q/ r: `( j# T! Z5 |' z( y, q# g
180.         calendar.sec=(tmp%3600)%60;//秒
     6 ?  a) t6 O( G- X, d
181.         return 0;
     
182. }
     
183. /*
     
184. RTC时钟中断
     
185. 每秒触发一次
     ' L. F0 q" ]8 D, h- @, x! P+ w& N
186. */
     * g) O' x* ]  g8 ?% G
187. void RTC_IRQHandler(void)
     . x5 ^: [+ |' F/ {( S" x/ @7 _
188. {         
     - O7 y7 u0 T( y
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     2 U4 q& j* X7 A. a( S
190.     {                           
     
191.         RTC_Get();//更新时间
     ' T8 r. E1 u& X0 s: Q/ o
192.       
     & K2 D) V( Y5 X4 o
193.      }
     
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     
195.     {
     
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     
197.   }                                                   
     ( _% F) N+ s% t1 u- ?4 l
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     
199.     RTC_WaitForLastTask();                                                   
     
200. }

复制代码

　　main.c

1. #include "stm32f10x.h"
   & s# U; O( e( x, l
2. #include "usart1.h"
   
3. #include "LED.h"
   
4. #include "delay.h"
   8 ]" d0 }( M( t! `( [
5. #include "flash.h"
   
6. #include "rtc.h"
   
7. #include "stdio.h"
   
8. int main(void)
   + C$ i" a$ n" L( ^% z
9. {
   0 i6 v* n1 t: S2 ?$ I& }& W: J
10.     u8 t=0;
    
11.     USART1_Config();
    
12.     GPIO_Configuration();
    ! O/ x# k, g( Z6 }. ^
13.     RTC_Init();
    2 \7 `4 i# e, ?
14.     while(1)
    
15.     {
    
16.         if(t!=calendar.sec)
    
17.         {
    * O/ \# }. @0 v) x( y3 V6 j
18.             t=calendar.sec;
    
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    / a. M$ R" a0 l, u
21.         }
    & x# v8 f4 ?# `4 a
22.         Delay(0x02FFFF);
    + }4 B6 |0 @# z: `( j
23.     }
    
24.    
    , {0 |7 ^) q( h1 [
25.    
    
26. }   

复制代码

3 Y3 R' Q# I! Y2 m5 t- L
. d7 ~# _- g! N! o- Q) Y9 [