程序博客网 > 淘宝评价生效时间

linux平台上GPIO模拟I2C

来源：互联网 发布：淘宝评价生效时间 编辑：程序博客网 时间：2024/05/29 04:44
GPIO模拟I2C是嵌入式中较为常用的一种应用。各个地方有各种不同的做法，按照我自己的个人理解，最好是把I2C的各种状态分割开来，比如起始条件终止条件，读数据和写数据，然后根据具体的使用场合组合起来。

      这里需要注意两点：一是SCL的波形并不规律，不能将它理解为方波，它本身只是一段段独立的波形。二是每段操作时，之前和之后的SCL和SDA波形是可以忽略的；通常情况下I2C开始之前和I2C结束之后，两者都是有上拉的高电平，而在正常工作时两者不受控制的情况下都是默认低电平。三是I2C是要默认外部上拉的，但是不能有内部上拉也就是必须内部下拉，否则会出现I2C传输时的错误。

[cpp] view plaincopyprint?
  1. （1）基础宏定义 
  2.  
  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输出 
  8.  
  9. void I2C_SCL_OUTP( void ) 
  10. { 
  11.       s3c2410_gpio_cfgpin(GPIO_SCL,GPIO_SCL_OUTP); 
  12. } 
  13.  
  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. } 
  25.  
  26.   
  27.  
  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. } 
  39.  
  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. } 
  51.  
  52. u8 I2C_SDA_Read(void)    //SDA读数据 
  53. { 
  54.        return s3c2410_gpio_getpin(GPIO_SDA);   
  55. } 
  56.  
  57. （2）基础段 
  58.  
  59. void I2C_Init(void) 
  60. {  
  61.       I2C_SDA_Output(1); 
  62.       I2C_SCL_Output(1);      //默认拉高 
  63. } 
  64.  
  65. void I2C_Wait(void) 
  66. { 
  67.       u16 i; 
  68.       for(i=0;i<200;i++); 
  69. } 
  70.  
  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. } 
  88.  
  89. （3）读写单个字节的段 
  90.  
  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. } 
  127.  
  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); 
  139.  
  140.   
  141.  
  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. } 
  155.  
  156. （4）读写单个字节的I2C应用函数 
  157.  
  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)  
  168.  
  169.              I2C_Stop(); 
  170.        I2C_Send_Byte(address); 
  171.        I2C_Send_Byte(bytedata); 
  172.        I2C_Stop(); 
  173.        I2C_Wait();  
  174.        return 0; 
  175. } 
  176.  
  177. u8 I2C_Byte_Read(u8 device_ID,u8 address) 
  178. {    
  179.        u8 bytedata; 
  180.  
  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. } 
  190.  
  191. （5）类似可以完成读写多个字节的函数，暂不补充。 

==================================================================================================================================

==================================================================================================================================

第二种方式也可以用

[cpp] view plaincopyprint?
  1. #ifdef I2C_USE_GPIO 
  2. #define GPIO_I2C_DEBUG 
  3.  
  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输出 
  9.  
  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) 
  12.  
  13. #define DELAY_TIME   0xc0 
  14.  
  15. u8 I2C_SDA_Read(void)   //SDA读数据 
  16. { 
  17.        return mt_get_gpio_in(GPIO_I2C_SDA_PIN);   
  18. } 
  19.  
  20.  
  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); 
  25.  
  26.     GPIO_SDA_OUTP; 
  27.     GPIO_SCL_OUTP; 
  28.      
  29.       I2C_SDA_Output(1); 
  30.       I2C_SCL_Output(1);      //默认拉高 
  31. } 
  32.  
  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.     } 
  46.  
  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.     } 
  59.  
  60. static kal_uint8 I2C_Send_Byte(kal_uint8 send_byte) 
  61. { 
  62.     volatile signedchar i = 0; 
  63.     volatile kal_uint16 j = 0; 
  64.     kal_uint8 ack = 0; 
  65.  
  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; 
  93.  
  94.     return ack; 
  95. } 
  96.  
  97.  
  98. static kal_uint8 I2C_Receive_Byte(void) 
  99. { 
  100.     volatile signedchar i = 0; 
  101.     volatile kal_uint16 j = 0; 
  102.     kal_uint8 get_byte = 0; 
  103.  
  104.     GPIO_SDA_INP; 
  105.  
  106.     for (j = 0; j < DELAY_TIME; j++); 
  107.  
  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.     } 
  118.  
  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); 
  126.  
  127.     return get_byte; 
  128. }    
  129.  
  130.  
  131.  
  132. static kal_uint16 I2C_Receive_word(void) 
  133. { 
  134.     volatile signedchar i = 0; 
  135.     volatile kal_uint32 j = 0; 
  136.     kal_uint16 get_byte = 0; 
  137.  
  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++); 
  178.  
  179.     return get_byte; 
  180. } 
  181.  
  182. u8 I2C_Byte_Write(u8 * a_puBuff , u8 len , u8 i2c_addr) 
  183. {    
  184.        kal_uint8 fail_try_no = 4; 
  185.     volatile signedchar 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. } 
  205.  
  206. u8 I2C_Bytes_Read(u8 *a_puBuff, u8 reglen ,u8 *byteget,u8 bytelen,u8 i2c_addr) 
  207. {    
  208.  
  209.     kal_uint16 get_byte = 0xFFFF; 
  210.     kal_uint8 fail_try_no = 4; 
  211.     volatile kal_uint32 i = 0; 
  212.     u8 ack_flag = 0; 
  213.  
  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; 
  244.  
  245.     printk("----%s---read data %x---\n",__func__,get_byte); 
  246.  
  247.     return get_byte; 
  248.  
  249. }    
  250.  
  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. } 
  256.  
  257. int iReadRegI2C(u8 *a_pSendData , u16 a_sizeSendData, u8 * a_pRecvData, u16 a_sizeRecvData, u16 i2cId) 
  258. { 
  259.     I2C_Bytes_Read(a_pSendData,a_sizeSendData,a_pRecvData,a_sizeRecvData,i2cId); 
  260.      return 0; 
  261. } 
  262. #endif 


淘宝评价生效时间 淘宝评价生效时间
原创粉丝点击
热门IT博客
性文化知乎性文化知乎
大数据行业的应用大数据行业的应用
淘宝押金5000怎么退
淘宝代购服务站
vs上mpi编程
部落冲突飞龙升级数据
主升浪起爆点 公式源码
淘宝店面装修在哪
淘宝购物网站
excel2003提取相同数据
java中网络编程
淘宝网如何排名
扑克牌设计软件
幼儿学唐诗软件
Nginx配置文件
java最新技术
中文俄语翻译软件
电路设计软件pertel
c语言中continue的作用
淘宝女西装品牌
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 二年级看图写话大全 举世闻名写话 二年级看图写话图片70 秋天看图写话 二年级看图写话大全集 二年级看图写话图片 看图说话写话 看图写话放风筝 臭名远扬写话 写话大全二年级 看图写话植树 小学生看图写话 二年级写话玩具 狮子抢球写话 堆雪人看图写话 植树看图写话 我的妈妈写话 二年级做手工写话50字 二年级上册看图写话 容易写错字 写错 易写错的字 容易写错的字 容易写错的字一览表 100个容易写错笔顺 淘宝地址写错了怎么改 京东地址写错了已发货 容易写错的成语 写错字的不良后果 书法容易写错的字 写错字了怎么办 淘宝收货地址写错了怎么办 对讲机写频 对讲机怎么写频 通用对讲机写频软件 对讲机写频线 写频线 摩托罗拉对讲机写频教程 摩托罗拉对讲机写频软件 冚 冚车

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里