外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  在我们的应用开发过程中,经常会使用到外部的EEPROM外部存储器来保存一些参数和配置数据等。而比较常用的就是AT24Cxx系列产品,这一节我们来开发用于操作AT24Cxx系列产品的驱动。

1、功能概述

  AT24Cxx系列EEPROM包括从1Kbit到2Mbit的各种容量。AT24Cxx系列产品采用I2C总线数据传送协议。尽管容量跨度很大,但它们都拥有相同的封装和引脚排布,具体的引脚分配如下:

 外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  由于A0、A1和A2可以组成000~111八种情况,即通过器件地址输入端A0、A1和A2可以实现将最多8个器件连接到同一条总线上,通过不同的配置进行器件的选择。

  对于AT24Cxx系列EEPROM不同的容量对地址的分配有较大差异,这涉及到设备地址和寄存器地址。从1K容量到2M容量寄存器地址分别采用7到18位来表示。16K及以下容量的EEPROM采用一个字节的寄存器地址配合设备地址段实现7到11位的寄存器地址寻址。而32k及以上的EEPROM采用两个字节的寄存器地址配合设备地址段实现12到18位的寄存器地址寻址。具体的地址分配如下: 外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  从上表我们很容易明白,设备地址的低3位的定义决定了在同一条I2C总线上,最多可以挂载多少个AT24Cxx设备。有3位用于设备地址则最多可挂载8个设备;有2位用于设备地址则最多可挂载4个设备;有1位用于设备地址则最多可挂载2个设备;有0位用于设备地址则最多可挂载1个设备。需要注意的是,不同定义的位的设备混用于同一总线时,相同的定义位必须一样,否则用作寄存器地址的位可能让总线上的总线无法识别。

  在一些AT24Cxx系列EEPROM型号中,带有序列号的专用存储单元。这些存储单元不占用存储器的存储单元。序列号为128位,读取序列号的设备地址以0xB0开头,以区别于EEPROM存储区域的读取。

  在一些AT24Cxx系列EEPROM型号中,除了带有序列号的专用存储单元外,还有带有48位或者64位的MAC地址,固定在专用的存储单元。这些单元不占用存储器的存储单元。读取序列号和读取MAC地址采用同样的设备地址,均以0xB0开头。有一些型号该区域并未用于MAC定制可用于用户操作。

  需要注意的是有些型号的AT24Cxx系列EEPROM存储器的设备地址是固化的,需通过型号的后缀标识来识别。

2、驱动设计与实现

       我们已经了解了AT24Cxx存储器的基本功能及读写方式,接下来我们将开发操作AT24Cxx系列EEPROM存储器的驱动程序。

2.1、对象定义

  在使用一个对象之前我们需要获得一个对象。同样的我们想要AT24Cxx系列EEPROM存储器就需要先定义AT24Cxx系列EEPROM存储器的对象。

2.1.1、对象的抽象

  我们要得到AT24Cxx系列EEPROM存储器对象,需要先分析其基本特性。一般来说,一个对象至少包含两方面的特性:属性与操作。接下来我们就来从这两个方面思考一下AT24Cxx系列EEPROM存储器的对象。

  先来考虑属性,作为属性肯定是用于标识或记录对象特征的东西。我们来考虑AT24Cxx系列EEPROM存储器对象属性。首先AT24Cxx系列EEPROM存储器采用的是I2C接口,对于每一个I2C接口元件都有一个设备地址用于区别总线上的设备,所以我们将I2C设备地址作为对象的属性用以区别总线设备。AT24Cxx系列EEPROM存储器存在多个型号对应不同的容量和特性,所以我们将其型号设置为对象的属性以区别对象的类型。前面我们也说过,不同容量的AT24Cxx系列EEPROM存储器由于寻址空间不同,所以寄存器地址长度也是不同的,所以我们将其地址长度作为属性以区分处理。

  接着我们还需要考虑AT24Cxx系列EEPROM存储器对象的操作问题。我们需要对AT24Cxx系列EEPROM存储器进行数据读写操作,无论读写其实都依赖于对I2C接口的操作,而这些操作基本都会依赖于具体的硬件平台,所以我们将读写操作作为对象的操作。

  根据上述我们对AT24Cxx系列EEPROM存储器的分析,我们可以定义AT24Cxx系列EEPROM存储器的对象类型如下:

1 typedef struct At24cObject {
2        uint8_t devAddress;          //设备地址
3        At24cModeType mode;           //设备类型
4        At24cMemAddLengthType memAddLength;           //寄存器地址长度
5        void (*Read)(struct At24cObject *at,uint16_t regAddress,uint8_t *rData,uint16_t rSize);       //读数据操作指针
6        void (*Write)(struct At24cObject *at,uint16_t regAddress,uint8_t *wData,uint16_t wSize);    //写数据操作指针
7        void (*Delayms)(volatile uint32_t nTime);       //毫秒延时操作指针
8 }At24cObjectType;

2.1.2、对象初始化

  我们知道,一个对象仅作声明是不能使用的,我们需要先对其进行初始化,所以这里我们来考虑AT24Cxx系列EEPROM存储器对象的初始化函数。一般来说,初始化函数需要处理几个方面的问题。一是检查输入参数是否合理;二是为对象的属性赋初值;三是对对象作必要的初始化配置。据此我们设计AT24Cxx系列EEPROM存储器对象的初始化函数如下:

 1 /* 初始化AT24CXX对象 */
 2 void At24cxxInitialization(At24cObjectType *at,    //AT24CXX对象实体
 3                            uint8_t devAddress,   //AT24CXX设备地址
 4                            At24cModeType mode,    //AT24CXX对象类型
 5                            At24cMemAddLengthType length,      //寄存器地址长度
 6                            At24cRead read,        //读AT24CXX对象操作指针
 7                            At24cWrite write,      //写AT24CXX对象操作指针
 8                            At24cDelayms delayms           //延时操作指针
 9                             )
10 {
11        if((at==NULL)||(read==NULL)||(write==NULL)||(delayms==NULL))
12        {
13               return;
14        }
15 
16        if((devAddress&0xF0)==0xA0)
17        {
18               at->devAddress=devAddress;
19        }
20        else
21        {
22               at->devAddress=0x00;
23        }
24       
25        at->mode=mode;
26        at->memAddLength=length;
27       
28        at->Read=read;
29        at->Write=write;
30        at->Delayms=delayms;
31 }

2.2、对象操作

  我们已经完成了AT24Cxx系列EEPROM存储器对象类型的定义和对象初始化函数的设计。但我们的主要目标是获取对象的信息,接下来我们还要实现面向AT24Cxx系列EEPROM存储器的各类操作。

2.2.1、写单个字节

       AT24Cxx系列EEPROM存储器支持单字节写数据,收到正确的设备地址和字地址字节后,EEPROM将发送一个确认。然后设备将准备接收8位数据字。在接收到8位数据字之后,EEPROM将返回一个ACK。然后,寻址设备(如总线主机)必须使用停止条件终止写操作。此时,EEPROM将进入一个内部自动定时的写周期,这个写周期将在一定时间内完成,而数据字将被编程到非易失性EEPROM中。在这个写周期中,所有的输入都是禁用的,EEPROM在写完成之前不会响应。

       如果AT24Cxx对象是一个使用7位到11位地址表示寄存器地址的话,其数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  如果AT24Cxx对象是一个使用12位到18位地址表示寄存器地址的话,其数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  根据上述时序图,我们可以编写AT24Cxx系列EEPROM存储器写单个字节数据程序如下:

 1 /*向AT24CXX写入单个字节*/
 2 void WriteByteToAT24CXX(At24cObjectType *at,uint32_t regAddress,uint8_t data)
 3 {
 4        uint8_t temp;
 5        uint16_t regAdd;
 6       
 7        if(at->memAddLength==AT24C8BitMemAdd)
 8        {
 9               regAdd=(uint16_t)(regAddress&0xFF);
10               temp=(uint8_t)(regAddress>>8);
11        }
12        else
13        {
14               regAdd=(uint16_t)regAddress;
15               temp=(uint8_t)(regAddress>>16);
16        }
17        temp=(temp&(~(devAddMask[at->mode]>>1)))<<1;
18        at->devAddress=(at->devAddress & devAddMask[at->mode])|temp;
19  
20        at->Write(at,regAdd,&data,1);
21 }

2.2.2、写多个字节

  AT24Cxx系列EEPROM存储器支持多字节的写操作,但对于AT24Cxx对象来说最多只支持写到发送地址所在的页尾,所以资料中也称其为页写。而对于不同型号的AT24Cxx系列EEPROM存储器每页所包含的字节数是不一样的,从8个字节到256个字节不等,我们需要注意写入的字节数。

  整页写的初始化方式与单字节写的初始化方式相同,但是总线主机在第一个数据字被锁定后不会发送停止条件。相反,在EEPROM承认接收到第一个数据字之后,总线主机可以传输最多到所在页结尾的数据字。EEPROM将在接收到每个数据字后返回一个ACK。一旦所有要写的数据都被发送到设备,总线主机必须发出一个停止条件此时内部的自计时写周期将开始。字地址的下四位在接收到每个数据字后进行内部递增,高阶位地址位元不会增加。整页写操作仅限于在单个物理页中写入字节,而不管实际写入的字节数。当增加的字地址到达页面边界时,地址计数器将滚动到同一页面的开头。这是必须要注意的,一旦继续写数据可能会将页面中先前加载的数据无意中更改。

  如果AT24Cxx对象是一个使用7位到11位地址表示寄存器地址的话,其写多个字节的数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  如果AT24Cxx对象是一个使用12位到18位地址表示寄存器地址的话,其写多个字节的数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  根据上述时序图,我们可以编写AT24Cxx系列EEPROM存储器写多个字节数据程序如下:

 1 /*向AT24CXX写入多个字节,从指定地址最多到所在页的结尾*/
 2 void WriteBytesToAT24CXX(At24cObjectType *at,uint32_t regAddress,uint8_t *wData,uint16_t wSize)
 3 {
 4        uint16_t regAdd;
 5        uint8_t size;
 6        uint8_t temp;
 7       
 8        if(at->memAddLength==AT24C8BitMemAdd)
 9        {
10               regAdd=(uint16_t)(regAddress&0xFF);
11               temp=(uint8_t)(regAddress>>8);
12        }
13        else
14        {
15               regAdd=(uint16_t)regAddress;
16               temp=(uint8_t)(regAddress>>16);
17        }
18        temp=(temp&(~(devAddMask[at->mode]>>1)))<<1;
19        at->devAddress=(at->devAddress & devAddMask[at->mode])|temp;
20       
21        if((wSize<=pageBytes[at->mode])&&(wSize<=(pageBytes[at->mode]-(regAddress&regAddMask[at->mode]))))
22        {
23               size=wSize;
24        }
25        else
26        {
27               size=pageBytes[at->mode]-(regAddress&regAddMask[at->mode]);
28        }
29  
30        at->Write(at,regAdd,wData,size);
31 }

2.2.3、读单个字节

  AT24Cxx系列EEPROM存储器支持单字节的读操作。这一方式其实有两种模式,读当前位置和读随机位置。其实读当前位置是读随机位置特例,我们考虑一般性则只考虑随机读取就可以了。随机读的开始方式与字节写操作加载新数据字地址的方式相同。这就是所谓的“伪写”序列;但是,必须省略数据字节和字节写的停止条件,以防止该部分进入内部写循环。一旦设备地址和字地址被锁定并被EEPROM确认,总线主机必须生成另一个启动条件。总线主机现在通过发送一个启动条件来初始化一个读取的当前地址,接着是一个有效的设备地址字节,其R/W位设置为逻辑“1”。之后EEPROM将对设备地址进行ACK处理,并在SDA线路上连续地输出数据字。如果总线主机在第9个时钟周期内没有响应ACK,则所有类型的读操作都将终止。在NACK响应之后,主进程可以发送一个停止条件来完成协议。

  如果AT24Cxx对象是一个使用7位到11位地址表示寄存器地址的话,其读单个字节的数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  如果AT24Cxx对象是一个使用12位到18位地址表示寄存器地址的话,其读单个字节的数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  根据上述时序图,我们可以编写AT24Cxx系列EEPROM存储器随机读取一个字节数据程序如下:

 1 /*从AT24CXX读取单个字节,从随机地址读取*/
 2 uint8_t ReadByteFromAT24CXX(At24cObjectType *at,uint32_t regAddress)
 3 {
 4        uint8_t rData;
 5        uint16_t regAdd;
 6        uint8_t temp;
 7  
 8        if(at->memAddLength==AT24C8BitMemAdd)
 9        {
10               regAdd=(uint16_t)(regAddress&0xFF);
11               temp=(uint8_t)(regAddress>>8);
12        }
13        else
14        {
15               regAdd=(uint16_t)regAddress;
16               temp=(uint8_t)(regAddress>>16);
17        }
18        temp=(temp&(~(devAddMask[at->mode]>>1)))<<1;
19        at->devAddress=(at->devAddress & devAddMask[at->mode])|temp;
20  
21        at->Read(at,regAdd,&rData,1);
22  
23        return rData;
24 }

2.2.4、读多个字节

  AT24Cxx系列EEPROM存储器支持多字节的读操作,类似于单字节读取,可以从当前位置开始读也可以从指定地址开始读。多字节读取也称为顺序读取由当前地址读取或随机读取启动。总线主接收到一个数据字后,它以ACK应答。只要EEPROM接收到ACK,它就会继续增加字地址,并连续地计时输出连续的数据字。当达到最大内存地址时,数据字地址将滚动,顺序读取将从内存数组的开头开始。如果总线主机在第9个时钟周期内没有响应ACK,则所有类型的读操作都将终止。在NACK响应之后,主进程可以发送一个停止条件来完成协议。

  如果AT24Cxx对象是一个使用7位到11位地址表示寄存器地址的话,其读多个字节的数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  如果AT24Cxx对象是一个使用12位到18位地址表示寄存器地址的话,其读多个字节的数据格式如下图所示:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

  根据上述时序图,我们可以编写AT24Cxx系列EEPROM存储器顺序读取多个字节数据程序如下:

 1 /*从AT24CXX读取多个字节,从指定地址最多到所在页的结尾*/
 2 void ReadBytesFromAT24CXX(At24cObjectType *at,uint32_t regAddress,uint8_t *rData,uint16_t rSize)
 3 {
 4        uint16_t regAdd;
 5        uint16_t size;
 6        uint8_t temp;
 7       
 8        if(at->memAddLength==AT24C8BitMemAdd)
 9        {
10               regAdd=(uint16_t)(regAddress&0xFF);
11               temp=(uint8_t)(regAddress>>8);
12        }
13        else
14        {
15               regAdd=(uint16_t)regAddress;
16               temp=(uint8_t)(regAddress>>16);
17        }
18        temp=(temp&(~(devAddMask[at->mode]>>1)))<<1;
19        at->devAddress=(at->devAddress & devAddMask[at->mode])|temp;
20       
21        if((rSize<=pageBytes[at->mode])&&(rSize<=(pageBytes[at->mode]-(regAddress&regAddMask[at->mode]))))
22        {
23               size=rSize;
24        }
25        else
26        {
27               size=pageBytes[at->mode]-(regAddress&regAddMask[at->mode]);
28        }
29  
30        at->Read(at,regAdd,rData,size);
31 }

3、驱动的使用

  在上一节我们设计并实现了AT24Cxx系列EEPROM存储器的驱动程序,而这一节我们将设计一个简单的应用来验证这一驱动程序。

3.1、声明并初始化对象

  使用基于对象的操作我们需要先得到这个对象,所以我们先要使用前面定义的AT24Cxx系列EEPROM存储器对象类型声明一个AT24Cxx系列EEPROM存储器对象变量,具体操作格式如下:

  At24cObjectType at24c;

  声明了这个对象变量并不能立即使用,我们还需要使用驱动中定义的初始化函数对这个变量进行初始化。这个初始化函数所需要的输入参数如下:

  At24cObjectType *at,AT24CXX对象实体

  uint8_t devAddress,AT24CXX设备地址

  At24cModeType mode,AT24CXX对象类型

  At24cMemAddLengthType length,寄存器地址长度

  At24cRead read,读AT24CXX对象操作指针

  At24cWrite write,写AT24CXX对象操作指针

  At24cDelayms delayms,延时操作指针

  对于这些参数,对象变量我们已经定义了。对象类型与寄存器地址长度为枚举,根据实际情况选择就好了。设备地址根据我们的实际使用情况设置就可以了。主要的是我们需要定义几个函数,并将函数指针作为参数。这几个函数的类型如下:

1 /* 定义读数据操作函数指针类型 */
2 typedef void (*At24cRead)(struct At24cObject *at,uint16_t regAddress,uint8_t *rData,uint16_t rSize);      
3 
4 /* 定义写数据操作函数指针类型 */
5 typedef void (*At24cWrite)(struct At24cObject *at,uint16_t regAddress,uint8_t *wData,uint16_t wSize);   
6 
7 /* 定义延时操作函数指针类型 */
8 typedef void (*At24cDelayms)(volatile uint32_t nTime);

  对于这几个函数我们根据样式定义就可以了,具体的操作可能与使用的硬件平台有关系。片选操作函数用于多设备需要软件操作时,如采用硬件片选可以传入NULL即可。具体函数定义如下:

 1 /*读AT24C寄存器值*/
 2 static void ReadDataFromAT24C(At24cObjectType *at24c,uint16_t regAddress,uint8_t *rData,uint16_t rSize)
 3 {
 4        uint16_t cSize;
 5        uint8_t cmd[2];
 6       
 7        if(at24c->memAddLength==AT24C8BitMemAdd)
 8        {
 9               cSize=1;
10               cmd[0]=(uint8_t)regAddress;
11        }
12        else
13        {
14               cSize=2;
15               cmd[0]=(uint8_t)(regAddress>>8);
16               cmd[1]=(uint8_t)regAddress;
17        }
18       
19        HAL_I2C_Master_Transmit(&at24chi2c,at24c->devAddress,cmd,cSize,1000);
20  
21        HAL_I2C_Master_Receive(&at24chi2c,at24c->devAddress+1,rData, rSize, 1000);
22 }
23  
24 /*写AT24C寄存器值*/
25 static void WriteDataToAT24C(At24cObjectType *at24c,uint16_t regAddress,uint8_t *wData,uint16_t wSize)
26 {
27        uint8_t tData[wSize+2];
28        uint16_t tSize;
29       
30        if(at24c->memAddLength==AT24C8BitMemAdd)
31        {
32               tSize=wSize+1;
33               tData[0]=(uint8_t)regAddress;
34        }
35        else
36        {
37               tSize=wSize+2;
38               tData[0]=(uint8_t)(regAddress>>8);
39               tData[1]=(uint8_t)regAddress;
40        }
41       
42        for(int i=0;i<wSize;i++)
43        {
44               tData[i+2]=wData[i];
45        }
46  
47        HAL_I2C_Master_Transmit(&at24chi2c,at24c->devAddress,wData,wSize,1000);
48 }

  对于延时函数我们可以采用各种方法实现。我们采用的STM32平台和HAL库则可以直接使用HAL_Delay()函数。于是我们可以调用初始化函数如下:

1 At24cxxInitialization(&at24c,       //AT24CXX对象实体
2                               0xAE,           //AT24CXX设备地址
3                               AT24C01C,        //AT24CXX对象类型
4                               AT24C8BitMemAdd,       //寄存器地址长度
5                               ReadDataFromAT24C,    //读AT24CXX对象操作指针
6                               WriteDataToAT24C, //写AT24CXX对象操作指针
7                               HAL_Delay //延时操作指针
8                             );

3.2、基于对象进行操作

  我们定义了对象变量并使用初始化函数给其作了初始化。接着我们就来考虑操作这一对象获取我们想要的数据。我们在驱动中已经将获取数据并转换为转换值的比例值,接下来我们使用这一驱动开发我们的应用实例。

 1 /*AT24XXX数据操作*/
 2 void AT24CReadWriteData(void)
 3 {
 4        uint16_t regAddress=0x02;
 5        uint8_t readByte;
 6        uint8_t writeByte=0x0A;
 7        uint8_t rData[2];
 8        uint16_t rSize=2;
 9        uint8_t wData[]={0x5A,0xA5};
10        uint16_t wSize=2;
11       
12        /*从AT24CXX读取单个字节,从随机地址读取*/
13        readByte=ReadByteFromAT24CXX(&at24c,regAddress);
14  
15        /*向AT24CXX写入单个字节*/
16        WriteByteToAT24CXX(&at24c,regAddress,writeByte);
17  
18        /*从AT24CXX读取多个字节,从指定地址最多到所在页的结尾*/
19        ReadBytesFromAT24CXX(&at24c,regAddress,rData,rSize);
20  
21        /*向AT24CXX写入多个字节,从指定地址最多到所在页的结尾*/
22        WriteBytesToAT24CXX(&at24c,regAddress,wData,wSize);
23 }

4、应用总结

  这一篇中,我们设计了AT24Cxx系列EEPROM存储器的读写驱动,而且设计了一个简单的应用验证了驱动程序,读写操作都能按预期要求完成,而且操作也很稳定。

       在使用驱动时我们需要注意,因为不同容量的AT24Cxx系列EEPROM存储器的每一页的字节数数不一样的。在多字节读写时,最多支持到所在页尾。到页尾后,EEPROM存储器的内部指针将回到页首,此时执行读则得到的是错误数据,若执行写则会覆盖原有数据造成错误。所以在程序中若读写的范围超越了一页的范围将会被舍弃。

       在使用驱动时还需注意,因为不同容量的AT24Cxx系列EEPROM存储器的寻址范围是不一样的,所以用于表示寄存器地址的寄存器地址位数有1个字节和2个字节的差别,为了便于区分需要在对AT24Cxx系列EEPROM存储器对象进行初始化时指定。

  源码下载:https://github.com/foxclever/ExPeriphDriver

欢迎关注:

外设驱动库开发笔记23:AT24Cxx外部存储器驱动

上一篇:基于GD32F30x单片机_读写外部FLASH(GD25Q256DF)驱动程序


下一篇:支持鸿蒙OS的产品级SSD1306 OLED屏驱动库(MIT许可证开源)