21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › IIC协议通信解析
返回列表 发新帖我要提问

[MM32软件] IIC协议通信解析

[复制链接]
1261|1
 楼主| rosemoore 发表于 2023-11-18 23:30 | 显示全部楼层 |阅读模式
ic, iic, iic协议, 通信


复制
  1. // 该代码用于测试没问题
    

  2.  
    

  3. #define I2C_SCL_PORT  GPIOB
    

  4. #define I2C_SCL_Pin   GPIO_Pin_8
    

  5.  
    

  6. #define I2C_SDA_PORT  GPIOB
    

  7. #define I2C_SDA_Pin   GPIO_Pin_9
    

  8.  
    

  9. #define OUTPUT 0
    

  10. #define INPUT 1
    

  11.  
    

  12. static void I2C_Tail(void); //发送结束标志
    

  13. static void I2C_Head(unsigned short Addrs); // 发送起始标志
    

  14.  
    

  15. static void hal_I2C_Config(void); // 模拟I2C配置函数
    

  16. static void hal_I2C_SCL_SET(unsigned char i);  // 设置时钟引脚
    

  17. static void hal_I2C_SDA_SET(unsigned char i);  // 设置数据引脚
    

  18. static void hal_I2C_Start(void);  // 起始标志
    

  19. static void hal_I2C_Stop(void);   // 结束标志
    

  20. static void I2C_Delay(unsigned short t);
    

  21. static void I2C_ACK(void);   // 有ACK应答
    

  22. static void I2C_NOACK(void); // 无ACK应答
    

  23. static void I2C_SendByte(unsigned char data);   // 写一个byte数据时序
    

  24. static void I2C_WriteByte(unsigned short Addr, unsigned char data); // 发送一个byte
    

  25. static unsigned char I2C_RecvByte(void); // 读一个字节时序 
    

  26. static unsigned char I2C_WaitAck(void);  // 返回0，无应答数据 。返回1，有应答数据
    

  27.  
    

  28. void hal_I2C_SDA_IO_SET(unsigned char IOMode); // OUTPUT 或者 INPUT
    

  29. unsigned char hal_IC_SDA_INPUT(void);
    

  30. unsigned char I2C_ReadByte(unsigned short Addr); // 读一个字节数据
    

  31.  
    

  32.  
    

  33. void hal_eeprom_Init(void)
    

  34. {
    

  35.   hal_I2C_Config();
    

  36. }
    

  37.  
    

  38. unsigned char I2C_ReadByte(unsigned short Addr)
    

  39. {
    

  40.   unsigned char dat;
    

  41.         hal_I2C_Start();
    

  42.         I2C_SendByte(0xA0);
    

  43.         I2C_WaitAck();
    

  44.         
    

  45.         I2C_SendByte((Addr>>8)&0xFF);
    

  46.         I2C_WaitAck();
    

  47.         
    

  48.         I2C_SendByte(Addr&0xFF);
    

  49.         I2C_WaitAck();
    

  50.         
    

  51.         hal_I2C_Start();
    

  52.         I2C_SendByte(0xA1); // 发送 1010 0001 最低位的1代表从该芯片读取数据
    

  53.         I2C_WaitAck();
    

  54.         
    

  55.         dat = I2C_RecvByte();
    

  56.         I2C_NOACK();
    

  57.         hal_I2C_Stop();
    

  58.         return dat;
    

  59. }
    

  60.  
    

  61. static unsigned char I2C_RecvByte(void)
    

  62. {
    

  63.    unsigned char i = 0;
    

  64.          unsigned char RecvByte = 0;
    

  65.         
    

  66.    hal_I2C_SCL_SET(0);
    

  67.          I2C_Delay(1);
    

  68.          hal_I2C_SDA_SET(1);
    

  69.          hal_I2C_SDA_IO_SET(INPUT);
    

  70.          
    

  71.          for(; i < 8; i++)
    

  72.         {
    

  73.              RecvByte<<=1;
    

  74.                   I2C_Delay(1);
    

  75.                   hal_I2C_SCL_SET(1);
    

  76.                   I2C_Delay(1);
    

  77.                   if(hal_IC_SDA_INPUT()) {
    

  78.                           RecvByte |= 0x01;
    

  79.                         }
    

  80.                         hal_I2C_SCL_SET(0);
    

  81.         }
    

  82.         hal_I2C_SDA_IO_SET(OUTPUT);
    

  83.         I2C_Delay(1);
    

  84.         return RecvByte;
    

  85. }
    

  86.  
    

  87. void hal_I2C_Read( unsigned short Addrs, unsigned char *pBuf, unsigned short Len)
    

  88. {
    

  89.   unsigned short i = 0;
    

  90.         
    

  91.         I2C_Head(Addrs);
    

  92.         
    

  93.         hal_I2C_Start();
    

  94.         I2C_SendByte(0xA1); // 发送 1010 0001 最低位的1代表从该芯片读取数据
    

  95.         I2C_WaitAck();
    

  96.         
    

  97.         for( i = 0; i < Len; i++)
    

  98.         {
    

  99.           pBuf[i] = I2C_RecvByte();
    

  100.                 if(i == Len - 1) I2C_NOACK();
    

  101.                 else I2C_ACK();
    

  102.         }
    

  103.         
    

  104.         hal_I2C_Stop();
    

  105. }
    

  106.  
    

  107. static void I2C_WriteByte(unsigned short Addr, unsigned char data)
    

  108. {
    

  109.   hal_I2C_Start(); // 发送有效数据起始标志
    

  110.         
    

  111.         // 该芯片最低位的一个bit位代表读/写：0 代表写入数据 || 1 代表读出数据
    

  112.         I2C_SendByte(0xA0); // 发送需要通信的硬件地址（对应的硬件手册上有！！！！！）
    

  113.         I2C_WaitAck();
    

  114.         
    

  115.         I2C_SendByte((Addr>>8)&0xFF); // 发送写入的地址（高字节地址）
    

  116.         I2C_WaitAck();
    

  117.         
    

  118.         I2C_SendByte(Addr&0xFF);    // 发送写入的地址（低字节地址）
    

  119.         I2C_WaitAck();
    

  120.         
    

  121.         I2C_SendByte(data);
    

  122.         I2C_WaitAck();
    

  123.         
    

  124.         hal_I2C_Stop();  // 发送有效数据结束标志
    

  125.         I2C_Delay(20000);
    

  126. }
    

  127.  
    

  128.  
    

  129. static unsigned char I2C_WaitAck(void)
    

  130. {
    

  131.   hal_I2C_SDA_SET(1);
    

  132.         hal_I2C_SDA_IO_SET(INPUT);  // 设置SDA引脚为输入引脚
    

  133.         hal_I2C_SCL_SET(1);
    

  134.         I2C_Delay(1);
    

  135.         if(hal_IC_SDA_INPUT()) { // 该引脚为高电平，代表无应答
    

  136.                 hal_I2C_SDA_IO_SET(OUTPUT);  // 设置SDA引脚为输出引脚
    

  137.           return 0;
    

  138.         }
    

  139.         
    

  140.         hal_I2C_SCL_SET(0);
    

  141.         hal_I2C_SDA_IO_SET(OUTPUT); 
    

  142.         I2C_Delay(1);
    

  143.         return 1;
    

  144. }
    

  145.  
    

  146. static void I2C_Head(unsigned short Addrs)
    

  147. {
    

  148.     hal_I2C_Start(); // 发送有效数据起始标志
    

  149.         
    

  150.           // 该芯片最低位的一个bit位代表读/写：0 代表写入数据 || 1 代表读出数据
    

  151.           I2C_SendByte(0xA0); // 发送需要通信的硬件地址（对应的硬件手册上有！！！！！）
    

  152.           I2C_WaitAck();
    

  153.         
    

  154.           I2C_SendByte((Addrs>>8)&0xFF); // 发送写入的地址（高字节地址）
    

  155.           I2C_WaitAck();
    

  156.         
    

  157.           I2C_SendByte(Addrs&0xFF);    // 发送写入的地址（低字节地址）
    

  158.           I2C_WaitAck();
    

  159. }
    

  160.  
    

  161. static void I2C_Tail(void)
    

  162. {
    

  163.   hal_I2C_Stop();  // 发送有效数据结束标志
    

  164.         I2C_Delay(20000);
    

  165. }
    

  166.  
    

  167. void hal_I2C_Write(unsigned short Addrs, unsigned char* pBuf, unsigned short Len)
    

  168. {
    

  169.         unsigned short tmp = 0;
    

  170.         unsigned short i = 0, j = 0;
    

  171.         unsigned short page = 0;
    

  172.         unsigned short size;
    

  173.         
    

  174.         if(Addrs%EEPROM_PAGE_SIZE) 
    

  175.         {
    

  176.           tmp = EEPROM_PAGE_SIZE-(Addrs%EEPROM_PAGE_SIZE); // 拿到当前页还有多少字节可写入
    

  177.                 if(tmp > Len)
    

  178.                 {
    

  179.              tmp = Len;        // 后续写入操作，需要tmp来做循环因子
    

  180.                 }
    

  181.         }
    

  182.         // 先将数据写入当前页
    

  183.         if(tmp)
    

  184.         {
    

  185.                 I2C_Head(Addrs);
    

  186.                 // 正式写入数据
    

  187.                 for(i = 0; i < tmp; i++)
    

  188.                 {
    

  189.                   I2C_SendByte(pBuf[i]);
    

  190.                         I2C_WaitAck();
    

  191.                 }
    

  192.                 I2C_Tail();
    

  193.         }
    

  194.         
    

  195.         Len -= tmp;   // 将已经发送过的数据个数减掉
    

  196.         Addrs += tmp; // 将写入的地址更新
    

  197.         
    

  198.         page = Len/EEPROM_PAGE_SIZE; // int整形除法，只会得到整数
    

  199.         size = Len%EEPROM_PAGE_SIZE; // 不足一页还有几个字节
    

  200.         
    

  201.         for(i = 0; i < page; i++)
    

  202.         {
    

  203.           I2C_Head(Addrs);
    

  204.                 
    

  205.                 for(j = 0; j < EEPROM_PAGE_SIZE; j++)
    

  206.                 {
    

  207.                   I2C_SendByte(pBuf[tmp + j]);
    

  208.                         I2C_WaitAck();
    

  209.                 }
    

  210.                 I2C_Tail();
    

  211.                 Addrs += EEPROM_PAGE_SIZE;
    

  212.                 tmp += EEPROM_PAGE_SIZE;
    

  213.         }
    

  214.         
    

  215.         if(size)
    

  216.         {
    

  217.           I2C_Head(Addrs);
    

  218.                 
    

  219.                 for(i = 0; i < size; i++)
    

  220.                 {
    

  221.                   I2C_SendByte(pBuf[tmp + i]);
    

  222.                         I2C_WaitAck();
    

  223.                 }
    

  224.                 I2C_Tail();
    

  225.         }
    

  226.         
    

  227. }
    

  228.  
    

  229. static void I2C_SendByte(unsigned char data)
    

  230. {
    

  231.   unsigned char i = 0;
    

  232.         for(; i < 8; i++)
    

  233.         {
    

  234.                 hal_I2C_SCL_SET(0);
    

  235.                 I2C_Delay(1);
    

  236.           if(data&0x80){
    

  237.                   hal_I2C_SDA_SET(1);
    

  238.                 } else {
    

  239.                   hal_I2C_SDA_SET(0);
    

  240.                 }
    

  241.                 I2C_Delay(1);
    

  242.                 hal_I2C_SCL_SET(1);
    

  243.                 I2C_Delay(1);
    

  244.                 data<<=1;
    

  245.         }
    

  246.         
    

  247.         hal_I2C_SCL_SET(0);
    

  248.   I2C_Delay(1);
    

  249.         hal_I2C_SDA_SET(1);
    

  250.   I2C_Delay(1);
    

  251. }
    

  252.  
    

  253.  
    

  254. static void I2C_ACK(void)
    

  255. {
    

  256.    hal_I2C_SCL_SET(0);
    

  257.          I2C_Delay(1); 
    

  258.          hal_I2C_SDA_SET(0); // SDA数据线置低，进行数据位应答。
    

  259.          I2C_Delay(1);
    

  260.          hal_I2C_SCL_SET(1);
    

  261.          I2C_Delay(1);
    

  262.          hal_I2C_SCL_SET(0);
    

  263.          I2C_Delay(1);
    

  264. }
    

  265.  
    

  266.  
    

  267. static void I2C_NOACK(void)
    

  268. {
    

  269.    hal_I2C_SCL_SET(0);
    

  270.          I2C_Delay(1);
    

  271.          hal_I2C_SDA_SET(1); // SDA数据线置高，不进行数据应答。
    

  272.          I2C_Delay(1);
    

  273.          hal_I2C_SCL_SET(1);
    

  274.          I2C_Delay(1);
    

  275.          hal_I2C_SCL_SET(0);
    

  276.          I2C_Delay(1);
    

  277. }
    

  278.  
    

  279. static void hal_I2C_Start(void)
    

  280. {
    

  281.   hal_I2C_SDA_SET(1);
    

  282.         I2C_Delay(1);
    

  283.         hal_I2C_SCL_SET(1);
    

  284.         I2C_Delay(1);
    

  285.         hal_I2C_SDA_SET(0);
    

  286.         I2C_Delay(1);
    

  287. }
    

  288.  
    

  289. static void hal_I2C_Stop(void)
    

  290. {
    

  291.   hal_I2C_SDA_SET(0);
    

  292.         I2C_Delay(1);
    

  293.         hal_I2C_SCL_SET(1);
    

  294.         I2C_Delay(1);
    

  295.         hal_I2C_SDA_SET(1);
    

  296.         I2C_Delay(1);
    

  297. }
    

  298.  
    

  299.  
    

  300. static void hal_I2C_Config(void)
    

  301. {
    

  302.    GPIO_InitTypeDef GPIO_Struct;
    

  303.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    

  304.          
    

  305.          GPIO_Struct.GPIO_Mode = GPIO_Mode_Out_OD;
    

  306.          GPIO_Struct.GPIO_Speed = GPIO_Speed_50MHz;
    

  307.          GPIO_Struct.GPIO_Pin = I2C_SCL_Pin | I2C_SDA_Pin;
    

  308.          GPIO_Init(GPIOB, &GPIO_Struct);
    

  309.         
    

  310.          hal_I2C_SDA_SET(1);
    

  311.          hal_I2C_SCL_SET(1);
    

  312.         
    

  313. }
    

  314.  
    

  315.  
    

  316. void hal_I2C_SDA_IO_SET(unsigned char IOMode)
    

  317. {
    

  318.   if(0 == IOMode) {
    

  319.          GPIO_InitTypeDef GPIO_Struct;
    

  320.          GPIO_Struct.GPIO_Mode = GPIO_Mode_Out_OD;
    

  321.          GPIO_Struct.GPIO_Speed = GPIO_Speed_50MHz;
    

  322.          GPIO_Struct.GPIO_Pin =  I2C_SDA_Pin;
    

  323.          GPIO_Init(GPIOB, &GPIO_Struct);
    

  324.         } 
    

  325.         if(1 == IOMode) {
    

  326.          GPIO_InitTypeDef GPIO_Struct;
    

  327.          GPIO_Struct.GPIO_Mode = GPIO_Mode_IPU;
    

  328.          GPIO_Struct.GPIO_Speed = GPIO_Speed_50MHz;
    

  329.          GPIO_Struct.GPIO_Pin =  I2C_SDA_Pin;
    

  330.          GPIO_Init(GPIOB, &GPIO_Struct);
    

  331.         }
    

  332. }
    

  333.  
    

  334.  
    

  335. static void hal_I2C_SDA_SET(unsigned char i)
    

  336. {
    

  337.   if(i) {
    

  338.            GPIO_SetBits(I2C_SDA_PORT,I2C_SDA_Pin);
    

  339.          } else {
    

  340.            GPIO_ResetBits(I2C_SDA_PORT,I2C_SDA_Pin);
    

  341.          }
    

  342. }
    

  343.  
    

  344.  
    

  345. static void hal_I2C_SCL_SET(unsigned char i)
    

  346. {
    

  347.    if(i) {
    

  348.            GPIO_SetBits(I2C_SCL_PORT,I2C_SCL_Pin);
    

  349.          } else {
    

  350.            GPIO_ResetBits(I2C_SCL_PORT,I2C_SCL_Pin);
    

  351.          }
    

  352. }
    

  353.  
    

  354. static void I2C_Delay(unsigned short t)
    

  355. {
    

  356.   unsigned short i=50,j,c; 
    

  357.    c = t;
    

  358.    for(j=0; j<c; j++)
    

  359.    {
    

  360.            while(i) 
    

  361.            { 
    

  362.                                 i--; 
    

  363.            } 
    

  364.         }
    

  365. }
    

  366.  
    

  367. unsigned char hal_IC_SDA_INPUT(void)
    

  368. {
    

  369.   return GPIO_ReadInputDataBit(I2C_SDA_PORT, I2C_SDA_Pin);
    

  370. }


回复

收藏 举报

相关帖子
单片小菜 发表于 2023-11-24 17:16 | 显示全部楼层
我还是认为软件的I2C更香，至少通用性更强一些。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

rosemoore

64

主题

1605

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部