标题: 请问I2C从机单片机接收程序怎么写? [打印本页]
作者: yxyxyxyx    时间: 2022-9-1 09:22
标题: 请问I2C从机单片机接收程序怎么写?
如题
作者: yzwzfyz    时间: 2022-9-1 17:41
仔细再读I2C通讯原理，芯片手册。
作者: 188610329    时间: 2022-9-1 22:00
从机通常是被动触发型, 大多情况下，你从机是不可能啥是都不干，就用一个 while(SDA); 一直等主机发起始信号过来吧？ 通常总要用到系统中断来等待被触发吧？？？
你连个单片机型号都没有，鬼知道应该用哪个中断方式来判定主机发送起始信号？
作者: yxyxyxyx    时间: 2022-9-2 10:40
188610329 发表于 2022-9-1 22:00
从机通常是被动触发型, 大多情况下，你从机是不可能啥是都不干，就用一个 while(SDA); 一直等主机发起始信 ...

这个单片机是已51为基础开发的型号，名字叫RX8F103 系列是通用型 1T 8051 Core MCU。在同样的系统时钟下，指令代码完全兼容传统 8051；
作者: yxyxyxyx    时间: 2022-9-2 10:46
yzwzfyz 发表于 2022-9-1 17:41
仔细再读I2C通讯原理，芯片手册。

感觉都看麻了
作者: yxyxyxyx    时间: 2022-9-2 10:47
188610329 发表于 2022-9-1 22:00
从机通常是被动触发型, 大多情况下，你从机是不可能啥是都不干，就用一个 while(SDA); 一直等主机发起始信 ...

我现在写的程序就是用whlie（），来判断是否开始
作者: 924966334    时间: 2022-9-2 11:58
仔细再读I2C通讯原理，芯片手册,根据单片机型号来编写程序
作者: angmall    时间: 2022-9-2 12:38

RX8F103系列





给你个思路吧 从机想要接收 就需要知道主机的时钟线 把时钟线接到外部中断 进入中断后读取数据线 最后把数组组成一个字节
时钟线时跳变的，最好有个片选CS，将CS脚接到中断可能更好

网上找来的，可能会有所帮助吧


  1. /****************************************************************/
  2. bit iic_start_decide()    //IIC 开始判断
  3. {
  4.         while(SCL==0);                   //开始不满足条件
  5.         while((SCL==1)&&(SDA==1));       //开始条件
  6.         if((SCL==1)&&(SDA==0))           //开始
  7.         {
  8.                 while(SCL==1);               //等待到时钟开始低跳变
  9.                 return 1;
  10.         }
  11.         else
  12.         return 0;
  13. }

  15. /****************************************************************/
  16. bit iic_stop_decide()            //IIC 结束判断
  17. {
  18.         while(SCL==0);               //结束不满足条件
  19.         if((SCL==1)&&(0==SDA))       //结束
  20.         {
  21.                 while(SDA==0);           //等待到数据开始高跳变
  22.                 return 1;
  23.         }
  24.         else
  25.         {
  26.                 return 0;
  27.         }
  28. }
  29. /****************************************************************/
  30. uchar iic_receive()
  31. {
  32.         uchar i;
  33.         uchar rdata='0';

  35.         SDA=1;
  36.         for(i=0;i<8;i++)
  37.         {
  38.                 rdata<<=1;
  39.                 while(SCL==0);        //当时钟为低时，数据无效，等待
  40.                 if(SDA==1)
  41.                 rdata++;
  42.                 while(SCL==1);        //防止在一个高电平时读8次
  43.         }
  44.         return (rdata);
  45. }
  46. /****************************************************************/
  47. bit iic_ack_decide()
  48. {
  49.         bit ack_flag;         //局部变量
  50.         SDA=0;                ////8位发送完毕，释放数据线SDA，准备接收应答位
  51.         while(SCL==0);        //等待SCL变高电平
  52.         //ack_flag=0;
  53.         while(SCL==1);        //等待SCL变高电平
  54.         SDA=1;
  55.         ack_flag=1;
  56.         return(ack_flag);
  57. }

复制代码




作者: Y_G_G    时间: 2022-9-2 16:16
感觉这没什么意义呀,还不如果用Modbus
如果你只是你自己用的,两个单片机之间的通讯,直接用串口就行了
作者: 188610329    时间: 2022-9-2 19:31
从8楼贴出的资料看, 你这片单片机是支持 硬件 I2C 从机模式的， 因此，不建议你用 软件来实现， 建议参看该单片机手册 I2C 从机这个篇章，用硬件来实现， 除了 几个寄存器需要设置一下，其他都和 串口一主多从的从机侧的发送/接收 差不多的流程。也是被触发后，查验地址，和自己是否吻合，吻合的话 分析指令，主机是读，还是写，写的话简单，收取所有主机发出的数据，然后统一处理，是读的话，把需要给主机的数据准备好，扔一个字节到 I2Cbuf， 等主机读走后，中断再次触发，再扔下一个字节到 I2Cbuf，周而复始。
作者: angmall    时间: 2022-9-3 08:31
给你个STC8G作为参考。


  2. //STC8G---I2C硬件模式
  3. //从机中断模式
  4. #include "reg51.h"
  5. #include "intrins.h"

  7. sfr     P_SW2   =   0xba;

  9. #define I2CCFG      (*(unsigned char volatile xdata *)0xfe80)
  10. #define I2CMSCR     (*(unsigned char volatile xdata *)0xfe81)
  11. #define I2CMSST     (*(unsigned char volatile xdata *)0xfe82)
  12. #define I2CSLCR     (*(unsigned char volatile xdata *)0xfe83)
  13. #define I2CSLST     (*(unsigned char volatile xdata *)0xfe84)
  14. #define I2CSLADR    (*(unsigned char volatile xdata *)0xfe85)
  15. #define I2CTXD      (*(unsigned char volatile xdata *)0xfe86)
  16. #define I2CRXD      (*(unsigned char volatile xdata *)0xfe87)

  18. sfr     P1M1    =   0x91;
  19. sfr     P1M0    =   0x92;
  20. sfr     P0M1    =   0x93;
  21. sfr     P0M0    =   0x94;
  22. sfr     P2M1    =   0x95;
  23. sfr     P2M0    =   0x96;
  24. sfr     P3M1    =   0xb1;
  25. sfr     P3M0    =   0xb2;
  26. sfr     P4M1    =   0xb3;
  27. sfr     P4M0    =   0xb4;
  28. sfr     P5M1    =   0xc9;
  29. sfr     P5M0    =   0xca;

  31. sbit    SDA     =   P1^4;
  32. sbit    SCL     =   P1^5;

  34. bit isda;                                       //设备地址标志
  35. bit isma;                                       //存储地址标志
  36. unsigned char addr;
  37. unsigned char pdata buffer[256];

  39. void I2C_Isr() interrupt 24
  40. {
  41.     _push_(P_SW2);
  42.     P_SW2 |= 0x80;

  44.     if (I2CSLST & 0x40)
  45.     {
  46.         I2CSLST &= ~0x40;                       //处理START事件
  47.     }
  48.     else if (I2CSLST & 0x20)
  49.     {
  50.         I2CSLST &= ~0x20;                       //处理RECV事件
  51.         if (isda)
  52.         {
  53.             isda = 0;                           //处理RECV事件（RECV DEVICE ADDR）
  54.         }
  55.         else if (isma)
  56.         {
  57.             isma = 0;                           //处理RECV事件（RECV MEMORY ADDR）
  58.             addr = I2CRXD;
  59.             I2CTXD = buffer[addr];
  60.         }
  61.         else
  62.         {
  63.             buffer[addr++] = I2CRXD;            //处理RECV事件（RECV DATA）
  64.         }
  65.     }
  66.     else if (I2CSLST & 0x10)
  67.     {
  68.         I2CSLST &= ~0x10;                       //处理SEND事件
  69.         if (I2CSLST & 0x02)
  70.         {
  71.             I2CTXD = 0xff;                      //接收到NAK则停止读取数据
  72.         }
  73.         else
  74.         {
  75.             I2CTXD = buffer[++addr];            //接收到ACK则继续读取数据
  76.         }
  77.     }
  78.     else if (I2CSLST & 0x08)
  79.     {
  80.         I2CSLST &= ~0x08;                       //处理STOP事件
  81.         isda = 1;
  82.         isma = 1;
  83.     }

  85.     _pop_(P_SW2);
  86. }

  88. void main()
  89. {
  90.     P0M0 = 0x00;
  91.     P0M1 = 0x00;
  92.     P1M0 = 0x00;
  93.     P1M1 = 0x00;
  94.     P2M0 = 0x00;
  95.     P2M1 = 0x00;
  96.     P3M0 = 0x00;
  97.     P3M1 = 0x00;
  98.     P4M0 = 0x00;
  99.     P4M1 = 0x00;
  100.     P5M0 = 0x00;
  101.     P5M1 = 0x00;

  103.     P_SW2 = 0x80;

  105.     I2CCFG = 0x81;                              //使能I2C从机模式
  106.     I2CSLADR = 0x5a;                            //设置从机设备地址寄存器I2CSLADR=0101_1010B
  107.                                                 //即I2CSLADR[7:1]=010_1101B,MA=0B。
  108.                                                 //由于MA为0,主机发送的的设备地址必须与
  109.                                                 //I2CSLADR[7:1]相同才能访问此I2C从机设备。
  110.                                                 //主机若需要写数据则要发送5AH(0101_1010B)
  111.                                                 //主机若需要读数据则要发送5BH(0101_1011B)
  112.     I2CSLST = 0x00;
  113.     I2CSLCR = 0x78;                             //使能从机模式中断
  114.     EA = 1;

  116.     isda = 1;                                   //用户变量初始化
  117.     isma = 1;
  118.     addr = 0;
  119.     I2CTXD = buffer[addr];

  121.     while (1);
  122. }


  125. //从机模式 查询方式
  126. #include "reg51.h"
  127. #include "intrins.h"

  129. sfr     P_SW2   =   0xba;

  131. #define I2CCFG      (*(unsigned char volatile xdata *)0xfe80)
  132. #define I2CMSCR     (*(unsigned char volatile xdata *)0xfe81)
  133. #define I2CMSST     (*(unsigned char volatile xdata *)0xfe82)
  134. #define I2CSLCR     (*(unsigned char volatile xdata *)0xfe83)
  135. #define I2CSLST     (*(unsigned char volatile xdata *)0xfe84)
  136. #define I2CSLADR    (*(unsigned char volatile xdata *)0xfe85)
  137. #define I2CTXD      (*(unsigned char volatile xdata *)0xfe86)
  138. #define I2CRXD      (*(unsigned char volatile xdata *)0xfe87)

  140. sfr     P1M1    =   0x91;
  141. sfr     P1M0    =   0x92;
  142. sfr     P0M1    =   0x93;
  143. sfr     P0M0    =   0x94;
  144. sfr     P2M1    =   0x95;
  145. sfr     P2M0    =   0x96;
  146. sfr     P3M1    =   0xb1;
  147. sfr     P3M0    =   0xb2;
  148. sfr     P4M1    =   0xb3;
  149. sfr     P4M0    =   0xb4;
  150. sfr     P5M1    =   0xc9;
  151. sfr     P5M0    =   0xca;

  153. sbit    SDA     =   P1^4;
  154. sbit    SCL     =   P1^5;

  156. bit isda;                                       //设备地址标志
  157. bit isma;                                       //存储地址标志
  158. unsigned char addr;
  159. unsigned char pdata buffer[256];

  161. void main()
  162. {
  163.     P0M0 = 0x00;
  164.     P0M1 = 0x00;
  165.     P1M0 = 0x00;
  166.     P1M1 = 0x00;
  167.     P2M0 = 0x00;
  168.     P2M1 = 0x00;
  169.     P3M0 = 0x00;
  170.     P3M1 = 0x00;
  171.     P4M0 = 0x00;
  172.     P4M1 = 0x00;
  173.     P5M0 = 0x00;
  174.     P5M1 = 0x00;

  176.     P_SW2 = 0x80;

  178.     I2CCFG = 0x81;                              //使能I2C从机模式
  179.     I2CSLADR = 0x5a;                            //设置从机设备地址寄存器I2CSLADR=0101_1010B
  180.                                                 //即I2CSLADR[7:1]=010_1101B,MA=0B。
  181.                                                 //由于MA为0,主机发送的的设备地址必须与
  182.                                                 //I2CSLADR[7:1]相同才能访问此I2C从机设备。
  183.                                                 //主机若需要写数据则要发送5AH(0101_1010B)
  184.                                                 //主机若需要读数据则要发送5BH(0101_1011B)
  185.     I2CSLST = 0x00;
  186.     I2CSLCR = 0x00;                             //禁止从机模式中断

  188.     isda = 1;                                   //用户变量初始化
  189.     isma = 1;
  190.     addr = 0;
  191.     I2CTXD = buffer[addr];

  193.     while (1)
  194.     {
  195.         if (I2CSLST & 0x40)
  196.         {
  197.             I2CSLST &= ~0x40;                   //处理START事件
  198.         }
  199.         else if (I2CSLST & 0x20)
  200.         {
  201.             I2CSLST &= ~0x20;                   //处理RECV事件
  202.             if (isda)
  203.             {
  204.                 isda = 0;                       //处理RECV事件（RECV DEVICE ADDR）
  205.             }
  206.             else if (isma)
  207.             {
  208.                 isma = 0;                       //处理RECV事件（RECV MEMORY ADDR）
  209.                 addr = I2CRXD;
  210.                 I2CTXD = buffer[addr];
  211.             }
  212.             else
  213.             {
  214.                 buffer[addr++] = I2CRXD;        //处理RECV事件（RECV DATA）
  215.             }
  216.         }
  217.         else if (I2CSLST & 0x10)
  218.         {
  219.             I2CSLST &= ~0x10;                   //处理SEND事件
  220.             if (I2CSLST & 0x02)
  221.             {
  222.                 I2CTXD = 0xff;                  //接收到NAK则停止读取数据
  223.             }
  224.             else
  225.             {
  226.                 I2CTXD = buffer[++addr];        //接收到ACK则继续读取数据
  227.             }
  228.         }
  229.         else if (I2CSLST & 0x08)
  230.         {
  231.             I2CSLST &= ~0x08;                   //处理STOP事件
  232.             isda = 1;
  233.             isma = 1;
  234.         }
  235.     }
  236. }

  238. //测试I2C从机模式代码的主机代码
  239. #include "reg51.h"
  240. #include "intrins.h"

  242. sfr     P_SW2   =   0xba;

  244. #define I2CCFG      (*(unsigned char volatile xdata *)0xfe80)
  245. #define I2CMSCR     (*(unsigned char volatile xdata *)0xfe81)
  246. #define I2CMSST     (*(unsigned char volatile xdata *)0xfe82)
  247. #define I2CSLCR     (*(unsigned char volatile xdata *)0xfe83)
  248. #define I2CSLST     (*(unsigned char volatile xdata *)0xfe84)
  249. #define I2CSLADR    (*(unsigned char volatile xdata *)0xfe85)
  250. #define I2CTXD      (*(unsigned char volatile xdata *)0xfe86)
  251. #define I2CRXD      (*(unsigned char volatile xdata *)0xfe87)

  253. sfr     P1M1    =   0x91;
  254. sfr     P1M0    =   0x92;
  255. sfr     P0M1    =   0x93;
  256. sfr     P0M0    =   0x94;
  257. sfr     P2M1    =   0x95;
  258. sfr     P2M0    =   0x96;
  259. sfr     P3M1    =   0xb1;
  260. sfr     P3M0    =   0xb2;
  261. sfr     P4M1    =   0xb3;
  262. sfr     P4M0    =   0xb4;
  263. sfr     P5M1    =   0xc9;
  264. sfr     P5M0    =   0xca;

  266. sbit    SDA     =   P1^4;
  267. sbit    SCL     =   P1^5;

  269. void Wait()
  270. {
  271.     while (!(I2CMSST & 0x40));
  272.     I2CMSST &= ~0x40;
  273. }

  275. void Start()
  276. {
  277.     I2CMSCR = 0x01;                             //发送START命令
  278.     Wait();
  279. }

  281. void SendData(char dat)
  282. {
  283.     I2CTXD = dat;                               //写数据到数据缓冲区
  284.     I2CMSCR = 0x02;                             //发送SEND命令
  285.     Wait();
  286. }

  288. void RecvACK()
  289. {
  290.     I2CMSCR = 0x03;                             //发送读ACK命令
  291.     Wait();
  292. }

  294. char RecvData()
  295. {
  296.     I2CMSCR = 0x04;                             //发送RECV命令
  297.     Wait();
  298.     return I2CRXD;
  299. }

  301. void SendACK()
  302. {
  303.     I2CMSST = 0x00;                             //设置ACK信号
  304.     I2CMSCR = 0x05;                             //发送ACK命令
  305.     Wait();
  306. }

  308. void SendNAK()
  309. {
  310.     I2CMSST = 0x01;                             //设置NAK信号
  311.     I2CMSCR = 0x05;                             //发送ACK命令
  312.     Wait();
  313. }

  315. void Stop()
  316. {
  317.     I2CMSCR = 0x06;                             //发送STOP命令
  318.     Wait();
  319. }

  321. void Delay()
  322. {
  323.     int i;

  325.     for (i=0; i<3000; i++)
  326.     {
  327.         _nop_();
  328.         _nop_();
  329.         _nop_();
  330.         _nop_();
  331.     }
  332. }

  334. void main()
  335. {
  336.     P0M0 = 0x00;
  337.     P0M1 = 0x00;
  338.     P1M0 = 0x00;
  339.     P1M1 = 0x00;
  340.     P2M0 = 0x00;
  341.     P2M1 = 0x00;
  342.     P3M0 = 0x00;
  343.     P3M1 = 0x00;
  344.     P4M0 = 0x00;
  345.     P4M1 = 0x00;
  346.     P5M0 = 0x00;
  347.     P5M1 = 0x00;

  349.     P_SW2 = 0x80;

  351.     I2CCFG = 0xe0;                              //使能I2C主机模式
  352.     I2CMSST = 0x00;

  354.     Start();                                    //发送起始命令
  355.     SendData(0x5a);                             //发送设备地址(010_1101B)+写命令(0B)
  356.     RecvACK();
  357.     SendData(0x00);                             //发送存储地址
  358.     RecvACK();
  359.     SendData(0x12);                             //写测试数据1
  360.     RecvACK();
  361.     SendData(0x78);                             //写测试数据2
  362.     RecvACK();
  363.     Stop();                                     //发送停止命令

  365.     Start();                                    //发送起始命令
  366.     SendData(0x5a);                             //发送设备地址(010_1101B)+写命令(0B)
  367.     RecvACK();
  368.     SendData(0x00);                             //发送存储地址高字节
  369.     RecvACK();
  370.     Start();                                    //发送起始命令
  371.     SendData(0x5b);                             //发送设备地址(010_1101B)+读命令(1B)
  372.     RecvACK();
  373.     P0 = RecvData();                            //读取数据1
  374.     SendACK();
  375.     P2 = RecvData();                            //读取数据2
  376.     SendNAK();
  377.     Stop();                                     //发送停止命令

  379.     P_SW2 = 0x00;

  381.     while (1);
  382. }


复制代码



作者: STC庄伟    时间: 2022-9-3 11:16
本帖最后由 STC庄伟 于 2022-9-5 13:29 编辑


STC-ISP软件V6.90I版

http://www.stcmcudata.com/STC8F-DATASHEET/STC32G.pdf




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