一、关于时间

　　在计算机应用上，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时间非常类似。可以算得：
  l! G" A/ p: `7 k7 s  l                 2^32/3600/24/365 ≈ 136年
. L+ f0 E1 |) d( e- N! z　　到2116年，这个整数将溢出。
( Z3 k6 l; I4 s9 _2 e% ~% {　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
) Q, X% V0 a8 e/ c6 g+ H  h
' ~' ]( N, q5 ]" {7 {) a* V  ~二、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控制寄存器中设置了相应允许位，比较匹配时，将产生一个闹钟中断。

　　

- v" o- {& b1 |$ P1 C9 K

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

　　　第一步： 通过设置寄存器 RCC_APB1ENR 的 PWREN 和 BKPEN 位来打开电源和后备接口的时钟
1 i! S+ T7 w4 A- `$ j7 q! t4 s! p* c　　　调用库函数：

　　　　RCC_APB1PeriphClockCmd (RCC_APB1Periph_PWR | RCC_APB1Periph_BKP,ENABLE );

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

　　　调用库函数：

　　　　PWR_BackupAccessCmd(ENABLE );

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

　　　调用库函数：

　　　BKP_DeInit ();

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

　　

) ?' j5 n  m/ _! g

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

　　　调用的库函数：　　

/ v: h7 r. k  J+ G7 X" X$ |

　　　RCC_LSEConfig (RCC_LSE_ON);

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

) s( f4 F8 R( I" a% d

　　　第五步：将 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 周期。
  # U/ e4 [$ [7 G- N2 Z* A; m

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

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   
2. 
   
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   
4. 
   : p( L0 c2 k+ \/ ]! e
5. /*
   
6. 
   
7. 2.置 CNF 值为 1 ，进入配置模式
   3 }' V# b3 X- G7 [0 f
8. 
   
9. 3.对一个或多个 RTC 寄存器进行写操作
   & _! t$ [6 A% B: B1 _- l
10. 
    + ]7 ]0 W9 K3 p  T  b/ K
11. 4.清除 CNF 标志位，退出配置模式
    * x4 @# w7 {8 `! {3 b1 }
12. 
    ) o; m$ L6 ], U$ ]
13. */
    ! L1 L8 O/ R8 ?, ]& e: z
14. 
    
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    3 ]6 H, ]# m) x5 N  K
16. 
    
17. /*
    
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    
19. */
    
20. RTC_WaitForLastTask();//等待更新结束
    
21. 
    
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    
23. 
    
24. RTC_WaitForLastTask();//等待更新结束

复制代码

/ `3 n* e0 u3 T5 w* J+ y( V3 p
% ~  E  s6 |' @7 ]$ X$ e0 [三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   ( n) M( k4 I4 y3 H. z( A
2. #define __RTC_H
   3 b0 r* ]9 a  s
3. #include "stm32f10x.h"
   ; {$ A2 q) j5 E$ P
4. 
   
5. //时间结构体
   : [4 q+ o1 t; H; J: V& T* s5 J5 ]
6. typedef struct
   
7. {
   % ?: E: a1 s6 y# c* G
8.     vu8 hour;
   
9.     vu8 min;
   
10.     vu8 sec;            
    
11.     //公历年月日周
    
12.     vu16 w_year;
    
13.     vu8  w_month;
    
14.     vu8  w_date;
    5 H" q! _4 }* Y0 V' L5 N* [
15.     vu8  week;     
    
16. }_calendar_obj;                     
    
17. extern _calendar_obj calendar;
    3 y2 a6 o6 O) M  w" x5 B+ q
18. void RCC_Configuration(void);
    
19. void RTC_Init(void);
    
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    $ _( w1 s; W2 ~; \1 f
21. u8 RTC_Get(void);
    * I2 X- t, A( P( l
22. #endif

复制代码

) ~) o6 V* r! ^3 J7 X

　　rtc.c

1. #include "rtc.h"
   
2. _calendar_obj calendar;    //时钟结构体
   
3. //平均的月份日期表
   0 s& I4 `* T9 F$ g* I. h
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   ) p  h. u( v7 `( w! Y
5. /*rtc中断向量配置*/
   
6. void NVIC_Configuration(void)
   
7. {
   - ^2 y& D; C" s) X% V- c
8.     NVIC_InitTypeDef NVIC_InitStructure;
   
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    , {) V2 e; ^, n6 t, K& U( \0 E2 l
14.     NVIC_Init(&NVIC_InitStructure);
    . D1 {! q1 z  e  M" f1 R
15. }
    
16. 
    , t8 J4 L5 E; d6 w! ~! L5 M
17. void RTC_Configuration(void)
    6 b0 B* @8 P& G
18. 
    ; k# [& y, ~% Y/ T: e, g0 F! ?
19. {
    % H. C6 \  b7 S* H
20.     /* 使能PWR和BKP时钟 */
    - }  j/ Q! i& r6 }
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    
22.     /* 使能对后备寄存器的访问 */
    6 j( c- D( \; o. e
23.     PWR_BackupAccessCmd(ENABLE);
    
24.     /* 复位BKP寄存器 */
    ( A! T0 ?+ I1 V9 c4 @
25.     BKP_DeInit();
    
26.     /* 使能LSE */
    
27.     RCC_LSEConfig(RCC_LSE_ON);
    
28.     /*等待启动完成 */
    
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    8 L& }0 f" J. i
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    ' s8 |$ v2 |, {% C0 t1 _5 i# P: L
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    % k* l2 Z/ m/ l
32.     /* 使能RTC Clock */
    3 b+ d' D9 M- f) l- ^6 b5 N( l* |
33.     RCC_RTCCLKCmd(ENABLE);
    2 _; w: S! e3 W1 j  o  R) l6 J
34.     /* 等待同步 */
    0 K; ~1 I7 E5 ]/ t% v0 W  u
35.     RTC_WaitForSynchro();
    : R- U  l6 C0 t# J
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    8 y& ^% x& X8 G0 h! \
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    
40.     /* 等待对RTC寄存器最后的写操作完成 */
    5 s/ g( |; _9 i) ~7 v
41.     RTC_WaitForLastTask();
    ! ^) a' h' u% @. o8 |
42.     /* 使能RTC秒中断 */
    
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    8 L: h3 K$ C& J; B+ `7 f& Q" f
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    
45.     RTC_WaitForLastTask();
    
46. 
    9 U7 m+ p4 i. z" u$ q% n! A4 ~
47. void RTC_Init(void)
    , S* G$ B  U1 v, l
48. {
    
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    
51.     {
    
52.             RCC_Configuration();
    + N7 h8 t- T- G8 |% @' f0 Y
53.             RTC_Set(2016,5,11,9,7,55);
    : Z1 R3 C( M$ G! b4 }7 p5 _  }
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    
56.     }
    0 @7 O9 d( x6 S* T( \+ m% M6 L
57.     else
    # u7 d9 U1 t, g0 z& e
58.     {
      G4 ^, u% {  i; J( S& h! H2 W3 y
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    : H/ k' C& |$ h* P9 X- @, U# R4 T9 T
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    6 P2 ^: N& y  `0 U9 |
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    : g. J/ v1 M& g+ X6 l. E0 U1 h& w
63.     }
    
64.     NVIC_Configuration();
    
65.     RTC_Get();//更新时间
    ' X3 G3 p; y) n, Y, V7 m' o
66. }
    $ |% y( O- X' h% ], z8 |
67. u8 Is_Leap_Year(u16 pyear)
    
68. {
    
69.     if(pyear%4==0)//首先需能被4整除
    & ^/ @7 _# t5 M, k4 C
70.     {
    ( ^1 f8 p* m; t  |1 P+ @# n" f
71.         if(pyear%100==0)
    / }+ @7 @, v+ Y7 ~/ `. ]" G$ y# Z
72.         {
    ; p4 c( c' Q$ J9 h* K
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    
74.             else    return 0;
    9 D  N9 r7 u% z, i9 B' M
75.         }
    
76.         else
    
77.             return 1;
    
78.     }
    ( I& L, q- A8 X, }
79.     else
    
80.         return 0;
    9 n( r3 i- O1 ]& v( j
81. }
    2 F* a' e$ ^4 i! m' M
82. /*
    ( M  [* I# E: i6 n4 b, `, _
83. *设置时钟
    
84. *把输入的时钟转换为秒钟
    # c$ B2 H6 g2 X2 z
85. *以1970年1月1日为基准
    . ]+ Q% j. c' D( ]3 F6 k2 W
86. *1970~2099年为合法年份
    * Y% d% q1 S) [0 S# E* {
87. 返回值：0，成功；其它：错误
    
88. */
    6 N$ V# `" L" S! v" o; Q( y( E
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    
90. {
    
91.     u16 t;
    , Y3 L9 ~; g# t  d  e
92.     u32 secCount=0;
    ) D% A- I; F5 k& V/ V0 u
93.     if(year<1970||year>2099)
    
94.         return 1;//³ö´í
    6 T5 W  y: U4 ]/ z: m3 z, ^7 d$ m
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    
96.     {
    ( b6 L. J# P# q# I. W$ x/ j
97.         if(Is_Leap_Year(t))//闰年
    
98.             secCount+=31622400;//闰年的秒钟数
    ) O8 [0 {* i: A+ W
99.         else
    
100.             secCount+=31536000;   
     
101.     }
     
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     
103.     for(t=0;t<mon;t++)
     
104.     {
     
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     & n- o5 u; D2 F+ I
106.         if(Is_Leap_Year(year)&&t==1)
     
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     1 ~" i; |  q4 _- U; a9 e
108.     }
     
109.    
     
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     + V' p5 x9 O: p7 z: j
111.     secCount+=(u32)hour*3600;//小时秒钟数
     / X4 a* w" Z4 S  f
112.     secCount+=(u32)min*60;//分钟秒钟数
     ) w4 F# [7 C: j/ s
113.     secCount+=sec;
     8 i. l% o/ B: t; e
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     
115. //    PWR_BackupAccessCmd(ENABLE);
     $ N/ E, c  [5 R3 L
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     - d9 R2 z1 n0 {* _
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     / c% f5 y$ C+ Z* s5 r% U. Q2 b
118.     RTC_Get();//更新时间
     7 ^: b6 q; @6 c: @8 j5 ~
119.     return 0;
     
120. }
     
121. 
     " q. Y% \, m$ t8 H
122. /*
     
123. 得到当前的时间
     
124. 成功返回0，错误返回其它
     
125. */
     
126. u8 RTC_Get(void)
     + Z' }% {5 L& c& a! K0 @
127. {
     
128.         static u16 dayCount=0;
     " f& w2 O7 N$ u! H
129.         u32 secCount=0;
     + q2 Q7 P: Y1 {  I, L% x: u, K
130.         u32 tmp=0;
     - }1 V  e; O7 l1 @3 p9 X
131.         u16 tmp1=0;
     * ^" z0 S' `1 ^; I- h
132.         secCount=RTC_GetCounter();
     
133.         tmp=secCount/86400;//得到天数
     
134.         if(dayCount!=tmp)//超过一天
     1 b- t3 d3 \$ `% I. E, g3 c8 t7 n
135.         {
     
136.             dayCount=tmp;
     
137.             tmp1=1970;//从1970年开始
     % P  Z% x; e) y6 c
138.             while(tmp>=365)
     : Y9 `; N5 H1 Y* D6 C! B  x* M9 C
139.             {
     
140.                 if(Is_Leap_Year(tmp1))//是闰年
     
141.                 {
     
142.                     if(tmp>=366)   
     7 B" |, g- `4 n: ]* {, O$ j- v
143.                         tmp-=366;//减掉闰年的天数
     # i( F5 ]2 h/ @$ L0 w/ }5 C9 w
144.                     else
     7 m9 @' c9 y# m1 w* z( b0 J2 J$ j
145.                     {
     : @) \6 e8 d7 L  Q0 K
146.                     //    tmp1++;
     
147.                         break;
     ( l' l; u: b: K
148.                     }
     7 \# G1 j# `6 y
149.                 }
     
150.                 else
     ! ~7 _$ E! C0 `/ |  L9 p
151.                     tmp-=365;//平年
     ! W% j8 G/ ~* E" f  F+ J
152.                 tmp1++;
     - u3 w0 @/ v$ u) ?6 D  R: I
153.             }
     
154.             calendar.w_year=tmp1;//得到年份
     5 g+ |$ ?: j' b, Q) P& y/ f2 q
155.             tmp1=0;
     ! q& }& V. @4 C- f
156.             while(tmp>=28)//超过一个月
     
157.             {
     
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     ( c9 W/ z0 g& c+ w$ |( r
159.                 {
     
160.                     if(tmp>=29)   
     
161.                         tmp-=29;
     
162.                     else
     
163.                         break;
     & G. C& M& Z2 z
164.                 }
     
165.                 else
       h' N2 U  `1 k  t+ a# h
166.                 {
     4 \' q- ?# d0 q- a" R* `, g
167.                     if(tmp>=mon_table[tmp1])//平年
     
168.                         tmp-=mon_table[tmp1];
     5 T% e1 ]6 p- ^! d* h7 ]
169.                     else
     
170.                         break;
     
171.                 }
     
172.                 tmp1++;
     
173.             }
     
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     , O9 j9 {+ {8 F- t3 j
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     
176.         }
     $ y0 b% B* V3 `$ E' O9 n8 {
177.         tmp=secCount%86400;//得到秒钟数
     
178.         calendar.hour=tmp/3600;//小时
     4 X  D9 H* b. r3 q  N; i
179.         calendar.min=(tmp%3600)/60;//分钟
     ( n# g- `. Y$ E' @5 m1 M
180.         calendar.sec=(tmp%3600)%60;//秒
     
181.         return 0;
     4 V" ]% Z3 Z6 c9 K* W- [
182. }
     ) i1 H$ f4 X; V' E& B6 s
183. /*
     . X) T/ k1 G  I( D
184. RTC时钟中断
     
185. 每秒触发一次
     
186. */
     
187. void RTC_IRQHandler(void)
     
188. {         
     
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     
190.     {                           
     
191.         RTC_Get();//更新时间
     0 B7 s" l+ l+ }4 X* n; S
192.       
     9 J" x2 `5 n" ]/ b
193.      }
     ! B& {7 X; B- _. z1 _; B
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     
195.     {
     : S! d7 S7 s# z) v
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     9 L' m) \- R( |# `8 g/ z7 A
197.   }                                                   
     1 o) \8 ^6 J( P4 U* {
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     
199.     RTC_WaitForLastTask();                                                   
     
200. }

复制代码

6 y, l  r; E, e6 U' f+ G& L$ R% w

　　main.c

1. #include "stm32f10x.h"
   
2. #include "usart1.h"
   2 G/ i  n  T) B2 U! U. _" j
3. #include "LED.h"
   ; d' x: D8 T- ?0 j% w" c4 d5 }
4. #include "delay.h"
   - M1 L3 Q/ I# F- X
5. #include "flash.h"
   
6. #include "rtc.h"
   
7. #include "stdio.h"
   
8. int main(void)
   
9. {
   # @1 F* o3 b- \. ]5 v6 C" {* {
10.     u8 t=0;
    
11.     USART1_Config();
    
12.     GPIO_Configuration();
    " Y" c5 z/ Z6 R3 g/ R' Y3 ^9 E+ ^* x. R
13.     RTC_Init();
    
14.     while(1)
    
15.     {
    
16.         if(t!=calendar.sec)
    + y5 _8 t( Q& ^1 R
17.         {
    
18.             t=calendar.sec;
    ; P' F( Z+ X- Q1 P8 M, s
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);
    
21.         }
    
22.         Delay(0x02FFFF);
    " u$ ^5 S1 |1 M8 @4 s; h3 h
23.     }
    
24.    
    ( G/ w" p1 ~4 C9 r. B7 L
25.    
    # ^4 z$ J- D% k* q2 U
26. }   

复制代码

" a9 c5 l* s5 M" r' E( i