标题: I2C通信ID自动查找，读写器制作 附单片机程序+仿真电路图 [打印本页]
作者: ksljxxq    时间: 2020-2-23 20:43
标题: I2C通信ID自动查找，读写器制作 附单片机程序+仿真电路图
本帖最后由 ksljxxq 于 2020-2-24 14:13 编辑

    I2C通信ID自动查找,在维修时碰到I2C通信要找ID地址也很麻烦，我们常用的比如24Cxx系列，显示屏通信，一般都是信号SDA与SCL，本主板用的主控芯片是stc15f2k60s2，编码开关，1602显示屏，二个按钮，编码开关按钮是移动光标，见下图24C测试ID 0XA0，TW8816测试ID 0X8A读写都正常，在i2c压缩包是程序和仿真

制作出来的实物图如下：


仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. #include<reg51.h>      
  2. #include<intrins.h>  
  3. #define uchar unsigned char
  4. #define uint unsigned int //函数声明
  5. #define yh 0x80    //第1行+3位数显示
  6. uint yi,ra,si,ra1,si1;
  7. void Init_Timer0(void);
  8. sbit  rs=P1^0;
  9. sbit  rw=P1^1;
  10. sbit  en=P1^2;

  12. sbit k3=P3^4;          //光标  
  13. sbit k1=P3^2;        //读开关
  14. sbit k2=P3^3;        //检测地址
  15. sbit CodingsWitch_B=P3^5; //A脚定义（即1脚） 这两脚必须接10K上拉电阻
  16. sbit CodingsWitch_A=P3^6; //B脚定义（即3脚?

  18. sbit SCL=P2^7;    //24c02  6
  19. sbit SDA=P2^6;          //       5
  20. void delay()
  21. {;;}
  22. void delay1(uint z)//延时为 1ms
  23. {
  24.   uchar x,x1;
  25.   for(;z>0;z--)
  26.   {
  27.    for(x=0;x<114;x++)
  28.     {
  29.     for(x1=0;x1<1;x1++);
  30.     }
  31.    }
  32. }

  34. write_1602com(uchar com)//****液晶写入指令函数****
  35. {
  36.         rs=0;//数据/指令选择置为指令
  37.         rw=0;
  38.         P0=com;//送入数据
  39.         delay1(1);
  40.         en=1;//拉高使能端，为制造有效的下降沿做准备
  41.         delay1(1);
  42.         en=0;//en由高变低，产生下降沿，液晶执行命令
  43. }

  45. write_1602dat(uchar dat)//***液晶写入数据函数****
  46. {
  47.         rs=1;//数据/指令选择置为数据
  48.         rw=0;
  49.         P0=dat;//送入数据
  50.         delay1(1);
  51.         en=1; //en置高电平，为制造下降沿做准备
  52.         delay1(1);
  53.         en=0; //en由高变低，产生下降沿，液晶执行命令
  54. }


  57. lcd_init()//***液晶初始化函数****
  58. {
  59.         write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
  60.         write_1602com(0x0c);//开显示不显示光标
  61.         write_1602com(0x06);//整屏不移动，光标自动右移
  62.         write_1602com(0x01);//清显示
  63. }


  66. void dsplay()
  67. {
  68.            if(xianshi==0)
  69.                         {               
  70.                                 unsigned int c, d;
  71.         //          a = (WriteDeviceAddress/256)/16; //    16进制千位
  72.         //    b = (WriteDeviceAddress/256)%16; //          百位
  73.                                 c = (WriteDeviceAddress%256)/16; //           十位
  74.                                 d = (WriteDeviceAddress%256)%16; //           个位
  75.                
  76.                                 write_1602com(yh);//指定显示
  77.                                 write_1602dat('I'); //
  78.                                 write_1602dat('D'); //
  79.                                 write_1602dat(':'); //
  80.                                 write_1602dat('0'); //
  81.                                 write_1602dat('x'); //
  82.                                 write_1602dat(hex_table[c]);    //
  83.                                 write_1602dat(hex_table[d]);    //
  84.                         }
  85.                         if(xianshi==1)
  86.                         {
  87.                           uchar a,b,c,d,e,f,g,h,a1,b1,c1,d1,e1,f1,g1,h1;
  88.                                 a = (yi%256)/16; //           十位
  89.                                 b = (yi%256)%16; //           个位
  90.                                 c = (ra%256)/16; //           十位
  91.                                 d = (ra%256)%16; //           个位
  92.                                 e = (yi+1%256)/16; //          十位
  93.                                 f = (yi+1%256)%16; //          个位
  94.                                 g = (si%256)/16; //           十位
  95.                                 h = (si%256)%16; //           个位
  96.                                 a1 = (yi+2%256)/16; //           十位
  97.                                 b1 = (yi+2%256)%16; //           个位
  98.                                 c1 = (ra1%256)/16; //           十位
  99.                                 d1 = (ra1%256)%16; //           个位
  100.                                 e1 = (yi+3%256)/16; //          十位
  101.                                 f1 = (yi+3%256)%16; //          个位
  102.                                 g1 = (si1%256)/16; //           十位
  103.                                 h1 = (si1%256)%16; //           个位
  104.                                 write_1602com(yh);//指定显示
  105.                                 write_1602dat('0');
  106.                                 write_1602dat('x');
  107.                                 write_1602dat(hex_table[a]);    //
  108.                                 write_1602dat(hex_table[b]);    //
  109.                                 write_1602dat(',');
  110.                                 write_1602dat(hex_table[c]);    //
  111.                                 write_1602dat(hex_table[d]);    //
  112.                                 write_1602dat(' ');
  113.                                 write_1602dat('0');
  114.                                 write_1602dat('x');
  115.                                 write_1602dat(hex_table[e]);    //
  116.                                 write_1602dat(hex_table[f]);    //
  117.                                 write_1602dat(',');
  118.                                 write_1602dat(hex_table[g]);    //
  119.                                 write_1602dat(hex_table[h]);    //
  120.                         
  121.                                 write_1602com(er);//指定显
  122.         write_1602dat('0');
  123.                                 write_1602dat('x');                                
  124.                                 write_1602dat(hex_table[a1]);    //
  125.                                 write_1602dat(hex_table[b1]);    //
  126.                                 write_1602dat(',');
  127.                                 write_1602dat(hex_table[c1]);    //
  128.                                 write_1602dat(hex_table[d1]);    //
  129.                                 write_1602dat(' ');
  130.                                 write_1602dat('0');
  131.                                 write_1602dat('x');
  132.                                 write_1602dat(hex_table[e1]);    //
  133.                                 write_1602dat(hex_table[f1]);    //
  134.                                 write_1602dat(',');
  135.                                 write_1602dat(hex_table[g1]);    //
  136.                                 write_1602dat(hex_table[h1]);    //
  137.                                        
  138.                         }        
  139.       if(xianshi==2)
  140.                         {
  141.                           uchar a,b,c,d,e,f,g,h,a1,b1,c1,d1,e1,f1,g1,h1;
  142.                                 a = (yi%256)/16; //           十位
  143.                                 b = (yi%256)%16; //           个位
  144.                                 c = (ra%256)/16; //           十位
  145.                                 d = (ra%256)%16; //           个位
  146.                                 e = (yi+1%256)/16; //          十位
  147.                                 f = (yi+1%256)%16; //          个位
  148.                                 g = (si%256)/16; //           十位
  149.                                 h = (si%256)%16; //           个位
  150.                                 a1 = (yi+2%256)/16; //           十位
  151.                                 b1 = (yi+2%256)%16; //           个位
  152.                                 c1 = (ra1%256)/16; //           十位
  153.                                 d1 = (ra1%256)%16; //           个位
  154.                                 e1 = (yi+3%256)/16; //          十位
  155.                                 f1 = (yi+3%256)%16; //          个位
  156.                                 g1 = (si1%256)/16; //           十位
  157.                                 h1 = (si1%256)%16; //           个位
  158.                                 write_1602com(yh);//指定显示
  159.                                 write_1602dat('0');
  160.                                 write_1602dat('x');
  161.                                 write_1602dat(hex_table[a]);    //
  162.                                 write_1602dat(hex_table[b]);    //
  163.                                 write_1602dat(',');
  164.                                 write_1602dat(hex_table[c]);    //
  165.                                 write_1602dat(hex_table[d]);    //
  166.                                 write_1602dat(' ');
  167.                                 write_1602dat('0');
  168.                                 write_1602dat('x');
  169.                                 write_1602dat(hex_table[e]);    //
  170.                                 write_1602dat(hex_table[f]);    //
  171.                                 write_1602dat(',');
  172.                                 write_1602dat(hex_table[g]);    //
  173.                                 write_1602dat(hex_table[h]);    //
  174.                         
  175.                                 write_1602com(er);//指定显
  176.         write_1602dat('0');
  177.                                 write_1602dat('x');                                
  178.                                 write_1602dat(hex_table[a1]);    //
  179.                                 write_1602dat(hex_table[b1]);    //
  180.                                 write_1602dat(',');
  181.                                 write_1602dat(hex_table[c1]);    //
  182.                                 write_1602dat(hex_table[d1]);    //
  183.                                 write_1602dat(' ');
  184.                                 write_1602dat('0');
  185.                                 write_1602dat('x');
  186.                                 write_1602dat(hex_table[e1]);    //
  187.                                 write_1602dat(hex_table[f1]);    //
  188.                                 write_1602dat(',');
  189.                                 write_1602dat(hex_table[g1]);    //
  190.                                 write_1602dat(hex_table[h1]);    //
  191.                                 
  192.                                 
  193.                         }        

  195. }

  197. void Start()  //开始总线
  198. {
  199.    SDA=1;
  200.    delay();
  201.    SCL=1;
  202.    delay();
  203.    SDA=0;
  204.    delay();
  205.    SCL=0;
  206.    delay();
  207. }


  210. void Stop()  //结束总线
  211. {
  212.    SCL=0;
  213.    delay();
  214.    SDA=0;
  215.    delay();
  216.    SCL=1;
  217.    delay();
  218.    SDA=1;
  219.    delay();
  220. }

  222. void NoAck()  //发 ACK0
  223. {
  224.     SDA=1;
  225.     delay();
  226.     SCL=1;
  227.     delay();
  228.     SCL=0;
  229.     delay();
  230.             
  231. }

  233. bit TestAck()  //测试 ACK
  234. {
  235.     bit ErrorBit;
  236.     SDA=1;
  237.     delay();
  238.     SCL=1;
  239.     delay();
  240.     ErrorBit=SDA;
  241.    
  242.     delay();
  243.     SCL=0;
  244.     delay();
  245.     return(ErrorBit);           
  246. }

  248. Write8Bit(unsigned char input)//写入 8 个 bit 到 24c02  
  249. {
  250.   unsigned char temp;
  251.    for(temp=8;temp!=0;temp--)  
  252.    {
  253.      SDA=(bit)(input&0x80);
  254.      delay();
  255.      SCL=1;
  256.      delay();
  257.      SCL=0;
  258.      delay();
  259.      input=input<<1;
  260.    }
  261. }

  263. void Write24c02(uchar ch,uchar address)//写入一个字节到 24c02 中  
  264. {
  265.     Start();
  266.     Write8Bit(WriteDeviceAddress);
  267.     TestAck();
  268.     Write8Bit(address);
  269.     TestAck();
  270.     Write8Bit(ch);
  271.     TestAck();
  272.     Stop();
  273.     delay1(10);
  274. }

  276. //从 24c02 中读出 8 个 bit
  277. uchar Read8Bit()  
  278. {
  279.    unsigned char temp,rbyte=0;
  280.     for(temp=8;temp!=0;temp--)  
  281.     {
  282.      SCL=1;
  283.      rbyte=rbyte<<1;
  284.      rbyte=rbyte|((unsigned char)(SDA));
  285.      SCL=0;
  286.     }
  287.     return(rbyte);
  288. }

  290. uchar Read24c02(uchar address) //从 24c02 中读出 1 个字节
  291. {
  292.      uchar ch;
  293.      Start();
  294.      Write8Bit(WriteDeviceAddress);
  295.      TestAck();
  296.      Write8Bit(address);
  297.      TestAck();
  298.      Start();
  299.      Write8Bit(ReadDviceAddress);
  300.      TestAck();
  301.      ch=Read8Bit();
  302.      NoAck();
  303.      Stop();
  304.      return(ch);
  305. }

  307. void xie()
  308. {
  309.            Write24c02(ra,yi);
  310.        delay1(10);
  311.            Write24c02(si,yi+1);
  312.        delay1(10);
  313.            Write24c02(ra1,yi+2);
  314.        delay1(10);
  315.            Write24c02(si1,yi+3);
  316.        delay1(10);
  317.        Stop();
  318. }
  319. void du()
  320. {
  321.            ra=Read24c02(yi);
  322.            delay1(20);
  323.            si=Read24c02(yi+1);
  324.            delay1(20);
  325.            ra1=Read24c02(yi+2);
  326.            delay1(20);
  327.            si1=Read24c02(yi+3);
  328.            delay1(20);
  329.            Stop();  
  330. }

  332. void set()
  333. {
  334.      Start();
  335.      Write8Bit(WriteDeviceAddress);
  336.      TestAck();
  337.            delay1(5);
  338.            Stop();
  339. }
  340. void keyscan()
  341. {
  342.       
  343.                    if(k2==0)
  344.                         {
  345.                           delay1(10);
  346.                           if(!k2)
  347.                           {
  348.                             delay1(10);
  349.                             while(!k2);
  350.                                         key1n+=1;
  351.                                         if(key1n>2)
  352.                                         {
  353.                                           key1n=1;
  354.                                         }
  355.                                         switch(key1n)
  356.                {
  357.                  case 1:open=1;        key3n=0;dsplaysw=0; write_1602com(0x0c);ra=0;si=0;ra1=0;si1=0;//关闭光标     
  358.                                           break;
  359.                        case 2:open=0;num=0;jishu=0; dsplaysw=0;xianshi=0;lcd_init(); key2n=0; key3n=0;   
  360.                                           break;
  361.                            }
  362.                          }
  363.                    }
  364.                 if(k1==0)
  365.                  {
  366.                         delay1(10);
  367.                         if(!k1)
  368.                         {
  369.                          delay1(10);
  370.                          while(!k1);
  371.                                 key2n+=1;
  372.                                         if(key2n>2)
  373.                                         {
  374.                                           key2n=1;
  375.                                         }
  376.                                         switch(key2n)
  377.                {
  378.                  case 1:        du();xianshi=1;key3n=0; dsplaysw=0; write_1602com(0x0c);//关闭光标     
  379.                                           break;
  380.                        case 2:  dsplaysw=1;xianshi=2; write_1602com(yh+5);write_1602com(0x0f);key3n=1;
  381.                                           break;
  382.                             }
  383.                            }
  384.                     }
  385.                  
  386.                 if(key2n==2)
  387.                 {
  388.      if(k3==0)
  389.                  {
  390.                         delay1(50);
  391.                         if(!k3)
  392.                         {
  393.                          delay1(50);
  394.                          while(!k3);
  395.                                 key3n+=1;
  396.                                         if(key3n>5)
  397.                                         {
  398.                                           key3n=1;
  399.                                         }
  400.                                         switch(key3n)
  401.                {
  402.                  case 1:  write_1602com(yh+5);  //设置按键按动一次秒位置显示光标
  403.                                             write_1602com(0x0f);  //设置光标为闪烁                                          
  404.                                           break;
  405.                        case 2:  write_1602com(yh+13);
  406.                     write_1602com(0x0f);  //设置光标为闪烁                                         
  407.                                           break;
  408.                                          case 3:  write_1602com(er+5);
  409.                     write_1602com(0x0f);  //设置光标为闪烁                                         
  410.                                           break;
  411.                                          case 4:  write_1602com(er+13);
  412.                                                   write_1602com(0x0f);  //设置光标为闪烁
  413.                                           break;
  414.                                          case 5:  write_1602com(0x0c);//关闭光标
  415.                                                   xie();
  416.                                                   xianshi=1;key2n=1;key3n=0; dsplaysw=0;
  417.                                           break;
  418.                             }
  419.                            }
  420.                     }
  421.                    }
  422. }

  424. uint CodingsWitchPolling()  
  425. {
  426.     static uchar Aold,Bold; //两个变量用来储存上一次调用时编码开关两引脚的电平   
  427.         static uchar st=0;       //用来储存以前是否出现了两个引脚都为高电平的状态
  428.         static uint tmp=0;    // ***这3个均为静态变量，以便保持上次结果***     
  429.         
  430.         if(CodingsWitch_A&&CodingsWitch_B)     
  431.          st = 1;            
  432.          if(st)                 //如果st为1执行下面的步骤      
  433.          {
  434.           if(CodingsWitch_A==0&&CodingsWitch_B==0) //如果两引脚都为低执行下面         
  435.           {           
  436.             if(Bold)         //为高说明编码开关在向加大的方向转            
  437.                  {               
  438.                   st = 0;               
  439.                    if(yi==9999)yi=9999;
  440.        if(ra>255)ra=0;        
  441.                    if(si>255)si=0;
  442.        if(ra1>255)ra1=0;        
  443.                    if(si1>255)si1=0;                          
  444.                           else
  445.         if(key2n==1){yi+=4;du();}                                       
  446.                           if(key3n==1){ra+=1;write_1602com(0x0c);dsplay();write_1602com(yh+5);write_1602com(0x0f);}
  447.         if(key3n==2){si+=1;write_1602com(0x0c);dsplay();write_1602com(yh+13);write_1602com(0x0f);}
  448.         if(key3n==3){ra1+=1;write_1602com(0x0c);dsplay();write_1602com(er+5);write_1602com(0x0f);}
  449.         if(key3n==4){si1+=1;write_1602com(0x0c);dsplay();write_1602com(er+13);write_1602com(0x0f);}                                
  450.                           }            
  451.                          if(Aold)   //为高说明编码开关在向减小的方向转            
  452.                           {               
  453.                            st = 0;                                       
  454.                            if(yi==0)yi=0;
  455.          if(ra<0)ra=0;        
  456.                      if(si<0)si=0;
  457.          if(ra1<0)ra1=0;        
  458.                      if(si1<0)si1=0;                                       
  459.                                 else                 
  460.                                  if(key2n==1){yi-=4;du();}     //设返回值
  461.          if(key3n==1){ra-=1;write_1602com(0x0c);dsplay();write_1602com(yh+5);write_1602com(0x0f);}
  462.          if(key3n==2){si-=1;write_1602com(0x0c);dsplay();write_1602com(yh+13);write_1602com(0x0f);}
  463.          if(key3n==3){ra1-=1;write_1602com(0x0c);dsplay();write_1602com(er+5);write_1602com(0x0f);}
  464.          if(key3n==4){si1-=1;write_1602com(0x0c);dsplay();write_1602com(er+13);write_1602com(0x0f);}                                         
  465.                                 }               
  466.                          }
  467.                   
  468.                  }
  469.                        
  470.             Aold = CodingsWitch_A;  //保持这次检测的电平，以备下次调用比较用      
  471.            Bold = CodingsWitch_B;      //     
  472.           return tmp;               //返回计数值  
  473.         }

  475.         
  476. void main()
  477. {                                 
  478.           lcd_init();
  479.     Init_Timer0();
  480.   while(1)
  481. {
  482.          keyscan();
  483.    if(dsplaysw==0){dsplay();}         
  484.    }        
  485. }

  487. void Init_Timer0(void)
  488. {
  489.          TMOD=0x01;
  490.          ET0=1;           //定时器中断打开
  491.          TR0=1;           //定时器开关打开
  492.          ET1=1;           //定时器中断打开
  493.          TR1=1;           //定时器开关打?
  494.          EA=1;            //总中断打开
  495. }
  496. void Timer0_isr(void) interrupt 1
  497. {

  499.          TH0=(65536-50000)/256;                  //重新赋值 2ms  62500
  500.          TL0=(65536-50000)%256;
  501.         
  502.           if(open==1)
  503.           {
  504.              num++;
  505.                  if(num==3)
  506.                  {
  507.                     num=0;
  508.                     jishu++;
  509.                           set();
  510.                          if(jishu>255)
  511.                   {
  512.                      jishu=255;        
  513.                     }
  514.                   }
  515.                   
  516.           }
  517.                
  518.         
  519.    }  
  520.          
  521.         void Timer1_isr(void) interrupt 3   
  522.         {
  523.           TH1=0xec;
  524.     TL1=0xec;
  525.     CodingsWitchPolling(); //调用编码开关函数
  526.                
  527.         }
复制代码

所有资料51hei提供下载:
i2c测地址.rar (87.22 KB, 下载次数: 36)


作者: tianqi911    时间: 2020-4-1 10:03
好帖子。虽然刚刚开始看还没懂。正在学习I2C。还请高人多写。谢谢。
作者: lig806    时间: 2024-2-7 14:24
好帖子。虽然刚刚开始看还没懂。正在学习I2C。还请高人多写。谢谢



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1