51单片机io摸拟IIC从机程序代码

[复制链接]
查看1 | 回复0 | 2021-5-22 02:27:23 | 显示全部楼层 |阅读模式
  1. /*************        用户系统配置        **************/

  2. #define MAIN_Fosc                12000000L        //定义主时钟, 模拟串口和红外接收会自动适应。5~36MHZ

  3. #define D_TIMER0                125                        //选择定时器时间, us, 红外接收要求在60us~250us之间

  4. #define        User_code                0xFD02                //定义红外接收用户码
  5. #define DECVICE_ADD 0x55<<1

  6. /*************        以下宏定义用户请勿修改        **************/
  7. #include        "reg51.H"
  8. #include        "string.H"

  9. #define        uchar        unsigned char
  10. #define uint        unsigned int

  11. //#define freq_base                        (MAIN_Fosc / 1200)
  12. //#define Timer0_Reload                (65536 - (D_TIMER0 * freq_base / 10000))




  13. /*************        本地常量声明        **************/



  14. /*************        本地变量声明        **************/
  15. sbit        SDA = P3^0;                //SDA
  16. sbit        SCL = P3^1;                //SCL

  17. bit                PreState;               
  18. bit                NowState;
  19. bit     START_flag;
  20. bit     STOP_flag;               
  21. //uchar        IR_SampleCnt;                //采样计数
  22. uchar NN;
  23. uchar DEVICE_ADR;        //器件地址
  24. uchar WORD_ADR;                //内存地址
  25. uchar REC_DATA;                //接收到的内容
  26. unsigned int  *send_ptr;//
  27. code unsigned AA0[9] = {0x70,0x2c,0x6e,0x2a,0x00,0x00,0x00,0xc0};  //
  28. code unsigned AA8[2] = {0xff,0x2c};  //
  29. //code unsigned AA0[9] = {0x70,0x2c,0x6e,0x2a,0x00,0x00,0x00,0xc0};  //
  30. code unsigned A00[33] = {0xed,0xcf,0x48,0xe6,0x89,0xe8,0x0c,0xe8,
  31.                                              0x97,0xaf,0xd2,0x40,0x6d,0xc2,0xc4,0x04,
  32.                                                  0xca,0xd5,0xea,0xa7,0xae,0x43,0x37,0xe2,
  33.                                                  0x12,0x05,0x3b,0x59,0xb7,0xfb,0x3d,0xa5
  34.                                                  };  //
  35. code unsigned A20[33] = {0xCB,0x85,0x8b,0x54,0x6d,0x97,0x3c,0x05,
  36.                          0x46,0x0f,0x45,0xb4,0xd1,0x0a,0xb8,0x9b,
  37.                                                  0xdf,0xa2,0x43,0x8d,0xe6,0x7a,0x6f,0xf8,
  38.                                                  0x7f,0xaa,0x52,0x37,0xa6,0x8f,0xdc,0x71
  39.                         
  40.                                                 };  //
  41. code unsigned A40[33] = {
  42.                          0x15,0x67,0xc5,0x82,0xfe,0x01,0x87,0x44,
  43.                                                  0x10,0xcd,0xf8,0xe2,0xd7,0xb1,0x7d,0xb6,
  44.                                                  0x53,0xc0,0x43,0x39,0x3a,0xb3,0x32,0xba,
  45.                                                  0x5d,0x84,0xf1,0x03,0x13,0xcd,0x74,0x28

  46.                                                 };  //
  47. code unsigned A60[33] = {
  48.                          0x34,0x39,0xab,0x32,0x3b,0x32,0x76,0x4b,
  49.                                                  0xff,0x6f,0x2d,0xd6,0x20,0xab,0x8c,0x73,
  50.                                                  0x6b,0xd0,0xad,0xa6,0x83,0xdf,0x60,0xe0,
  51.                                                  0x63,0x51,0xe4,0x76,0x1e,0x58,0x9f,0x52
  52.                                                
  53.                                                 };  //


  54. uchar temp;






  55. /*************  外部函数和变量声明 *****************/
  56. void init(void);//初如化函数
  57. void delay_24C02(void); // 延时 5us
  58. void ACK(void);//应答
  59. void WaitACK(void);//等待主机回复

  60. /********************* 主函数 *************************/
  61. void main(void)
  62. {
  63.   uchar gg,MM,i,count;
  64.   init();//初如化

  65.   while(1)
  66.    {
  67.          NN=50;
  68.          PreState = SDA;         
  69.          while(SCL && NN--)
  70.           {
  71.                 NowState = SDA;
  72.                 if(PreState && !NowState) //启动
  73.                  {
  74.                     START_flag = 1;
  75.                     //_DINT();
  76.                  }
  77.                 if(!PreState && NowState) //结束
  78.                  {
  79.                 STOP_flag = 1;
  80.                     //_EINT();
  81.                  }
  82.                 PreState = NowState;

  83.                 if(START_flag) //如果是启动的话
  84.                  {
  85.                         START_flag=0;
  86.                         while(SCL); //START时的SCL高电平状态就等待
  87.                         for(gg=8;gg>0;gg--) //接收器件地址
  88.                      {
  89.                                 while(!SCL); //SCL低电平状态就等待
  90.                                
  91.                                 DEVICE_ADR<<=1;
  92.                                 if(SDA) //数据的第一个CLK高电平来临
  93.                                 DEVICE_ADR |= 0x01;
  94.                                
  95.                                 while(SCL); //SCL高电平状态就等待
  96.                          }

  97.                         ACK(); //对设备地址ACK应答信
  98.                 //-----------以上收到了设备地址,并知晓主机要对从机进行读还是写操作---
  99.                     for(gg=8;gg>0;gg--) //接收内存单元地址
  100.                          {
  101.                            while(!SCL);
  102.                                
  103.                                 WORD_ADR<<=1;
  104.                                 if(SDA)
  105.                                 WORD_ADR |= 0x01;
  106.                                
  107.                                 while(SCL);
  108.                          }
  109.                         //-----------以上就已经接收到内存单元地址------------
  110.                         ACK(); //对内存单元ACK应答信号

  111.                         //--------------------- 以上就已经接收到内存单元地址 -------------------------
  112.                         delay_24C02();//5us
  113.                         delay_24C02();
  114.                         delay_24C02();//5us
  115.                         delay_24C02();
  116.                         MM=50;
  117.                         PreState = SDA;
  118.                         while(SCL && MM--)
  119.                          {
  120.                                 NowState = SDA;
  121.                                 if(PreState && !NowState) // 如果 SDA 下降沿且 SCL 为高 , 则示开始信号
  122.                                 {
  123.                                    START_flag = 1;
  124.                                 }
  125.                          }

  126.                         //--------------------START_Flag=1: 表示随即读数据 -------------------------
  127.                         if(START_flag==1)
  128.                         {
  129.                                 //--------------------------- 读取器件地址 ---------------------------------
  130.                                 //while(!SCL);
  131.                                 START_flag=0; // 清除标志位
  132.                                 while(SCL); //START 时的 SCL 高电平状态就等待
  133.                                 for(gg=8;gg>0;gg--) // 接收器件地址
  134.                                 {
  135.                                         while(!SCL); //SCL 低电平状态就等待
  136.                                          DEVICE_ADR<<=1; // 高位在前
  137.                                         if(SDA) // 数据的第一个 CLK 高电平来临
  138.                                          DEVICE_ADR |= 0x01; // 上升沿读取数据位
  139.                                         while(SCL); //SCL 高电平状态就等待
  140.                                 }
  141.                                 ACK(); // 对设备地址 ACK 应答信

  142.        
  143.                  

  144.                                 //------------------ 判断地址是否为 0xa1 ,表示读数据指令 -------------------
  145.                                 if(DEVICE_ADR == 0xab)           //( DECVICE_ADD+1)
  146.                                 {
  147.                        
  148.                                         switch(WORD_ADR)
  149.                                      {
  150.                                                 case 0xa0:  count=8; send_ptr =AA0;        //                  memcpy(temp,AA0,count);
  151.                                               break;
  152.                                             case 0xa8:  count=1; send_ptr =AA8;        //            memcpy(temp,AA8,count);
  153.                                                          break;
  154.                                                 case 0x00:  count=32; send_ptr =A00; //  memcpy(temp,A00,count);
  155.                                                          break;
  156.                                                 case 0x20:  count=32; send_ptr =A20;//  memcpy(temp,A20,count);
  157.                                                          break;
  158.                                                 case 0x40:  count=32; send_ptr =A40; //                  memcpy(temp,A40,count);
  159.                                                          break;
  160.                                                 case 0x60:  count=32; send_ptr =A60;//        /          memcpy(temp,A60,count);
  161.                                                          break;
  162.                                                  
  163.                                          }
  164.                                                                                
  165.                                         for(i=0;i<count;i++) // 要 读 多 少 字 节 , 由
  166.                                         {
  167.                                             //*send_ptr =WORD_ADR;
  168.                                                 temp = send_ptr[i];
  169.                                                 for(gg=8;gg>0;gg--) // 输出数据给主机
  170.                                                 {
  171.                                                         while(SCL);//如果为高,保持
  172.                                                         if( temp & 0x80)
  173.                                                          {
  174.                                                                 SDA=1; // 输出 1
  175.                                                          }
  176.                                                         else
  177.                                                          {
  178.                                                                 SDA=0; // 输出 0
  179.                                                          }
  180.                                                         while(!SCL);
  181.                                                         //while(SCL); //SCL 为 1 ,就保持 SDA 输出不变
  182.                                                     //  SDA=1;
  183.                                                         //*send_ptr <<=1;
  184.                                                         temp <<=1;
  185.                                                 }
  186.                                            WaitACK();//主机回复ACK
  187.                                            //send_ptr++;
  188.                                         }

  189.                                     
  190.                                 }//if(DEVICE_ADR==0xa1)
  191.                                 else  //如果不是,退出
  192.                                 {
  193.                                   
  194.                                 }
  195.                         }//if(START_flag==1)
  196.                         else // 如果 START_flag!=1 则表示主机对从机进行写操作
  197.                         {       
  198.                             if(WORD_ADR == 0xa9)
  199.                              {
  200.                                         for(i=0;i<8;i++)
  201.                                         {
  202.                                                 for(gg=8;gg>0;gg--) // 读取主机发来的数据
  203.                                                 {
  204. //                                                        while(!SCL);
  205. //                                                         //READ_BUF[i] <<=1;
  206. //                                                         //SDA=0;
  207. //                                                        if(SDA)
  208. //                                                         ;
  209. //                                                         //READ_BUF[i] |= 0x01;
  210. //                                                         //SDA=0;
  211. //                                                        while(SCL);
  212.                                                   
  213.                                                    while(!SCL);
  214.                                                                                                   
  215.                                                         while(SCL);

  216.                                                 }
  217.                                                
  218.                                                 ACK(); // 对设备地址 ACK 应答信
  219.                                     }                                 
  220.                                  
  221.                                  }


  222.                      }





  223.           }// if(START_flag)


  224.           }//end while(SCL && NN--)


  225.    }//end while(1)
  226. }

  227. /********************************************************************
  228. 函数功能:初始化函数
  229. 入口参数:无
  230. 返 回:无。
  231. 备 注:无。
  232. ********************************************************************/
  233. void init(void)
  234. {
  235.         SDA=1; // 初始数据引脚
  236.         SCL=1; // 初始时钟引脚
  237. //        EA=1; // 开总中断
  238. //        IP=0x90; // 中断优先级设定,设为串口 >INTO>T0>INT1>T1
  239. //        EX0=1; // 开外部中断 0
  240. }

  241. /********************************************************************
  242. 函数功能:从机应答函数
  243. 入口参数:无
  244. 返 回:无。
  245. 备 注:应答函数,保证在两个时钟跳变沿 SDA 为低,则主机认为是从机应答
  246. ********************************************************************/
  247. void ACK(void)
  248. {
  249. //        while(!SCL);
  250. //        SDA=0; // 第 9 个 CLK 变高的情况下, SDA 输出 0
  251. //        while(SCL);
  252. //        SDA=1; // 第 9 个 CLK 变低的情况下, SDA 输出 1

  253.         while(SCL); //低就阻塞
  254.         delay_24C02();
  255.         SDA=0; // 第 9 个 CLK 变高的情况下, SDA 输出 0
  256.         while(!SCL); //低就阻塞
  257.         while(SCL);         //高就阻塞
  258.         delay_24C02();
  259.         SDA=1; // 第 9 个 CLK 变低的情况下, SDA 输出 1


  260. }


  261. /********************************************************************
  262. 函数功能:主机应答函数
  263. 入口参数:无
  264. 返 回:无。
  265. 备 注:应答函数,保证在两个时钟跳变沿 SDA 为低,则主机认为是从机应答
  266. ********************************************************************/
  267. void WaitACK(void)
  268. {
  269. //        while(!SCL);
  270. //        SDA=0; // 第 9 个 CLK 变高的情况下, SDA 输出 0
  271. //        while(SCL);
  272. //        SDA=1; // 第 9 个 CLK 变低的情况下, SDA 输出 1

  273.         while(SCL); //高就阻塞
  274.         delay_24C02();
  275.         SDA=1; // 第 9 个 CLK 变高的情况下, SDA 输出 0
  276.         while(!SCL); //低就阻塞
  277.         while(SCL);         //高就阻塞
  278.         delay_24C02();
  279.         //SDA=1; // 第 9 个 CLK 变低的情况下, SDA 输出 1


  280. }
  281. /********************************************************************
  282. 函数功能:延时 us
  283. 入口参数:无
  284. 返 回:无。
  285. 备 注:函数是用来实现短暂延时,用于对接上主机时钟
  286. ********************************************************************/
  287. void delay_24C02(void) // 延时 5us
  288. {
  289. //; ; ; ; ;
  290. uchar i;
  291. i=3;
  292. while(i--);
  293. }
复制代码


回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则