1、IIC定义
IIC 即Inter-Integrated Circuit(集成电路总线），这种总线类型是由飞利浦半导体公司（后被NXP收购）在八十年代初设计出来的一种简单、双向、二线制、同步串行总线，主要是用来连接整体电路(ICS) ，IIC是一种多向控制总线，也就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实时数据传输的控制源。多主多从的通讯协议。

1 T: t0 x' z, V$ ?7 [下文将结合NXP官方的IIC手册讲解IIC协议。下载链接见文末。
. l: U3 D  I" U) \: p( z
" |, m& u/ b5 o# r2 y8 M# e4 g7 ^' r* k
& x  @, R- @! y7 a* S! ]& _) B# V4 c
I2C串行总线一般有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL。所有接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上。速率最高400Kbit/s。
; t! n. R& S- u* l


; R# n+ \6 c+ J' Q1 z在1998年的修订中增加了高速模式，速率高达3.4Mbit/s。(这里不讲，只说快速模式)。


2 v4 J+ f# C2 S  C
2、IIC协议规范
% e0 h" a' y2 q2 o2.1 SDA和SCL信号
" A# s9 `6 ?9 ~$ {% M


连接到总线的器件输出级必须是漏极开路或集电极开路才能执行线与的功能，当总线空
4 Q& _: b* B6 q2 B: ]5 C3 I" s: W
闲时这两条线路都是高电平。SDA 和SCL 都是双向线路都通过一个电流源或上拉电阻连接到正的电源电压。一般情况下我们都采用上拉电阻的方式

2.2 数据有效性

$ O: U  u# x# G+ u9 S2 @# U

在SCL高电平的时候采样，也就是有效。低电平的时候切换数据

2.3 开始和结束信号
- Y' |; x4 C$ N2 N起始条件：SCL线是高电平时，SDA线从高电平向低电平切换。
6 y5 Y/ V1 Q# s7 O- m' u- E
: d5 U& u5 l$ n+ N  C; [0 m停止条件：SCL线是高电平时，SDA线从低电平向高电平切换。



2 H! _" I! e; C& ^# v( ]+ ?动画展示启动信号


) N& z/ r5 n$ M  H- z. a; W
代码实现
( M& c8 T8 G# B4 M; X5 U
- G3 |9 z- L* \' g/ w7 A

1. void I2C_Start(void)
   9 y4 b. `5 t4 ~8 @% N
2. {
   ) m6 p2 \1 {; R1 C, U' A
3.   //IO输出
   . s3 j: Z6 ]' D( E! l
4.   SDA_OUT();
   
5.   SCL_OUT();
   
6.   I2C_DELAY();
   ; b! Q. r) l) T+ M! A' i7 }
7.   //IO置高
   ' k% N+ d4 K+ d/ f9 }- U) B
8.   SDA_SET();  
   - `. h0 l* A, l1 H
9.   SCL_SET();
   ! u3 U5 \( y, U3 z! p8 |  R
10.   //延时
    
11.   I2C_DELAY();  
    5 J1 A& X2 k7 N6 x) G& c+ L
12.   //为低
    7 _$ w+ B8 k# K# Y3 f# [3 z
13.   SDA_CLR();
    5 l2 ?7 p  e" I
14.   I2C_DELAY();
    
15.   I2C_DELAY();
    
16.   SCL_CLR();
    # z. E+ k& f4 A
17. }

复制代码

6 T* p- q4 Y) S3 ~  S结束信号时类似的方式（不是动图）


0 ]/ o1 F+ ]) H0 ~
3 D4 c& K7 V/ K+ S, w代码实现
! j+ v) R+ y. f- R
6 T# Y4 @  @3 u! F, `% q

1. void I2C_Stop(void)
   , @9 _8 B9 r- E
2. {
   
3.   //IO输出
   
4.   SDA_OUT();
   : d8 j" B2 W( [' O
5.   SCL_OUT();
   
6.   //IO置0
   
7.   SDA_CLR();  
   8 Z% A4 w1 D, O& f
8.   SCL_CLR();
   % v  F3 z) D+ U7 G* B0 P
9.   I2C_DELAY();
   
10.   SCL_SET();
    1 X3 U4 @. G+ h! L  R  Y* T2 z
11.   //延时
    
12.   I2C_DELAY();  
    
13.   I2C_DELAY();
    4 M+ H9 [) ~1 ?- K
14.   I2C_DELAY();
    " j9 O$ R4 U# \& K8 D* N8 l, p4 K
15.   //SDA置1
    
16.   SDA_SET();
    
17.   I2C_DELAY();
    1 [& d! W2 ?& M8 E4 e) K3 ^' C
18.   I2C_DELAY();
    
19. }

复制代码

* r! _- \% ^1 z$ A. J' M+ h0 r; n- [2.4 字节格式
) ?2 u! B/ ?  X8 v  @& VSDA数据线上的每个字节必须是8位，每次传输的字节数量没有限制。每个字节后必须跟一个响应位（ACK）。首先传输的数据是最高位（MSB)，SDA上的数据必须在SCL高电平周期时保持稳定，数据的高低电平翻转变化发生在SCL低电平时期。
( Y# l* |1 K$ x
7 ~- P$ V* X8 G0 ^3 I  N) {
3 b$ Q6 _' Q, E! ^8 j! V
2 L# \8 a8 A' Q" ^/ \每一个字节后面跟着一个ACK，有ACK就可以继续写或读。NACK，就停止
8 R! ]" l: s6 X: l
ACK：主机释放总线，传输完字节最后1位后的SCL的高电处，从机拉低电平。

NACK：主机释放总线，传输完字节最后1位后的SCL的高电处，从机无响应，总线为高电平。
6 Q  ~0 Y- Z) E" h! d2 A" `! v
. p8 y' @2 ]1 L8 m0 @0 Y7 c动画描述写入的过程

  G+ h+ I9 _4 m  A5 c2 W/ H/ q$ V

代码实现
* F9 e5 U5 p$ U- b- d

1. uint8_t I2C_Send_byte(uint8_t data)
   
2. {
   , K3 F  i7 v" ^4 g& z( g9 m6 k
3.   uint8_t k;
   
4.   //发送8bit数据
   % V, r2 F( U! e3 |. z! Z
5.   for(k=0;k<8;k++){
   
6. 
   3 b  t$ O- B) a/ ]; U, Z# `
7.     I2C_DELAY();
   
8.     if(data&0x80){
   ' C+ s& S" V' ]/ |- g4 W, W
9.       SDA_SET();
   
10.     }
    1 ~1 D+ @1 P6 s% ]% r4 K
11.     else{
    4 g# U* j/ m0 s3 U% A, F5 {4 P
12.       SDA_CLR();
    
13.     }
    - f7 p6 o: S% H- F. r& `
14.     data=data<<1;
    
15.     I2C_DELAY();
    6 U" L% I$ `+ F* M9 b
16.     SCL_SET();
    
17.     I2C_DELAY();
    
18.     I2C_DELAY();
    $ \9 J" K3 Q! S4 E: @8 j
19.     SCL_CLR();
    
20.   }
    5 H  |8 t, U: x' K& e- w) S
21.   //延时读取ACK响应
    
22.   I2C_DELAY();
    
23.   SDA_SET();
    5 i" e# ~3 g6 B& c1 }& L  b# s; M
24.   //置为输入线
    
25.   SDA_IN();
    / B! d$ j6 Q1 @5 H- p, e' F
26.   I2C_DELAY();
    0 M' M) U9 B' l9 L, A4 V7 P
27.   SCL_SET();   
    - `* S2 X4 q5 e
28.   I2C_DELAY(); //这里出现了问题，延时变的无限大
    
29.   //读数据
    
30.   k=SDA_READ();
    ( @) T" v/ L2 ?3 Z* a9 ?  S
31.   if(k){ NACK响应
    
32.     return 0;
    
33.   }
    
34.   I2C_DELAY();
    % \/ j; O5 F( U2 W" H% S
35.   SCL_CLR();
    5 o( Q; F3 A+ n5 l1 F; z
36.   I2C_DELAY();
    / r- V9 L: o1 ^; z  t7 K. \0 _+ T: b
37.   SDA_OUT();
    
38.   if(k){ NACK响应
    
39.     return 0;
    
40.   }
    
41.   return 1;
    
42. }
    3 g9 Z* T9 B+ e* `/ L  S) ^8 {7 }
43. 
    " T1 _- W( L4 H" c: {" o7 k% d. H
44. uint8_t I2C_Receive_byte(uint8_t flg)
    
45. {
    2 w0 }& }5 e& L6 b7 _
46.   uint8_t k,data;
    
47.   //接收8bit数据
    , x- D! |: H* o
48.   //置为输入线
    5 d3 y! j( c# t/ s, M: A8 z" O' X
49. 
    & ^/ X; q& g; [# M; O# l
50.   SDA_IN();
    ; n9 ?, o5 E& V
51.   data=0;
    * l$ _. @2 n3 E- f- F! X- h
52.   for(k=0;k<8;k++){
    
53.     I2C_DELAY();
    
54.     SCL_SET();
    
55.     I2C_DELAY();
    
56.     //读数据
    
57.     data=data |SDA_READ();
    4 J8 \) o1 c! v& J2 g4 R( W) A5 X9 n
58.     data=data<<1;
    
59.     I2C_DELAY();
    " w7 C! G! m- c& F3 p% w% U
60.     SCL_CLR();
    
61.     I2C_DELAY();
    6 `9 {+ {0 Z- c& i: f
62.   }
    
63.   data=data>>1; //往回移动1次
    
64.   //返回ACK响应
    0 W1 p' ~2 s/ s9 F
65.   //置为输出线
    
66.   SDA_OUT();
    $ x0 ?9 ~/ q! k( Y/ A) E. y! j: [5 \
67.   if(flg){
    
68.     SDA_SET(); //输出1-NACK
    
69.   }else{
    
70.     SDA_CLR();//输出0-ACK
    
71.   }
    - e4 x! I  o+ K9 R& A; B
72.   I2C_DELAY();
    - @9 F5 A; G/ U" O
73.   SCL_SET();
    , D: i& i7 L# X# J
74.   I2C_DELAY();
    ; l* O( R5 w- B3 y8 l- `2 r0 @
75.   I2C_DELAY();
    - w" R3 s2 h0 F* ^7 P
76.   SCL_CLR();
    " H( c2 q& m' T8 ]0 y) {9 W
77.   I2C_DELAY();
    . P( }7 N' s3 Y
78.   SDA_OUT();
    3 `! Z8 K3 [# ~. R9 L/ L1 L
79.   //返回读取的数据
    ! p' M) |% H: D; i6 ]3 `+ w! m
80.   return (uint8_t)data;
    9 Z! D2 t$ q$ v
81. }

复制代码

# X2 r/ w  M$ W3 t% J2.5 从机地址和读写位
# o' i5 E0 J8 l% c开始信号—>地址—>读写位—>ACK—>数据—>ACK.............—>停止位

$ c8 l5 u9 K- z: r

( C9 Z7 B: x+ a; F& ]! \这里只说7位地址，前7位为地址，最后一位为读写位，1表示读操作，0表示写操作


% e+ W  u  h) b: m
主机发给从机数据，也就是写，没有数据转向时


# l) X: u! M$ R4 ^2 i/ Q
主机立即读从机数据，从第一个字节
1 U, |5 C7 F6 x- Q


0 ]) t1 b3 c# b5 R(Combined)综合数据格式
+ @2 y' n4 c* z! O; d

+ c3 S3 ?( A" H' \$ G
3、计算IIC的频率
. |4 D' O; @/ V. U% d通信频率由主机掌控，也就是代码中的延时函数决定的
1 E+ M' [: X9 J! I( i2 Q1 G
" N2 X5 h! S& ^9 H6 n从上面，我们得知最高速为400Kbit/s。我们设计300Kbit/s。

+ j5 u+ o7 O# s+ C3 h
) X7 g+ T6 L5 T8 K8 d
速率300Kbit/s，对应周期1/300ms=10/3us≈3us，4分频就是3/4us。
7 e1 O3 J+ A/ b3 A
我们使用的延时是，1/120MHZ*3*30 =3/4us
9 q% A: [1 W4 Y# A* z5 ]6 j4 ]9 Z
- l: l/ Q  b+ v5 H7 A# ~也就是频率是300Kbit/s
2 f! J! q3 z2 J* M  y
和SPI类似，时钟下降沿时，数据转换，时钟上升沿时，采样数据。也就是时钟高电平数据有效。

7 Z8 [4 a# m& c2 d6 C  X% U

1. /*120Mhz时钟时，当ulCount为1时，函数耗时3个时钟，延时=3*1/120us=1/40us*/
   : Z0 A: B/ ]* x( f( N# z2 S4 ?5 y7 T' _& I
2. /*
   
3. SystemCoreClock=120000000
   & y2 A3 ?5 p7 t8 W3 V# K* y) b+ u
4. us级延时,延时n微秒
   ; I2 W+ k. ~7 u: p0 F: h: B
5. SysCtlDelay(n*(SystemCoreClock/3000000));
   " p9 ]  E: a/ {8 w. N* K
6. ms级延时,延时n毫秒
   - x7 w2 q+ o% H& p, K5 `# e! Y6 F
7. SysCtlDelay(n*(SystemCoreClock/3000));
   / T1 {) Z) S/ E
8. m级延时,延时n秒
   
9. SysCtlDelay(n*(SystemCoreClock/3));
   
10. */
    8 ~" @! g  b4 U: ^+ g4 J6 B% x$ a
11. 
    0 T$ A, x% R/ H
12. #if defined   (__CC_ARM) /*!< ARM Compiler */
    
13. __asm void
      }6 Z8 j  h# C4 u# l* i
14. SysCtlDelay(unsigned long ulCount)
    5 Z( ]2 D9 N9 w/ c" e
15. {
    
16.     subs    r0, #1;
    / x' V. N/ A0 ~* I5 h; d4 V7 E/ u
17.     bne     SysCtlDelay;
    + i6 ^. T1 J7 k* i/ Q  w
18.     bx      lr;
    
19. }
    
20. #elif defined ( __ICCARM__ ) /*!< IAR Compiler */
    
21. void
    8 l5 g0 j2 A9 f
22. SysCtlDelay(unsigned long ulCount)
    ; r6 ]5 I+ R, A7 u
23. {
    
24.     __asm("    subs    r0, #1\n"
    - F. E3 p  B- w" N1 o4 B  d+ o* |
25.        "    bne.n   SysCtlDelay\n"
    
26.        "    bx      lr");
    / y! i+ }5 D/ G$ {4 f* R
27. }
    
28. 
    
29. #elif defined (__GNUC__) /*!< GNU Compiler */
    0 j  F  Z, i6 a1 W3 m. F
30. void __attribute__((naked))
    
31. SysCtlDelay(unsigned long ulCount)
    % h/ m# U8 p- B3 Q2 P
32. {
    
33.     __asm("    subs    r0, #1\n"
    
34.        "    bne     SysCtlDelay\n"
    
35.        "    bx      lr");
    6 ^4 }* s5 L5 d, V% X8 u3 d
36. }
    ' E( J, {. H% v7 W
37. 
    + \# X7 E' n& x# X
38. #elif defined  (__TASKING__) /*!< TASKING Compiler */                           
    
39. /*无*/
    
40. #endif /* __CC_ARM */
    - e+ Y' h$ W, ?& E* Z
41. 
    + J. d8 p  e1 ~& D9 D9 O% e! }
42. 
    5 B0 {3 W% I) V" a0 |
43. /*
    : ]( u3 Q+ B5 n; M
44. * @brief  SysCtlDelay
    ) R2 x1 v( j* N( M
45. * @param  ulCount 延时值，必须大于0
    
46. * @retval None
    
47. */
    " T0 y6 l0 ?- P4 e# ?7 E
48. void SysCtlDelay_IIC(unsigned long ulCount)
    , D! o1 [$ \, o3 ?
49. {
    ( N: s+ u( h2 z1 g9 l. J: p
50.         SysCtlDelay(ulCount);
    / S3 Q1 ]; H& W
51. }
    
52. 
    
53. 
    
54. /定义时钟频率,300KHz
    
55. #define I2C_DELAY()  SysCtlDelay_IIC(30)

复制代码

4、PCF8536
! B/ C  ?' q/ {. Z+ e4.1 Acknowledge
这个地方能看到关于2.4节关于ACK和NACk的说明。
! a$ L- v1 S9 U8 w3 ]) O8 _+ v

7 h1 B$ Y- C. M, T) b) o
4.2 Addressing
4 o8 Z7 y5 |$ r- I2 v; J5 v1 c这里直接给出读地址和写地址，也就是最后一位的区别
$ Z! l0 C9 @$ }! j+ W+ [5 G9 y/ c" `
' P0 u, g, a7 q0 W6 p2 z% Y$ K
  R% E7 p: t, G, f% [+ f! s( Y/ R
4.3 读写时序
其实就是按照IIC协议的

读指定器件的指定寄存器
! ^3 g- y8 p0 W7 V5 m


# K5 r4 ?7 H; k( t% o- ~: X主机设置完寄存器地址之后，再去读写
* e; s: N; o- Q. d2 ~, t* O* I
注意：读取多个字节，最后一个字节的回包应该是NACK

8 J/ U: D8 ~: h

4 m) z& `' n9 o( Q( |主机立即从机第一个字节读取
0 ?& a7 v. i( x3 W  ?
5 Y+ ~8 s$ X9 L; B注意：读取多个字节，最后一个字节的回包应该是NACK
2 Z; \) J3 g+ ]; w  t/ w



6 l; m8 F$ I" p( D5 U( ]