所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。

1、I2C通信流程中包含信号如下：
- j( z  ~& k# `+ v$ \
开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
% U# e+ X( [( O5 y+ B  e( [& c结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
/ i! Q. y& {& |7 b2 g4 g7 [应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
2、I2C总线时序图如下：

8 o8 ]% V4 C& T; O" |) O0 {; t' w

2 i! {% m: G& Y4 Z$ [: C: _
4 g! a+ c, w) L/ ~4 w" W4 Z3、I2C通讯过程的基本结构如下所示：
' u9 Y! Q! l8 R4 o8 }* y& T+ |' R
9 R6 z" m  B$ }; z+ ?+ f" I0 c$ E1）主机写数据到从机
5 B2 z- {. D8 `5 V+ l
- p" G6 Z3 n% @

2）主机由从机中读数据

$ K& Y1 m4 W' ]7 b9 x: b3）I2C通讯复合格式

, ^$ H. W+ s0 T  z

2 N) I# J  [' X3 U# B

& c9 C. {; |7 ~/ u/ q" T/ z其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。
! x( y) ?  s' l
起始信号产生后，所有从机就等待主机广播从机地址信号(SLAVE_ADDRESS)。在 I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据 I2C协议，这个从机地址可以是 7位或 10位。

在地址位之后，是传输方向的选择位，该位为 0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为 1时，则相反，即主机由从机读数据。

" V- |8 a3 ?, G5 i; s从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。

若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。
$ P# Y" p9 W( }5 m7 o. u( b+ m
% K% h% a  ^" T0 U5 f若配置的方向传输位为“读数据”方向，即第二幅图的情况，广播完地址，接收到应答信号后，从机开始向主机返回数据(DATA)，数据包大小也为 8 位，从机每发送完一个数据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回 N 个数据，这个 N 也没有大小限制。当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自动停止数据传输。
5 D  W$ S+ z5 y7 p
除了基本的读写，I2C通讯更常用的是复合格式，即第三幅图的情况，该传输过程有两次起始信号(S)。一般在第一次传输中，主机通过 SLAVE_ADDRESS寻找到从设备后，发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它与 SLAVE_ADDRESS 的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。
7 {6 o& ?9 c  n; Q* p2 l
8 J5 N; y: m; Z. W& r8 c$ {4）数据有效性时序图如下：

  p, S8 s7 L7 K, Y' {) ?. I' B
3 {% l6 ]1 T5 a4 Q& FI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。
5 e" f! W% A" v2 U5 m# b" m
5）地址及数据方向
$ L1 y! t) v$ i/ t# }
0 O1 u0 Z+ j2 k3 z* UI2C 总线上的每个设备都有自己的独立地址，主机发起通讯时，通过 SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机。I2C 协议规定设备地址可以是 7位或 10 位，实际中 7 位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向位(R/W)，第 8位或第 11 位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据，如图：
* V( G, A0 w; W
3 H% L& @2 K. x! S+ c5 Z4 s

读数据方向时，主机会释放对 SDA信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。
& t+ Q& P! G6 g) h$ L
bsp_soft_i2c.c程序如下：
( O, o- H& _6 o  w7 X5 P$ {& o

1. #include "bsp_soft_i2c.h"   
   % R* {3 A- c* f7 H
2. #include <stdbool.h>
   
3. 
   
4. // 初始化IIC的IO口
   
5. void I2C2_Soft_Init(void)
   7 o- g! D7 m+ [$ h6 z& i/ q5 p% l0 m
6. {
     w0 {  `$ L0 T" w3 c
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   ( r9 |9 J  D, a: y- @3 X( H
8.         
   " f8 D7 \  C% |
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   
10.         
    
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    ! n0 T9 c7 W( g
12.     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; // 开漏
    
13.     GPIO_InitStructure.GPIO_Pin = Pin_SCL | Pin_SDA ; // IIC对应IO口
    * b) \5 C8 A$ ]; q# w' e( a
14.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // 上拉
    6 \9 S& y% J9 {+ D
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3; // 50MHZ
    ) r( C& y7 e. `" I' K
16.     GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIO
    4 t" Y* t* l/ e$ V( l
17.         
    
18.     I2C2_Stop();
    
19. }
    
20. 
    & K. M6 A$ H* o
21. // 发送IIC起始信号
    + l+ R# D  P8 F+ l% `) p# a
22. bool I2C2_Start(void)
    % n5 @, P# U$ M) `7 Z- a
23. {
    : ]8 ]$ ?* K" Q' D& I
24.     Pin_SCL_H; // 拉高时钟线
    # P) o2 W* q; o1 B6 S
25.     Pin_SDA_H; // 拉高信号线
    . A' [& \# [! G+ y0 I$ z, s9 I. X: d
26.     I2C2_Delay1us();
    ' o% @* k1 H, D5 t
27.     if(!Read_SDA_Pin)                return false;
    ( ~2 `$ y0 u1 x) H! I
28.     Pin_SDA_L;
    
29.     I2C2_Delay1us();
    ! a: `: _+ w+ w% w2 k+ e1 Y( [
30.     Pin_SDA_L;
    * |$ H% M$ w. G+ z
31.     I2C2_Delay1us();
    2 N) g1 _3 ^* c8 }; \
32.     return true;
    
33. }
    ; B+ h7 E1 t& M. q! r; Z4 h
34. 
    
35. // 发送IIC停止信号
    
36. bool I2C2_Stop(void)
    0 X4 `8 s- I& }/ }. K
37. {
    3 c- N% G; @. \# B6 f
38.     Pin_SCL_H;
    
39.     Pin_SDA_L;
    
40.     I2C2_Delay1us();
    
41.     if(Read_SDA_Pin)        return false;
    
42.     Pin_SDA_H;
      I, V& {/ N# y) Q
43.     I2C2_Delay1us();
    6 a5 Y) |. E% w3 S
44.     if(!Read_SDA_Pin) return false;
    % E% u- E" B7 Y! D) P9 x' l
45.     Pin_SDA_H;
    
46.     I2C2_Delay1us();        
    
47.     return true;
    
48. }
    1 [+ K2 j+ [! \' w/ b
49. 
    
50. // IIC发送ACK信号
    
51. void I2C2_Ack(void)
    : U$ a; N# _+ ^: k/ s, Y7 g* L
52. {
    % G3 G& q) Y, m1 R' e5 r
53.     Pin_SCL_L;
    
54.     I2C2_Delay1us();
    & n7 P* W3 S/ k# P; d/ D
55.     Pin_SDA_L;        
    1 I* j( N! \9 P# |9 x1 c) w' p; {
56.     Pin_SCL_H;
    5 z9 r$ n9 ?/ ?+ D
57.     I2C2_Delay1us();
    
58.     Pin_SCL_L;
    ) M7 {3 ~6 g% T, D. h
59.     Pin_SDA_H;
    
60.     I2C2_Delay1us();
    5 f. u2 f5 Z8 M( i( y
61. }
    1 r, h% _, T5 c# j4 I  ?
62. 
    
63. // IIC不发送ACK信号
    + s) h. @" b1 I
64. void I2C2_NAck(void)
    % U/ ~: W) e1 D7 ^
65. {
    
66.     Pin_SCL_L;
    
67.     I2C2_Delay1us();        
    
68.     Pin_SDA_H;
    " G. e/ E- ?2 Z- p) [
69.     Pin_SCL_H;
    
70.     I2C2_Delay1us();
    ' |) Y* f7 [6 P, A* g
71.     Pin_SCL_L;
    
72.     I2C2_Delay1us();
    . J: N' F9 g8 m6 w( a8 `% s4 A
73. }
    8 \5 S. Z( G( b6 r
74. 
    
75. // IIC等待ACK信号
    
76. uint8_t I2C2_Wait_Ack(void)
    
77. {
    
78.     Pin_SCL_L;
    4 ?* m. i7 x! A
79.     I2C2_Delay1us();        
    8 W$ n. p, P& \) N- E& C
80.     Pin_SDA_H;
    * H5 N+ _9 {$ Y, j. ]2 ^$ Z# K
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
    : M0 p$ R; _% d9 W" A+ j2 A4 x
84.     {
    
85.         Pin_SCL_L;
    % a: @4 N2 ?' `4 C) e! u
86.         I2C2_Delay1us();
    # V0 p( R: o+ o! [. h
87.         return false;
    - x$ X% E; ]* N7 s0 ~
88.     }
    
89.     Pin_SCL_L;
    
90.     I2C2_Delay1us();
    
91.     return true;
    7 L6 {; c5 |( Z2 A# `, T
92. }
    
93. 
    
94. // IIC发送一个字节
    
95. void I2C2_Send_Byte(uint8_t txd)
    
96. {
    
97.     for(uint8_t i=0; i<8; i++)
    1 ^( U2 N# Q  g1 g# l9 e  r
98.     {
    
99.         Pin_SCL_L;
    
100.         I2C2_Delay1us();
     7 H$ i  N3 t  Z# a; @6 j) i- G1 N
101.         if(txd & 0x80)
     
102.             Pin_SDA_H;
     
103.         else
     
104.             Pin_SDA_L;
     ' R/ n. \: a9 Y' O
105.             txd <<= 1;
     
106.             Pin_SCL_H;
     , O0 \5 r6 z) T' T+ O- n' k- t
107.             I2C2_Delay1us();
       i+ t3 Z/ b5 k/ G8 @- E
108.     }
     
109. }
     
110. 
     
111. // IIC读取一个字节
     ; C+ ~3 C. X  d/ B3 u
112. uint8_t        I2C2_Read_Byte(void)
     
113. {
     
114.     uint8_t rxd = 0;
     & R( o. B/ P& J2 o
115.     for(uint8_t i=0; i<8; i++)
     & H. S1 }0 Q9 n+ A; m
116.     {
     
117.         rxd <<= 1;
     
118.         Pin_SCL_L;
     : q! r+ N8 \1 a# p- b3 R
119.         I2C2_Delay1us();
     2 \3 j2 t) I/ N: y; c
120.         Pin_SCL_H;        
     . y6 Z' L& F  J5 D+ ~9 d$ U
121.         I2C2_Delay1us();               
     : W1 B! ^" E9 h* ]1 d* w' C! |
122.         if(Read_SDA_Pin)
     9 D! i% n3 x# e# Q" w' h6 S
123.         {
     4 _. S* O' n, |
124.             rxd |= 0x01;
     
125.         }
     6 ~' X$ b) A5 e5 @+ k
126.     }
     
127.     return rxd;
     # f1 |9 z- d3 W6 M2 W% I( Q
128. }
       T9 {, i, L0 y+ A# j
129. 
     
130. // 向从机指定地址写数据
     
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     
132. {
     
133.     if(!I2C2_Start())                return false;
     - A) _1 m& N- Y/ M' M4 x
134.     I2C2_Send_Byte(SlaveAddress);
     
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
136.     I2C2_Send_Byte(REG_Address);
     
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     : l8 ], ]3 M4 F
138.     I2C2_Send_Byte(REG_data);
     
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     - M" I( e) I. q. t! L) l
140.     if(!I2C2_Stop()) return false;
     . A- s3 U+ _  T% P
141.     return true;
     
142. }
     
143. 
     
144. // 从设备中读取数据
     
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     2 V8 ~' a; J  p: o' j) {' G1 f
146. {
     % Y! @: l9 v- a$ p7 [; z7 j* S
147.     uint8_t data;
     . `, o+ ~6 G: q7 J7 q
148.     if(!I2C2_Start())        return false;
     
149.     I2C2_Send_Byte(SlaveAddress);
     
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
151.     I2C2_Send_Byte(REG_Address);
     3 b& _2 g) ?7 Y# O" `5 Z; N
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     , M( X7 [% s: t5 G8 x# ~8 P* \2 h
153.     if(!I2C2_Start())        return false;
     
154.     I2C2_Send_Byte(SlaveAddress + 1);
     3 A2 H& m7 ]  M: i6 K4 K
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     * p2 e, s9 z5 M- t: F
156.     data = I2C2_Read_Byte();
     
157.     I2C2_NAck();
     9 t! j: g. `& j$ {
158.     if(!I2C2_Stop())        return false;        
     4 h3 A; {& {5 H7 H1 g, X
159.     return data;
     
160. }
     8 @) V. b% g0 u# f- u- u+ P
161. 
     + L& X" \# ]5 S# Z2 ~3 ^5 i; D( ~2 D
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     - f' ]! u; w, Z
164. {
     2 ?1 y* n- E4 j; G7 d- b. r* u
165.     if(!I2C2_Start())return false;
     
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     & p6 i6 a* _8 D, v9 S( w2 U' l) ~
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     : u( `- M* A0 S% G- m
168.     I2C2_Send_Byte(REG_Address);   
     8 i0 R4 M- ~2 \7 P) l. ^/ s
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     - Y, ~' Z3 F; x# P
170.     for(uint16_t i=0; i<len; i++)
     
171.     {
     + T- z# y* ~) d
172.         I2C2_Send_Byte(buf<i>);
     
173.       </i>  if(i<len-1)
     ' j8 I4 I* k: x& m2 a: x
174.         {
       u7 X6 e3 q+ M; l$ M$ i
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
176.         }
     + I4 L6 S) @' ~+ V$ ^3 e( K! G
177.     }
     
178.     I2C2_Stop();
     
179.     return true;
     6 ?6 s  s! J3 }; t' ^+ I
180. }
     
181. 
     5 h7 {( L1 p6 |! x1 x9 m
182. // 连续读N个字节
     & X2 ?8 N$ h" J: [/ z5 F% K
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     
184. {
     
185.     if(!I2C2_Start())return false;
     + }. d2 L* y0 i% C
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     0 t3 x3 Y" l5 R9 c$ J- d: p  b
188.     I2C2_Send_Byte(REG_Address);   
     ! V* K/ \, Q5 Y* t- C+ c  I$ u
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
190.     if(!I2C2_Start())return false;
     " W: h1 P  N0 X/ p3 T
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     7 c* K' t0 P# ~& a* U8 v/ i9 b
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     0 `8 ]' I9 e; ~, H0 o1 `  Z8 _0 A
193.     for(uint16_t i=0; i<len; i++)
     & u- m1 w/ a; i8 K
194.     {
     
195.         buf = I2C2_Read_Byte();
       [5 x8 g) a& Y' `' P
196.         if(i<len-1)
     
197.         {
     ! {* e# |+ G! Y! x3 y
198.             I2C2_Ack();
     
199.         }
     
200.     }
     
201.     I2C2_NAck();
     / ?- d. ?% a" G- u5 e
202.     I2C2_Stop();
     ' @( X" u, B4 Y7 I2 }
203.     return true;
     
204. }
     , ]9 D! E, C+ M/ |
205. 
     2 O7 m' m4 W4 e+ T
206. // 检查设备地址
     
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     
208. {
     
209.     if(!I2C2_Start())        return false;
     ( M9 g3 W. O8 ^
210.     I2C2_Send_Byte(SlaveAddress);
     
211.     if(!I2C2_Wait_Ack())
     0 z& q. f+ i# p; `
212.     {
     , z3 r8 S! ~6 X4 y: j
213.         I2C2_Stop();
     ) x$ i, a- V% S6 d
214.         return false;               
     
215.     }
     
216.     if(!I2C2_Stop())        return false;        
     
217.     return true;        
     : V& x7 b: k; ]; `$ M  p
218. }

复制代码

9 \  V/ x' E/ r7 q' d. \bsp_soft_i2c.h程序如下：
5 n; ?$ H# s8 M1 z: ]" r# M0 z, a  l
9 X5 S6 p* z4 N7 k. {& \3 I

1. #ifndef _BSP_SOFT_I2C_H_
   : w' w* N/ u! _1 d  `1 A. R6 z
2. #define _BSP_SOFT_I2C_H_
   
3. 
   - N$ c+ H- G% M% Q& t: K* u' A
4. #include "stm32f0xx.h"
   ) F: \3 `2 O8 e- r! i: f& F
5. #include <stdbool.h>
   
6. 
   , s" ?% C0 V" u# d0 B
7. // 定义内联延时函数        
   
8. static inline void I2C2_Delay1us(void)
   
9. {
   
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    ) v% N- s. v; W/ e# P
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
    0 B9 t  t) a0 y
16. }        
    
17. 
    % [3 @' c: q* n! ^4 R! e1 u
18. 
    0 z7 r' q' m' P) p2 l! j8 g
19. #define        I2C2_GPIOx  GPIOB
    
20. #define Pin_SCL                GPIO_Pin_10
    ) \7 K9 S: L" H
21. #define Pin_SDA                GPIO_Pin_11
    ! T) M4 I2 ~7 [+ Z+ n
22. 
    
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    
25. 
    3 U3 X, Y: T) z: f
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    : n+ ?. a$ u! j6 o6 B) Y# w' V7 Q) v
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
    
28. 
    2 E6 b1 c4 i4 X% z/ ~) D
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    
30. 
    
31. void I2C2_Soft_Init(void);                        
    
32. bool I2C2_Start(void);                                                
    % q* f- h; o! H, Z- A- `
33. bool I2C2_Stop(void);                                          
    
34. void I2C2_Send_Byte(uint8_t txd);
    ( U% H+ [- z9 D% a+ l
35. uint8_t I2C2_Read_Byte(void);
    ) l) B/ U3 X, a9 e$ l3 Q4 k
36. uint8_t I2C2_Wait_Ack(void);                 
    9 j8 p" `2 T" W6 S! G- v
37. void I2C2_Ack(void);                                                        
    
38. void I2C2_NAck(void);                                                
    
39. 
    
40. bool I2C2_Write_REG(uint8_t SlaveAddress,uint8_t REG_Address,uint8_t REG_data);
    
41. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address);
    
42. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    
43. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    ; @4 y) ~& V# J" J$ Y9 T
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    & W# D/ p7 J# i, P
45. #endif

复制代码

5 Z6 q3 }) Y& ]+ T! w0 `
( {$ H/ h$ T  `. S  V; L6 O
/ J7 \! I" `  \. s  `3 V: Z% G