devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【裸机开发】I2C 通信接口（三）—— I2C 底层驱动接口实现_i2c驱动程序开发流程

作者：AllinToyou | 2024-03-07 13:17:00

赞

踩

i2c驱动程序开发流程

目录

一、I2C 初始化

二、产生开始 / 停止信号

1、开始信号

2、重复开始信号

3、停止信号

三、向总线上发送数据（阻塞模式）

四、从总线上读取数据（阻塞模式）

五、整合：数据读写统一调用接口

一、I2C 初始化

初始化步骤如下：

  • 时钟源配置。PERCLK_CLK_ROOT 的时钟源是 66MHz
  • 关闭 I2C。在配置 I2C 相关寄存器时，我们需要先将 I2C 关闭
  • 分频。分频的目的是控制 I2C 的传输速率（如果要控制 I2C 的速率为 100K，可以640 分频）
  • 开启 I2C。 

  1. /* i2c 初始化 */
  2. void i2c_init()
  3. {
  4.     // 时钟源的初始化放到了时钟初始化（CCM_init）
  5.  
  6.     // 关闭I2C
  7.     I2C1_I2CR &= ~(1 << 7);
  8.     // 设置分频值(分频值为 640)
  9.     I2C1_IFDR = 0x15;
  10.     // 打开I2C
  11.     I2C1_I2CR |= (1 << 7);
  12. }

 

二、产生开始 / 停止信号

1、开始信号

当总线空闲时，总线上的设备可以发送开始信号来占用总线。如果存在多个设备同时占用总线，此时就会发生冲裁。

  • 判断总线是否空闲
  • 设为主机模式，设为发送模式
  • 发送要通信的设备地址和通信方向
  1. /* 产生开始信号 */
  2. i2c_status_t i2c_master_start(unsigned char address, i2c_direction direction)
  3. {
  4.     /* 总线是否被占用 */
  5.     if (is_bus_busy())
  6.     {
  7.         return Status_I2C_Busy;
  8.     }
  9.  
  10.     /* 
  11.      * 发送开始信号
  12.      * bit 5: 1 主机
  13.      * bit 4: 1 发送
  14.      */
  15.     I2C1_I2CR |= ((1 << 4) | (1 << 5));
  16.  
  17.     /* 发送通信地址和通信方向 */
  18.     I2C1_I2DR = (((unsigned int)address << 1) | (direction == I2C_Read ? 1 : 0));
  19.  
  20.     return Status_I2C_Success;
  21. }

2、重复开始信号

当某个设备在通信时，可能会需要临时改变通信方向，此时就可以发送一个重复开始信号来改变通信方向。发送重复开始信号要求总线空闲，且当前设备是主机，只要有一者不满足，就会发送失败

  • 判断主机是否空闲，且当前设备是否为主机模式
  • 发送一个重复开始信号
  • 发送通信地址和通信方向
  1. /* 重复产生开始信号（可能是修改通信方向、通信设备的地址） */
  2. i2c_status_t i2c_master_repeated_start(unsigned char address, i2c_direction direction)
  3. {
  4.     /* 
  5.      * 总线是否被占用
  6.      *  - 如果是其他设备占用总线，直接返回
  7.      *  - 如果是当前设备占用总线，发送一个重复的开始信号
  8.      */
  9.     if (is_bus_busy() && is_master() == 0)
  10.     {
  11.         return Status_I2C_Busy;
  12.     }
  13.  
  14.     /* 产生一个重复开始信号 */
  15.     I2C1_I2CR |= ((1 << 2) | (1 << 4));
  16.  
  17.     /* 发送通信地址和通信方向 */
  18.     I2C1_I2DR = (((unsigned int)address << 1U) | (direction & 0x01));
  19.  
  20.     return Status_I2C_Success;
  21. }

 

3、停止信号

当主机打算继续通信时，可以发送一个停止信号来结束通信；如果从机不想继续通信，可以选择不回应主机表示想结束通信。

  • 产生一个停止信号
  • 等待总线被释放
  1. /* 产生停止信号 */
  2. i2c_status_t i2c_master_stop()
  3. {
  4.     unsigned short timeout = UINT16_MAX;
  5.  
  6.     /* 
  7.      * 产生一个停止信号 
  8.      * bit 3: 0 产生一个ACK
  9.      * bit 4: 0 接收（要产生一个ACK，当前设备必须为接收模式）
  10.      * bit 5: 0 从机
  11.      */
  12.     I2C1_I2CR &= ~((1 << 3) | (1 << 4) | (1 << 5));
  13.  
  14.     /* 等待总线被释放 */
  15.     while (is_bus_busy() && (timeout--));
  16.  
  17.     // 等待超时
  18.     if (timeout == 0)       
  19.     {
  20.         return Status_I2C_Timeout;
  21.     }
  22.     
  23.     return Status_I2C_Success;
  24. }

三、向总线上发送数据（阻塞模式）

只有当上一次的数据全部发送完，才能开始下一次通信。其本质是，每次传输 8 bit（需要 8 个时钟周期），当第 9 个时钟周期的边沿触发时，我们认为数据传输完毕。

  • 等待 DR 寄存器准备就绪
  • 清除中断、仲裁标志位
  • 状态设为发送状态
  • while 循环逐字节发送
    • 每发送一个字节，都要将数据保存到 DR 寄存器
    • 等待传输完成（传输完成时会触发中断）
    • 清除中断标志位
    • 判断仲裁是否失败（可能存在多主机占用总线的情况）
    • 是否收到 NACK（从机是否想继续通信）
    • 如果遇到其他问题，直接跳出while循环
  1. /* 
  2.  * @description: 阻塞式发送 
  3.  * @param - sendbuf: 保存要发送的数据（允许多字节）
  4.  * @param - len: 发送数据的长度
  5.  * @param - stopflag: 下一次是否还要继续发送
  6.  */
  7. i2c_status_t i2c_master_write_blocking(unsigned char* sendbuf, unsigned int len, unsigned int stopflag)
  8. {
  9.     i2c_status_t i2c_stat = Status_I2C_Success;
  10.     
  11.     /* 等待DR寄存器准备就绪 */
  12.     while (((I2C1_I2SR >> 7) & 0x01) == 0);
  13.  
  14.     /* 清除中断标志位 */
  15.     clear_intpending_flag();
  16.  
  17.     /* 状态设为发送 */
  18.     I2C1_I2CR |= (1 << 4);
  19.  
  20.     /* 逐字节发送 */
  21.     while (len--)
  22.     {
  23.         // 将要发送的数据保存到寄存器
  24.         I2C1_I2DR = *(sendbuf++);
  25.  
  26.         // 等待传输完成（传输完成时会触发中断）
  27.         while (((I2C1_I2SR >> 1) & 0x01) == 0);
  28.  
  29.         // 清除中断标志位
  30.         clear_intpending_flag();
  31.  
  32.         // 仲裁是否失败
  33.         if(((I2C1_I2SR >> 4) & 0x01))
  34.         {
  35.             i2c_stat = Status_I2C_Lost_Arbitration;
  36.         }
  37.  
  38.         // 是否收到 NACK
  39.         if (((I2C1_I2SR >> 0) & 0x01))
  40.         {
  41.             i2c_stat = Status_I2C_NAK;
  42.         }
  43.  
  44.         if (i2c_stat != Status_I2C_Success)
  45.         {
  46.             break;
  47.         }
  48.     }
  49.  
  50.     // 从机不想收了 或者 主机不想发了
  51.     if ((i2c_stat == Status_I2C_NAK) || stopflag)
  52.     {
  53.         clear_intpending_flag();    
  54.         i2c_stat = i2c_master_stop();     
  55.     }
  56.     
  57.     return i2c_stat;
  58. }
  59.  
  60. /* 清除中断标志位 */
  61. void clear_intpending_flag()
  62. {
  63.     I2C1_I2SR &= ~(1 << 1);
  64. }

四、从总线上读取数据（阻塞模式）

在DR寄存器准备就绪以后，要将当前状态设为接收，逐字节接收（需要考虑接收缓冲区的大小），一旦接收缓冲区大小不足以接收后续的数据，需要提前发送停止信号告诉对方，不要再继续发了。

接收缓冲区大小 = 0，表示本次接收继续，下一次接收无法进行，直接发送停止信号

接收缓冲区大小 = 1，表示下一次接收继续，但是后续接收无法继续，发送 NACK

  • 等待 DR 寄存器准备就绪
  • 清除中断标志位
  • 状态设为接收
  • 循环读取
    • 等待数据传输完毕（对方将一个字节的数据全部发送到总线上时会触发中断）
    • 清除标志位
    • 如果接收缓冲区大小为 0，直接发送停止信号
    • 如果接收缓冲区大小为 1，发送 NACK
    • 读取 DR 寄存器数据
  1. /*
  2.  * @description		: 阻塞式读取
  3.  * @param - recvbuf	: 读取到数据
  4.  * @param - len 	: 要读取的数据大小（单位：字节）
  5.  */
  6. i2c_status_t i2c_master_read_blocking(unsigned char* recvbuf, unsigned int len)
  7. {
  8.     i2c_status_t result = Status_I2C_Success;
  9.     volatile unsigned char dummy = 0;
  10.  
  11.     /* 使用这个变量的目的是避免编译报错 */
  12.     dummy++;
  13.  
  14.     /* 等待DR寄存器准备就绪 */
  15.     while (((I2C1_I2SR >> 1) & 0x01) == 0);
  16.  
  17.     /* 清除中断标志位 */
  18.     clear_intpending_flag();
  19.  
  20.     /* 状态设为接收 */
  21.     I2C1_I2CR &= ~((1 << 3) | (1 << 4));
  22.     /* 后续只想再接收一个字节的数据 */
  23.     if (len == 1)
  24.     {
  25.         I2C1_I2CR |= (1 << 3);
  26.     }
  27.  
  28.     /* 假读 */
  29.     dummy = I2C1_I2DR;
  30.     
  31.     while (len--)
  32.     {
  33.         /* 有一个字节的数据被传输到总线上，中断触发 */
  34.         while (((I2C1_I2SR >> 1) & 0x01) == 0);
  35.  
  36.         /* 清除中断标志位 */
  37.         clear_intpending_flag();
  38.  
  39.         /* 下一次没有足够的空间去读取 */
  40.         if (len == 0)
  41.         {
  42.             result = i2c_master_stop();
  43.         }
  44.  
  45.         // 后续只能再接收一个字节的数据，告诉对方不要再发数据了
  46.         if (len == 1)
  47.         {
  48.             I2C1_I2CR |= (1 << 3);
  49.         }
  50.  
  51.         /* 从寄存器中读取 */
  52.         *(recvbuf++) = I2C1_I2DR & 0xFF;
  53.     }
  54.  
  55.     return result;
  56. }
  57.  
  58. /* 清除中断标志位 */
  59. void clear_intpending_flag()
  60. {
  61.     I2C1_I2SR &= ~(1 << 1);
  62. }

五、整合：数据读写统一调用接口

实际上我们真正要调用的接口，只需要这一个即可，上述内容其实都是在为这个接口做铺垫。当数据开始传输的时候，

  • 等待 DR 寄存器准备就绪
  • 清除中断、仲裁标志位
  • 判断是否为读时序，如果是读时序，需要临时修改通信方向（因为要先发送寄存器地址让对方知道自己要读取哪个寄存器）
  • 发送开始信号（发送设备地址和通信方向）
  • 等待信号发送完毕
  • 发送寄存器地址（考虑到寄存器地址可能不止一个字节）
  • 发送 / 读取数据

这里需要分别参考读时序和写时序的通信过程：I2C 通信时序

写时序：​​​​​​​

读时序：

  1. typedef struct 
  2. {
  3.     unsigned char slaveAddress;         // 要通信的设备地址
  4.     i2c_direction direction;            // 传输方向
  5.     unsigned char reg;                  // 要读写的寄存器地址
  6.     unsigned int reg_size;              // 寄存器地址大小（单位: 字节, 一般是1个字节，也有可能大于1个字节）
  7.     unsigned char stopFlag;             // 下一次是否要停止发送
  8.     unsigned char* buf;                 // 缓冲区
  9.     unsigned int buf_size;              // 缓冲区大小
  10. } i2c_transfer_t;
  11.  
  12. /* 数据传输（发送 / 接收） */
  13. i2c_status_t i2c_master_transfer(i2c_transfer_t* xfer)
  14. {
  15.     i2c_direction direction = xfer->direction;
  16.  
  17.     /* 传输之前清除所有的标志位（仲裁、中断挂起） */
  18.     I2C1_I2SR &= ~((1 << 1) | (1 << 4));
  19.  
  20.     /* DR 寄存器是否准备就绪 */
  21.     while (!((I2C1_I2SR >> 7) & 0x01));
  22.     
  23.     /* 如果是读时序，需要先临时修改通信方向 */
  24.     if ((xfer->reg_size > 0) && (xfer->direction == I2C_Read))
  25.     {
  26.         direction = I2C_Write;
  27.     }
  28.  
  29.     /* 1、发送开始信号 */
  30.     i2c_status_t ret = i2c_master_start(xfer->slaveAddress, direction);
  31.     if (ret != Status_I2C_Success)
  32.     {
  33.         return ret;
  34.     }
  35.  
  36.     /* 等待传输完成 */
  37.     while (!((I2C1_I2SR >> 1) & 0x01));
  38.     /* 检查传输是否发生错误 */
  39.     if ((ret = i2c_check_and_clear_error()) != Status_I2C_Success)
  40.     {
  41.         i2c_master_stop();
  42.         return ret;
  43.     }
  44.     
  45.     /* 2、发送寄存器地址 */
  46.     if (xfer->reg_size > 0)
  47.     {
  48.         do
  49.         {
  50.             clear_intpending_flag();
  51.             xfer->reg_size --;
  52.  
  53.             /* 写入地址 */
  54.             I2C1_I2DR = ((xfer->reg) >> (xfer->reg_size * 8));      // 先传输高字节
  55.  
  56.             /* 等待传输完成 */
  57.             while (((I2C1_I2SR >> 1) & 0x01) == 0);
  58.             /* 检查传输是否发生错误 */
  59.             if ((ret = i2c_check_and_clear_error()) != Status_I2C_Success)
  60.             {
  61.                 i2c_master_stop();
  62.                 return ret;
  63.             }
  64.         } while (xfer->reg_size > 0);
  65.         
  66.         /* 如果是读时序，需要先发送重复开始信号；如果是写时序，直接发送数据 */
  67.         if (xfer->direction == I2C_Read)
  68.         {
  69.             clear_intpending_flag();
  70.  
  71.             /* 发送重复开始信号 */
  72.             ret = i2c_master_repeated_start(xfer->slaveAddress, I2C_Read);
  73.             if (ret != Status_I2C_Success)
  74.             {
  75.                 i2c_master_stop();
  76.                 return ret;
  77.             }
  78.             /* 等待传输完成 */
  79.             while (((I2C1_I2SR >> 1) & 0x01) == 0);
  80.             /* 检查传输是否发生错误 */
  81.             if ((ret = i2c_check_and_clear_error()) != Status_I2C_Success)
  82.             {
  83.                 i2c_master_stop();
  84.                 return ret;
  85.             }
  86.         }
  87.     }
  88.     
  89.     /* 到此，准备工作完毕 */
  90.     /* 发送数据 */
  91.     if (xfer->direction == I2C_Write)
  92.     {
  93.         ret = i2c_master_write_blocking(xfer->buf, xfer->buf_size, xfer->stopFlag);
  94.     }
  95.     
  96.     if (xfer->direction == I2C_Read)
  97.     {
  98.         ret = i2c_master_read_blocking(xfer->buf, xfer->buf_size);
  99.     }
  100.  
  101.     return ret;
  102. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/205817?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号