21ic电子技术开发论坛

标题: 函数指针在I2C收发上的应用 [打印本页]
作者: 小明的同学    时间: 2024-6-16 16:04
标题: 函数指针在I2C收发上的应用
看到了NANO130的一个示例，操作I2C读写一个传感器芯片的。在中断中执行读或者写作业，通过函数指针传递进来，实现中断函数执行读或者写。
复制
  1. /**************************************************************************//**
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     CJMCU116.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00
    

  4.  * $Revision: 1 $
    

  5.  * $Date: 14/05/13 7:20p $ 
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    CJMCU116 Library
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
    

  10.  *
    

  11.  ******************************************************************************/
    

  12. #include <stdio.h>
    

  13. #include "CJMCU116.h"
    


  14. 

  15. __INLINE void I2C_PIN_Init(void)
    

  16. {
    

  17.                 /* Set GPA8,9 multi-function pins for I2C0 SDA and SCL */
    

  18.                 SYS->PA_H_MFP |= (SYS_PA_H_MFP_PA8_MFP_I2C0_SDA | SYS_PA_H_MFP_PA9_MFP_I2C0_SCL);
    

  19.         
    

  20.           /* Enable I2C0 clock */        
    

  21.    // CLK->APBCLK |= CLK_APBCLK_I2C0_EN;
    

  22.                 CLK->APBCLK |= CLK_APBCLK_I2C0_EN_Msk;//CLK_APBCLK_I2C0_EN_Pos
    

  23.     /* Reset I2C0 */
    

  24.     SYS->IPRST_CTL2 |=  SYS_IPRST_CTL2_I2C0_RST_Msk;
    

  25.     SYS->IPRST_CTL2 &= ~SYS_IPRST_CTL2_I2C0_RST_Msk;        
    

  26. }
    


  27. 

  28. /*---------------------------------------------------------------------------------------------------------*/
    

  29. /* Global variables                                                                                        */
    

  30. /*---------------------------------------------------------------------------------------------------------*/
    

  31. uint8_t g_au8TxData[3];
    

  32. uint8_t g_u8RxData;
    

  33. uint8_t g_u8DataLen;
    

  34. volatile uint8_t g_u8EndFlag = 0;
    

  35. typedef void (*I2C_FUNC)(uint32_t u32Status);
    

  36. static I2C_FUNC s_I2CHandlerFn = NULL;
    


  37. 

  38. /*---------------------------------------------------------------------------------------------------------*/
    

  39. /*  I2C IRQ Handler                                                                                       */
    

  40. /*---------------------------------------------------------------------------------------------------------*/
    

  41. void I2C0_IRQHandler(void)
    

  42. {
    

  43.     uint32_t u32Status;
    


  44. 

  45.     // clear interrupt flag
    

  46.     I2C0->INTSTS = I2C_INTSTS_INTSTS_Msk;        
    

  47.         
    

  48.     u32Status = I2C0->STATUS;
    


  49. 

  50.     if (I2C0->INTSTS & I2C_INTSTS_TIF_Msk)
    

  51.     {
    

  52.         /* Clear I2C Timeout Flag */
    

  53.         I2C0->INTSTS = I2C_INTSTS_TIF_Msk;                   
    

  54.     }    
    

  55.     else
    

  56.     {
    

  57.         if (s_I2CHandlerFn != NULL)
    

  58.             s_I2CHandlerFn(u32Status);
    

  59.     }
    

  60. }
    


  61. 

  62. /*---------------------------------------------------------------------------------------------------------*/
    

  63. /*  I2C Initial Function                                                                                       */
    

  64. /*---------------------------------------------------------------------------------------------------------*/
    

  65. void I2C0_Init(uint8_t u8Freg)
    

  66. {
    

  67.                 uint8_t u8Divider;
    

  68.                 I2C_PIN_Init();
    

  69.     /* Enable I2C Controller */
    

  70.     I2C0->CON |= I2C_CON_IPEN_Msk;
    

  71.     
    

  72.     /* I2C clock divider, I2C Bus Clock = PCLK / (4*120) = 100kHz */
    

  73.     u8Divider = SystemCoreClock/(u8Freg*4000)-1;
    

  74.                 I2C0->DIV = u8Divider;
    


  75. 

  76.     /* Enable I2C interrupt and set corresponding NVIC bit */
    

  77.     I2C0->CON |= I2C_CON_INTEN_Msk;
    

  78.     NVIC_EnableIRQ(I2C0_IRQn);
    

  79. }
    


  80. 

  81. /*---------------------------------------------------------------------------------------------------------*/
    

  82. /*  I2C Rx Callback Function                                                                               */
    

  83. /*---------------------------------------------------------------------------------------------------------*/
    

  84. void I2C_MasterRx(uint32_t u32Status)
    

  85. {
    

  86.     if (u32Status == 0x08)                      /* START has been transmitted and prepare SLA+W */
    

  87.     {
    

  88.         I2C0->DATA = g_au8TxData[g_u8DataLen++] << 1;     /* Write SLA+W to Register I2CDAT */
    

  89.         I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  90.     }   
    

  91.     else if (u32Status == 0x18)                 /* SLA+W has been transmitted and ACK has been received */
    

  92.     {
    

  93.         I2C0->DATA = g_au8TxData[g_u8DataLen++];
    

  94.         I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  95.     }
    

  96.     else if (u32Status == 0x20)                 /* SLA+W has been transmitted and NACK has been received */
    

  97.     {
    

  98.         I2C_SET_CONTROL_REG(I2C0, I2C_STA | I2C_STO | I2C_SI);
    

  99.     }
    

  100.     else if (u32Status == 0x28)                 /* DATA has been transmitted and ACK has been received */
    

  101.     {
    

  102.         I2C_SET_CONTROL_REG(I2C0, I2C_STA | I2C_SI); 
    

  103.     }
    

  104.                 
    

  105.     else if (u32Status == 0x10)                 /* Repeat START has been transmitted and prepare SLA+R */
    

  106.     {
    

  107.         I2C0->DATA = ((g_au8TxData[0] << 1) | 0x01);   /* Write SLA+R to Register I2CDAT */
    

  108.         I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  109.     }
    

  110.     else if (u32Status == 0x40)                 /* SLA+R has been transmitted and ACK has been received */
    

  111.     {
    

  112.         I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  113.     }       
    

  114.     else if (u32Status == 0x58)                 /* DATA has been received and NACK has been returned */
    

  115.     {
    

  116.         g_u8RxData = I2C0->DATA;
    

  117.         I2C_SET_CONTROL_REG(I2C0, I2C_STO | I2C_SI);
    

  118.         g_u8EndFlag = 1;
    

  119.     }
    

  120.     else if (u32Status == 0xF8)    /*I2C wave keeps going*/
    

  121.     {
    


  122. 

  123.     }                 
    

  124.     else
    

  125.     {
    

  126.         /* TO DO */
    

  127.         //printf("Status 0x%x is NOT processed\n", u32Status);
    

  128.                                 while(1);
    

  129.     }           
    

  130. }
    


  131. 

  132. /*---------------------------------------------------------------------------------------------------------*/
    

  133. /*  I2C Tx Callback Function                                                                               */
    

  134. /*---------------------------------------------------------------------------------------------------------*/
    

  135. void I2C_MasterTx(uint32_t u32Status)
    

  136. {
    

  137.     if (u32Status == 0x08)                      /* START has been transmitted */
    

  138.     {
    

  139.         I2C0->DATA = g_au8TxData[g_u8DataLen++] << 1;     /* Write SLA+W to Register I2CDAT */
    

  140.         I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  141.     }   
    

  142.     else if (u32Status == 0x18)                 /* SLA+W has been transmitted and ACK has been received */
    

  143.     {
    

  144.         I2C0->DATA = g_au8TxData[g_u8DataLen++];
    

  145.         I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  146.     }
    

  147.     else if (u32Status == 0x20)                 /* SLA+W has been transmitted and NACK has been received */
    

  148.     {
    

  149.         I2C_SET_CONTROL_REG(I2C0, I2C_STA | I2C_STO | I2C_SI);
    

  150.     }   
    

  151.     else if (u32Status == 0x28)                 /* DATA has been transmitted and ACK has been received */
    

  152.     {
    

  153.         if (g_u8DataLen != 3)
    

  154.         {
    

  155.             I2C0->DATA = g_au8TxData[g_u8DataLen++];
    

  156.             I2C_SET_CONTROL_REG(I2C0, I2C_SI);
    

  157.         }
    

  158.         else
    

  159.         {
    

  160.             I2C_SET_CONTROL_REG(I2C0, I2C_STO | I2C_SI);
    

  161.             g_u8EndFlag = 1;
    

  162.         }       
    

  163.     }
    

  164.     else if (u32Status == 0xF8)    /*I2C wave keeps going*/
    

  165.     {
    


  166. 

  167.     }                 
    

  168.     else
    

  169.     {
    

  170.         /* TO DO */
    

  171.         //printf("Status 0x%x is NOT processed\n", u32Status);
    

  172.                                 while(1);
    

  173.     }       
    

  174. }
    


  175. 

  176. /*---------------------------------------------------------------------------------------------------------*/
    

  177. /*  Write I2C                                                                                     */
    

  178. /*---------------------------------------------------------------------------------------------------------*/
    

  179. void I2C0_Write(uint8_t u8Address,uint8_t u8Reg, uint8_t u8Data)
    

  180. {
    

  181.                 g_au8TxData[0] = u8Address;
    

  182.                 g_au8TxData[1] = u8Reg;
    

  183.                 g_au8TxData[2] = u8Data;        
    

  184.         
    

  185.                 g_u8DataLen = 0;
    

  186.                 g_u8EndFlag = 0;
    

  187.                 
    

  188.                 /* I2C function to write data to slave */
    

  189.                 s_I2CHandlerFn = (I2C_FUNC)I2C_MasterTx;
    

  190.                 
    

  191.                 /* I2C as master sends START signal */
    

  192.                 I2C_SET_CONTROL_REG(I2C0, I2C_STA);
    


  193. 

  194.                 /* Wait I2C Tx Finish */
    

  195.                 while (g_u8EndFlag == 0);        
    

  196. }
    


  197. 

  198. /*---------------------------------------------------------------------------------------------------------*/
    

  199. /*  Read I2C                                                                                */
    

  200. /*---------------------------------------------------------------------------------------------------------*/
    

  201. uint8_t I2C0_Read(uint8_t u8Address, uint8_t u8Reg)
    

  202. {
    

  203.                 g_au8TxData[0] = u8Address;
    

  204.                 g_au8TxData[1] = u8Reg;        
    

  205.         
    

  206.                 g_u8DataLen = 0;
    

  207.                 g_u8EndFlag = 0;
    

  208.                 
    

  209.                 /* I2C function to write data to slave */
    

  210.                 s_I2CHandlerFn = (I2C_FUNC)I2C_MasterRx;
    

  211.                 
    

  212.                 /* I2C as master sends START signal */
    

  213.                 I2C_SET_CONTROL_REG(I2C0, I2C_STA);
    


  214. 

  215.                 /* Wait I2C Tx Finish */
    

  216.                 while (g_u8EndFlag == 0);        
    

  217.         
    

  218.                 return g_u8RxData;
    

  219. }
    


  220. 


  221. 


  222. 


  223.


作者: 小明的同学    时间: 2024-6-16 16:09
不过这种没有直接写成函数式的好理解，或者说更方便使用。
作者: 小明的同学    时间: 2024-6-16 16:09
这是需要多个函数配合才实现的收发。
作者: 小明的同学    时间: 2024-6-16 16:09
这是以前的系列都是这样的，看了最近几年出的型号的BSP已经提供了相关单个函数实现收发了。
作者: 小明的同学    时间: 2024-6-16 16:33
复制
  1. uint8_t I2C_WriteByte(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t data);
    

  2. uint32_t I2C_WriteMultiBytes(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t data[], uint32_t u32wLen);
    

  3. uint8_t I2C_WriteByteOneReg(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t data);
    

  4. uint32_t I2C_WriteMultiBytesOneReg(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t data[], uint32_t u32wLen);
    

  5. uint8_t I2C_WriteByteTwoRegs(I2C_T *i2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t data);
    

  6. uint32_t I2C_WriteMultiBytesTwoRegs(I2C_T *i2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t data[], uint32_t u32wLen);
    

  7. uint8_t I2C_ReadByte(I2C_T *i2c, uint8_t u8SlaveAddr);
    

  8. uint32_t I2C_ReadMultiBytes(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t rdata[], uint32_t u32rLen);
    

  9. uint8_t I2C_ReadByteOneReg(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr);
    

  10. uint32_t I2C_ReadMultiBytesOneReg(I2C_T *i2c, uint8_t u8SlaveAddr, uint8_t u8DataAddr, uint8_t rdata[], uint32_t u32rLen);
    

  11. uint8_t I2C_ReadByteTwoRegs(I2C_T *i2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr);
    

  12. uint32_t I2C_ReadMultiBytesTwoRegs(I2C_T *i2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, uint8_t rdata[], uint32_t u32rLen);

M487系列提供的新函数，更加好用了。



欢迎光临 21ic电子技术开发论坛 (https://bbs.21ic.com/) Powered by Discuz! X3.5