《DNESP32S3使用指南-IDF版_V1.6》第二十章 IIC_EEPROM实验

正点原子

1）实验平台：正点原子ESP32S3开发板
2）购买链接：https://detail.tmall.com/item.htm?id=768499342659
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-347618-1-1.html
4）正点原子官方B站：https://space.bilibili.com/394620890
5）正点原子手把手教你学ESP32S3快速入门视频教程：https://www.bilibili.com/video/BV1sH4y1W7Tc
6）正点原子FPGA交流群：132780729

第二十章 IIC_EEPROM实验

       本章将介绍使用ESP32-S3驱动板载的EEPROM进行读写操作。通过本章的学习，读者将学习到使用IIC接口驱动24C02器件。
       本章分为如下几个小节：
       20.1 24C02简介
       20.2 硬件设计
       20.3 程序设计
       20.4 下载验证

       20.1 24C02简介
       24C02是一个2K bit的串行EEPROM存储器，内部含有256个字节。在24C02里面还有一个8字节的页写缓冲器。该设备的通信方式IIC，通过其SCL和SDA与其他设备通信，芯片的引脚图如图35.1.2.1所示。

图20.1.1 24C02引脚图

       上图的WP引脚是写保护引脚，接高电平只读，接地允许读和写，我们的板子设计是把该引脚接地。每一个设备都有自己的设备地址，24C02也不例外，但是24C02的设备地址是包括不可编程部分和可编程部分，可编程部分是根据上图的硬件引脚A0、A1和A2所决定。设备地址最后一位用于设置数据的传输方向，即读操作/写操作，0是写操作，1是读操作，具体格式如下图20.1.2所示：

图20.1.2 24C02设备地址格式图

       根据我们的板子设计，A0、A1和A2均接地处理，所以24C02设备的读操作地址为：0xA1；写操作地址为：0xA0。
       在前面已经说过IIC总线的基本读写操作，那么我们就可以基于IIC总线的时序的上，理解24C02的数据传输时序。
       下面把实验中到的数据传输时序讲解一下，分别是对24C02的写时序和读时序。24C02写时序图见图20.1.3所示：

图20.1.3 24C02写时序图

       上图展示的主机向24C02写操作时序图，主机在IIC总线发送第1个字节的数据为24C02的设备地址0xA0，用于寻找总线上找到24C02，在获得24C02的应答信号之后，继续发送第2个字节数据，该字节数据是24C02的内存地址，再等到24C02的应答信号，主机继续发送第3字节数据，这里的数据即是写入在第2字节内存地址的数据。主机完成写操作后，可以发出停止信号，终止数据传输。
       上面的写操作只能单字节写入到24C02，效率比较低，所以24C02有页写入时序，大大提高了写入效率，下面看一下24C02页写时序图，图20.1.4所示。

图20.1.4 24C02页写时序

       在单字节写时序时，每次写入数据时都需要先写入设备的内存地址才能实现，在页写时序中，只需要告诉24C02第一个内存地址1，后面数据会按照顺序写入到内存地址2，内存地址3等，大大节省了通信时间，提高了时效性。因为24C02每次只能8bit数据，所以它的页大小也就是1字节。页写时序的操作方式跟上面的单字节写时序差不多，所以不作过多解释了。参考以上说明去理解页写时序。
       说完两种写入方式之后，下面看一下图20.1.5关于24C02的读时序：

图20.1.5 24C02读时序图

       24C02读取数据的过程是一个复合的时序，其中包含写时序和读时序。先看第一个通信过程，这里是写时序，起始信号产生后，主机发送24C02设备地址0xA0，获取从机应答信号后，接着发送需要读取的内存地址；在读时序中，起始信号产生后，主机发送24C02设备地址0xA1,获取从机应答信号后，接着从机返回刚刚在写时序中内存地址的数据，以字节为单位传输在总线上，假如主机获取数据后返回的是应答信号，那么从机会一直传输数据，当主机发出的是非应答信号并以停止信号发出为结束，从机就会结束传输。

       20.2 硬件设计

       20.2.1 例程功能
       通过按下KEY0~4按键来控制蜂鸣器和LED灯开关状态，KEY0和KEY1控制蜂鸣器开与关；KEY2和KEY3控制LED灯开与关。

       20.2.2 硬件资源

       1. LED
              LED - IO1

       2. 独立按键
              KEY0(XL9555) - IO1_7
              KEY1(XL9555) - IO1_6

       3.  UART_NUM_0（U0TX、U0RX连接至板载USB转串口芯片上）
              U0TXD - IO43
              U0RXD - IO44

       4. 24C02
              IIC_SCL - IO42
              IIC_SDA - IO41

       20.2.3 原理图
       本章实验使用了板载的24C02芯片，该芯片是一个EEPROM，MCU是通过两个GPIO与该EEPROM进行连接与通信的，该EEPROM与MCU的连接原理图，如下图所示：

图20.1.3.1 24C02与MCU的连接原理图

       20.3 程序设计

       20.3.1 程序流程图
       程序流程图能帮助我们更好的理解一个工程的功能和实现的过程，对学习和设计工程有很好的主导作用。下面看看本实验的程序流程图：

图20.3.1.1 24C02实验程序流程图

       20.3.2 IIC_EEPROM函数解析
       ESP-IDF提供了一套API来配置IIC。要使用此功能，需要导入必要的头文件：

1. #include "driver/i2c.h"

复制代码

       接下来，作者将介绍一些常用的ESP32-S3中的IIC函数，以及24C02中用到的函数，这些函数的描述及其作用如下：

       1，设置IIC初始化参数
       该函数用给定的配置，来配置IIC总线，该函数原型如下所示：

1. esp_err_t i2c_param_config(i2c_port_t i2c_num, const i2c_config_t *i2c_conf);

复制代码

       该函数的形参描述如下表所示：

表20.3.2.1 i2c_param_config函数形参描述

       返回值：ESP_OK表示配置成功。其他表示配置失败。
       该函数使用i2c_config_t类型的结构体变量传入，该结构体的定义如下所示：

表20.3.2.2 i2c_config_t结构体参数值描述

       完成上述结构体参数配置之后，可以将结构传递给 i2c_param_config () 函数，用以实例化IIC并返回IIC句柄。

       2，安装IIC驱动
       该函数设置某个管脚的中断服务函数，该函数原型如下所示：

1. esp_err_t i2c_driver_install(i2c_port_t i2c_num,
   
2.                              i2c_mode_t mode,
   
3.                              size_t slv_rx_buf_len,
   
4.                              size_t slv_tx_buf_len,
   
5.                              int intr_alloc_flags);

复制代码

       该函数的形参描述如下表所示：

表20.3.2.3 i2c_driver_install()函数形参描述

       返回值：ESP_OK表示配置成功。其他表示配置失败。

       3，IIC读写操作
       根据函数功能，以下函数可以归为一类进行讲解，下面将以表格的形式逐个介绍这些函数的作用与参数。

表20.3.2.4 IIC读写操作函数描述

       4，初始化24C02的IIC引脚
       在配置24C02芯片引脚之前，需要对IIC初始化进行一个判断。因为ESP32系统不支持同一个外设进行两次初始化，否则会出现系统不断复位的现象。因此，我们需要在24C02的初始化前面添加IIC端口判断。

       5，在指定地址写入数据
       该函数用于在24C02指定地址写入一个数据，其函数原型如下所示：

1. void at24cxx_write_one_byte(uint16_t addr, uint8_t data);

复制代码

       该函数的形参描述，如下表所示：

表20.3.2.5 函数at24cxx_write_one_byte ()形参描述

       返回值：无。

       6，在指定地址读出数据
       该函数用于在24C02指定地址读出一个数据，其函数原型如下所示：

1. uint8_t at24cxx_read_one_byte(uint16_t addr);

复制代码

       该函数的形参描述，如下表所示：

表20.3.2.6  函数at24cxx_read_one_byte ()形参描述

       返回值：读取的数据。

       7，检查24C02是否正常
       在器件的末地址写如：0X55, 然后再读取, 如果读取值为0X55则表示检测正常。否则，则表示检测失败，其函数原型如下所示：

1. uint8_t at24cxx_check(void);

复制代码

       返回值：1表示检验成功。0表示检验失败。

       8，在指定地址读出数据
       在24C02里面的指定地址开始读出指定个数的数据，其函数原型如下所示：

1. void at24cxx_read(uint16_t addr, uint8_t *pbuf, uint16_t datalen);

复制代码

       该函数的形参描述，如下表所示：

表20.3.2.7  函数at24cxx_read()形参描述

       返回值：无。

       9，在指定地址读出数据
       在24C02里面的指定地址开始读出指定个数的数据，其函数原型如下所示：

1. void at24cxx_write(uint16_t addr, uint8_t *pbuf, uint16_t datalen);

复制代码

       该函数的形参描述，如下表所示：

表20.3.2.8  函数at24cxx_write ()形参描述

       返回值：无。

       20.3.3 IIC_EEPROM驱动解析
       在IDF版的10_iic_eeprom例程中，作者在10_iic_eeprom \components\BSP路径下新增了一个24CXX文件夹，用于存放24cxx.c和24cxx.h这两个文件。其中，24cxx.h文件负责声明24CXX相关的函数和变量，而24cxx.c文件则实现了24CXX的驱动代码。下面，我们将详细解析这两个文件的实现内容。


       1，24cxx.h文件
       为了使代码功能更加健全，所以在24cxx.h中宏定义了不同容量大小的24C系列型号，具体定义如下：

1. #define AT24C01                        127
   
2. #define AT24C02             255
   
3. #define AT24C04             511
   
4. #define AT24C08             1023
   
5. #define AT24C16             2047
   
6. #define AT24C32             4095
   
7. #define AT24C64             8191
   
8. #define AT24C128            16383
   
9. #define AT24C256            32767
   
10. 
    
11. /* 开发板使用的是24c02，所以定义EE_TYPE为AT24C02 */
    
12. #define EE_TYPE             AT24C02

复制代码

       2，24cxx.c文件
       在24cxx.c文件中，读/写操作函数对于不同容量大小的24Cxx芯片都有相对应的代码块解决处理。下面先看一下at24cxx_write_one_byte函数，实现在AT24Cxx芯片指定地址写入一个数据，代码如下：

1. /**
   
2. * @brief             在AT24CXX指定地址写入一个数据
   
3. * @param       addr: 写入数据的目的地址
   
4. * @param              data: 要写入的数据
   
5. * @retval             无
   
6. */
   
7. void at24cxx_write_one_byte(uint16_t addr, uint8_t data)
   
8. {
   
9.     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
   
10.     i2c_master_start(cmd);
    
11.         
    
12.     if(EE_TYPE > AT24C16)
    
13.     {
    
14.         i2c_master_write_byte(cmd,
    
15.                                                           (AT_ADDR << 1) |
    
16. I2C_MASTER_WRITE,
    
17. ACK_CHECK_EN);                                    /* 发送写命令 */
    
18.         i2c_master_write_byte(cmd, addr >> 8, ACK_CHECK_EN);         /* 发送高地址 */                           
    
19.     }
    
20.     else
    
21.     {
    
22.         i2c_master_write_byte(cmd,
    
23. 0XA0 + ((addr/256) << 1),
    
24. ACK_CHECK_EN);             /* 发送器件地址0XA0,写数据 */
    
25.     }
    
26.     i2c_master_write_byte(cmd, addr % 256, ACK_CHECK_EN);                /* 发送低地址 */                              
    
27.     i2c_master_write_byte(cmd, data, ACK_CHECK_EN);
    
28.     i2c_master_stop(cmd);
    
29.     i2c_master_cmd_begin(at24cxx_master.port, cmd, 1000);
    
30.     i2c_cmd_link_delete(cmd);
    
31.     vTaskDelay(10);
    
32. }

复制代码

       该函数的操作流程跟前面已经分析过的24C02单字节写时序一样，首先调用i2c_master_start()函数产生起始信号，然后调用i2c_master_write_byte()函数发送第1个字节数据设备地址；收到应答信号后，继续发送第2个1字节数据内存地址addr，最后发送第3个字节数据写入内存地址的数据data，24Cxx设备接收完数据，返回应答信号，主机调用i2c_master_stop()函数产生停止信号终止数据传输，最终需要延时10ms，等待eeprom写入完毕。
       我们的函数兼容24Cxx系列多种容量，就在发送设备地址处做了处理，这里说一下为什么需要这样子设计。大家请看一下24Cxx芯片内存组织表，见表35.2.2.1所示。

表20.3.3.1 24Cxx芯片内存组织表

       主机发送的设备地址和内存地址共同确定了要写入的地方，这里分析一下24C16的使用的是i2c_master_write_byte(cmd, 0XA0 + ((addr/256) << 1),  ACK_CHECK_EN);
和   i2c_master_write_byte(cmd, addr %256),  ACK_CHECK_EN)确定写入位置，由于它内存大小一共2048字节，所以只需要定义11个寻址地址线，2048 = 2^11。主机下发读写命令的时候带了3位，后面再跟1个字节（8位）的地址，正好11位，就不需要再发后续的地址字节了。
       而容量大于24C16的芯片，需要单独发送2个字节（甚至更多）的地址，如24C32，它的大小为4096，需要12个寻址地址线支持，4096 = 2^12。24C16是2个字节刚刚好，而它需要三个字节才能确定写入的位置。24C32芯片规定设备写地址0xA0/读地址0xA1，后面接着发送8位高地址，最后才发送8位低地址。与函数里面的操作是一致。
       接下来看一下at24cxx_read_one_byte函数，其定义如下：

1. /**
   
2. * @brief       在AT24CXX指定地址读出一个数据
   
3. * @param       addr: 开始读数的地址
   
4. * @retval      读到的数据
   
5. */
   
6. uint8_t at24cxx_read_one_byte(uint16_t addr)
   
7. {
   
8.     uint8_t data = 0;
   
9. 
   
10.     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
    
11.     i2c_master_start(cmd);
    
12.     /* 根据不同的24CXX型号, 发送高位地址
    
13.      * 1, 24C16以上的型号, 分2个字节发送地址
    
14.      * 2, 24C16及以下的型号, 分1个低字节地址 + 占用器件地址的bit1~bit3位 用于表示高位地址, 最多11位地址
    
15.      *    对于24C01/02, 其器件地址格式(8bit)为: 1  0  1  0  A2  A1  A0  R/W
    
16.      *    对于24C04,    其器件地址格式(8bit)为: 1  0  1  0  A2  A1  a8  R/W
    
17.      *    对于24C08,    其器件地址格式(8bit)为: 1  0  1  0  A2  a9  a8  R/W
    
18.      *    对于24C16,    其器件地址格式(8bit)为: 1  0  1  0  a10 a9  a8  R/W
    
19.      *    R/W      :    读/写控制位 0,表示写; 1,表示读;
    
20.      *    A0/A1/A2 :    对应器件的1,2,3引脚(只有24C01/02/04/8有这些脚)
    
21.      *    a8/a9/a10:    对应存储整列的高位地址, 11bit地址最多可以表示2048个位置,可以寻址24C16及以内的型号
    
22.      */
    
23.     if(EE_TYPE > AT24C16)
    
24.     {
    
25.         i2c_master_write_byte(cmd,
    
26.                                                           (AT_ADDR << 1) |
    
27.                                                            I2C_MASTER_WRITE,
    
28.             ACK_CHECK_EN);                                    /* 发送写命令 */
    
29.         i2c_master_write_byte(cmd, addr >> 8, ACK_CHECK_EN);         /* 发送高地址 */                           
    
30.     }
    
31.     else
    
32.     {
    
33.         i2c_master_write_byte(cmd,
    
34.                                                            0XA0 + ((addr / 256) << 1),
    
35. ACK_CHECK_EN);     /* 发送器件地址0XA0,写数据 */
    
36.     }
    
37.     i2c_master_write_byte(cmd, addr % 256, ACK_CHECK_EN); /* 发送低地址 */                              
    
38.     i2c_master_start(cmd);
    
39.     i2c_master_write_byte(cmd, (AT_ADDR << 1) | I2C_MASTER_READ, ACK_CHECK_EN);
    
40.     i2c_master_read_byte(cmd, &data, ACK_CHECK_EN);
    
41.     i2c_master_stop(cmd);
    
42.     i2c_master_cmd_begin(at24cxx_master.port, cmd, 1000);
    
43.     i2c_cmd_link_delete(cmd);
    
44.     vTaskDelay(10);
    
45. 
    
46.     return data;
    
47. }

复制代码

       这里的函数的实现跟前面第20.1小节24C02数据传输中的读时序一致，主机首先调用i2c_master_start()函数产生起始信号，然后调用i2c_master_write_byte()函数发送第1个字节数据设备写地址；收到应答信号后，继续发送第2个1字节数据内存地址addr；等待接收应答后，重新调用i2c_master_start()函数产生起始信号，这一次的设备方向改变了，调用i2c_master_write_byte()函数发送设备读地址，同时使用i2c_master_read_byte()去读取从从机发出来的数据。由于i2c_master_read_byte函数的参数是指针类型&data，所以在获取完1个字节的数据后，主机发送非应答信号，停止数据传输，最终调用i2c_master_stop()函数产生停止信号，返回由从机addr中读取到的数据。
       为了方便检测24Cxx芯片是否正常工作，在这里也定义了一个检测函数，代码如下：

1. /**
   
2. * @brief            检查AT24CXX是否正常
   
3. *   @note      检测原理: 在器件的末地址写如0X55, 然后再读取, 如果读取值为0X55
   
4. *              则表示检测正常. 否则,则表示检测失败.
   
5. * @param       无
   
6. * @retval      检测结果
   
7. *              0: 检测成功
   
8. *              1: 检测失败
   
9. */
   
10. uint8_t at24cxx_check(void)
    
11. {
    
12.     uint8_t temp;
    
13.     uint16_t addr = EE_TYPE;
    
14.     temp = at24cxx_read_one_byte(addr);                /* 避免每次开机都写AT24CXX */
    
15. 
    
16.     if (temp == 0X55)                                                   /* 读取数据正常 */
    
17.     {
    
18.         return 0;
    
19.     }
    
20.     else                                                                            /* 排除第一次初始化的情况 */
    
21.     {
    
22.         at24cxx_write_one_byte(addr, 0X55);        /* 先写入数据 */
    
23.         temp = at24cxx_read_one_byte(255);         /* 再读取数据 */
    
24. 
    
25.         if (temp == 0X55)
    
26.         {
    
27.             return 0;
    
28.         }
    
29. }
    
30. 
    
31.     return 1;
    
32. }

复制代码

       这里利用的是EEPROM芯片掉电不丢失的特性，在第一次写入了某个值之后，再去读一下是否写入成功，这种方式去检测芯片是否正常工作。
       此外方便多字节写入和读取，还定义了在指定地址读取指定个数的函数以及在指令地址写入指定个数的函数，代码如下：

1. /**
   
2. * @brief             在AT24CXX里面的指定地址开始读出指定个数的数据
   
3. * @param       addr    : 开始读出的地址 对24c02为0~255
   
4. * @param              pbuf    : 数据数组首地址
   
5. * @param              datalen : 要读出数据的个数
   
6. * @retval             无
   
7. */
   
8. void at24cxx_read(uint16_t addr, uint8_t *pbuf, uint16_t datalen)
   
9. {
   
10.     while (datalen--)
    
11.     {
    
12.         *pbuf++ = at24cxx_read_one_byte(addr++);
    
13.     }
    
14. }
    
15. 
    
16. /**
    
17. * @brief             在AT24CXX里面的指定地址开始写入指定个数的数据
    
18. * @param       addr    : 开始写入的地址 对24c02为0~255
    
19. * @param       pbuf    : 数据数组首地址
    
20. * @param       datalen : 要写入数据的个数
    
21. * @retval      无
    
22. */
    
23. void at24cxx_write(uint16_t addr, uint8_t *pbuf, uint16_t datalen)
    
24. {
    
25.     while (datalen--)
    
26.     {
    
27.         at24cxx_write_one_byte(addr, *pbuf);
    
28.         addr++;
    
29.         pbuf++;
    
30.     }
    
31. }

复制代码

       对于这两个函数都是调用前面的单字节操作函数去实现的，利用while循环，连续调用单字节操作函数去实现，这里就不多讲。

       20.3.4 CMakeLists.txt文件
       打开本实验BSP下的CMakeLists.txt文件，其内容如下所示：

1. set(src_dirs
   
2.             24CXX
   
3.             IIC
   
4.             LED
   
5.             XL9555)
   
6. 
   
7. set(include_dirs
   
8.             24CXX
   
9.             IIC
   
10.             LED
    
11.             XL9555)
    
12. 
    
13. set(requires
    
14.             driver)
    
15. 
    
16. idf_component_register(SRC_DIRS ${src_dirs} INCLUDE_DIRS ${include_dirs} REQUIRES ${requires})
    
17. 
    
18. component_compile_options(-ffast-math -O3 -Wno-error=format=-Wno-format)

复制代码

       上述的红色24CXX驱动需要由开发者自行添加，以确保24C02驱动能够顺利集成到构建系统中。这一步骤是必不可少的，它确保了24C02驱动的正确性和可用性，为后续的开发工作提供了坚实的基础。

       20.3.5 实验应用代码
       打开main/main.c文件，该文件定义了工程入口函数，名为app_main。该函数代码如下。

1. i2c_obj_t i2c0_master;
   
2. 
   
3. const uint8_t g_text_buf[] = {"ESP32-S3 EEPROM"};   /* 要写入到24c02的字符串数组 */
   
4. #define TEXT_SIZE   sizeof(g_text_buf)              /* TEXT字符串长度 */
   
5. 
   
6. /**
   
7. * @brief       显示实验信息
   
8. * @param       无
   
9. * @retval      无
   
10. */
    
11. void show_mesg(void)
    
12. {
    
13.     /* 串口输出实验信息 */
    
14.     printf("\n");
    
15.     printf("********************************\n");
    
16.     printf("ESP32\n");
    
17.     printf("IIC EEPROM TEST\n");
    
18.     printf("ATOM@ALIENTEK\n");
    
19.     printf("KEY0:Write Data, KEY1:Read Data\n");
    
20.     printf("********************************\n");
    
21.     printf("\n");
    
22. }
    
23. 
    
24. /**
    
25. * @brief       程序入口
    
26. * @param       无
    
27. * @retval      无
    
28. */
    
29. void app_main(void)
    
30. {
    
31.     uint16_t i = 0;
    
32.     uint8_t err = 0;
    
33.     uint8_t key;
    
34.     uint8_t datatemp[TEXT_SIZE];
    
35.     esp_err_t ret;
    
36.    
    
37.     ret = nvs_flash_init();                                        /* 初始化NVS */
    
38. 
    
39. if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
    
40.             ret == ESP_ERR_NVS_NEW_VERSION_FOUND)
    
41.     {
    
42.         ESP_ERROR_CHECK(nvs_flash_erase());
    
43.         ret = nvs_flash_init();
    
44.     }
    
45. 
    
46.     led_init();                                 /* 初始化LED */
    
47.     i2c0_master = iic_init(I2C_NUM_0);                /* 初始化IIC0 */
    
48.     xl9555_init(i2c0_master);                   /* IO扩展芯片初始化 */
    
49.     at24cxx_init(i2c0_master);                  /* 初始化24CXX */
    
50.     show_mesg();                                /* 显示实验信息 */
    
51.     err = at24cxx_check();                      /* 检测AT24C02 */
    
52.     if (err != 0)
    
53.     {
    
54.         while (1)                               /* 检测不到24c02 */
    
55.         {
    
56.             printf("24C02 check failed, please check!\n");
    
57.             vTaskDelay(500);
    
58.             LED_TOGGLE();                       /* LED闪烁 */
    
59.         }
    
60.     }
    
61.     printf("24C02 Ready!\n");
    
62.     printf("\n");
    
63.     while(1)
    
64.     {
    
65.         key = xl9555_key_scan(0);
    
66.         
    
67.         switch (key)
    
68.         {
    
69.             case KEY0_PRES:
    
70.             {
    
71.                 at24cxx_write(0, (uint8_t *)g_text_buf, TEXT_SIZE);
    
72.                 printf("The data written is:%s\n", g_text_buf);
    
73.                 break;
    
74.             }
    
75.             case KEY1_PRES:
    
76.             {
    
77.                 at24cxx_read(0, datatemp, TEXT_SIZE);
    
78.                 printf("The data read is:%s\n", datatemp);
    
79.                 break;
    
80.             }
    
81.             default:
    
82.             {
    
83.                 break;
    
84.             }
    
85.         }
    
86.         i++;
    
87. 
    
88.         if (i == 20)
    
89.         {
    
90.             LED_TOGGLE();               /* LED闪烁 */
    
91.             i = 0;
    
92.         }
    
93.         vTaskDelay(10);
    
94.     }
    
95. }

复制代码

       从本章实验的应用代码中可以看到，在初始化完EEPROM后，会检测与EEPROM的连接是否正常，若与EEPROM的连接正常，则会不断地等待按键输入，若检测到KEY0按键被按下，则会往EEPROM的指定地址中写入指定的数据，若检测到KEY1按键被按下，则会从EEPROM的指定地址中读取数据，并通过串口或者VSCode终端进行打印。

       20.4 下载验证
       在完成编译和烧录操作后，若MCU与EEPROM的连接无误，则可以在串口助手或者VSCode终端上看到“24C02 Ready!”的提示信息，此时可以按下KEY0按键往EEPROM的指定地址写入指定数据，然后再按下KEY1按键从EEPROM的指定地址将写入的数据读回来在串口助手或者VSCode终端上进行显示，此时便可以看到在串口助手或者VSCode终端上显示了“ESP32-S3 EEPROM”的提示信息，该提示信息就是从EEPROM中读回的数据。

图20.4.1 串口助手显示实验信息