21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › 秀一个GD32的通用IIC主机驱动
返回列表 发新帖我要提问

秀一个GD32的通用IIC主机驱动

[复制链接]
4469|11
 楼主| Simon21ic 发表于 2017-1-22 16:56 | 显示全部楼层 |阅读模式
iic, I2c, gd32f1, GD32F1x0
本帖最后由 Simon21ic 于 2017-1-22 17:02 编辑

使用中断的方式，没有用DMA，把阻塞等待的代码减少了最少：
调用方式类似linux的IIC驱动方式，不过简化了非常多，代码也非常简单
不过，这个库是有BUG的，只是在我们目前的项目中，没问题，就懒得改了


复制
  1. #include "app_cfg.h"
    

  2. #include "app_type.h"
    

  3. #include "interfaces.h"
    


  4. 

  5. #if IFS_I2C_EN
    


  6. 

  7. #include "../core.h"
    

  8. #define IIC_NUM                                2
    


  9. 

  10. struct i2c_ctrl_t
    

  11. {
    

  12.         uint8_t chip_addr;
    

  13.         uint8_t msg_len;
    

  14.         uint8_t msg_prt;
    

  15.         uint16_t msg_buf_prt;
    

  16.         struct interface_i2c_msg_t *msg;
    

  17.         void *param;
    

  18.         void (*callback)(void *, vsf_err_t);
    

  19. } static gd32f1x0_i2c[IIC_NUM];
    


  20. 

  21. struct i2c_param_t
    

  22. {
    

  23.         I2C_TypeDef *reg;
    

  24.         struct gd32f1x0_afio_pin_t sda[3];
    

  25.         struct gd32f1x0_afio_pin_t scl[3];
    

  26. } static const gd32f1x0_i2c_param[IIC_NUM] = 
    

  27. {
    

  28. #if IIC_NUM >= 1
    

  29.         {
    

  30.                 I2C1,
    

  31.                 {
    

  32.                         {0, 10, 4},                // PA10, AF4
    

  33.                         {1, 7, 1},                // PB7, AF1
    

  34.                         {1, 9, 1},                // PB9, AF1
    

  35.                 },
    

  36.                 {
    

  37.                         {0, 9, 4},                // PA9, AF4
    

  38.                         {1, 6, 1},                // PB6, AF1
    

  39.                         {1, 8, 1},                // PB8, AF1
    

  40.                 },
    

  41.         },
    

  42. #endif
    

  43. #if IIC_NUM >= 2
    

  44.         {
    

  45.                 I2C2,
    

  46.                 {
    

  47.                         {0, 1, 4},                // PA1, AF4
    

  48.                         {1, 11, 1},                // PB11, AF1
    

  49.                         {6, 7, -1},                // PF7, default
    

  50.                 },
    

  51.                 {
    

  52.                         {0, 0, 4},                // PA0, AF4
    

  53.                         {1, 10, 1},                // PB10, AF1
    

  54.                         {6, 6, -1},                // PF6, default
    

  55.                 },
    

  56.         },
    

  57. #endif
    

  58. };
    


  59. 

  60. // index spec(LSB to MSB):
    

  61. // 2-bit iic_idx, 3-bit sda_idx, 3-bit scl_idx
    

  62. vsf_err_t gd32f1x0_i2c_init(uint8_t index)
    

  63. {
    

  64.         uint8_t iic_idx = (index & 0x03) >> 0;
    

  65.         uint8_t sda_idx = (index & 0x1C) >> 2;
    

  66.         uint8_t scl_idx = (index & 0xE0) >> 5;
    

  67.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    


  68. 

  69.         gd32f1x0_afio_config(&gd32f1x0_i2c_param[iic_idx].sda[sda_idx], gd32f1x0_GPIO_AF | gd32f1x0_GPIO_OD);
    

  70.         gd32f1x0_afio_config(&gd32f1x0_i2c_param[iic_idx].scl[scl_idx], gd32f1x0_GPIO_AF | gd32f1x0_GPIO_OD);
    

  71.         
    

  72.         RCC->APB1CCR |= RCC_APB1CCR_I2C1EN << iic_idx;
    

  73.         reg->CTLR1 = 0;
    

  74.         return VSFERR_NONE;
    

  75. }
    


  76. 

  77. vsf_err_t gd32f1x0_i2c_fini(uint8_t index)
    

  78. {
    

  79.         uint8_t iic_idx = (index & 0x03) >> 0;
    

  80.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    

  81.         reg->CTLR1 = 0;
    

  82.         return VSFERR_NONE;
    

  83. }
    


  84. 

  85. vsf_err_t gd32f1x0_i2c_config(uint8_t index, uint16_t kHz)
    

  86. {
    

  87.         uint8_t iic_idx = (index & 0x03) >> 0;
    

  88.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    

  89.         struct gd32f1x0_info_t *info;
    

  90.         uint16_t iic_clk, iic_freq;
    

  91.         
    

  92.         gd32f1x0_interface_get_info(&info);
    

  93.         iic_clk = info->apb_freq_hz / 1000000;
    

  94.         iic_clk = min(iic_clk, 36);
    

  95.         reg->CTLR2 = iic_clk;
    

  96.         
    

  97.         if (kHz <= 100)
    

  98.         {
    

  99.                 // standard mode
    

  100.                 iic_freq = info->apb_freq_hz / (kHz * 2000);
    

  101.                 if (iic_freq < 4)
    

  102.                         iic_freq = 4;
    

  103.                 reg->RTR = (iic_clk >= 36) ? 36 : iic_clk + 1;
    

  104.         }
    

  105.         else
    

  106.         {
    

  107.                 // fast mode
    

  108.                 iic_freq = info->apb_freq_hz / (kHz * 3000);
    

  109.                 if (!iic_freq)
    

  110.                         iic_freq = 1;
    

  111.                 reg->RTR = (uint16_t)(((iic_clk * 300) / 1000) + 1);
    

  112.         }
    

  113.         reg->CLKR = iic_freq;
    

  114.         reg->CTLR1 = I2C_CTLR1_I2CEN;
    

  115.         
    

  116.         switch (iic_idx)
    

  117.         {
    

  118. #if IIC_NUM >= 1
    

  119.         case 0: NVIC_EnableIRQ(I2C1_EV_IRQn); NVIC_EnableIRQ(I2C1_ER_IRQn); break;
    

  120. #endif
    

  121. #if IIC_NUM >= 2
    

  122.         case 1: NVIC_EnableIRQ(I2C2_EV_IRQn); NVIC_EnableIRQ(I2C2_ER_IRQn); break;
    

  123. #endif
    

  124.         }
    

  125.         reg->CTLR2 |= I2C_CTLR2_EE | I2C_CTLR2_EIE | I2C_CTLR2_BIE;
    

  126.         return VSFERR_NONE;
    

  127. }
    


  128. 

  129. vsf_err_t gd32f1x0_i2c_config_cb(uint8_t index, void *param,
    

  130.                                                         void (*callback)(void *, vsf_err_t))
    

  131. {
    

  132.         uint8_t iic_idx = (index & 0x03) >> 0;
    

  133.         gd32f1x0_i2c[iic_idx].param = param;
    

  134.         gd32f1x0_i2c[iic_idx].callback = callback;
    

  135.         return VSFERR_NONE;
    

  136. }
    


  137. 

  138. vsf_err_t gd32f1x0_i2c_xfer(uint8_t index, uint16_t chip_addr,
    

  139.                                                         struct interface_i2c_msg_t *msg, uint8_t msg_len)
    

  140. {
    

  141.         uint8_t iic_idx = (index & 0x03) >> 0;
    

  142.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    


  143. 

  144.         if ((msg == NULL) || (msg_len == 0))
    

  145.                 return VSFERR_INVALID_PARAMETER;
    


  146. 

  147.         gd32f1x0_i2c[iic_idx].chip_addr = chip_addr;
    

  148.         gd32f1x0_i2c[iic_idx].msg = msg;
    

  149.         gd32f1x0_i2c[iic_idx].msg_len = msg_len;
    

  150.         gd32f1x0_i2c[iic_idx].msg_prt = 0;
    

  151.         gd32f1x0_i2c[iic_idx].msg_buf_prt = 0;
    


  152. 

  153.         reg->CTLR1 |= I2C_CTLR1_GENSTA;
    

  154.         return VSFERR_NONE;
    

  155. }
    


  156. 

  157. static void gd32f1x0_i2c_cb(uint8_t iic_idx, vsf_err_t err)
    

  158. {
    

  159.         struct i2c_ctrl_t *ctrl = &gd32f1x0_i2c[iic_idx];
    

  160.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    

  161.         
    

  162.         // MUST wait STOP clear, or next START will fail
    

  163.         reg->CTLR1 |= I2C_CTLR1_GENSTP;
    

  164.         while (reg->CTLR1 & I2C_CTLR1_GENSTP);
    

  165.         if (ctrl->callback != NULL)
    

  166.                 ctrl->callback(ctrl->param, err);
    

  167. }
    


  168. 

  169. static void gd32f1x0_i2c_chk_recv_next(uint8_t iic_idx)
    

  170. {
    

  171.         struct i2c_ctrl_t *ctrl = &gd32f1x0_i2c[iic_idx];
    

  172.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    

  173.         struct interface_i2c_msg_t *msg = &ctrl->msg[ctrl->msg_prt];
    


  174. 

  175.         if ((msg->flag & I2C_ACKLAST) || (ctrl->msg_buf_prt < msg->len - 1) ||
    

  176.                 ((ctrl->msg_len > ctrl->msg_prt + 1) &&
    

  177.                         (ctrl->msg[ctrl->msg_prt + 1].flag & (I2C_READ | I2C_NOSTART))))
    

  178.         {
    

  179.                 reg->CTLR1 |= I2C_CTLR1_ACKEN;
    

  180.         }
    

  181.         else
    

  182.         {
    

  183.                 reg->CTLR1 &= ~I2C_CTLR1_ACKEN;
    

  184.         }
    

  185. }
    


  186. 

  187. static void gd32f1x0_i2c_err(uint8_t iic_idx)
    

  188. {
    

  189.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    

  190.         reg->STR1 &= ~(I2C_STR1_BE | I2C_STR1_LOSTARB | I2C_STR1_AE);
    

  191.         gd32f1x0_i2c_cb(iic_idx, VSFERR_FAIL);
    

  192. }
    


  193. 

  194. static void gd32f1x0_i2c_int(uint8_t iic_idx)
    

  195. {
    

  196.         struct i2c_ctrl_t *ctrl = &gd32f1x0_i2c[iic_idx];
    

  197.         I2C_TypeDef *reg = gd32f1x0_i2c_param[iic_idx].reg;
    

  198.         struct interface_i2c_msg_t *msg = &ctrl->msg[ctrl->msg_prt];
    

  199.         uint16_t status = reg->STR1;
    


  200. 

  201.         if (status & I2C_STR1_SBSEND)
    

  202.         {
    

  203.                 // I2C_STR1_SBSEND is cleared by reading STR1 and writing DTR
    

  204.                 reg->DTR = (ctrl->chip_addr << 1) | ((msg->flag & I2C_READ) ? 1 : 0);
    

  205.                 // can not put in I2C_STR1_ADDSEND, no idea why
    

  206.                 if (msg->flag & I2C_READ)
    

  207.                 {
    

  208.                         gd32f1x0_i2c_chk_recv_next(iic_idx);
    

  209.                 }
    

  210.         }
    

  211.         else if (status & I2C_STR1_ADDSEND)
    

  212.         {
    

  213.                 // I2C_STR1_ADDSEND is cleared by reading STR1 and reading STR2
    

  214.                 status = reg->STR2;
    

  215.         }
    

  216.         else if (status & I2C_STR1_TBE)
    

  217.         {
    

  218.                 // I2C_STR1_TBE is cleared by writing DTR while sending data
    

  219.                 if (ctrl->msg_buf_prt < msg->len)
    

  220.                 {
    

  221.                 send_data:
    

  222.                         reg->DTR = msg->buf[ctrl->msg_buf_prt++];
    

  223.                 }
    

  224.                 else if (++ctrl->msg_prt < ctrl->msg_len)
    

  225.                 {
    

  226.                         ctrl->msg_buf_prt = 0;
    

  227.                         msg = &ctrl->msg[ctrl->msg_prt];
    

  228.                         if (!(msg->flag & I2C_READ) && (msg->flag & I2C_NOSTART))
    

  229.                                 goto send_data;
    

  230.                         else
    

  231.                                 reg->CTLR1 |= I2C_CTLR1_GENSTA;
    

  232.                 }
    

  233.                 else
    

  234.                 {
    

  235.                         gd32f1x0_i2c_cb(iic_idx, VSFERR_NONE);
    

  236.                 }
    

  237.         }
    

  238.         else if (status & I2C_STR1_RBNE)
    

  239.         {
    

  240.                 msg->buf[ctrl->msg_buf_prt++] = reg->DTR;
    

  241.                 if (ctrl->msg_buf_prt < msg->len)
    

  242.                 {
    

  243.                 recv_data:
    

  244.                         gd32f1x0_i2c_chk_recv_next(iic_idx);
    

  245.                 }
    

  246.                 else if (++ctrl->msg_prt < ctrl->msg_len)
    

  247.                 {
    

  248.                         ctrl->msg_buf_prt = 0;
    

  249.                         msg = &ctrl->msg[ctrl->msg_prt];
    

  250.                         if ((msg->flag & I2C_READ) && (msg->flag & I2C_NOSTART))
    

  251.                                 goto recv_data;
    

  252.                         else
    

  253.                                 reg->CTLR1 |= I2C_CTLR1_GENSTA;
    

  254.                 }
    

  255.                 else
    

  256.                 {
    

  257.                         gd32f1x0_i2c_cb(iic_idx, VSFERR_NONE);
    

  258.                 }
    

  259.         }
    

  260. }
    


  261. 

  262. #if IIC_NUM >= 1
    

  263. ROOTFUNC void I2C1_EV_IRQHandler(void)
    

  264. {
    

  265.         gd32f1x0_i2c_int(0);
    

  266. }
    

  267. ROOTFUNC void I2C1_ER_IRQHandler(void)
    

  268. {
    

  269.         gd32f1x0_i2c_err(0);
    

  270. }
    

  271. #endif
    


  272. 

  273. #if IIC_NUM >= 2
    

  274. ROOTFUNC void I2C2_EV_IRQHandler(void)
    

  275. {
    

  276.         gd32f1x0_i2c_int(1);
    

  277. }
    

  278. ROOTFUNC void I2C2_ER_IRQHandler(void)
    

  279. {
    

  280.         gd32f1x0_i2c_err(1);
    

  281. }
    

  282. #endif
    

  283. #endif
    


  284.


回复

收藏 举报

相关帖子
tongbu2015 发表于 2017-1-30 18:24 | 显示全部楼层
这个例程的主要实现了什么功能的？
回复

收藏 举报

tongbu2015 发表于 2017-1-30 18:25 | 显示全部楼层
只是个简单的I2C总线通讯的？
回复

收藏 举报

baimiaocun2015 发表于 2017-1-31 10:26 | 显示全部楼层
这个程序的分享的比较好
回复

收藏 举报

叶覃 发表于 2017-1-31 22:42 | 显示全部楼层
代码看上去写的非常好，非常规范。我多会也写的这么牛X就好了。
回复

收藏 举报

 楼主| Simon21ic 发表于 2017-2-7 22:06 | 显示全部楼层
tongbu2015 发表于 2017-1-30 18:25
只是个简单的I2C总线通讯的？

这个是我们的系统构架下的IIC底层驱动，实现IIC主机功能
回复

收藏 举报

 楼主| Simon21ic 发表于 2017-2-7 22:09 | 显示全部楼层
叶覃 发表于 2017-1-31 22:42
代码看上去写的非常好，非常规范。我多会也写的这么牛X就好了。

写着写着就发现自己越来越牛了，所有人都这样
回复

收藏 举报

shenmu2012 发表于 2017-2-10 22:08 | 显示全部楼层
利用中断的方式处理有优势的，，只需要设置好优先级 的
回复

收藏 举报

vivilzb1985 发表于 2017-2-12 22:04 | 显示全部楼层
IIC的总线数据通讯的还是蛮重要的
回复

收藏 举报

firstblood 发表于 2017-2-12 22:51 | 显示全部楼层
这个代码的分享的确很给力的，，连通讯的容错功能的都有的
回复

收藏 举报

smilingangel 发表于 2017-2-12 23:15 | 显示全部楼层
IIC的主机驱动的是比较重要的
回复

收藏 举报

angerbird 发表于 2017-2-14 23:03 | 显示全部楼层
struct i2c_ctrl_t
{
        uint8_t chip_addr;
        uint8_t msg_len;
        uint8_t msg_prt;
        uint16_t msg_buf_prt;
        struct interface_i2c_msg_t *msg;
        void *param;
        void (*callback)(void *, vsf_err_t);
} static gd32f1x0_i2c[IIC_NUM];

采用结构体设计管理的，非常好
回复

收藏 举报

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

本版积分规则

Simon21ic

266

主题

2597

帖子

104

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