21ic电子技术开发论坛 › 单片机与嵌入式系统 › 国民技术MCU › 国民技术N32G430 I2C1 Master的设置
返回列表 发新帖我要提问

[N32G430] 国民技术N32G430 I2C1 Master的设置

[复制链接]
946|6
 楼主| 呐咯密密 发表于 2024-6-28 11:26 | 显示全部楼层 |阅读模式
N32G430, Master, ma, MaTE, I2c
I2C1 Master的设置

1、将PB6 PB7 初始化为I2C1 的 master 模式，然后往AT24C02里写五个数据，然后读出来。

2、在Common里增加i2c.c i2c.h文件

i2c.c

复制
  1. #include "main.h"
    

  2. #include "i2c.h"
    

  3. /**
    

  4.  * PB6 PB7   初始化为I2C1  i2c master 模式
    

  5.  * PB10 PB11 初始化为I2C2  i2c slaver 模式
    

  6. */
    


  7. 

  8. #define I2CT_FLAG_TIMEOUT ((uint32_t)0x1000)
    

  9. #define I2CT_LONG_TIMEOUT ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))
    

  10. #define I2C_SLAVE_ADDR    0xA0
    


  11. 

  12. static __IO uint32_t I2CTimeout;
    

  13. static CommCtrl_t Comm_Flag = C_READY;  
    


  14. 


  15. 

  16. static void CommTimeOut_CallBack(ErrCode_t errcode)
    

  17. {
    

  18.     max_print("...ErrCode:%d\r\n", errcode);
    

  19.     
    

  20. #if (COMM_RECOVER_MODE == MODULE_SELF_RESET)
    

  21.     IIC_SWReset();
    

  22. #elif (COMM_RECOVER_MODE == MODULE_RCC_RESET)
    

  23.     IIC_RCCReset();
    

  24. #elif (COMM_RECOVER_MODE == SYSTEM_NVIC_RESET)
    

  25.     SystemNVICReset();
    

  26. #endif
    

  27. }
    


  28. 


  29. 

  30. static void Delay(uint32_t nCount)
    

  31. {
    

  32.     uint32_t tcnt;
    

  33.     while (nCount--)
    

  34.     {
    

  35.         tcnt = 48000 / 5;
    

  36.         while (tcnt--){;}
    

  37.     }
    

  38. }
    


  39. 

  40. static void Delay_us(uint32_t nCount)
    

  41. {
    

  42.     uint32_t tcnt;
    

  43.     while (nCount--)
    

  44.     {
    

  45.         tcnt = 48 / 5;
    

  46.         while (tcnt--){;}
    

  47.     }
    

  48. }
    


  49. 


  50. 

  51. MI_BOOL i2c1_init(void)
    

  52. {
    

  53.     /** GPIO configuration and clock enable */
    

  54.     GPIO_InitType GPIO_InitStructure;
    

  55.     I2C_InitType I2C_InitStructure;
    

  56.     #if PROCESS_MODE == 1 // interrupt
    

  57.     NVIC_InitType NVIC_InitStructure;
    

  58.     #endif 
    


  59. 

  60.     /** enable peripheral clk*/
    

  61.     RCC_APB1_Peripheral_Clock_Enable(RCC_APB1_PERIPH_I2C1);
    

  62.     /* I2C1 Reset */
    

  63.     RCC_APB1_Peripheral_Reset(RCC_APB1_PERIPH_I2C1);
    

  64.     RCC_AHB_Peripheral_Clock_Enable(RCC_AHB_PERIPH_GPIOB);
    


  65. 

  66.     GPIO_Structure_Initialize(&GPIO_InitStructure);
    

  67.     GPIO_InitStructure.Pin            = GPIO_PIN_6 | GPIO_PIN_7;
    

  68.     GPIO_InitStructure.GPIO_Slew_Rate = GPIO_SLEW_RATE_SLOW;
    

  69.     GPIO_InitStructure.GPIO_Mode      = GPIO_MODE_AF_OD;
    

  70.     GPIO_InitStructure.GPIO_Alternate = GPIO_AF2_I2C1;
    

  71.     GPIO_InitStructure.GPIO_Pull      = GPIO_PULL_UP;
    

  72.     GPIO_Peripheral_Initialize(GPIOB, &GPIO_InitStructure);
    


  73. 

  74.     /** I2C periphral configuration */
    

  75.     RCC_APB1_Peripheral_Reset(RCC_APB1_PERIPH_I2C1);
    

  76.     I2C_InitStructure.BusMode     = I2C_BUSMODE_I2C;
    

  77.     I2C_InitStructure.DutyCycle   = I2C_FMDUTYCYCLE_2;
    

  78.     I2C_InitStructure.OwnAddr1    = 0xff;
    

  79.     I2C_InitStructure.AckEnable   = I2C_ACKEN;
    

  80.     I2C_InitStructure.AddrMode    = I2C_ADDR_MODE_7BIT;
    

  81.     I2C_InitStructure.ClkSpeed    = 400000;  //400K
    

  82.     I2C_Initializes(I2C1, &I2C_InitStructure);
    

  83.     
    

  84.     I2C_ON(I2C1);
    

  85.     return MI_TRUE;
    

  86. }
    


  87. 

  88. /**
    

  89.  * i2c1 挂着一个AT24C02 
    

  90.  * 我们写入一个字节，读一个字节
    

  91.  * 验证iic读写的函数即可。
    

  92. */
    


  93. 

  94. MI_BOOL i2c_master_send_bytes_by_addr(MI_U8 slave_addr,MI_U8 reg_addr,MI_U8 *w_data,MI_U16 len)
    

  95. {
    

  96.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  97.     while (I2C_Flag_Status_Get(I2C1, I2C_FLAG_BUSY))
    

  98.     {
    

  99.         if ((I2CTimeout--) == 0)
    

  100.             CommTimeOut_CallBack(MASTER_BUSY);
    

  101.     }
    


  102. 

  103.     /** Send START condition */
    

  104.     I2C_Generate_Start_Enable(I2C1);
    

  105.     /** Test on EV5 and clear it */
    

  106.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  107.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_MODE_FLAG))  /*EV5*/
    

  108.     {
    

  109.         if ((I2CTimeout--) == 0)
    

  110.             CommTimeOut_CallBack(MASTER_MODE);
    

  111.     }
    


  112. 

  113.     /** Send slave address for write */
    

  114.     I2C_7bit_Addr_Send(I2C1, slave_addr, I2C_DIRECTION_SEND);
    

  115.     /** Test on EV6 and clear it */
    

  116.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  117.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_TXMODE_FLAG))
    

  118.     {
    

  119.         if ((I2CTimeout--) == 0)
    

  120.             CommTimeOut_CallBack(MASTER_TXMODE);
    


  121. 

  122.     }
    


  123. 

  124.     I2C_Data_Send(I2C1, reg_addr);
    

  125.     /** Test on EV8 and clear it */
    

  126.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  127.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_SENDED))
    

  128.     {
    

  129.         if ((I2CTimeout--) == 0)
    

  130.             CommTimeOut_CallBack(MASTER_SENDED);
    

  131.     }
    


  132. 

  133.      /** While there is data to be written */
    

  134.     while (len--)
    

  135.     {
    

  136.         /** Send the current byte */
    

  137.         I2C_Data_Send(I2C1, *w_data);
    

  138.         /** Point to the next byte to be written */
    

  139.         w_data++;
    

  140.         /** Test on EV8 and clear it */
    

  141.         I2CTimeout = I2CT_LONG_TIMEOUT;
    

  142.         while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_SENDED))
    

  143.         {
    

  144.             if ((I2CTimeout--) == 0)
    

  145.                 CommTimeOut_CallBack(MASTER_SENDED);
    

  146.         }
    

  147.     }
    

  148.     /** Send STOP condition */
    

  149.     I2C_Generate_Stop_Enable(I2C1);
    

  150.     return MI_TRUE;
    

  151. }
    


  152. 

  153. MI_BOOL i2c_master_receive_bytes_by_addr(MI_U8 slave_addr,MI_U8 reg_addr,MI_U8 *r_data,MI_U16 len)
    

  154. {
    

  155.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  156.     while (I2C_Flag_Status_Get(I2C1, I2C_FLAG_BUSY))
    

  157.     {
    

  158.         if ((I2CTimeout--) == 0)
    

  159.             CommTimeOut_CallBack(MASTER_BUSY);
    

  160.     }
    


  161. 

  162.     I2C_PEC_Position_Set(I2C1, I2C_PEC_POS_CURRENT);
    

  163.     I2C_Acknowledg_Enable(I2C1);
    

  164.     
    

  165.     /** Send START condition */
    

  166.     I2C_Generate_Start_Enable(I2C1);
    


  167. 

  168.     /** Test on EV5 and clear it */
    

  169.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  170.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_MODE_FLAG))
    

  171.     {
    

  172.         if ((I2CTimeout--) == 0)
    

  173.             CommTimeOut_CallBack(MASTER_MODE);
    

  174.     }
    


  175. 

  176.     /** Send slave address for write */
    

  177.     I2C_7bit_Addr_Send(I2C1, slave_addr, I2C_DIRECTION_SEND);
    

  178.     /** Test on EV6 and clear it */
    

  179.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  180.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_TXMODE_FLAG))
    

  181.     {
    

  182.         if ((I2CTimeout--) == 0)
    

  183.             CommTimeOut_CallBack(MASTER_TXMODE);
    

  184.     }
    


  185. 

  186.     I2C_ON(I2C1);
    

  187.     /** Send the slave's internal address to write to */
    

  188.     I2C_Data_Send(I2C1, reg_addr);
    

  189.     /** Test on EV8 and clear it */
    

  190.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  191.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_SENDED))
    

  192.     {
    

  193.         if ((I2CTimeout--) == 0)
    

  194.             CommTimeOut_CallBack(MASTER_SENDED);
    

  195.     }
    

  196.     I2C_Generate_Stop_Enable(I2C1);
    


  197. 

  198.     /** Send STRAT condition a second time */
    

  199.     I2C_Generate_Start_Enable(I2C1);
    

  200.     /** Test on EV5 and clear it */
    

  201.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  202.     while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_MODE_FLAG))
    

  203.     {
    

  204.         if ((I2CTimeout--) == 0)
    

  205.             CommTimeOut_CallBack(MASTER_MODE);
    

  206.     }
    


  207. 

  208.     /** Send slave address for read */
    

  209.     I2C_7bit_Addr_Send(I2C1, slave_addr, I2C_DIRECTION_RECV);
    

  210.     /* Test on EV6 and clear it */
    

  211.     I2CTimeout = I2CT_LONG_TIMEOUT;
    

  212.     while (!I2C_Flag_Status_Get(I2C1, I2C_FLAG_ADDRF))    //EV6
    

  213.     {
    

  214.         if ((I2CTimeout--) == 0)
    

  215.             CommTimeOut_CallBack(MASTER_RECVD);
    

  216.     }
    


  217. 

  218.     /** While there is data to be read */
    

  219.     if (len == 1)
    

  220.     {
    

  221.         /** Disable Acknowledgement */
    

  222.         I2C_Acknowledg_Disable(I2C1);
    

  223.         /** clear ADDR */
    

  224.         (void)(I2C1->STS1); 
    

  225.         (void)(I2C1->STS2);
    

  226.         /** Generates START condition to close communication */
    

  227.         I2C_Generate_Start_Enable(I2C1);
    

  228.     }
    

  229.     else
    

  230.     {
    

  231.         /** clear ADDR */
    

  232.         (void)(I2C1->STS1); 
    

  233.         (void)(I2C1->STS2);
    

  234.     }
    


  235. 

  236.     while (len)
    

  237.     {
    

  238.         if (len <= 2)
    

  239.         {
    

  240.             /** One byte */
    

  241.             if (len == 1)
    

  242.             {
    

  243.                 /** Wait until RXNE flag is set */
    

  244.                 I2CTimeout = I2CT_LONG_TIMEOUT;
    

  245.                 while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_RECVD_FLAG))
    

  246.                 {
    

  247.                     if ((I2CTimeout--) == 0)
    

  248.                         CommTimeOut_CallBack(MASTER_RECVD);
    

  249.                 }
    

  250.                 /** Read data from DAT */
    

  251.                 *r_data = I2C_Data_Recv(I2C1);
    

  252.                 /** Point to the next location where the byte read will be saved */
    

  253.                 r_data++;
    

  254.                 /** Decrement the read bytes counter */
    

  255.                 len--;
    

  256.                  /** Generates STOP condition to release SCL/SDA line */
    

  257.                 I2C_Generate_Stop_Enable(I2C1);   
    

  258.              
    

  259.             }
    

  260.             /** 2 Last bytes */
    

  261.             else
    

  262.             {   
    

  263.                 /** Wait until RXNE flag is set */
    

  264.                 I2CTimeout = I2CT_LONG_TIMEOUT;
    

  265.                 while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_RECVD_FLAG))
    

  266.                 {
    

  267.                     if ((I2CTimeout--) == 0)
    

  268.                         CommTimeOut_CallBack(MASTER_RECVD);
    

  269.                 }
    

  270.                 /** Disable Acknowledgement */ 
    

  271.                 I2C_Acknowledg_Disable(I2C1);
    

  272.                                
    

  273.                 /** Read data from DAT */
    

  274.                 *r_data = I2C_Data_Recv(I2C1);
    

  275.                 /** Point to the next location where the byte read will be saved */
    

  276.                 r_data++;
    

  277.                 /** Decrement the read bytes counter */
    

  278.                 len--;
    

  279.                 
    

  280.                 /** Generates START condition to close communication */
    

  281.                 I2C_Generate_Start_Enable(I2C1);
    

  282.                 
    

  283.                 while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_RECVD_FLAG))
    

  284.                 {
    

  285.                     if ((I2CTimeout--) == 0)
    

  286.                         CommTimeOut_CallBack(MASTER_RECVD);
    

  287.                 }                                                 
    

  288.                 /** Read data from DAT */
    

  289.                 *r_data = I2C_Data_Recv(I2C1);              
    

  290.                 /** Point to the next location where the byte read will be saved */
    

  291.                 r_data++;
    

  292.                 /** Decrement the read bytes counter */
    

  293.                 len--;
    

  294.                 
    

  295.                 /** Generates STOP condition to release SCL/SDA line */
    

  296.                 I2C_Generate_Stop_Enable(I2C1);
    

  297.             }
    

  298.         }
    

  299.         else
    

  300.         {
    

  301.             /** Test on EV7 and clear it */
    

  302.             I2CTimeout = I2CT_LONG_TIMEOUT;
    

  303.             while (!I2C_Event_Check(I2C1, I2C_EVT_MASTER_DATA_RECVD_FLAG))
    

  304.             {
    

  305.                 if ((I2CTimeout--) == 0)
    

  306.                     CommTimeOut_CallBack(MASTER_RECVD);
    

  307.             }
    

  308.             /** Read a byte from the EEPROM */
    

  309.             *r_data = I2C_Data_Recv(I2C1);
    

  310.             /** Point to the next location where the byte read will be saved */
    

  311.             r_data++;
    

  312.             /** Decrement the read bytes counter */
    

  313.             len--;
    

  314.             if (I2C_Flag_Status_Get(I2C1, I2C_FLAG_BYTEF))
    

  315.             {
    

  316.                 /** Read a byte from the EEPROM */
    

  317.                 *r_data = I2C_Data_Recv(I2C1);
    

  318.                 /** Point to the next location where the byte read will be saved */
    

  319.                 r_data++;
    

  320.                 /** Decrement the read bytes counter */
    

  321.                 len--;
    

  322.             }
    

  323.         }
    

  324.     }
    


  325. 

  326.     return MI_TRUE;
    

  327. }

i2c.h

复制
  1. #ifndef __I2C_H__
    

  2. #define __I2C_H__
    

  3. #include "type.h"
    


  4. 

  5. #define NON_REENTRANT
    


  6. 

  7. typedef enum
    

  8. {
    

  9.     FAILED = 0,
    

  10.     PASSED = !FAILED
    

  11. } Status;
    


  12. 

  13. typedef enum
    

  14. {
    

  15.     C_READY = 0,
    

  16.     C_START_BIT,
    

  17.     C_STOP_BIT
    

  18. }CommCtrl_t;
    


  19. 

  20. typedef enum
    

  21. {
    

  22.     MASTER_OK = 0,
    

  23.     MASTER_BUSY,
    

  24.     MASTER_MODE,
    

  25.     MASTER_TXMODE,
    

  26.     MASTER_RXMODE,
    

  27.     MASTER_SENDING,
    

  28.     MASTER_SENDED,
    

  29.     MASTER_RECVD,
    

  30.     MASTER_BYTEF,
    

  31.     MASTER_BUSERR,
    

  32.     MASTER_UNKNOW,
    

  33.     SLAVE_OK = 20,
    

  34.     SLAVE_BUSY,
    

  35.     SLAVE_MODE,
    

  36.     SLAVE_BUSERR,
    

  37.     SLAVE_UNKNOW,
    


  38. 

  39. }ErrCode_t;
    


  40. 

  41. #define MODULE_SELF_RESET       1
    

  42. #define MODULE_RCC_RESET        2
    

  43. #define SYSTEM_NVIC_RESET       3
    

  44. #define COMM_RECOVER_MODE       0
    


  45. 

  46. MI_BOOL i2c1_init(void);
    

  47. MI_BOOL i2c_master_send_bytes_by_addr(MI_U8 slave_addr,MI_U8 reg_addr,MI_U8 *w_data,MI_U16 len);
    

  48. MI_BOOL i2c_master_receive_bytes_by_addr(MI_U8 slave_addr,MI_U8 reg_addr,MI_U8 *r_data,MI_U16 len);
    


  49. 

  50. #endif
复制
  1.  MI_U8 w_read[5] = {0x50,0x60,0x70,0xf4,0x68};
    

  2.         SysTick_Delay_Ms(5000);
    

  3.         i2c1_init();
    

  4.         i2c_master_send_bytes_by_addr(0xa0,0x00,w_read,5);
    

  5.         SysTick_Delay_Us(5000);
    


  6. 

  7.         MI_U8 r_data[5] = {0};
    

  8.         i2c_master_receive_bytes_by_addr(0xa0,0x00,r_data,5);


回复

收藏 举报

相关帖子
结合国际经验 发表于 2024-8-31 20:01 | 显示全部楼层
为了完成你的任务，我们需要在 STM32 上配置 I2C1 作为 Master，并实现与 AT24C02 EEPROM 的读写操作。
回复

收藏 举报

结合国际经验 发表于 2024-8-31 20:01 | 显示全部楼层
需要确保 I2C1_ADDRESS 与 EEPROM 的实际地址一致。
回复

收藏 举报

结合国际经验 发表于 2024-8-31 20:01 | 显示全部楼层
目前你使用的是轮询模式进行 I2C 操作。如果系统对延迟较敏感，考虑使用中断模式来提高效率和响应性。
回复

收藏 举报

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

本版积分规则

呐咯密密 Image Image
认证：苏州澜宭自动化科技嵌入式工程师
简介：本人从事磁编码器研发工作，负责开发2500线增量式磁编码器以及17位、23位绝对值式磁编码器，拥有多年嵌入式开发经验，精通STM32、GD32、N32等多种品牌单片机，熟练使用单片机各种外设。

568

主题

4085

帖子

56

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