image.png
资料包括芯片手册、IIC寄存器控制手册、IIC通信例程、PCB demo板PCB文件。除了可以实现基本功能，还可以可以利用单片机模拟IIC通信扩展其他功能。
单片机源程序如下:

  1. #include "CSU32P10.h"
  2. //#include "define_data.h"
  3. #include "define_function.h"
  4. #include "my_define.h"
  6. #define SDA PT3_1                           //定义SDA所对应的GPIO接口编号P1.4  
  7. #define SCL PT3_0                           //定义SCL所对应的GPIO接口编号P1.5
  8. #define SDAEN PT3EN_1                           //定义SDA所对应的GPIO接口编号P1.4  
  9. #define SCLEN PT3EN_0                           //定义SCL所对应的GPIO接口编号P1.5
  10. #define I2C_ADDR 0x3c
  11. #define somenop asm("nop");asm("nop");asm("nop");asm("nop");
  12. //#define I2C_ADDR 0x3c
  13. unsigned char buf0;
  14. unsigned char buf1;
  15. unsigned char i2c_step;
  18. //短delay
  20. /* I2C起始条件 */  
  21. void i2c_start()  
  22. {  
  23.         //初始化GPIO口
  24.         SDAEN = 1;                                //设置SDA方向为输出
  25.         SCLEN = 1;                                //设置SCL方向为输出
  26.         SDA = 1;                //设置SDA为高电平
  27.         asm("nop");
  28.         SCL = 1;                //设置SCL为高电平   
  29.         somenop
  30.         somenop
  31.         SDA = 0;                //SCL为高电平时，SDA由高变低  
  32.         somenop
  33.         somenop
  34.         somenop
  35.         somenop
  36.         somenop
  37.         somenop
  38.         SCL = 0;
  39. }  
  40. /* I2C终止条件 */  
  41. void i2c_stop()  
  42. {  
  43.         somenop
  44.         SDA = 0;      
  45.         SDAEN = 1;   
  46.         somenop
  47.         SCL = 1;
  48.         somenop
  49.         somenop
  50.         somenop
  51.         somenop
  52.         somenop
  53.         somenop
  54.         SDA = 1;            //SCL高电平时，SDA由低变高
  55.         somenop      
  56.         SDAEN = 0;
  57. //        SCL = 0;
  58. }  
  59. /*   
  60. I2C读取ACK信号(写数据时使用)  
  61. 返回值 ：0表示ACK信号有效；非0表示ACK信号无效  
  62. */  
  63. void i2c_read_ack()  
  64. {   
  65.         SCL = 0;               // SCL变低
  66.         SDAEN = 0;                                 //设置SDA方向为输入
  67.         somenop      
  68.         SCL = 1;              // SCL变高  
  69.         somenop
  70.         if(SDA)
  71.         {
  72.                 i2c_step = 0xff;
  73.                 return;
  74.         }
  75.         SCL = 0;
  76.         asm("nop");
  77.         asm("nop");
  78.         asm("nop");
  79.         asm("nop");
  80. }  
  81. /* I2C发出ACK信号(读数据时使用) */  
  82. void i2c_send_ack()  
  83. {
  84.         SCL = 0;              // SCL变低
  85.         somenop
  86.         SDA = 1;              //发出ACK信号
  87.         SDAEN = 1;              //设置SDA方向为输出      
  88.         asm("nop");
  89.         asm("nop");
  90.         asm("nop");      
  91.         SCL = 1;             // SCL变高  
  92.         somenop
  93.         SCL = 0;
  94. //        SDAEN = 1;
  95.         asm("nop");
  96.         asm("nop");
  97. }  
  98. /* I2C字节写 */
  100. void i2c_resume()
  101. {
  102.         GIE = 0;
  103.         delay_1s();
  104.         delay_1s();
  105.         i2c_read_ack();
  106.         i2c_read_ack();
  107.         i2c_read_ack();
  108.         i2c_read_ack();
  109.         i2c_read_ack();
  110.         i2c_read_ack();
  111.         i2c_read_ack();
  112.         i2c_read_ack();
  113.         GIE = 1;
  114. }
  116. void i2c_write_byte(unsigned char b)  
  117. {   
  118.         SDAEN = 1;    //设置SDA方向为输出  
  119.         SCL = 0;
  120.         for (i2c_step = 8; i2c_step > 0; i2c_step --)
  121.         {  
  122.                 SCL = 0;             // SCL变低
  123.                 asm("nop");
  124.                 if( b & (1 << (i2c_step - 1)))
  125.                         SDA = 1;
  126.                 else
  127.                         SDA = 0;
  128.                 asm("nop");
  129.                 SCL = 1;             // SCL变高  
  130.                 somenop
  131.                 SCL = 0;
  132.         }  
  133.         i2c_read_ack();
  134. }
  136. /* I2C字节读 */  
  137. void i2c_read_byte()  
  138. {   
  139.         buf1 = 0;
  140.         SDAEN = 0;                                //设置SDA方向为输入
  141.         for(i2c_step = 8; i2c_step > 0; i2c_step --)
  142.         {  
  143.                 SCL = 0;         // SCL变低  
  144.                 asm("nop");
  145.                 asm("nop");
  146.                 SCL = 1;
  147.                 //i2c_result = (i2c_result << 1) | SDA;
  148.                 buf1 = (buf1 << 1) | SDA;
  149.                                                         // SCL变高  
  150. //                asm("nop");
  151. //                asm("nop");
  152.                 SCL = 0;
  153.         }
  154.         i2c_send_ack();                                                //向目标设备发送ACK信号
  155. }  
  156. /*  
  157. I2C读操作  
  158. addr：目标设备地址  
  159. buf：读缓冲区  
  160. len：读入字节的长度  
  161. */  
  162. void i2c_read()  
  163. {  
  164.         i2c_start();                                                        //起始条件，开始数据通信  
  165.                                                                         //发送地址和数据读写方向  
  166.         i2c_write_byte(I2C_ADDR<<1);        //I2C ADDR
  168.         asm("nop");
  169.         if(i2c_step == 0xff)
  170.         {
  171.                 i2c_resume();
  172.                 return;
  173.         }      
  175.         i2c_write_byte(buf0);                        //Reg ADDR
  177.         asm("nop");
  178.         if(i2c_step == 0xff)
  179.         {
  180.                 i2c_resume();
  181.                 return;
  182.         }      
  183.         //asm("nop");
  184.         i2c_start();//restart
  186.         i2c_write_byte((I2C_ADDR<<1) +1);        //Reg ADDR
  188.         asm("nop");
  189.         if(i2c_step == 0xff)
  190.         {
  191.                 i2c_resume();
  192.                 return;
  193.         }
  194.         //读入数据  
  196.         i2c_read_byte();
  198.         i2c_stop();
  199.         //终止条件，结束数据通信  
  200. }  
  201. /*  
  202. I2C写操作  
  203. addr：目标设备地址  
  204. buf：写缓冲区  
  205. len：写入字节的长度  
  206. */  
  207. void i2c_write()  
  208. {  
  209.         i2c_start();                                                        //起始条件，开始数据通信  
  210.         //发送地址和数据读写方向
  212.         i2c_write_byte(I2C_ADDR<<1);
  214.         asm("nop");
  215.         if(i2c_step == 0xff)
  216.         {
  217.                 i2c_resume();
  218.                 return;
  219.         }      
  220.       
  221.         //写入数据
  223.         i2c_write_byte(buf0);
  225.         asm("nop");
  226.         if(i2c_step == 0xff)
  227.         {
  228.                 i2c_resume();
  229.                 return;
  230.         }
  232.         i2c_write_byte(buf1);
  234.         asm("nop");
  235.         if(i2c_step == 0xff)
  236.         {
  237.                 i2c_resume();
  238.                 return;
  239.         }
  240.         i2c_stop();                     //终止条件，结束数据通信  
  241. }