21ic电子技术开发论坛 › 单片机与嵌入式系统 › 极海MCU › 【APM32E030R Micro-EVB开发板评测】I2C读取FM24C02测试 ...
返回列表 发新帖我要提问

[APM32E0] 【APM32E030R Micro-EVB开发板评测】I2C读取FM24C02测试

[复制链接]
30|0
abner_ma 发表于 2025-8-29 15:53 | 显示全部楼层 |阅读模式
本帖最后由 abner_ma 于 2025-8-29 15:56 编辑

一、测评背景与目的
  在嵌入式系统开发中，IIC（Inter-Integrated Circuit）接口因结构简单、占用引脚少等优势，被广泛应用于传感器、存储芯片等外设的通信。APM32E030R8T6 是一款基于 ARM Cortex-M0 + 内核的微控制器，具备丰富的外设资源，其 PF6 和 PF7 引脚可配置为 IIC 接口功能。FM24C02 则是一款常见的 2KB IIC 接口 EEPROM 存储芯片，常用于数据的掉电保存。
  本次测评旨在验证 APM32E030R8T6 的 PF6、PF7 引脚作为 IIC 接口时，与 FM24C02 之间的通信功能是否正常，同时测试其读写性能、稳定性等关键指标，为后续嵌入式项目中该硬件组合的应用提供可靠依据。
硬件：
1.jpg

二、测评环境搭建（一）硬件环境
1. APM32E030R Micro-EVB开发板主控芯片：APM32E030R8T6 微控制器，工作电压 3.3V，主频最高 48MHz。
2. 存储芯片：FM24C02是一款基于I²C总线接口的串行EEPROM芯片，容量为2Kbit，支持掉电后数据不丢失，非常适合用于存储关键配置信息、设备ID、校准数据等。它采用SOP8贴片封装，体积小巧，安装方便，适合各种空间受限的电路设计。它最大的亮点之一就是“非易失性存储”，也就是说，即使断电了，里面的数据也不会消失。这在很多需要长期保存参数的设备中非常关键，比如智能仪表、家电控制、工业设备等。而且它支持高频率的读写操作，稳定性强，寿命长，简直是“小身材，大能量”的代表！
3. 硬件连接：
◦ APM32E030R8T6 的 PF6 引脚（IIC_SCL）与 FM24C02 的 SCL 引脚相连，PF7 引脚（IIC_SDA）与 FM24C02 的 SDA 引脚相连。
◦ 为保证 IIC 通信的稳定性，在 SCL 和 SDA 引脚上分别串联一个 4.7kΩ 的上拉电阻，将引脚电平拉至 3.3V。
◦ 连接 APM32E030R8T6 和 FM24C02 的 GND 引脚，确保两者共地；为 FM24C02 提供 3.3V 工作电压，与 APM32E030R8T6 的工作电压保持一致。
◦ 搭建调试环境，使用 板载DAP调试器连接 APM32E030R8T6 的调试接口（SWDIO 和 SWCLK），用于程序下载和调试；通过串口将 APM32E030R8T6 与电脑连接，用于输出测试数据和日志。
2.png


（二）软件环境
开发工具：使用 Keil MDK-ARM V5 开发环境，该工具支持 ARM Cortex-M 系列微控制器的程序开发、编译和调试，具备丰富的库函数和调试功能。
固件库：采用 APM32 官方提供的 APM32E030_SDK_V1.0.3库，该固件库包含了 IIC 外设的驱动函数、GPIO 引脚配置函数等，可简化程序开发流程，提高开发效率。
测试程序设计：
引脚初始化：配置 PF6 和 PF7 引脚为复用功能模式，将其映射为 IIC 接口的 SCL 和 SDA 引脚；同时配置引脚的输出模式、上拉 / 下拉电阻等参数，确保引脚工作在正确的电气状态。
IIC 外设初始化：设置 IIC 的通信速率（分别测试 100kHz 标准模式和 400kHz 快速模式）、地址模式（7 位地址模式）、时钟占空比等参数；使能 IIC 外设，准备进行通信。
FM24C02 读写函数：编写 FM24C02 的字节写入函数、字节读取函数、页写入函数和页读取函数。其中，字节读写函数用于单个字节数据的写入和读取，页读写函数用于连续多个字节数据的批量写入和读取（FM24C02 的页容量为 8 字节）。
测试逻辑设计：在主函数中，先对 FM24C02 进行初始化；然后执行写入操作，向 FM24C02 的指定地址写入测试数据（包括单个字节数据和多字节页数据）；等待写入完成后，执行读取操作，从相同地址读取数据；最后将写入数据和读取数据进行比较，判断读写操作是否成功，并通过串口输出测试结果（成功 / 失败、写入数据、读取数据、通信速率等信息）。
IIC.C
复制
  1. #include "fm24c02_iic.h"
    

  2. #include "apm32e03x_gpio.h"
    

  3. #include "apm32e03x_i2c.h"
    

  4. #include "apm32e03x_rcc.h"
    


  5. 

  6. // 定义IIC相关引脚和外设
    

  7. #define I2C_PORT         I2C1
    

  8. #define I2C_SCL_PORT     GPIOF
    

  9. #define I2C_SDA_PORT     GPIOF
    

  10. #define I2C_SCL_PIN      GPIO_PIN_6
    

  11. #define I2C_SDA_PIN      GPIO_PIN_7
    


  12. 

  13. // FM24C02设备地址和容量
    

  14. #define FM24C02_ADDR     0xA0  // 7位地址为0x50，写入时为0xA0，读取时为0xA1
    

  15. #define FM24C02_PAGE_SIZE 8    // 页大小为8字节
    

  16. #define FM24C02_MAX_ADDR 0xFF  // 最大地址(256字节)
    


  17. 

  18. /**
    

  19.  * @brief  初始化IIC外设和相关GPIO引脚
    

  20.  * @param  无
    

  21.  * @retval 无
    

  22.  */
    

  23. void IIC_Init(void)
    

  24. {
    

  25.     GPIO_Config_T gpioConfig;
    

  26.     I2C_Config_T i2cConfig;
    

  27.     
    

  28.     // 使能外设时钟
    

  29.     RCC_EnableAPB1PeriphClock(RCC_APB1_PERIPH_I2C1);
    

  30.     RCC_EnableAHBPeriphClock(RCC_AHB_PERIPH_GPIOF);
    

  31.     
    

  32.     // 配置SCL和SDA引脚为复用功能
    

  33.     gpioConfig.mode = GPIO_MODE_AF_OD;      // 开漏输出
    

  34.     gpioConfig.speed = GPIO_SPEED_50MHz;    // 高速
    

  35.     gpioConfig.pin = I2C_SCL_PIN | I2C_SDA_PIN;
    

  36.     GPIO_Config(I2C_SCL_PORT, &gpioConfig);
    

  37.     
    

  38.     // 配置I2C外设
    

  39.     i2cConfig.mode = I2C_MODE_I2C;                  // I2C模式
    

  40.     i2cConfig.dutyCycle = I2C_DUTYCYCLE_2;          // 占空比1:2
    

  41.     i2cConfig.ownAddr1 = 0x00;                      // 主机地址(不使用)
    

  42.     i2cConfig.addrMode = I2C_ADDR_MODE_7BIT;        // 7位地址模式
    

  43.     i2cConfig.speed = I2C_SPEED_STANDARD;           // 标准模式(100kHz)
    

  44.     //i2cConfig.speed = I2C_SPEED_FAST;             // 快速模式(400kHz)
    

  45.     i2cConfig.ackEn = I2C_ACK_ENABLE;               // 使能应答
    

  46.     
    

  47.     I2C_Config(I2C_PORT, &i2cConfig);
    

  48.     I2C_Enable(I2C_PORT);  // 使能I2C外设
    

  49. }
    


  50. 

  51. /**
    

  52.  * @brief  等待IIC操作完成
    

  53.  * @param  timeOut: 超时时间
    

  54.  * @retval 成功返回0，失败返回1
    

  55.  */
    

  56. uint8_t IIC_WaitForOperation(uint32_t timeOut)
    

  57. {
    

  58.     while(timeOut--)
    

  59.     {
    

  60.         if(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_BUSY))
    

  61.             return 0;
    

  62.     }
    

  63.     return 1; // 超时
    

  64. }
    


  65. 

  66. /**
    

  67.  * @brief  向FM24C02写入一个字节
    

  68.  * @param  addr: 写入地址(0x00~0xFF)
    

  69.  * @param  data: 要写入的数据
    

  70.  * @retval 成功返回0，失败返回1
    

  71.  */
    

  72. uint8_t FM24C02_WriteByte(uint8_t addr, uint8_t data)
    

  73. {
    

  74.     // 等待总线空闲
    

  75.     if(IIC_WaitForOperation(0xFFFF))
    

  76.         return 1;
    

  77.     
    

  78.     // 发送起始信号
    

  79.     I2C_GenerateStart(I2C_PORT);
    

  80.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_SB));
    

  81.     
    

  82.     // 发送设备地址和写命令
    

  83.     I2C_TxData(I2C_PORT, FM24C02_ADDR);
    

  84.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_ADDR));
    

  85.     I2C_ClearAddrFlag(I2C_PORT);  // 清除地址标志
    

  86.     
    

  87.     // 发送内存地址
    

  88.     I2C_TxData(I2C_PORT, addr);
    

  89.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_TXE));
    

  90.     
    

  91.     // 发送数据
    

  92.     I2C_TxData(I2C_PORT, data);
    

  93.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_TXE));
    

  94.     
    

  95.     // 发送停止信号
    

  96.     I2C_GenerateStop(I2C_PORT);
    

  97.     
    

  98.     // 等待写入完成
    

  99.     for(uint32_t i = 0; i < 0xFFFF; i++);
    

  100.     
    

  101.     return 0;
    

  102. }
    


  103. 

  104. /**
    

  105.  * @brief  从FM24C02读取一个字节
    

  106.  * @param  addr: 读取地址(0x00~0xFF)
    

  107.  * @param  data: 存储读取数据的指针
    

  108.  * @retval 成功返回0，失败返回1
    

  109.  */
    

  110. uint8_t FM24C02_ReadByte(uint8_t addr, uint8_t *data)
    

  111. {
    

  112.     if(data == NULL)
    

  113.         return 1;
    

  114.     
    

  115.     // 等待总线空闲
    

  116.     if(IIC_WaitForOperation(0xFFFF))
    

  117.         return 1;
    

  118.     
    

  119.     // 发送起始信号
    

  120.     I2C_GenerateStart(I2C_PORT);
    

  121.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_SB));
    

  122.     
    

  123.     // 发送设备地址和写命令(用于设置读取地址)
    

  124.     I2C_TxData(I2C_PORT, FM24C02_ADDR);
    

  125.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_ADDR));
    

  126.     I2C_ClearAddrFlag(I2C_PORT);
    

  127.     
    

  128.     // 发送要读取的内存地址
    

  129.     I2C_TxData(I2C_PORT, addr);
    

  130.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_TXE));
    

  131.     
    

  132.     // 重新发送起始信号
    

  133.     I2C_GenerateStart(I2C_PORT);
    

  134.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_SB));
    

  135.     
    

  136.     // 发送设备地址和读命令
    

  137.     I2C_TxData(I2C_PORT, FM24C02_ADDR | 0x01);
    

  138.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_ADDR));
    

  139.     I2C_ClearAddrFlag(I2C_PORT);
    

  140.     
    

  141.     // 禁止应答，准备接收最后一个字节
    

  142.     I2C_DisableAck(I2C_PORT);
    

  143.     
    

  144.     // 读取数据
    

  145.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_RXNE));
    

  146.     *data = I2C_RxData(I2C_PORT);
    

  147.     
    

  148.     // 发送停止信号
    

  149.     I2C_GenerateStop(I2C_PORT);
    

  150.     
    

  151.     // 重新使能应答
    

  152.     I2C_EnableAck(I2C_PORT);
    

  153.     
    

  154.     return 0;
    

  155. }
    


  156. 

  157. /**
    

  158.  * @brief  向FM24C02写入一页数据(最多8字节)
    

  159.  * @param  addr: 起始地址(0x00~0xFF)
    

  160.  * @param  buf: 数据缓冲区
    

  161.  * @param  len: 数据长度(1~8)
    

  162.  * @retval 成功返回0，失败返回1
    

  163.  */
    

  164. uint8_t FM24C02_WritePage(uint8_t addr, uint8_t *buf, uint8_t len)
    

  165. {
    

  166.     if(buf == NULL || len == 0 || len > FM24C02_PAGE_SIZE)
    

  167.         return 1;
    

  168.     
    

  169.     // 检查是否超出页边界
    

  170.     if(addr + len > ((addr & ~(FM24C02_PAGE_SIZE - 1)) + FM24C02_PAGE_SIZE))
    

  171.         return 1;
    

  172.     
    

  173.     // 等待总线空闲
    

  174.     if(IIC_WaitForOperation(0xFFFF))
    

  175.         return 1;
    

  176.     
    

  177.     // 发送起始信号
    

  178.     I2C_GenerateStart(I2C_PORT);
    

  179.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_SB));
    

  180.     
    

  181.     // 发送设备地址和写命令
    

  182.     I2C_TxData(I2C_PORT, FM24C02_ADDR);
    

  183.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_ADDR));
    

  184.     I2C_ClearAddrFlag(I2C_PORT);
    

  185.     
    

  186.     // 发送内存地址
    

  187.     I2C_TxData(I2C_PORT, addr);
    

  188.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_TXE));
    

  189.     
    

  190.     // 发送数据
    

  191.     for(uint8_t i = 0; i < len; i++)
    

  192.     {
    

  193.         I2C_TxData(I2C_PORT, buf[i]);
    

  194.         while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_TXE));
    

  195.     }
    

  196.     
    

  197.     // 发送停止信号
    

  198.     I2C_GenerateStop(I2C_PORT);
    

  199.     
    

  200.     // 等待写入完成
    

  201.     for(uint32_t i = 0; i < 0xFFFF; i++);
    

  202.     
    

  203.     return 0;
    

  204. }
    


  205. 

  206. /**
    

  207.  * @brief  从FM24C02连续读取多个字节
    

  208.  * @param  addr: 起始地址(0x00~0xFF)
    

  209.  * @param  buf: 存储读取数据的缓冲区
    

  210.  * @param  len: 要读取的数据长度
    

  211.  * @retval 成功返回0，失败返回1
    

  212.  */
    

  213. uint8_t FM24C02_ReadBuffer(uint8_t addr, uint8_t *buf, uint16_t len)
    

  214. {
    

  215.     if(buf == NULL || len == 0 || addr + len > FM24C02_MAX_ADDR + 1)
    

  216.         return 1;
    

  217.     
    

  218.     // 等待总线空闲
    

  219.     if(IIC_WaitForOperation(0xFFFF))
    

  220.         return 1;
    

  221.     
    

  222.     // 发送起始信号
    

  223.     I2C_GenerateStart(I2C_PORT);
    

  224.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_SB));
    

  225.     
    

  226.     // 发送设备地址和写命令(用于设置读取地址)
    

  227.     I2C_TxData(I2C_PORT, FM24C02_ADDR);
    

  228.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_ADDR));
    

  229.     I2C_ClearAddrFlag(I2C_PORT);
    

  230.     
    

  231.     // 发送要读取的内存地址
    

  232.     I2C_TxData(I2C_PORT, addr);
    

  233.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_TXE));
    

  234.     
    

  235.     // 重新发送起始信号
    

  236.     I2C_GenerateStart(I2C_PORT);
    

  237.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_SB));
    

  238.     
    

  239.     // 发送设备地址和读命令
    

  240.     I2C_TxData(I2C_PORT, FM24C02_ADDR | 0x01);
    

  241.     while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_ADDR));
    

  242.     I2C_ClearAddrFlag(I2C_PORT);
    

  243.     
    

  244.     // 读取数据
    

  245.     for(uint16_t i = 0; i < len; i++)
    

  246.     {
    

  247.         // 最后一个字节前禁止应答
    

  248.         if(i == len - 1)
    

  249.             I2C_DisableAck(I2C_PORT);
    

  250.         
    

  251.         while(!I2C_ReadStatusFlag(I2C_PORT, I2C_FLAG_RXNE));
    

  252.         buf[i] = I2C_RxData(I2C_PORT);
    

  253.     }
    

  254.     
    

  255.     // 发送停止信号
    

  256.     I2C_GenerateStop(I2C_PORT);
    

  257.     
    

  258.     // 重新使能应答
    

  259.     I2C_EnableAck(I2C_PORT);
    

  260.     
    

  261.     return 0;
    

  262. }
    


  263. 

  264. /**
    

  265.  * @brief  向FM24C02写入多个字节(可跨页)
    

  266.  * @param  addr: 起始地址(0x00~0xFF)
    

  267.  * @param  buf: 数据缓冲区
    

  268.  * @param  len: 数据长度
    

  269.  * @retval 成功返回0，失败返回1
    

  270.  */
    

  271. uint8_t FM24C02_WriteBuffer(uint8_t addr, uint8_t *buf, uint16_t len)
    

  272. {
    

  273.     uint8_t bytesToWrite;
    

  274.     
    

  275.     if(buf == NULL || len == 0 || addr + len > FM24C02_MAX_ADDR + 1)
    

  276.         return 1;
    

  277.     
    

  278.     while(len > 0)
    

  279.     {
    

  280.         // 计算当前页可写入的字节数
    

  281.         bytesToWrite = FM24C02_PAGE_SIZE - (addr % FM24C02_PAGE_SIZE);
    

  282.         if(bytesToWrite > len)
    

  283.             bytesToWrite = len;
    

  284.         
    

  285.         // 写入一页数据
    

  286.         if(FM24C02_WritePage(addr, buf, bytesToWrite) != 0)
    

  287.             return 1;
    

  288.         
    

  289.         // 更新地址、缓冲区指针和剩余长度
    

  290.         addr += bytesToWrite;
    

  291.         buf += bytesToWrite;
    

  292.         len -= bytesToWrite;
    

  293.     }
    

  294.     
    

  295.     return 0;
    

  296. }
main函数
复制
  1. #include "apm32e03x.h"
    

  2. #include "fm24c02_iic.h"
    

  3. #include <stdio.h>
    


  4. 

  5. // 测试函数声明
    

  6. void SystemInit(void);
    

  7. void UART_Init(void);
    

  8. int fputc(int ch, FILE *f);
    


  9. 

  10. int main(void)
    

  11. {
    

  12.     uint8_t writeData = 0x5A;
    

  13.     uint8_t readData;
    

  14.     uint8_t pageData[8] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
    

  15.     uint8_t readBuffer[8];
    

  16.     uint8_t multiData[12] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B};
    

  17.     uint8_t readMulti[12];
    

  18.     
    

  19.     // 系统初始化
    

  20.     SystemInit();
    

  21.     UART_Init();  // 初始化串口用于输出调试信息
    

  22.     IIC_Init();   // 初始化IIC接口
    

  23.     
    

  24.     printf("FM24C02 IIC Communication Test Start\r\n");
    

  25.     
    

  26.     // 测试单个字节读写
    

  27.     if(FM24C02_WriteByte(0x00, writeData) == 0)
    

  28.     {
    

  29.         printf("Write byte 0x%02X to address 0x00 success\r\n", writeData);
    

  30.         
    

  31.         if(FM24C02_ReadByte(0x00, &readData) == 0)
    

  32.         {
    

  33.             printf("Read byte from address 0x00: 0x%02X\r\n", readData);
    

  34.             if(readData == writeData)
    

  35.                 printf("Single byte test: PASS\r\n");
    

  36.             else
    

  37.                 printf("Single byte test: FAIL\r\n");
    

  38.         }
    

  39.         else
    

  40.         {
    

  41.             printf("Read byte failed\r\n");
    

  42.         }
    

  43.     }
    

  44.     else
    

  45.     {
    

  46.         printf("Write byte failed\r\n");
    

  47.     }
    

  48.     
    

  49.     // 测试页写入和读取
    

  50.     if(FM24C02_WritePage(0x10, pageData, 8) == 0)
    

  51.     {
    

  52.         printf("Write page data to address 0x10 success\r\n");
    

  53.         
    

  54.         if(FM24C02_ReadBuffer(0x10, readBuffer, 8) == 0)
    

  55.         {
    

  56.             printf("Read page data: ");
    

  57.             for(uint8_t i = 0; i < 8; i++)
    

  58.             {
    

  59.                 printf("0x%02X ", readBuffer[i]);
    

  60.             }
    

  61.             printf("\r\n");
    

  62.             
    

  63.             // 验证数据
    

  64.             uint8_t pass = 1;
    

  65.             for(uint8_t i = 0; i < 8; i++)
    

  66.             {
    

  67.                 if(readBuffer[i] != pageData[i])
    

  68.                 {
    

  69.                     pass = 0;
    

  70.                     break;
    

  71.                 }
    

  72.             }
    

  73.             if(pass)
    

  74.                 printf("Page test: PASS\r\n");
    

  75.             else
    

  76.                 printf("Page test: FAIL\r\n");
    

  77.         }
    

  78.         else
    

  79.         {
    

  80.             printf("Read page data failed\r\n");
    

  81.         }
    

  82.     }
    

  83.     else
    

  84.     {
    

  85.         printf("Write page data failed\r\n");
    

  86.     }
    

  87.     
    

  88.     // 测试跨页写入和读取
    

  89.     if(FM24C02_WriteBuffer(0x1C, multiData, 12) == 0)
    

  90.     {
    

  91.         printf("Write multi-page data to address 0x1C success\r\n");
    

  92.         
    

  93.         if(FM24C02_ReadBuffer(0x1C, readMulti, 12) == 0)
    

  94.         {
    

  95.             printf("Read multi-page data: ");
    

  96.             for(uint8_t i = 0; i < 12; i++)
    

  97.             {
    

  98.                 printf("0x%02X ", readMulti[i]);
    

  99.             }
    

  100.             printf("\r\n");
    

  101.             
    

  102.             // 验证数据
    

  103.             uint8_t pass = 1;
    

  104.             for(uint8_t i = 0; i < 12; i++)
    

  105.             {
    

  106.                 if(readMulti[i] != multiData[i])
    

  107.                 {
    

  108.                     pass = 0;
    

  109.                     break;
    

  110.                 }
    

  111.             }
    

  112.             if(pass)
    

  113.                 printf("Multi-page test: PASS\r\n");
    

  114.             else
    

  115.                 printf("Multi-page test: FAIL\r\n");
    

  116.         }
    

  117.         else
    

  118.         {
    

  119.             printf("Read multi-page data failed\r\n");
    

  120.         }
    

  121.     }
    

  122.     else
    

  123.     {
    

  124.         printf("Write multi-page data failed\r\n");
    

  125.     }
    

  126.     
    

  127.     printf("FM24C02 IIC Communication Test Complete\r\n");
    

  128.     
    

  129.     while(1)
    

  130.     {
    

  131.         // 主循环
    

  132.     }
    

  133. }


三、功能测试（一）单个字节读写测试
  测试步骤：
设定 FM24C02 的目标地址为 0x00（可选择任意有效地址，范围 0x00-0xFF）。
调用字节写入函数，向 0x00 地址写入一个字节的测试数据，例如 0x5A。
延时一段时间（FM24C02 的写入周期最大为 5ms，此处设置延时 10ms，确保写入操作完成）。
调用字节读取函数，从 0x00 地址读取数据。
比较写入数据（0x5A）和读取数据，若两者相等，则单个字节读写测试成功；否则失败。
重复上述测试过程 100 次，测试不同的目标地址（如 0x10、0x20、0x50、0xFF 等）和不同的测试数据（如 0x00、0xFF、0xAA、0x33 等），验证测试结果的一致性。
测试结果：
  1. 在 100kHz 标准模式和 400kHz 快速模式下，经过 100 次不同地址和不同数据的测试，所有写入数据与读取数据均完全一致，单个字节读写功能正常，无数据错误或 通信失败的情况。
  2.串口输出日志显示，每次读写操作均能在预期时间内完成，无超时或异常报错。
（二）多字节页读写测试
  测试步骤：
设定 FM24C02 的起始地址为 0x10（该地址需满足页对齐要求，即起始地址的低 3 位为 0，因 FM24C02 页容量为 8 字节，页地址范围为 0x00-0x07、0x08-0x0F、0x10-0x17 等）。
  准备一个 8 字节的测试数据数组，例如 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}。
  写入函数，将该数据数组写入起始地址为 0x10 的页中。
  延时 10ms，等待页写入操作完成。
  调用页读取函数，从起始地址为 0x10 的页中读取 8 字节数据，存储到另一个数据数组中。
逐字节比较写入数据数组和读取数据数组，若所有字节均相等，则多字节页读写测试成功；否则失败。
  更换不同的起始页地址（如 0x20、0x30、0x70 等）和不同的测试数据数组（如全 0、全 1、递增数据、随机数据等），重复测试 100 次。
  测试结果：
在两种通信速率下，100 次不同页地址和不同数据的测试均全部成功，写入的 8 字节数据与读取数据完全匹配，无数据丢失、错位或错误的情况。
即使在快速模式（400kHz）下，页读写操作依然稳定，未出现因通信速率过高导致的通信异常。

四、测评结论
   本次对 APM32E030R8T6 的 PF6、PF7 引脚读写 IIC 接口 FM24C02 的测评结果表明：APM32E030R8T6硬件IIC功能还是非常可靠的！


回复

收藏 举报

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

本版积分规则

abner_ma Image
认证：项目经理
简介：资深嵌入式开发工程师

97

主题

183

帖子

3

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