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

I2C支持多主机模式：

4 f' o3 I- _! E8 g3 f# K

3 D+ v( y3 x+ L, A4 Q0 Y: A0 m4 f

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

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

' K1 `3 g& g, \( S" Z/ w

整体时序图：

+ D! y1 y" h  Q; t/ ?7 ]. r7 G- |

各状态：

• 空闲状态
  
  3 G' b6 f: V) r5 b& \

* r# C2 }* N1 V. n8 T2 L
* j- G5 v1 B4 K- N) {6 r' I0 R" b1 i

' e/ t  o: Q, X( q# I& h. P5 l

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

• 起始信号
  
  ) V* D. T' J$ y$ d

- d" d5 D5 A! R; r; R" T: K! i9 g: |
0 ]" _$ C1 `, N& a! k1 t1 O8 P* d! E

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

• 停止信号
  
  

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

% j* x" a' h7 \& V

• 应答信号
  
  

. y$ E) v. ~) m! R1 i


3 a$ G# {4 h9 B& G

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

/ F0 t' v+ n6 W+ D5 G2 k4 X

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

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

• 数据的有效性
  
  * W; X# z$ M! b8 ^9 w$ G

) h+ Q. U# y, R6 H$ t; M6 w

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

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

  g! I. d: p+ [

• 数据的传输
  
  0 H- x5 U1 c- h- @& O8 C" o( Y

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

. f6 b/ L4 |! n; D

示例代码讲解

• 初始化IIC
  
  

4 b  X# B5 _0 S7 L0 b4 B
: q( T# ~: @2 K1 v# h# F* F

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

• 产生IIC起始信号
  
  

4 H5 S1 |7 l% r5 U5 _) W% J: T  B
1 o) J& `4 H: ^3 u
, X7 ]- T% J0 T0 v  v3 e" W9 R! J
# W, @! ]  B- u1 ]9 Q
0 a4 P" [# i' V' J5 Q0 j

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

0 \; k3 E7 T7 q) ]4 C. P

• 产生IIC停止信号
  
  

, t5 q- f' p1 x% [" w3 g" P" J
( w- O. `0 C# {* Y4 ~! A

' ~% u3 @3 N) F' y' j! a

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

; K# X4 Z( D3 T5 c. [% c. `! [$ h! i. v

• 等待应答信号到来
  
  0 u2 O1 L9 L; t$ W; a1 r

% _/ W# [! n! y) K( K6 @2 ?

/ q+ q+ k8 ^* ]$ a

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

• 产生应答信号
  
  

% O) Q, J3 p$ u8 X- }
; O* s$ ], F1 [

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

• 不产生应答信号
  
  

- p' G' X; q0 b" f5 F6 l
. w' n# y, ?0 B) r# x
; Q+ }  v/ ~' o, l9 K& q

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

• IIC发送一个字节
  
  

  G3 ~' I! o1 O6 i
% h- q. ~: A3 G
; @9 g8 T/ ~" u& ~# d2 E/ \/ g- E0 _
! Q0 F3 I  c8 l: N. `5 Y

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

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

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

• 读取数据
  
  
  / j  s: V' d* x0 W; K. t

( w% A& I+ E# u: U( A" Q

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

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

i2c.h

1. #ifndef __MYIIC_H
   
2. #define __MYIIC_H
   
3. #include "sys.h"
   
4. #include "stm32f10x_gpio.h"
   
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;}
     I/ s2 S& `5 z4 h3 ]) b9 e  |
8. //IO操作函数
   
9. #define IIC_SCL PBout(6) //SCL
   ; p! z' y6 W- G. |/ C: z6 w
10. #define IIC_SDA PBout(7) //SDA
    ! [& m9 ?: j# ]/ z( m
11. #define READ_SDA PBin(7) //输入SDA
    . v# S4 l& q* T. ^5 v- ]4 o
12. //IIC所有操作函数
    
13. void IIC_Init(void); //初始化IIC的IO口
    ' \+ {( v7 w) ]( q7 U1 k* N5 ]
14. void IIC_Start(void); //发送IIC开始信号
    # ~! Y! ^. ^) t% e- d
15. void IIC_Stop(void); //发送IIC停止信号
    ( e" q/ W% \# o/ Y4 H& `( A+ A4 @8 N
16. void IIC_Send_Byte(u8 txd); //IIC发送一个字节
    1 ]8 X& _7 t% l( N8 o  M0 B2 G
17. u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
    8 L, C; d: D& A: y6 g
18. u8 IIC_Wait_Ack(void); //IIC等待ACK信号
    - `3 Z0 t) t. t) H
19. void IIC_Ack(void); //IIC发送ACK信号
    
20. void IIC_NAck(void); //IIC不发送ACK信号
    
21. void IIC_Write_One_Byte(u8 daddr,u8 addr,u8 data);
    " V. P; T# E6 s4 t- z
22. u8 IIC_Read_One_Byte(u8 daddr,u8 addr);
    " |) [) ^0 P/ L$ S5 n1 n3 ~
23. #endif

复制代码

i2c.c

1. #include "myiic.h"
   0 |8 R2 M4 L1 V
2. #include "delay.h"
   
3. //初始化IIC
   
4. void IIC_Init(void)
   
5. {                                         
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );        //使能GPIOB时钟
   
8.          
   : F; k, [7 }0 j! \' p. h1 x3 Y
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;
    9 N; P2 W, f2 c$ Y8 o; M
12.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    - L' [* j' S( h+ I% Q- s
13.         GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);         //PB6,PB7 输出高
    " v* V2 L# u1 g) |
14. }
    ; x$ p* ~! H. {: ^
15. //产生IIC起始信号
    
16. void IIC_Start(void)
    " \( I0 a5 B) {
17. {
    ( `, W8 ?0 G6 E! Y
18.         SDA_OUT(); //sda线输出
    
19.         IIC_SDA=1;                  
    
20.         IIC_SCL=1;
    $ [0 ^1 Y- w+ h; R& Y
21.         delay_us(4);
    ' @' _* j- `! Q" ]' O
22.         IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
23.         delay_us(4);
    
24.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    * Y& l( Q1 D$ f1 _
25. }         
    
26. //产生IIC停止信号
    , ^! {% R4 Q5 Q- K
27. void IIC_Stop(void)
    
28. {
    8 n' W; J2 n  q3 Y
29.         SDA_OUT();//sda线输出
    
30.         IIC_SCL=0;
    
31.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
32.         delay_us(4);
    - [" Z- X+ m( Q5 C* V6 S
33.         IIC_SCL=1;
    
34.         IIC_SDA=1;//发送I2C总线结束信号
    
35.         delay_us(4);                                                                
    ( x* }2 x" U' c6 x; r& Z
36. }
    ; j3 J$ g1 I+ i/ r) W  F
37. //等待应答信号到来
    
38. //返回值：1，接收应答失败
    * E. p6 Q. i/ C9 b; b
39. // 0，接收应答成功
    
40. u8 IIC_Wait_Ack(void)
    ' T0 Q# x- r& k5 q9 ~) J
41. {
    
42.         u8 ucErrTime=0;
    2 N) B* v  q9 S3 w6 }+ q. r* a2 K
43.         SDA_IN(); //SDA设置为输入
    
44.         IIC_SDA=1;delay_us(1);         
    
45.         IIC_SCL=1;delay_us(1);         
    
46.         while(READ_SDA)
    0 H6 I- }- U1 n4 `! R  n
47.         {
    
48.                 ucErrTime++;
    
49.                 if(ucErrTime>250)
    * l( N4 Z. W# p3 b: j
50.                 {
    
51.                         IIC_Stop();
    ; J- @9 P# O' S7 _8 N5 F6 E
52.                         return 1;
    / c7 d! b! d, N9 ?
53.                 }
    7 b: Z) }0 b) V4 i+ Q7 Y6 U4 X
54.         }
    
55.         IIC_SCL=0;//时钟输出0          
    
56.         return 0;
    3 O" [. `/ N0 [* f' i/ C1 R
57. }
    
58. //产生ACK应答
    8 A/ U& O  K2 C+ D5 I
59. void IIC_Ack(void)
    
60. {
    . V1 d3 M* h7 I! H! X' Y
61.         IIC_SCL=0;
    : A4 Z8 n9 E7 {& |6 d# G( z
62.         SDA_OUT();
    
63.         IIC_SDA=0;
    
64.         delay_us(2);
    5 Z4 B& Y2 J* t- P
65.         IIC_SCL=1;
    
66.         delay_us(2);
    
67.         IIC_SCL=0;
      ?& E- B1 F4 ^; g* e3 A, L3 M2 Y6 Z
68. }
    ; u; e* c8 Z3 L) w. B: S
69. //不产生ACK应答                 
    ) v. |8 q1 W2 l
70. void IIC_NAck(void)
    & U3 F$ N  d* Q& v
71. {
    
72.         IIC_SCL=0;
    
73.         SDA_OUT();
    
74.         IIC_SDA=1;
    
75.         delay_us(2);
    
76.         IIC_SCL=1;
    1 X" E5 c" n% }
77.         delay_us(2);
    ! m9 c, }' M6 ~- j6 I
78.         IIC_SCL=0;
    % G: T  q5 L4 g
79. }                                                                          
    
80. //IIC发送一个字节
    
81. //返回从机有无应答
    5 y9 ?9 q* ?: k
82. //1，有应答
    
83. //0，无应答                         
    : _$ K$ w+ D/ g: W
84. void IIC_Send_Byte(u8 txd)
    - ]8 p: D  Q! R) g
85. {
    
86. u8 t;
    , [& U2 o, O$ D' ^, V
87.         SDA_OUT();          
    & ]" b' E) i' N8 ^1 W, g6 y9 y0 |5 t
88. IIC_SCL=0;//拉低时钟开始数据传输
    % W) _6 \. S" k5 E, a$ D
89. for(t=0;t<8;t++)
    
90. {
    7 \& I5 h+ k( P- l! t# U3 |' N
91. //IIC_SDA=(txd&0x80)>>7;
    
92.                 if((txd&0x80)>>7)
    
93.                         IIC_SDA=1;
    
94.                 else
    8 l# j/ r( L# v3 e# s% W* a
95.                         IIC_SDA=0;
    ; b3 j( O# Y& w6 F; n
96.                 txd<<=1;          
    
97.                 delay_us(2);
    
98.                 IIC_SCL=1;
    
99.                 delay_us(2);
    
100.                 IIC_SCL=0;       
     ; Z/ F. B& `: n) n3 P3 B
101.                 delay_us(2);
     
102. }         
     % [" _4 s0 \0 S
103. }          
     5 J$ @* Z- C6 J2 f* h) h( O
104. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK
     0 U6 e, a) p# Q2 b: ^: v: q
105. u8 IIC_Read_Byte(unsigned char ack)
     0 B) W% u0 I1 v; _4 E
106. {
     # B8 }. d: A0 N7 F
107.         unsigned char i,receive=0;
     
108.         SDA_IN();//SDA设置为输入
     " @' _: h7 l0 q! q
109. for(i=0;i<8;i++ )
     
110.         {
     
111. IIC_SCL=0;
     
112. delay_us(2);
     , _4 s) X& J+ u+ h5 m( J, p  g9 O
113.                 IIC_SCL=1;
     
114. receive<<=1;
     # n' |* t2 v4 O! v/ J. X
115. if(READ_SDA)receive++;
     
116.                 delay_us(1);
     . Z* _0 [/ G3 b3 b
117. }                                         
     
118. if (!ack)
     
119. IIC_NAck();//发送nACK
     
120. else
     
121. IIC_Ack(); //发送ACK
     5 d$ L0 [0 \( J7 n- ^. i
122. return receive;
     , X8 [3 f* a% b* C' x; H
123. }

复制代码

4 O, i0 s- X& |) T& v; E% K转载自：电源研发精英圈
如有侵权请联系删除


' i: d* W/ T. E$ F+ b0 Y, S4 |3 A