Chinaunix首页 | 论坛 | 博客

xingfuhaitun的ChinaUnix博客xingfuhaitun.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

xingfuhaitun

  • 博客访问： 383343
  • 博文数量： 82
  • 博客积分： 1855
  • 博客等级： 上尉
  • 技术积分： 846
  • 用 户 组： 普通用户
  • 注册时间： 2010-09-12 12:28
文章分类

全部博文（82）

文章存档

2013年（3）

2012年（8）

2011年（71）

我的朋友
最近访客
推荐博文
相关博文
linux平台上GPIO模拟I2C

分类： LINUX

2012-12-23 13:57:32

GPIO模拟I2C是嵌入式中较为常用的一种应用。各个地方有各种不同的做法，按照我自己的个人理解，最好是把I2C的各种状态分割开来，比如起始条件终止条件，读数据和写数据，然后根据具体的使用场合组合起来。
这里需要注意两点：一是SCL的波形并不规律，不能将它理解为方波，它本身只是一段段独立的波形。二是每段操作时，之前和之后的SCL和SDA波形是可以忽略的；通常情况下I2C开始之前和I2C结束之后，两者都是有上拉的高电平，而在正常工作时两者不受控制的情况下都是默认低电平。三是I2C是要默认外部上拉的，但是不能有内部上拉也就是必须内部下拉，否则会出现I2C传输时的错误。

点击(此处)折叠或打开

  1. （1）基础宏定义

  3. #define GPIO_SCL S3C2410_GPF3
  4. #define GPIO_SDA S3C2410_GPF0
  5. #define GPIO_SDA_OUTP S3C2410_GPF0_OUTP //设定SDA输出
  6. #define GPIO_SDA_INP S3C2410_GPF0_INP //设定SDA输入
  7. #define GPIO_SCL_OUTP S3C2410_GPF3_OUTP //设定SCL输出

  9. void I2C_SCL_OUTP( void )
  10. {
  11.       s3c2410_gpio_cfgpin(GPIO_SCL,GPIO_SCL_OUTP);
  12. }

  14. void I2C_SCL_Output(u8 value)
  15. {
  16.       if(value)
  17.       { 
  18.             s3c2410_gpio_setpin(GPIO_SCL,value); 
  19.       }
  20.       else
  21.       {
  22.             s3c2410_gpio_setpin(GPIO_SCL,value ); 
  23.       } 
  24. }

  26.  

  28. void I2C_SDA_Mode(u8 v_mode) //SDA输出方向
  29. {
  30.        if(v_mode)
  31.        { 
  32.               s3c2410_gpio_cfgpin(GPIO_SDA, GPIO_SDA_OUTP); 
  33.        }
  34.        else
  35.        {
  36.               s3c2410_gpio_cfgpin(GPIO_SDA, GPIO_SDA_INP); 
  37.        }
  38. }

  40. void I2C_SDA_Output(u8 value)
  41. {
  42.        if(value)
  43.        { 
  44.                s3c2410_gpio_setpin(GPIO_SDA,value); 
  45.        }
  46.        else
  47.        {
  48.                 s3c2410_gpio_setpin(GPIO_SDA,value ); 
  49.        }
  50. }

  52. u8 I2C_SDA_Read(void) //SDA读数据
  53. {
  54.        return s3c2410_gpio_getpin(GPIO_SDA); 
  55. }

  57. （2）基础段

  59. void I2C_Init(void)
  60. { 
  61.       I2C_SDA_Output(1);
  62.       I2C_SCL_Output(1); //默认拉高
  63. }

  65. void I2C_Wait(void)
  66. {
  67.       u16 i;
  68.       for(i=0;i<200;i++);
  69. }

  71. void I2C_Start(void) 
  72. {
  73.       I2C_SDA_Output(1);
  74.       I2C_SCL_Output(1);
  75.       I2C_Wait();
  76.       I2C_SDA_Output(0);
  77.       I2C_Wait();
  78.       I2C_SCL_Output(0);
  79. }
  80. void I2C_Stop(void) 
  81. {
  82.       I2C_SDA_Output(0);
  83.       I2C_Wait();
  84.       I2C_SCL_Output(1);
  85.       I2C_Wait();
  86.       I2C_SDA_Output(1);
  87. }

  89. （3）读写单个字节的段

  91. u8 I2C_Send_Byte(u8 bytedata) 
  92. {
  93.       u8 i,ack;
  94.       I2C_SDA_Mode(1); //SDA输出
  95.       I2C_SCL_OUTP();
  96.       for (i = 0; i < 8; i++) 
  97.       {
  98.               if (bytedata & 0x80) 
  99.               {
  100.                      I2C_SDA_Output(1);
  101.               }
  102.               else
  103.               {
  104.                     I2C_SDA_Output(0);
  105.               }
  106.               bytedata <<= 1;
  107.              
  108.               I2C_SCL_Output(1);
  109.               udelay(3);
  110.               I2C_SCL_Output(0);
  111.               udelay(1);
  112.        } 
  113.    
  114.         I2C_SDA_Output(1); //release
  115.         udelay(3);
  116.         
  117.         I2C_SDA_Mode(0); //设定SDA输入
  118.         I2C_SCL_Output(1); 
  119.         udelay(3);
  120.         ack = I2C_SDA_Read(); //读应答
  121.         I2C_SDA_Mode(1); 
  122.         I2C_SCL_Output(0); 
  123.         udelay(3);
  124.        
  125.         return ack; 
  126. }

  128. u8 I2C_Receive_Byte(void) 
  129. {
  130.        u8 i;
  131.        u8 bytedata = 0x00;
  132.        u8 temp;
  133.  
  134.        I2C_SDA_Mode(0); 
  135.        for ( i = 0; i < 8; i++)
  136.        {
  137.              I2C_SCL_Output(1);
  138.              udelay(3);

  140.  

  142.              bytedata <<= 1;
  143.              temp = I2C_SDA_Read(); 
  144.              printk("reda SDA'value is:%d/n",temp);
  145.  
  146.              if (temp)
  147.                    bytedata |= 0x01; 
  148.              printk(" bytedata is:%x/n",bytedata);
  149.              I2C_SCL_Output(0);
  150.              udelay(1);
  151.        }
  152.        I2C_SDA_Mode(1); 
  153.        return bytedata;
  154. }

  156. （4）读写单个字节的I2C应用函数

  158. u8 I2C_Byte_Write(u8 device_ID,u8 address,u8 bytedata)
  159. { 
  160.        u8 ack;
  161.        printk("device_ID is:%x/n",device_ID);
  162.        printk("address is:%x/n",address);
  163.        printk("date is:%x/n",bytedata);
  164.        I2C_Start(); 
  165.        ack=I2C_Send_Byte(device_ID);
  166.        printk("ack is:%d/n",ack);
  167.        if(ack) 

  169.              I2C_Stop();
  170.        I2C_Send_Byte(address);
  171.        I2C_Send_Byte(bytedata);
  172.        I2C_Stop();
  173.        I2C_Wait(); 
  174.        return 0;
  175. }

  177. u8 I2C_Byte_Read(u8 device_ID,u8 address)
  178. { 
  179.        u8 bytedata;

  181.        I2C_Start();
  182.        I2C_Send_Byte(device_ID);
  183.        I2C_Send_Byte(address);
  184.        I2C_Start();
  185.        I2C_Send_Byte(device_ID+1);
  186.        bytedata = I2C_Receive_Byte(); //读单个字节，不需要再发应答
  187.        I2C_Stop(); 
  188.        return bytedata;
  189. }

  191. （5）类似可以完成读写多个字节的函数，暂不补充。
第二种方式也可以用

点击(此处)折叠或打开

  1. #ifdef I2C_USE_GPIO
  2. #define GPIO_I2C_DEBUG

  4. #define GPIO_I2C_SDA_PIN GPIO_I2C1_SCA_PIN
  5. #define GPIO_I2C_SCA_PIN GPIO_I2C1_SDA_PIN
  6. #define GPIO_SDA_OUTP mt_set_gpio_dir(GPIO_I2C_SDA_PIN,GPIO_DIR_OUT) //设定SDA输出
  7. #define GPIO_SDA_INP mt_set_gpio_dir(GPIO_I2C_SDA_PIN,GPIO_DIR_IN) //设定SDA输入
  8. #define GPIO_SCL_OUTP mt_set_gpio_dir(GPIO_I2C_SCA_PIN,GPIO_DIR_OUT) //设定SCL输出

  10. #define I2C_SDA_Output(value) mt_set_gpio_out(GPIO_I2C_SDA_PIN,value)
  11. #define I2C_SCL_Output(value) mt_set_gpio_out(GPIO_I2C_SCA_PIN,value)

  13. #define DELAY_TIME 0xc0

  15. u8 I2C_SDA_Read(void) //SDA读数据
  16. {
  17.        return mt_get_gpio_in(GPIO_I2C_SDA_PIN); 
  18. }


  21. void I2C_Init(void)
  22. { 
  23.     mt_set_gpio_mode(GPIO_I2C_SDA_PIN,GPIO_MODE_00);
  24.     mt_set_gpio_mode(GPIO_I2C_SCA_PIN,GPIO_MODE_00);

  26.     GPIO_SDA_OUTP;
  27.     GPIO_SCL_OUTP;
  28.     
  29.       I2C_SDA_Output(1);
  30.       I2C_SCL_Output(1); //默认拉高
  31. }

  33. #define I2C_START_TRANSMISSION \
  34.     { \
  35.         volatile u8 idx; \
  36.         GPIO_SCL_OUTP; \
  37.         GPIO_SDA_OUTP; \
  38.         I2C_SDA_Output(1); \
  39.         for (idx = 0; idx < DELAY_TIME; idx++); \
  40.         I2C_SCL_Output(1); \
  41.         for (idx = 0; idx < DELAY_TIME; idx++); \
  42.         I2C_SDA_Output(0); \
  43.         for (idx = 0; idx < DELAY_TIME; idx++); \
  44.         I2C_SCL_Output(0); \
  45.     }

  47.     #define I2C_STOP_TRANSMISSION \
  48.     { \
  49.         volatile u8 idx; \
  50.         GPIO_SCL_OUTP; \
  51.         GPIO_SDA_OUTP; \
  52.         I2C_SCL_Output(0); \
  53.         I2C_SDA_Output(0); \
  54.         for (idx = 0; idx < DELAY_TIME; idx++); \
  55.         I2C_SCL_Output(1); \
  56.         for (idx = 0; idx < DELAY_TIME; idx++); \
  57.         I2C_SDA_Output(1); \
  58.     }

  60. static kal_uint8 I2C_Send_Byte(kal_uint8 send_byte)
  61. {
  62.     volatile signed char i = 0;
  63.     volatile kal_uint16 j = 0;
  64.     kal_uint8 ack = 0;

  66.     for (i = 7; i >= 0; i--)
  67.     {
  68.         if (send_byte&(1 << i))
  69.         {
  70.             I2C_SDA_Output(1);
  71.         }
  72.         else
  73.         {
  74.             I2C_SDA_Output(0);
  75.         }
  76.         for (j = 0; j < DELAY_TIME; j++);
  77.         I2C_SCL_Output(1);
  78.         for (j = 0; j < DELAY_TIME; j++);
  79.         GPIO_SDA_OUTP; /* only for delay */
  80.         for (j = 0; j < DELAY_TIME; j++);
  81.         I2C_SCL_Output(0);
  82.         for (j = 0; j < DELAY_TIME; j++);
  83.     }
  84.     GPIO_SDA_INP;
  85.     for (j = 0; j < DELAY_TIME; j++);
  86.     I2C_SCL_Output(1);
  87.     for (j = 0; j < DELAY_TIME; j++);
  88.     ack = I2C_SDA_Read();
  89.     for (j = 0; j < DELAY_TIME; j++);
  90.     I2C_SCL_Output(0);
  91.     for (j = 0; j < DELAY_TIME; j++);
  92.     GPIO_SDA_OUTP;

  94.     return ack;
  95. }


  98. static kal_uint8 I2C_Receive_Byte(void)
  99. {
  100.     volatile signed char i = 0;
  101.     volatile kal_uint16 j = 0;
  102.     kal_uint8 get_byte = 0;

  104.     GPIO_SDA_INP;

  106.     for (j = 0; j < DELAY_TIME; j++);

  108.     for (i = 7; i >= 0; i--) { // data bit 7~0
  109.         I2C_SCL_Output(1);
  110.         for (j = 0; j < DELAY_TIME; j++);
  111.         if (I2C_SDA_Read()) {
  112.             get_byte |= (1 << i);
  113.         }
  114.         for (j = 0; j < DELAY_TIME; j++);
  115.         I2C_SCL_Output(0);
  116.         for (j = 0; j < DELAY_TIME; j++);
  117.     }

  119.     // don't care bit, 9th bit
  120.     GPIO_SDA_OUTP;
  121.     I2C_SDA_Output(1);
  122.     for (j = 0; j < DELAY_TIME; j++);
  123.     I2C_SCL_Output(1);
  124.     for (j = 0; j < DELAY_TIME; j++);
  125.     I2C_SCL_Output(0);

  127.     return get_byte;
  128. } 



  132. static kal_uint16 I2C_Receive_word(void)
  133. {
  134.     volatile signed char i = 0;
  135.     volatile kal_uint32 j = 0;
  136.     kal_uint16 get_byte = 0;

  138.     for (i = 15; i >= 8; i--)
  139.     {
  140.         GPIO_SDA_INP;
  141.         for (j = 0; j < DELAY_TIME; j++);
  142.         I2C_SCL_Output(1);
  143.         for (j = 0; j < DELAY_TIME; j++);
  144.         if (I2C_SDA_Read()) get_byte |= (1 << i);
  145.         for (j = 0; j < DELAY_TIME; j++);
  146.         I2C_SCL_Output(0);
  147.         for (j = 0; j < DELAY_TIME; j++);
  148.     }
  149.     I2C_SDA_Output(0);
  150.     GPIO_SDA_OUTP;
  151.     for (j = 0;j < DELAY_TIME; j++);
  152.     I2C_SCL_Output(1);
  153.     for (j = 0;j < DELAY_TIME; j++);
  154.     GPIO_SDA_OUTP; /* just for delay */
  155.     for (j = 0;j < DELAY_TIME; j++);
  156.     I2C_SCL_Output(0);
  157.     for (j = 0;j < DELAY_TIME; j++);
  158.     for (; i >= 0; i--)
  159.     {
  160.         GPIO_SDA_INP;
  161.         for (j = 0; j < DELAY_TIME; j++);
  162.         I2C_SCL_Output(1);
  163.         for (j = 0; j < DELAY_TIME; j++);
  164.         if (I2C_SDA_Read()) get_byte |= (1 << i);
  165.         for (j = 0; j < DELAY_TIME; j++);
  166.         I2C_SCL_Output(0);
  167.         for (j = 0; j < DELAY_TIME; j++);
  168.     }
  169.     I2C_SDA_Output(1);
  170.     GPIO_SDA_OUTP;
  171.     for (j = 0;j < DELAY_TIME; j++);
  172.     I2C_SCL_Output(1);
  173.     for (j = 0;j < DELAY_TIME; j++);
  174.     GPIO_SDA_OUTP; /* just for delay */
  175.     for (j = 0;j < DELAY_TIME; j++);
  176.     I2C_SCL_Output(0);
  177.     for (j = 0;j < DELAY_TIME; j++);

  179.     return get_byte;
  180. }

  182. u8 I2C_Byte_Write(u8 * a_puBuff , u8 len , u8 i2c_addr)
  183. { 
  184.        kal_uint8 fail_try_no = 4;
  185.     volatile signed char i = 0 ;
  186.     u8 ack_flag = 0;
  187.     while (--fail_try_no > 0)
  188.     {
  189.         ack_flag = 0;
  190.         I2C_START_TRANSMISSION;
  191.         if (I2C_Send_Byte(i2c_addr)) continue;
  192.            for(i = 0 ;i < len;i++){
  193.             if (I2C_Send_Byte(a_puBuff[i])){
  194.                 ack_flag = 1;
  195.                 break;
  196.             } 
  197.            }
  198.         if(ack_flag)
  199.             continue;
  200.         break;
  201.     }
  202.     I2C_STOP_TRANSMISSION;
  203.        return 0;
  204. }

  206. u8 I2C_Bytes_Read(u8 *a_puBuff, u8 reglen ,u8 *byteget,u8 bytelen,u8 i2c_addr)
  207. { 

  209.     kal_uint16 get_byte = 0xFFFF;
  210.     kal_uint8 fail_try_no = 4;
  211.     volatile kal_uint32 i = 0;
  212.     u8 ack_flag = 0;

  214.     while (--fail_try_no > 0)
  215.     {
  216.         ack_flag = 0;
  217.         I2C_START_TRANSMISSION;
  218.         if (I2C_Send_Byte(i2c_addr)) continue;
  219.         
  220.         //send reg
  221.      for(i = 0 ;i < reglen;i++){
  222.             if (I2C_Send_Byte(a_puBuff[i])){
  223.                 ack_flag = 1;
  224.                 break;
  225.             } 
  226.            }
  227.         if(ack_flag)
  228.             continue;
  229.         
  230.         I2C_START_TRANSMISSION;
  231.         if (I2C_Send_Byte(i2c_addr | 1)) continue;
  232.         
  233.         if(bytelen == 1)
  234.          byteget[0] = get_byte = I2C_Receive_Byte(); //读单个字节，不需要再发应答
  235.         else if(bytelen > 1)
  236.         {
  237.              get_byte=I2C_Receive_word();
  238.              byteget[1] = get_byte & 0x00ff;
  239.               byteget[0] = (get_byte & 0xff00) >> 8;
  240.          }
  241.         break;
  242.     }
  243.     I2C_STOP_TRANSMISSION;

  245.     printk("----%s---read data %x---\n",__func__,get_byte);

  247.     return get_byte;

  249. }    

  251. int iWriteRegI2C(u8 *a_pSendData , u16 a_sizeSendData, u16 i2cId)
  252. {
  253.     I2C_Byte_Write(a_pSendData,a_sizeSendData,i2cId);
  254.     return 0;
  255. }

  257. int iReadRegI2C(u8 *a_pSendData , u16 a_sizeSendData, u8 * a_pRecvData, u16 a_sizeRecvData, u16 i2cId)
  258. {
阅读(2340) | 评论(0) | 转发(3) |
1

上一篇：H264简单描述

下一篇：NTP校时源码

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6