I2C两线式串行总线通讯协议，它是由飞利浦开发的，主要用于连接微控制器及其外围设备之间，它是由数据线SDA和信号线SCL构成的，可发送和接收数据即在MUC和I2C设备之间，I2C和I2C之间进行全双工信号传输，高速I2C总线一般可达到400kbps。一般我们也称为TWI接口。

I2C支持多主机模式：

- d2 |3 L7 `% a4 N0 p, W

" i( I  S! R3 a' v9 k

即在这个主线上可以挂载n个I2C外设。

* d# ]( A; I+ k1 Y1 ?

对于I2C协议，其实也很简单，不要想的那么复杂，其实就是电平的变换。我们可以人为的分为6个部分

; g9 _/ q, f( r: U# G8 m# Y. f

整体时序图：

/ b3 Z1 O* J7 I1 b2 C

: X5 u3 {0 b3 f
8 C. z$ k( Z- w8 Y! _

各状态：

• 空闲状态
  
  

( |( z4 j6 `7 G3 N& j/ v
: }0 B  v6 z  M$ B0 x
% w: s6 C' S, M7 g  B; |. V% L8 b2 X

I2C总线的SCK和SDA两个线同时处于高电平的时候，规定为总线的空闲状态，这个就是由总线上的上拉电阻把电平拉高的。

• 起始信号
  
  

- f! V$ ]  n1 M/ q# m. V! d

1 f0 F  I8 L- s6 }

当SCL为高电平期间，SDA由高电平变成低电平，即为起始信号。启动信号是一种电平跳变时序信号，不是一个电平信号。

0 V, `' T, k9 D! T

• 停止信号
  
  

当SCL为高电平期间，SDA由低电平变为高电平，即为停止信号。停止信号也是一种电平跳变时序信号，不是一个电平信号。

/ ^: V& r8 {4 X2 W* B

• 应答信号
  
  - X! _+ S/ H% _! \( ^

4 `' H2 Z7 s! l/ i; n6 C

发送器每发送一个字节（8bit）数据，就在时钟脉冲（SCL）9期间释放数据线（SDA），再由接收器来反馈一个应答信号，应答信号为低电平的时候，规定为有效应答位(ACK:应答位)，表明接收器已经成功的接收了该字节，应答信号为高电平时，规定为非应答位（NACK：非应答位），表示接收器没有成功的接收该字节。

对于反馈有效应答位（ACK）：接收器在第9个时钟脉冲之前的低电平期间将SDA拉低，并且保证在该时钟的高电平期间，SDA为稳定的低电平。大家主要看图，看看是不是这样的。

要是接收器是主控器，那么它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据的发送，并且释放SDA线，以便主控接收器发送一个停止信号。

• 数据的有效性
  
  ( X8 i- a3 V  B7 ], Y1 ]

. m' |2 }6 K* m( r7 z; V

5 e$ Q! ?2 f; Y
4 D( a  U- l# J# i; Z9 r( @
- r% C1 F4 V1 i, {3 f! x8 P

时钟信号（SCL）为高电平期间，数据线上的数据必须保持稳定，只有在时钟信号（SCL）为低电平期间，数据线上的高电平或者低电平才能发生变化。

数据必须在时钟信号（SCL）的上升沿到来之前就准备好，并且在数据信号的下降沿来到之前必须稳定。

• 数据的传输
  
  

在SDA上的每一个位的数据的传输都需要一个时钟脉冲，即在SCL串行时钟的配合下，SDA上逐位的串行发送每一位数据。数据位的传输是边沿触发。

示例代码讲解

• 初始化IIC
  
  4 N3 y2 V+ G$ P& p& ^- p

- m2 b( {( a( [/ W3 v3 g
9 x7 R+ ?( G/ e( \+ T, x

其实就是对两个线的初始化，我这里使用的是PA6和PA7，开始都设置为输出，中途会改变PA7的输入输出属性，在空闲状态，我们知道SCL和SDA是被拉高的，所以这个地方我们给高电平。

• 产生IIC起始信号
  
  

" r: P. Y1 l* F' v7 t
0 e, s: X+ z/ q" B

2 s* v' }/ B9 |+ U6 j

将SDA线设置为输出，然后SDA和SCL都设置为高电平，延迟4us，然后将SDA拉低，延迟4us，最后将SCL拉低。这其实就是协议规定的动作了。

• 产生IIC停止信号
  
  ; b8 n( x8 g7 X  z. z( j3 {6 H

2 Z; p- e$ m9 h+ w$ M
, w9 i+ N5 {- R$ x2 P" a

7 b) [: H5 X5 T

同样的道理，和协议的时序保持一致就好了。

0 _) d' k6 S* s8 w* d# p$ r7 D: }

• 等待应答信号到来
  
  , U% D  o% y$ ^* I; _% c

# K% X6 E8 q$ ]" U) }0 w
5 N6 f3 P2 F3 Q8 z- T7 I

首先我们需要把SDA设置为输入，因为接收方要给发射方返回一个应答信号的。就是在SCL第9个高电平的时候，释放信号线，先拉高，然后持续等待，是不是有应答信号返回，其实就是返回一个低电平，所以我们一直在检测READ_SDA这个电平，持续一段时间，要是没有返回的话，我们认为超时了，就直接停止协议了，

' y) O& k1 l0 H6 S) y9 X

• 产生应答信号
  
  

# b% U8 j! ]1 `) d$ H" b

" S, h9 x, R+ w7 b3 r/ f/ I% Q

即在第9个时钟周期内，SDA都为低电平，为应答

! W6 ?2 W3 s5 h4 a- b( X

• 不产生应答信号
  
  & C9 P- v# i. k+ c; }7 W

$ v) H2 d* d% n- i& B
; x% _- h8 Z; \; e! |3 D8 ?' U) E- M! ]

即在第9个时钟周期内，SDA都为高电平，为不应答

• IIC发送一个字节
  
  2 L  E, A5 N/ |7 j$ i/ T/ X

5 T$ M2 r1 y' J2 f; u5 y
' {. }, W! X: B, n- H& n

8 h) i* i  {/ S$ O2 H, b2 l

发送数据，SDA设置为输出。SCL拉低，SDA准备。

做一个8次循环，拿出1byte的数据，将你发送的数据和0x80作与运算，拿出最高位，然后右移7位，将这个数据放到最低位，这个数据要是1的话，那么SDA输出一个高电平，要是与后的结果为低电平的话，那么SDA输出一个低电平。这都属于准备发送信号阶段。

然后SCL拉高，完成数据的发送，然后SCL拉低，此时SDA也就可以拉低了，接着开始次高位的传输，直到传输完成。

* J/ L0 X) L, y/ y

• 读取数据
  
  7 t( R# j% y+ q  a) e2 I
  

读取数据，SDA要设置为输入了。SCL开始为低电平，然后SCL为高电平，我们开始读SDA上的数据，然后左移数据，将读取的数据放在低位。然后检测一下有没有应答。

其实基本思路就是这样了。我把源码附上：

% U" s% @; ~: B$ o. ]7 ]

i2c.h

1. #ifndef __MYIIC_H
   
2. #define __MYIIC_H
   # e( M/ L; p, v% y7 M
3. #include "sys.h"
   
4. #include "stm32f10x_gpio.h"
   + c6 M. k5 u6 K9 v4 H" b
5. //IO方向设置
   
6. #define SDA_IN() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
   
7. #define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}
   , e/ h6 ~: K) `7 \
8. //IO操作函数
   , ~: @$ z; \0 w7 ?/ u7 d
9. #define IIC_SCL PBout(6) //SCL
   
10. #define IIC_SDA PBout(7) //SDA
    ! E" g+ M8 O( A8 B" S
11. #define READ_SDA PBin(7) //输入SDA
    
12. //IIC所有操作函数
    
13. void IIC_Init(void); //初始化IIC的IO口
    
14. void IIC_Start(void); //发送IIC开始信号
    ! v8 o$ }  @# }, T5 v. P
15. void IIC_Stop(void); //发送IIC停止信号
    
16. void IIC_Send_Byte(u8 txd); //IIC发送一个字节
    
17. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
    ; P' A! j' G. m0 b1 r* e
18. u8 IIC_Wait_Ack(void); //IIC等待ACK信号
    
19. void IIC_Ack(void); //IIC发送ACK信号
    ) ~0 O$ N# `1 T. ]( G
20. void IIC_NAck(void); //IIC不发送ACK信号
    
21. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    ' t4 w" c" D/ Q& c7 F& L
22. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);
    
23. #endif

复制代码

: [1 Z7 y1 O6 \7 D+ R; a

i2c.c

1. #include "myiic.h"
   
2. #include "delay.h"
   0 x' ]) s' ]' P( |. |7 }; R; y4 r% L+ b
3. //初始化IIC
   * J4 [8 `7 R5 N# T) x
4. void IIC_Init(void)
   * e$ k; I( b2 d. w) q
5. {                                         
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );        //使能GPIOB时钟
   
8.          
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
   4 x. j7 n# e& s! o7 f% Z& h) R, O
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ; //推挽输出
    ! t! e! Q# Z  A
11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
12.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
13.         GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);         //PB6,PB7 输出高
    
14. }
    ' b/ ~/ U; s% ~" V& s  N
15. //产生IIC起始信号
    
16. void IIC_Start(void)
    
17. {
    
18.         SDA_OUT(); //sda线输出
    2 g& {( C  H7 x! O
19.         IIC_SDA=1;                  
    
20.         IIC_SCL=1;
    
21.         delay_us(4);
    * y1 P" s4 L2 F4 V) \& J' j: J- S! V
22.         IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
23.         delay_us(4);
    5 U' H  ^, a6 a- ^- k
24.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    
25. }         
    
26. //产生IIC停止信号
    
27. void IIC_Stop(void)
    ; a5 \7 ]& y2 i1 q1 B
28. {
    9 d4 g. e9 D7 b- n7 w% F# D
29.         SDA_OUT();//sda线输出
    
30.         IIC_SCL=0;
    ! N0 ~2 N2 \! M3 C
31.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
32.         delay_us(4);
    7 w5 W# }/ @* X
33.         IIC_SCL=1;
    , M7 m' g( {( J  v& E- I
34.         IIC_SDA=1;//发送I2C总线结束信号
    5 }- K1 m% d% H# Z* S  `
35.         delay_us(4);                                                                
    
36. }
    
37. //等待应答信号到来
    6 x* F0 C  n2 d- N/ y& h+ o) L1 d, p
38. //返回值：1，接收应答失败
    
39. // 0，接收应答成功
    
40. u8 IIC_Wait_Ack(void)
    5 H# n7 D, Y- K
41. {
    
42.         u8 ucErrTime=0;
    # I2 F- I- E0 V+ m- K( o
43.         SDA_IN(); //SDA设置为输入
    
44.         IIC_SDA=1;delay_us(1);         
    
45.         IIC_SCL=1;delay_us(1);         
    5 G+ E. c( C) ?/ Z% J' H" ?) R
46.         while(READ_SDA)
    
47.         {
    8 Q/ O1 \8 U: h6 X) J7 _
48.                 ucErrTime++;
      c% U3 B4 O' U# B# t
49.                 if(ucErrTime>250)
    
50.                 {
    
51.                         IIC_Stop();
    
52.                         return 1;
    * n/ ]' k' ^2 o" `- Z
53.                 }
    ( h/ S4 g$ S5 I7 M" |' |( b* g# [5 t
54.         }
    
55.         IIC_SCL=0;//时钟输出0          
    ! F" s! ?0 |" d0 _7 K  `
56.         return 0;
    
57. }
    
58. //产生ACK应答
    ( Q! A- t+ i4 F
59. void IIC_Ack(void)
    / |) G2 T$ A- F* x, t9 Z
60. {
    8 o8 W! Y. `! A
61.         IIC_SCL=0;
    2 v: X0 j6 D; _$ }* L
62.         SDA_OUT();
    
63.         IIC_SDA=0;
    
64.         delay_us(2);
    
65.         IIC_SCL=1;
    5 g. @3 I0 r! x% Q/ O% Y* b
66.         delay_us(2);
    % l9 r/ |# L9 F" j& ]
67.         IIC_SCL=0;
    
68. }
    4 K' X! {9 Q4 z8 w4 h1 A5 R
69. //不产生ACK应答                 
    " a# {% e+ Z, B% I2 V% A+ E, k
70. void IIC_NAck(void)
    3 }5 i( e- y9 q6 l$ V
71. {
    
72.         IIC_SCL=0;
    
73.         SDA_OUT();
    
74.         IIC_SDA=1;
    & w7 O- L4 [! k. K* S! _$ ?0 C. ?
75.         delay_us(2);
    ; g; C" N5 a) `2 n3 D
76.         IIC_SCL=1;
    " C$ k9 G3 X: n$ \9 K
77.         delay_us(2);
    
78.         IIC_SCL=0;
    # g% J0 ]& O; q5 M/ T
79. }                                                                          
    
80. //IIC发送一个字节
    
81. //返回从机有无应答
    
82. //1，有应答
    
83. //0，无应答                         
    ( j% L3 f$ @/ ]
84. void IIC_Send_Byte(u8 txd)
    
85. {
    
86. u8 t;
    # Q# E+ Q! d; e8 c2 W% r2 H' }
87.         SDA_OUT();          
    8 x% P  G6 t8 y
88. IIC_SCL=0;//拉低时钟开始数据传输
    0 O8 `/ c% E+ ~& {1 x" T" q" K
89. for(t=0;t<8;t++)
    
90. {
    
91. //IIC_SDA=(txd&0x80)>>7;
    
92.                 if((txd&0x80)>>7)
    
93.                         IIC_SDA=1;
    
94.                 else
    * j5 {" n' b% E0 e
95.                         IIC_SDA=0;
    : d: v/ W! l; I& x( V
96.                 txd<<=1;          
    # Z$ n# t" ^6 n, m
97.                 delay_us(2);
    
98.                 IIC_SCL=1;
    & j# f+ G$ p- A5 I# S
99.                 delay_us(2);
    
100.                 IIC_SCL=0;       
     
101.                 delay_us(2);
     
102. }         
     * L6 m( o3 y& X
103. }          
     
104. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK
     
105. u8 IIC_Read_Byte(unsigned char ack)
     # x  S0 Q" i  T2 x( ?
106. {
     
107.         unsigned char i,receive=0;
     & k% r0 c  ~& q9 b  |: }
108.         SDA_IN();//SDA设置为输入
     
109. for(i=0;i<8;i++ )
     9 z/ s& J; O2 w: Y
110.         {
     
111. IIC_SCL=0;
     
112. delay_us(2);
     
113.                 IIC_SCL=1;
     
114. receive<<=1;
     + ~; B8 E! l7 Q$ t
115. if(READ_SDA)receive++;
     * E, M% a2 W# e0 O: c3 [& _
116.                 delay_us(1);
     - ?7 b7 M) _# a  A
117. }                                         
     ' O; c) y- l& U7 a9 p
118. if (!ack)
     
119. IIC_NAck();//发送nACK
     7 G+ f9 f1 l, z+ ?. a
120. else
     
121. IIC_Ack(); //发送ACK
     
122. return receive;
     . S6 [8 w9 @6 t/ j, M' k) [8 v! {
123. }

复制代码

, g2 I8 @. H  V6 ?转载自：电源研发精英圈
如有侵权请联系删除
  p3 O0 I+ W3 Z2 {
" }4 z1 y8 R1 K' w
; j* h% n/ r2 Z