I2c总线协议.docx

I2c总线协议.docx

《I2c总线协议.docx》由会员分享，可在线阅读，更多相关《I2c总线协议.docx（12页珍藏版）》请在冰豆网上搜索。

I2c总线协议

12C协议

   2条双向串行线，一条数据线，一条时钟线。

  传输数据是大端传输，每次传输8，即一字节。

  支持多主控（），任何时间点只能有一个主控。

  总线上每个设备都有自己的一个，共7个，广播地址全0.

  系统中可能有多个同种芯片，为此分为固定部分和可编程部份，细节视芯片而定，看。

1.1I2C位传输

  数据传输：

为高电平时，线若保持稳定，那么上是在传输数据；

  若发生跳变，则用来表示一个会话的开始或结束（后面讲）

  数据改变：

为低电平时，线才能改变传输的

 1.2I2C开始和结束信号

  开始信号：

为高电平时，由高电平向低电平跳变，开始传送数据。

  结束信号：

为高电平时，由低电平向高电平跳变，结束传送数据。

1.3I2C应答信号

  每发送完8数据后等待的。

  即在第9个，若从发，会被拉低。

  若没有，会被置高，这会引起发生或流程，如下所示：

 1.4I2C写流程

写寄存器的标准流程为：

1.   发起

2.   发送I2C（7）和w操作0

（1），等待

3.   发送

4.   发送（8），等待

5.   发送

6.   发送（8），即要写入寄存器中的数据，等待

7.   发送

8.   第6步和第7步可以重复多次，即顺序写多个寄存器

9.   发起

写一个寄存器

 写多个寄存器

 1.5I2C读流程

读寄存器的标准流程为：

1.   发送I2C（7）和w操作1

（1），等待

2.   发送

3.   发送（8），等待

4.   发送

5.   发起

6.   发送I2C（7）和r操作1

（1），等待

7.   发送

8.   发送（8），即寄存器里的值

9.   发送

10.   第8步和第9步可以重复多次，即顺序读多个寄存器

读一个寄存器

 读多个寄存器

 2.的I2C实现

8560的中控制I2C的寄存器共有6个。

2.1I2地址寄存器

也可以是I2C的，的I2C地址有I2指定

 2.2I2频率设置寄存器

 .

用来设置I2C总线频率

2.3I2控制寄存器

：

.   置1时，I2C模块使能

：

.置1时，I2C中断使能。

：

.1，0.

      当1->0时，发起信号

      当0->1时，发起信号

：

.0，1

：

.置1时，在9发送拉低

：

.置1时，发送

：

置1，接收广播信息（信息的为7个0）

2.4I2状态寄存器

 ：

0 

    1 

：

当作为时，若I2与会话中匹配，此被置1

：

0I2C  

    1I2C

：

若置1，表示仲裁失败

：

若置1，表示接收到广播信息

：

,.

  0,

  1,

：

.,a（I2[]）

：

若置1，表示收到了

2.5I2数据寄存器

这个寄存器储存将要传输的数据。

3.中I2C的实现

 内核代码中，通过I2C总线存取寄存器的函数都在文件22中

 最重要的函数是.

1.  （ i2 *,  i2 *,  ）

2.{

3.     i2 *;

4.     i;

5.      = 0;

6.       = ;

7.     2c *i2c = i2（）;

8.    2（i2c）;    设置I2[],使能I2C 

9.    /*1s*/

10.    一直读I2[]，等待I2C总线空闲下来

11.     （（i2> + 2） & ） {

12.         （（）） {

13.            （"I2C:

\n"）;

14.            （i2c, 0）;

15.             ;

16.        }

17.         （（,  + ）） {

18.            （"I2C:

\n"）;

19.             （（i2> + 2） 

20.                （ |  | ））

21.                2（i2c）;

22.             ;

23.        }

24.        （）;

25.    }

26.     （i = 0;  >= 0  i < ; ） {

27.         = [i];

28.        （"002x-\n",

29.             > & I2 ?

 "" :

 "",

30.             >, >, i + 1, ）;

31.        根据消息里的进行读操作或写操作

32.         （> & I2） 

33.             = （i2c, >, >, >, i）;

34.        

35.             = （i2c, >, >, >, i）;

36.    }

37.    2（i2c）;    保证为I2[]为0，保证能触发

38.     （ < 0） ?

  :

 ;

39.}

1.  （ 2c *i2c,  ,

2.              u8 * ,  ,  ）

3.{

4.     i;

5.      = i2>;

6.    u32 =  ?

  :

 0;

7.    /**/    以防万一，保证I2C模块使能起来

8.     （）

9.        （i2c, ）;

10.    /**/       写了I2[]，触发发起信号

11.    （i2c,  |  |  |  | ）;

12.    /**/     发送一个字节，I2C和0（写操作） 

13.    （（ << 1）, i2> + 2）;

14.     （i2（i2c, , 1） < 0）    等待发

15.         -1;

16.     （i = 0; i < ; ） {

17.        /**/

18.        （[i], i2> + 2）; 接着发数据，包括和

19.         （i2（i2c, , 1） < 0）       等待发

20.             -1;

21.    }

22.     0;

23.}

1.  i2（ 2c *i2c,  ,  ）

2.{

3.       = ;

4.    u32x;

5.      = 0;

6.     （i2>  0）

7.    {    循环读I2，直到I2[]置1

8.         （!

（（i2> + 2） & ）） {

9.            （）;

10.             （（,  + ）） {

11.                （"I2C:

\n"）;

12.                （i2c, 0）;

13.                 = ;

14.                ;

15.            }

16.        }

17.        x = （i2> + 2）;

18.        （0, i2> + 2）;

19.    }  {

20.        /**/

21.         = （i2>,

22.            （i2> & ）,  * ）;

23.         （（ < 0）） {

24.            （"I2C:

\n"）;

25.            （i2c, 0）;

26.        }   （（!

（i2> & ））） {

27.            （"I2C:

\n"）;

28.            （i2c, 0）;

29.             = ;

30.        }

31.        x = i2>;

32.        i2> = 0;

33.    }

34.     （ < 0）

35.         ;

36.     （!

（x & ）） {

37.        （"I2C:

\n"）;

38.         ;

39.    }

40.     （x & ） {    仲裁失败

41.        （"I2C:

\n"）;

42.         ;

43.    }

44.     （  （x & ）） {写后没收到

45.        （"I2C:

\n"）;

46.        /**/

47.        （i2c, ）;

48.         ;

49.    }

50.     0;

51.}

1.  （ 2c *i2c,  ,

2.            u8 * ,  ,  ）

3.{

4.      = i2>;

5.     i;

6.    u32 =  ?

  :

 0;

7.    /**/    以防万一，保证I2C模块使能

8.     （）

9.        （i2c, ）;

10.    /*-*/

11.    注意这里，再次把置1，再触发 

12.    （i2c,  |  |  |  | ）;

13.    /*-*/ 

14.    发送I2C和读操作1

15.    （（ << 1） | 1, i2> + 2）;

    等待发

1.     （i2（i2c, , 1） < 0）

2.         -1;

3.     （） {

4.         （  1）

5.            （i2c,  |  |  | ）;

6.         为什么不置

7.            （i2c,  |  | ）;

8.        /**/

9.        （i2> + 2）;

10.    }

11.     （i = 0; i < ; ） {

12.         （i2（i2c, , 0） < 0）

13.             -1;

14.        /**/

15.        注意这里置1，表示每收到1数据后，会发送

16.         （i   - 2） 

17.            （i2c,  |  |  | ）;

18.        /**/

19.        注意这里[1->0]会触发

20.         （i   - 1）    

21.            （i2c,  |  | ）;

22.        [i] = （i2> + 2）;

23.    }

24.     ;

25.}

26.