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

; T& D* `2 }9 I' Q8 n" ^8 z

I2C支持多主机模式：

" [8 a# g# [, S, ?# ^. v7 r
4 R, Q3 t+ J5 r3 g% M+ G. o
  S% l& y6 w2 K1 K9 u

  A( m. @9 T1 j

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

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

整体时序图：

+ [! e/ q# Q5 N/ V$ Y% J3 t

; i+ d1 v# N$ `* ~5 v+ r

各状态：

• 空闲状态
  
  

+ ]( R/ ]  i7 C3 [& a8 Y! V) j6 z


3 H$ `& o1 b6 |  O+ F. C" ?1 U7 b& u& p1 `

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

• 起始信号
  
  

/ [# ]& f) E" b3 [
8 _  T( q# x* `1 h/ r

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

• 停止信号
  
  $ w1 c+ [  w6 f: [1 E% w, t$ g

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

# I7 a6 u$ ?! ~1 ?  I( s- ]

• 应答信号
  
  

% \, H. B% i, M7 w6 Y
% s, a: ^$ c! a2 U9 I- R. e, h
7 Y) S  U, p. @  F+ \, Z$ g

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

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

+ D% E: h) o, C% j; C

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

& O, J9 M4 u. `* c4 Z$ ?; u

• 数据的有效性
  
  6 g! K% J" |  ]* |. c/ E

* b0 ~/ p+ \2 v* J" i

, o8 D+ h& }' _& x4 H% Z# y

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

/ n9 c' f- ~: Y1 U2 r

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

% o% \7 ~; a% K2 f+ {

• 数据的传输
  
  

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

( H6 _0 ^% E, @8 b, M) u

示例代码讲解

• 初始化IIC
  
  . h1 Z6 d  a4 o- }: B! y

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

  D# d6 W5 p% I  m* l* w* Z" t8 w; \% [& |

• 产生IIC起始信号
  
  ! G' \8 A1 r8 c* h$ N

4 K/ F; w) N* w# t# L. X0 m% S

8 D% R  [& d2 K2 s0 J: q


1 Q- Z) P$ c7 z' u9 s8 v7 X* F8 Z

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

• 产生IIC停止信号
  
  

5 p, ]+ V1 _" R6 ?' c, ^

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

• 等待应答信号到来
  
  $ L' S) r8 a' {) @

& ~6 L0 y: k8 F# ^0 B! ?2 A; @

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

+ P* m; D: C0 Z; Y) ^

• 产生应答信号
  
  3 T- x+ m) M/ [& i/ b

" K$ @3 r( U9 y9 X5 d- h- j
# d' j. j0 f9 |, e' P$ p

+ h9 r; l  n! m; f# A2 H& f

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

9 R2 X. t3 B) W2 h6 p) y$ |: E

• 不产生应答信号
  
  ( o& Y, _% N) }( R

/ S8 j0 l, W6 \' N# O; D' A
7 C4 k" L4 H" o% N1 f
' u# a! _. ^6 ^2 ]
! S" J  d3 t" o" K2 \

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

8 C/ U- D* }. s: _( {* Q8 D9 I

• IIC发送一个字节
  
  % ]5 s: m3 ]0 d

9 t6 i9 s# ?* U9 p
- |' a% \9 f# E5 @  n

& b- k1 q; F' v5 B$ S' D, ~

  L6 a' e  j' k1 e% w( G* z

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

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

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

. U. M1 p% l8 O6 M0 r

• 读取数据
  
  
  9 c0 \- e! W& Q

: j3 _! \1 d* q; I

7 f+ x8 S9 b1 C4 \) _( B

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

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

' D( L  n; h$ v

i2c.h

1. #ifndef __MYIIC_H
   % a  z1 J) ?5 B- k
2. #define __MYIIC_H
   , j0 ^. z1 e9 b' a! s: ^% p& @
3. #include "sys.h"
   
4. #include "stm32f10x_gpio.h"
   8 R' D6 z1 C4 [! k0 }8 }
5. //IO方向设置
   8 `1 W, B, O% ~* T4 l5 b+ R2 }4 ?
6. #define SDA_IN() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
   
7. #define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}
   
8. //IO操作函数
   
9. #define IIC_SCL PBout(6) //SCL
   / Q2 G+ f6 W2 |+ p
10. #define IIC_SDA PBout(7) //SDA
    7 R: q0 ]/ B6 I! C) T& \
11. #define READ_SDA PBin(7) //输入SDA
    # k8 I9 ]7 `5 w1 h8 _* N. U
12. //IIC所有操作函数
    & r) s5 R) q( x3 `& R# O9 f
13. void IIC_Init(void); //初始化IIC的IO口
    
14. void IIC_Start(void); //发送IIC开始信号
    & i$ K! S7 X  r9 z' C
15. void IIC_Stop(void); //发送IIC停止信号
    ' l0 @5 q( _+ ]& n" `2 K
16. void IIC_Send_Byte(u8 txd); //IIC发送一个字节
    
17. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
    ' T/ w9 N& X& {  B
18. u8 IIC_Wait_Ack(void); //IIC等待ACK信号
    " Y0 ^0 [0 D: x2 N* _$ }
19. void IIC_Ack(void); //IIC发送ACK信号
    2 G6 n# k7 p  N0 L* k) q$ |
20. void IIC_NAck(void); //IIC不发送ACK信号
    2 p% A/ {5 a! V+ G8 Q3 w7 @9 @. L
21. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    2 H9 D' v( K  f2 ]
22. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);
    
23. #endif

复制代码

i2c.c

1. #include "myiic.h"
   4 P* }) u, v7 O
2. #include "delay.h"
   
3. //初始化IIC
   
4. void IIC_Init(void)
   
5. {                                         
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   4 j4 m/ ^- q) S' m1 g7 [
7.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );        //使能GPIOB时钟
   ! `$ {$ D% X+ c; D+ I8 k
8.          
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
   
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ; //推挽输出
    
11.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ! A) e* O: T9 u- O0 h; ]3 D
12.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
13.         GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);         //PB6,PB7 输出高
    
14. }
    " }$ j# w  L! H: x* G
15. //产生IIC起始信号
    
16. void IIC_Start(void)
    
17. {
    
18.         SDA_OUT(); //sda线输出
    + y4 Q* N5 [9 J
19.         IIC_SDA=1;                  
    4 A0 L9 W) w3 J" @
20.         IIC_SCL=1;
    
21.         delay_us(4);
    
22.         IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
23.         delay_us(4);
    : q6 d" @' r; {$ H+ p9 H
24.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    ( e2 l3 y0 P, s8 _+ u  l# p) u1 R
25. }         
    
26. //产生IIC停止信号
    
27. void IIC_Stop(void)
    & R. d$ }* @0 d/ g
28. {
    
29.         SDA_OUT();//sda线输出
    ' {8 i3 r* U: y' H  B
30.         IIC_SCL=0;
    
31.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
32.         delay_us(4);
    
33.         IIC_SCL=1;
    4 ~" x1 j/ u: U4 [
34.         IIC_SDA=1;//发送I2C总线结束信号
    1 D7 q6 Z* |6 U' R6 _5 A9 @% v
35.         delay_us(4);                                                                
    5 \6 O! T1 @6 w% U( m* @3 M
36. }
    
37. //等待应答信号到来
    
38. //返回值：1，接收应答失败
    / _8 k) [+ R4 b3 p$ n
39. // 0，接收应答成功
    
40. u8 IIC_Wait_Ack(void)
    ; `0 i/ Q3 h* U$ @9 @( c
41. {
    . g/ Z7 _" K" P. a
42.         u8 ucErrTime=0;
    8 K. Y* u, m$ |2 l# V) a* f5 H
43.         SDA_IN(); //SDA设置为输入
    . x' e9 A2 w& t
44.         IIC_SDA=1;delay_us(1);         
    9 l8 j( g; O$ b
45.         IIC_SCL=1;delay_us(1);         
    ! Q; v# a2 K# s" _3 I5 E
46.         while(READ_SDA)
    
47.         {
    
48.                 ucErrTime++;
    # H6 B' y4 O5 z1 P' [+ z6 f
49.                 if(ucErrTime>250)
    
50.                 {
    
51.                         IIC_Stop();
    
52.                         return 1;
    # t6 k; h& ~) O7 Z
53.                 }
    - d$ d4 \9 e" C  `- _. i
54.         }
    4 m3 B8 t; ^7 I
55.         IIC_SCL=0;//时钟输出0          
    . q: @0 I- o/ D" v9 h5 r  Q) ?  ]
56.         return 0;
    4 K9 \. i8 r8 ?6 H/ L: ~; v; K
57. }
    
58. //产生ACK应答
    1 u' r) G* d1 X4 m% X6 o+ m
59. void IIC_Ack(void)
    
60. {
    
61.         IIC_SCL=0;
    
62.         SDA_OUT();
    2 `$ `, {7 N: p" m5 U
63.         IIC_SDA=0;
    
64.         delay_us(2);
    : A7 e$ i  r% B, `9 q/ d2 ]4 }7 |! B
65.         IIC_SCL=1;
    
66.         delay_us(2);
    8 o! |  S' h" N$ C! T
67.         IIC_SCL=0;
    * `, C) D+ o1 O" O
68. }
    7 G+ u) Y7 V+ r! b( u0 ^0 z
69. //不产生ACK应答                 
    
70. void IIC_NAck(void)
    
71. {
    
72.         IIC_SCL=0;
    
73.         SDA_OUT();
    ( X7 U9 |3 ~$ f9 S  I, r+ T
74.         IIC_SDA=1;
    . G; F( M( I1 ~" h/ [
75.         delay_us(2);
    " ?! ]; I7 P- O* U
76.         IIC_SCL=1;
    5 I" ~# B) l/ ^6 \
77.         delay_us(2);
    , K/ b) w/ G% j4 {! f9 Z) X
78.         IIC_SCL=0;
    
79. }                                                                          
    
80. //IIC发送一个字节
    
81. //返回从机有无应答
    
82. //1，有应答
    
83. //0，无应答                         
    * V1 O; {- L: R) a
84. void IIC_Send_Byte(u8 txd)
    
85. {
    1 R- s0 k* ?2 X; `5 J2 Z
86. u8 t;
    
87.         SDA_OUT();          
    * z9 l: z3 f5 |$ u/ s4 G9 W
88. IIC_SCL=0;//拉低时钟开始数据传输
    
89. for(t=0;t<8;t++)
    ! T& {* k: Y; J$ g) n
90. {
    
91. //IIC_SDA=(txd&0x80)>>7;
    
92.                 if((txd&0x80)>>7)
    / A0 f# B4 p/ j. l7 D9 d, L- K
93.                         IIC_SDA=1;
    
94.                 else
    : _7 B6 C, _: e9 h2 `
95.                         IIC_SDA=0;
    
96.                 txd<<=1;          
    4 v( n" R2 w/ t) P, ^8 z
97.                 delay_us(2);
    
98.                 IIC_SCL=1;
    
99.                 delay_us(2);
    
100.                 IIC_SCL=0;       
     
101.                 delay_us(2);
     8 g1 A4 @, S4 {, }- T7 ?
102. }         
     : }2 {8 i5 K: C7 i; o; r6 r
103. }          
     
104. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK
     / i+ k( H/ ?! I5 a+ q. Z4 L  M
105. u8 IIC_Read_Byte(unsigned char ack)
     ! K. E+ Q4 Q, O& V9 w% j/ k% g
106. {
     / k' K9 M8 X* [/ O4 |
107.         unsigned char i,receive=0;
     
108.         SDA_IN();//SDA设置为输入
     
109. for(i=0;i<8;i++ )
     $ a2 n+ D6 b# @0 i. H5 G: o
110.         {
     ' f1 D- E: q2 T% l9 D" R
111. IIC_SCL=0;
     
112. delay_us(2);
     
113.                 IIC_SCL=1;
     6 P! Z$ E/ \. P
114. receive<<=1;
     
115. if(READ_SDA)receive++;
     % f3 J( {0 v+ F  Q6 O$ d6 Y
116.                 delay_us(1);
     
117. }                                         
     % u. U$ t0 k) \8 i1 |8 s, ^' H- e
118. if (!ack)
     ; q7 i& \. T& Y% g+ `: K
119. IIC_NAck();//发送nACK
     2 Y0 @$ }! n0 C8 @# q. a) o
120. else
     
121. IIC_Ack(); //发送ACK
     
122. return receive;
     
123. }

复制代码

+ W( U& J' Q6 W: o" T3 p' l) R转载自：电源研发精英圈
7 l4 b8 N, Y: b0 n$ R& J如有侵权请联系删除

- n% q' A9 r; P