[MM32硬件] 【灵动微电子MM32F0121测评】5.I2C_EEPROM读写测试

[复制链接]
3374|12
 楼主| 阿源玩电子 发表于 2025-6-25 22:02 | 显示全部楼层 |阅读模式
I2C_EEPROM读写测试

1.原理图部分

原理图部分.jpg

2.基于MM32F0121,实现了I2C接口的EEPROM(AT24C系列)读写功能

I2C_BSP.C

  1. #include "I2C_BSP.h"
  2. #include <stdio.h>
  3. #include <string.h>

  4. #define EEPROM_I2C_ADDRESS      0xA0
  5. #define EEPROM_PAGE_SIZE        0x08

  6. void I2C_Configure(void)
  7. {
  8.     GPIO_InitTypeDef GPIO_InitStruct;
  9.     I2C_InitTypeDef  I2C_InitStruct;

  10.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
  11.     I2C_DeInit(I2C1);

  12.     I2C_StructInit(&I2C_InitStruct);
  13.     I2C_InitStruct.I2C_Mode       = I2C_MODE_MASTER;
  14.     I2C_InitStruct.I2C_OwnAddress = I2C_OWN_ADDRESS;
  15.     I2C_InitStruct.I2C_ClockSpeed = 100000;
  16.     I2C_Init(I2C1, &I2C_InitStruct);

  17.     I2C_TargetAddressConfig(I2C1, EEPROM_I2C_ADDRESS);

  18.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
  19.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_1);
  20.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_1);

  21.     GPIO_StructInit(&GPIO_InitStruct);
  22.     GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_10 | GPIO_Pin_11;
  23.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_High;
  24.     GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF_OD;
  25.     GPIO_Init(GPIOB, &GPIO_InitStruct);

  26.     I2C_Cmd(I2C1, ENABLE);
  27. }

  28. void I2C_TxData_Polling(uint8_t *Buffer, uint8_t Length)
  29. {
  30.     for (uint8_t i = 0; i < Length; i++) {
  31.         I2C_SendData(I2C1, Buffer[i]);
  32.         while (RESET == I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_TFE)) {}
  33.     }
  34. }

  35. void I2C_RxData_Polling(uint8_t *Buffer, uint16_t Length)
  36. {
  37.     for (uint16_t i = 0; i < Length; i++) {
  38.         I2C_ReadCmd(I2C1);
  39.         while (RESET == I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_RFNE)) {}
  40.         Buffer[i] = I2C_ReceiveData(I2C1);
  41.     }
  42. }

  43. void EEPROM_WritePage(uint8_t Address, uint8_t *Buffer, uint8_t Length)
  44. {
  45.     I2C_TxData_Polling(&Address, 1);
  46.     I2C_TxData_Polling(Buffer, Length);
  47.     while (RESET == I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_TFE)) {}
  48.     I2C_GenerateSTOP(I2C1);
  49.     while (RESET == I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_TFE)) {}
  50. }

  51. void EEPROM_ReadData(uint8_t Address, uint8_t *Buffer, uint8_t Length)
  52. {
  53.     I2C_TxData_Polling(&Address, 1);
  54.     I2C_RxData_Polling(Buffer, Length);
  55.     I2C_GenerateSTOP(I2C1);
  56.     while (RESET == I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_TFE)) {}
  57. }

  58. void EEPROM_WriteData(uint8_t Address, uint8_t *Buffer, uint8_t Length)
  59. {
  60.     uint8_t Start = Address % EEPROM_PAGE_SIZE;
  61.     uint8_t StartCount = 0, PageNumber = 0, FinalCount = 0;

  62.     if (Start == 0) {
  63.         PageNumber = Length / EEPROM_PAGE_SIZE;
  64.         FinalCount = Length % EEPROM_PAGE_SIZE;
  65.     } else {
  66.         if ((Start + Length) <= EEPROM_PAGE_SIZE) {
  67.             StartCount = Length;
  68.         } else {
  69.             StartCount = EEPROM_PAGE_SIZE - Start;
  70.             PageNumber = (Length - StartCount) / EEPROM_PAGE_SIZE;
  71.             FinalCount = (Length - StartCount) % EEPROM_PAGE_SIZE;
  72.         }
  73.     }

  74.     if (StartCount) {
  75.         EEPROM_WritePage(Address, Buffer, StartCount);
  76.         Address += StartCount;
  77.         Buffer  += StartCount;
  78.         Delay_MS(50);
  79.     }

  80.     while (PageNumber--) {
  81.         EEPROM_WritePage(Address, Buffer, EEPROM_PAGE_SIZE);
  82.         Address += EEPROM_PAGE_SIZE;
  83.         Buffer  += EEPROM_PAGE_SIZE;
  84.         Delay_MS(50);
  85.     }

  86.     if (FinalCount) {
  87.         EEPROM_WritePage(Address, Buffer, FinalCount);
  88.     }
  89. }

  90. void I2C_Master_EEPROM_Polling_Sample(void)
  91. {
  92.     const char* targetString = "Hello 21ic, Hello MM32F0121";
  93.     uint8_t len = strlen(targetString);
  94.     uint8_t WriteBuffer[len];
  95.     uint8_t ReadBuffer[len];
  96.     uint8_t errors = 0;

  97.     memset(ReadBuffer, 0, len);
  98.     memcpy(WriteBuffer, targetString, len);

  99.     I2C_Configure();
  100.     EEPROM_WriteData(0, WriteBuffer, len);
  101.     Delay_MS(50);
  102.     EEPROM_ReadData(0, ReadBuffer, len);

  103.     printf("\r\nEEPROM Write/Read Comparison (Length: %d bytes)\r\n", len);
  104.     printf("Offset | Write Data     | Read Data      | Status\r\n");
  105.     printf("-------+----------------+----------------+-----------\r\n");
  106.    
  107.     for (uint8_t i = 0; i < len; i++) {
  108.         uint8_t writeVal = WriteBuffer[i];
  109.         uint8_t readVal = ReadBuffer[i];
  110.         char writeChar = (writeVal >= 0x20) ? writeVal : '.';
  111.         char readChar = (readVal >= 0x20) ? readVal : '.';
  112.         
  113.         const char* status = "OK";
  114.         if (writeVal != readVal) {
  115.             status = "ERROR";
  116.             errors++;
  117.         }
  118.         
  119.         printf("%6d | 0x%02X '%c' (%-3d) | 0x%02X '%c' (%-3d) | %s\r\n",
  120.                i,
  121.                writeVal, writeChar, writeVal,
  122.                readVal, readChar, readVal,
  123.                status);
  124.     }
  125.    
  126.     printf("\r\nOriginal String: "");
  127.     for (uint8_t i = 0; i < len; i++) {
  128.         printf("%c", (WriteBuffer[i] >= 0x20) ? WriteBuffer[i] : '.');
  129.     }
  130.     printf(""");
  131.    
  132.     printf("\r\nRead String:     "");
  133.     for (uint8_t i = 0; i < len; i++) {
  134.         printf("%c", (ReadBuffer[i] >= 0x20) ? ReadBuffer[i] : '.');
  135.     }
  136.     printf(""");
  137.    
  138.     printf("\r\n\r\nSummary: %d/%d bytes matched. %s\r\n",
  139.            len - errors, len,
  140.            (errors == 0) ? "SUCCESS (Strings match)" : "FAILED (Strings differ)");
  141. }
I2C_BSP.h

  1. #include "hal_conf.h"
  2. #include "delay_dsp.h"
  3. void I2C_Configure(void);
  4. void I2C_Master_EEPROM_Polling_Sample(void);
3.实验现象
I2C读写实验.jpg


MM32F0121C6PV_05I2C.zip

5.97 MB, 下载次数: 2

工程

youtome 发表于 2025-7-2 12:46 | 显示全部楼层
学习I2C外设操作的入门实验。              
linfelix 发表于 2025-7-3 18:00 | 显示全部楼层
建议结合DMA传输数据,进一步提高I2C通信效率。
pmp 发表于 2025-7-4 09:57 | 显示全部楼层
可以帮助开发者理解和掌握I2C通信的工作原理和应用。
lzbf 发表于 2025-7-4 18:15 | 显示全部楼层
可以学习如何配置MCU的I2C接口、如何编写控制EEPROM的代码
linfelix 发表于 2025-7-6 13:08 | 显示全部楼层
上拉电阻需求,符合I2C总线规范
rosemoore 发表于 2025-7-7 15:43 | 显示全部楼层
提供完整的初始化代码片段,包括I2C外设、GPIO和时钟配置,用户可直接复制使用。
abotomson 发表于 2025-7-10 14:08 | 显示全部楼层
提供了常见问题的解决方案或调试技巧。
sanfuzi 发表于 2025-7-10 16:22 | 显示全部楼层
I2C配置说明详尽,覆盖了从初始化到具体读写操作的所有必要步骤。
wilhelmina2 发表于 2025-7-11 12:03 | 显示全部楼层
EEPROM读写测试是一个实用的项目
pl202 发表于 2025-7-11 14:58 | 显示全部楼层
使用了模块化编程,使得I2C通信部分可以轻松移植到其他项目中。
bartonalfred 发表于 2025-7-12 12:30 | 显示全部楼层
合MM32F0121初学者快速掌握I2C核心功能。
claretttt 发表于 2025-7-12 18:05 | 显示全部楼层
通过复用功能配置为I2C模式  
您需要登录后才可以回帖 登录 | 注册

本版积分规则

13

主题

35

帖子

0

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