[嵌入式]STM32F429入门（二十）：IIC通讯协议（硬件）

一、I2C协议

I2C 通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件 实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。

（一）I2C物理层的特点：

?

电阻一般选择4.7k。

它的物理层有如下特点：

(1) 它是一个支持多设备的总线。“总线”指多个设备共用的信号线。在一个 I2C 通讯总 线中，可连接多个 I2C 通讯设备，支持多个通讯主机及多个通讯从机。

(2) 一个 I2C 总线只使用两条总线线路，一条双向串行数据线(SDA) ，一条串行时钟线 (SCL)。数据线即用来表示数据，时钟线用于数据收发同步。

(3) 每个连接到总线的设备都有一个独立的地址，主机可以利用这个地址进行不同设备之间的访问。

(4) 总线通过上拉电阻接到电源。当 I2C 设备空闲时，会输出高阻态，而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。（线与特性）如果这个时候有个设备输出低电平，那其他设备不可能会输出高电平，可以呈现高阻态的形式（即断开）。

(5) 多个主机同时使用总线时，为了防止数据冲突，会利用仲裁方式决定由哪个设备占用 总线。（0V）

(6) 具有三种传输模式：标准模式传输速率为 100kbit/s ，快速模式为 400kbit/s ，高速模式 下可达 3.4Mbit/s，但目前大多 I 2C 设备尚不支持高速模式。一般采用低速模式。

(7) 连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制 。（防止受到干扰）

（二）IIC的协议层

IIC的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。

1. IIC基本读写过程：

   主机写数据到从机：

阴影部分为：数据由主机传输至从机。

非阴影部分为：数据由从机传输至主机。（方向由读写位控制）

起始信号产生后，所有从机就开始等待主机紧接下来广播 的从机地址信号 (SLAVE_ADDRESS)。在 I2C 总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。 根据 I2C 协议，这个从机地址可以是 7 位或 10 位。 在地址位之后，是传输方向的选择位，该位为 0 时，表示后面的数据传输方向是由主 机传输至从机，即主机向从机写数据。该位为 1 时，则相反，即主机由从机读数据。 从机接收到匹配的地址后，主机或从机会返回一个应答(ACK)或非应答(NACK)信号， 只有接收到应答信号后，主机才能继续发送或接收数据。

广播完地址，接收到应 答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8 位，主机每发送完一 个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据， 这个 N 没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。

S：传输开始信号。

SLAVE_ADDRESS:从机地址。（相当于点名）

A/A：应答（ACK）或非应答（NACK）信号

主机由从机中读数据：

广播完地址，接收到应 答信号后，从机开始向主机返回数据(DATA)，数据包大小也为 8 位，从机每发送完一个数 据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回 N 个数据，这个 N 也没有 大小限制。当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自 动停止数据传输。

通讯复合模式：

?

除了基本的读写，I2C 通讯更常用的是复合格式，该传输过程有 两次起始信号(S)。一般在第一次传输中，主机通过 SLAVE_ADDRESS 寻找到从设备后， 发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它 与 SLAVE_ADDRESS 的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是 说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。而前面所讲的SLAVE_ADDRESS是区分设备的地址。而这个地址是已经区分好设备后，写入设备里面的内存地址。

2. 通讯的起始和停止信号

?

• 当SCL线是高电平时SDA线从高电平向低电平切换——通讯的起始。

• 当SCL线是高电平时SDA线从低电平向高电平切换——通讯的停止。

• 起始和停止信号一般由主机产生。

3.数据有效性

IIC使用SDA信号线来传输数据，使用SCL信号线进行数据同步，SDA数据写在SCL的每个时钟周期传输一位数据。

?

• SCL为高电平的时候SDA表示的数据有效，即此时的SDA为高电平时表示数据1，为低电平表示数据0

• SCL为低电平时，SDA的数据无效，一般在这个时候SDA进行电平切换，为下一次表示数据做好准备。

• 每次数据传输都以字节为单位，每次传输的字节数不受限制。

?4.地址及数据方向

• IIC总线上的每个设备上都有自己的独立地址，主机发起通讯时，通过SDA信号线发送设备地址（SLAVE_ADDRESS）来查找从机。设备地址可以是7位或10位。

• 紧跟设备地址的一个数据位R/W用来表示数据传输方向，数据方向位位1时表示主机由从机读取数据，该位为0时表示主机向从机写数据。

• 读数据方向时，主机会释放对SDA 信号线的控制，由从机控制 SDA 信号线，主机接 收信号，写数据方向时，SDA 由主机控制，从机接收信号。（发送端具有SDA线的控制权）

通常我们都使用7位来存储地址，有些IIC可以使用10位，当我们使用7位时，我们会将最后一位方向位并入其中，形成8位读地址或者是8位写地址。

5.??响应

?

• I2C 的数据和地址传输都带响应。响应包括“应答(ACK)”和“非应答(NACK)”两种 信号。作为数据接收端时，当设备(无论主从机)接收到 I2C 传输的一个字节数据或地址后， 若希望对方继续发送数据，则需要向对方发送“应答(ACK)”信号，发送方会继续发送下 一个数据；若接收端希望结束数据传输，则向对方发送“非应答(NACK)”信号，发送方接 收到该信号后会产生一个停止信号，结束信号传输。

• 传输时主机产生时钟，在第 9 个时钟时，数据发送端会释放 SDA 的控制权，由数据接 收端控制 SDA，若 SDA 为高电平，表示非应答信号(NACK)，低电平表示应答信号(ACK)。

（三）STM32的IIC特性及架构

• 软件IIC：使用CPU直接控制通讯引脚的电平，产生出符合通讯协议标准的逻辑。

• 硬件IIC：由STM32的IIC片上外设专门负责实现IIC通讯协议，只要配置好该外设，它就会自动根据协议要求产生通讯信号，收发数据并缓存起来，CPU只要检测该外设的状态和访问数据寄存器，就能完成数据的收发。这种由硬件外设处理IIC协议的方式减轻了CPU的工作，且使软件设计更加简单。

• STM32的IIC外设可用作通讯的主机及从机，支持100Kbit/s和400Kbit/s的速率，支持7位、10位设备地址，支持DMA数据传输，并具有数据校验功能。

架构剖析：

1为通讯引脚；2为时钟控制逻辑；3为数据控制逻辑；4为整体控制逻辑。

（1）通讯引脚

（2）时钟控制逻辑

SCL线的时钟信号，由IIC接口根据时钟控制器（CCR）控制，控制的参数主要为时钟频率。

• 选择IIC通讯的“标准/快速”模式，这两个模式分别为IIC对应100Kbit/s或400Kbit/s的通讯速率。

• 在快速模式下可选择SCL时钟的占空比，可选用Tlow/Thigh=2或Tlow/Thigh=16/9模式。所说的Tlow就是低电平所占的周期，Thigh就是高电平所占的周期。

• CCR寄存器中12位的配置因子CCR，它与IIC外设的输入时钟源共同作用，产生SCL时钟。STM32的IIC外设输入时钟源为PCLK1。

计算时钟频率的公式如下：

标准模式： Thigh=CCR * TPCKL1 Tlow = CCR*TPCLK1

快速模式中Tlow/Thigh=2时： Thigh = CCR * TPCKL1 Tlow = 2 * CCR * TPCKL1

快速模式中Tlow/Thigh=16/9时： Thigh = 9 * CCR * TPCKL1 Tlow = 16* CCR*TPCKL1

例如，PCLK1=45MHz，想要配置400Kbit/s的速率，计算方式如下：

PCLK时钟周期： TPCLK1 = 1/45000000

目标SCL时钟周期： TSCL = 1/400000

SCL时钟周期内的高电平时间： THIGH = TSCL/3

SCL时钟周期内的低电平时间： TLOW = 2*TSCL/3

计算CCR的值： CCR = THIGH/TPCLK1 = 37.5

计算结果为小数，而CCR寄存器是无法配置小数参数的，所以我们只能把CCR 取值为38，这样I2C的SCL实际频率无法达到400KHz (约为394736Hz)。

（3）数据控制逻辑

IIC的SDA信号主要连接到数据移位寄存器上，数据移位寄存器的数据来源及目标是数据寄存器(DR)、地址寄存器（OAR）、PEC寄存器（校验）以及SDA数据线。

• 当向外发送数据的时候，数据移位寄存器以“数据寄存器”为数据源，把数据一位一位地通过SDA信号线发送出去。

• 当从外部接收数据时，数据移位寄存器就把SDA信号线采样到的数据一位一位地存储到“数据寄存器”中。

• 若使能了数据校验，接收到的数据会经过 PCE 计算器运算，运算结果存储在“PEC 寄存器”中。

• 当 STM32 的 I2C 工作在从机模式的时候，接收到设备地址信号时，数据移位寄存器会把接收到的地址与 STM32 的自身的“I2C 地址寄存器”的值作比较，以便响应主机的寻址。

• STM32 的自身 I2C 地址可通过修改“自身地址寄存器”修改，支持同时使用两个 I2C 设备地址，两个地址分别存储在 OAR1 和 OAR2 中。

（4）整体逻辑控制

整体控制逻辑负责协调整个IIC外设，控制逻辑的工作模式根据我们配置地“控制寄存器（CR1/CR2）”的参数而改变。在外设工作时，控制逻辑会根据外设的工作状态修改状态寄存器（SR1/SR2），我们只要读取这些寄存器相关的寄存器位，就可以了解IIC的工作状态。控制逻辑还会根据要求，负责控制产生IIC中断信号、DMA请求及各种IIC的通讯信号（起始、停止、响应信号等）。

?

（四）STM32的IIC通讯过程

使用IIC外设通讯时，在通讯的不同阶段它会对“状态寄存器（SR1及SR2）”的不同数据位写入参数，通过读取这些寄存器标志来了解通讯状态。

1. 主机发送器

?先生成起始位：

?之后会产生EV5这一事件，在寄存器I2C_SR1可看到，检测SB位是否为1：

?之后，就开始发送地址，也就是我们前面所说的8位写地址，紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件”EV6“及”EV8“，这时SR1寄存器的”ADDR“位及”TXE“位被置1，ADDR为1表示地址已经发送，TXE为1表示寄存器为空。

?

以上步骤正常执行并对ADDR位清零后，我们往IIC的”数据寄存器DR“写入要发送的数据，这时TXE位会被重置0，表示数据寄存器非空，IIC外设通过SDA信号线一位位把数据发送出去后，又会产生”EV8“事件，即TXE位被置1，重复这个过程，就可以发送多个字节数据了；最后产生一个停止信号P，这个时候会产生EV2事件，SR1的TXE位及BTF位都被置1，表示通讯结束。

2. 主接收器

主接收器接收流程及事件说明如下：

(1) 同主发送流程，起始信号(S)是由主机端产生的，控制发生起始信号后，它产生事 件“EV5”，并会对 SR1 寄存器的“SB”位置 1，表示起始信号已经发送；

(2) 紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”这时 SR1 寄存器的“ADDR”位被置 1，表示地址已经发送。

(3) 从机端接收到地址后，开始向主机端发送数据。当主机接收到这些数据后，会产 生“EV7”事件，SR1 寄存器的 RXNE 被置 1，表示接收数据寄存器非空，我们 读取该寄存器后，可对数据寄存器清空，以便接收下一次数据。此时我们可以控 制 I2C 发送应答信号(ACK)或非应答信号(NACK)，若应答，则重复以上步骤接收数据，若非应答，则停止传输；

(4) 发送非应答信号后，产生停止信号(P)，结束传输。

（五）IIC初始化结构体

typedef struct {
	 uint32_t I2C_ClockSpeed; 	//设置 SCL 时钟频率，此值要低于40y0000
	 uint16_t I2C_Mode; 		//指定工作模式，可选 I2C 模式及 SMBUS 模式 
	 uint16_t I2C_DutyCycle;	//指定时钟占空比，可选 low/high = 2:1 及 16:9 模式
	 uint16_t I2C_OwnAddress1;  //指定自身的 I2C 设备地址 
	 uint16_t I2C_Ack; 			//使能或关闭响应(一般都要使能) 
	 uint16_t I2C_AcknowledgedAddress; //指定地址的长度，可为 7 位及 10 位 
} I2C_InitTypeDef;

• I2C_ClockSpeed：设置IIC的传输速率，函数会根据输入的数值经过运算后把时钟因子写入到IIC的时钟控制寄存器CCR。

• I2C_Mode ：选择 I 2C 的使用方式，有 I2C 模式(I2C_Mode_I2C )和 SMBus 主、从模式 (I2C_Mode_SMBusHost、 I2C_Mode_SMBusDevice ) 。I2C 不需要在此处区分主从模式，直接设置 I2C_Mode_I2C 即可。

• I2C_DutyCycle：设置IIC的SCL线时钟占空比。

• I2C_OwnADDress1：配置的是设备自己的地址。每个连接到 I2C 总线上的设备都要有 一个自己的地址，作为主机也不例外。地址可设置为 7 位或 10 位(受下面 I2C_AcknowledgeAddress 成员决定)，只要该地址是 I2C 总线上唯一的即可。STM32 的 I2C 外设可同时使用两个地址，即同时对两个地址作出响应，这个结构成员 I2C_OwnAddress1 配置的是默认的、OAR1 寄存器存储的地址，若需要设置第二个地址寄 存器 OAR2，可使用 I2C_OwnAddress2Config 函数来配置，OAR2 不支持 10 位地址。

• I2C_Ack_Enable：设置为使能可以发送响应信号，应答与非应答，改为非应答往往会导致通讯错误。

• I2C_AcknowledgeAddress：本成员选择 I2C 的寻址模式是 7 位还是 10 位地址。这需要根据实际连接到 I2C 总线上 设备的地址进行选择，这个成员的配置也影响到 I2C_OwnAddress1 成员，只有这里设置成 10 位模式时，I2C_OwnAddress1 才支持 10 位地址。

（六）读写EEPROM实验

（1）首先，我们来熟悉板子上的EEPROM：

?

?由图可以看出，该芯片为AT24C02，它的设备地址是固定的，高四位固定为1010，而后三位为A2\A1\A0，由于三个引脚都接地，则1010000为该设备的设备地址。以上由AT24C02规格书得知。而我们也可以通过修改A2/A1/A0的值去区分多个EEPROM。

?

EEPROM中的读写方式跟STM32有些区别 ，它每次写入一个数据后，必须重新发送一次地址才可以继续写下去：

?所以我们使用下面这种方式，我们只需要确定起始地址跟起始数据，之后的数据它都会按顺序的填下去：

?接下来是读，先写后读，先确定数据的位置，再进行传输，传输一次需要发三个字节，这会消耗很多的时间。下面的图比较节省时间，取决于用户是否继续响应。

EEPROM 芯片中还有一个 WP 引脚，具有写保护功能，当该引脚电平为高时，禁止写 入数据，当引脚为低电平时，可写入数据，我们直接接地，不使用写保护功能。

（2）软件设计

1. 设置引脚

#define EEPROM_I2C                              I2C1
#define EEPROM_I2C_CLK                         RCC_APB1Periph_I2C1

#define EEPROM_SCL_GPIO_PORT                    GPIOB
#define EEPROM_SCL_GPIO_CLK                     RCC_AHB1Periph_GPIOB
#define EEPROM_SCL_PIN                          GPIO_Pin_6
#define EEPROM_SCL_AF                           GPIO_AF_I2C1
#define EEPROM_SCL_SOURCE                       GPIO_PinSource6

#define EEPROM_SDA_GPIO_PORT                GPIOB
#define EEPROM_SDA_GPIO_CLK                 RCC_AHB1Periph_GPIOB
#define EEPROM_SDA_PIN                       GPIO_Pin_7
#define EEPROM_SDA_AF                        GPIO_AF_I2C1
#define EEPROM_SDA_SOURCE                   GPIO_PinSource7

2. 初始化GPIO

void EEPROM_GPIO_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
		
RCC_AHB1PeriphClockCmd(EEPROM_SCL_GPIO_CLK|EEPROM_SDA_GPIO_CLK,ENABLE);
  
  /* 连接SCL*/
GPIO_PinAFConfig(EEPROM_SCL_GPIO_PORT,EEPROM_SCL_SOURCE,EEPROM_SCL_AF);
  /*  连接 SDA*/
GPIO_PinAFConfig(EEPROM_SDA_GPIO_PORT,EEPROM_SDA_SOURCE,EEPROM_SDA_AF);

  /* GPIO初始化 */
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  
  /* 配置SCL引脚为复用功能  */
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Pin = EEPROM_SCL_PIN  ;  
  GPIO_Init(EEPROM_SCL_GPIO_PORT, &GPIO_InitStructure);

  /* 配置SDA引脚为复用功能 */
  GPIO_InitStructure.GPIO_Pin = EEPROM_SDA_PIN;
  GPIO_Init(EEPROM_SDA_GPIO_PORT, &GPIO_InitStructure);

}

3.初始化IIC

#define I2C_OWN_ADDR 0x77 		//这个地址只需要与STM32上IIC外设地址不一样即可

#define I2C_SPEED 400000

#define EEPROM_ADDR (0x50<<1)   //0xA0也可以

上面得EEPROM_ADDR为什么需要左移一位是因为补上了方向位，因为在库函数中是这么处理的：

?接下来进行初始化：

void EEPROM_I2C_ModeConfig(void)
{
  I2C_InitTypeDef I2C_InitStruct;
    
  //使能 I2C时钟 
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
  //使能响应
  I2C_InitStruct.I2C_Ack =  I2C_Ack_Enable;
  //IIC寻址模式
  I2C_InitStruct.I2C_AcknowledgedAddress =  I2C_AcknowledgedAddress_7bit;
  //通信速率
  I2C_InitStruct.I2C_ClockSpeed =  I2C_SPEED; 
  //占空比
  I2C_InitStruct.I2C_DutyCycle =  I2C_DutyCycle_2;
  //IIC模式
  I2C_InitStruct.I2C_Mode =  I2C_Mode_I2C ;
  //IIC自身地址
  I2C_InitStruct.I2C_OwnAddress1 = I2C_OWN_ADDR;
  //IIC写入配置
  I2C_Init(EEPROM_I2C,&I2C_InitStruct);
  //使能IIC
  I2C_Cmd(EEPROM_I2C,ENABLE);

}

?4.byte write 函数

这个函数的顺序是来源于上面EEPROM写入数据的顺序，它所产生的EV5等事件，在库函数中均有声明：

?最后实现的程序如下：

void EEPROM_Byte_Write(uint8_t* pData,uint8_t addr)
{
  I2C_GenerateSTART(EEPROM_I2C,ENABLE); //产生起始信号
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT)!= SUCCESS )
  {
     
  }
    
  I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDR,I2C_Direction_Transmitter);
   					      while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)!= SUCCESS)
  {
  
  }
  
  I2C_SendData(EEPROM_I2C,addr);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!= SUCCESS)
  {
  
  }
  
  I2C_SendData(EEPROM_I2C,*pData);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!= SUCCESS)
  {
  
  }
  
  I2C_GenerateSTOP(EEPROM_I2C,ENABLE);

}

?5.测试

写一个读一个字节的函数来进行测试，我们使用串口来测试，在测试的过程中，我们需要注意的是需要等待EEPROM写完数据后才可以接下一步，检测ADDR位中的ACK有没有置1，如果没有，则重新发送。会导致以上原因是因为STM32运行速度过快，在EEPROM还未写入时，STM32认为已经传输完毕后，会导致卡在某个等待函数中。

void Wait_for_EEPROM(void)
{
  do
  {
    I2C_GenerateSTART(EEPROM_I2C,ENABLE);
      
    I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDR,I2C_Direction_Transmitter);  
  
  }while(I2C_GetFlagStatus(EEPROM_I2C,I2C_FLAG_ADDR) == RESET);
  
  //等待ADDR = 1 才执行下面的语句
  I2C_ClearFlag(EEPROM_I2C,I2C_FLAG_AF);
  
  I2C_GenerateSTOP(EEPROM_I2C,ENABLE);
    
  while(I2C_GetFlagStatus(EEPROM_I2C,I2C_FLAG_BUSY) == SET);
  //总线空闲，执行下面的语句,防止在执行的过程中，刚结束即又开始

}  

解决了上述问题后，就可以写读的函数了：

uint8_t EEPROM_Byte_Read(uint8_t addr)
{
  uint8_t readTemp;

  Wait_for_EEPROM();
  
  
  I2C_GenerateSTART(EEPROM_I2C,ENABLE);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS )
  {
    
  }
    
  I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDR,I2C_Direction_Transmitter);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS )
  {
  
  }
  
  I2C_SendData(EEPROM_I2C,addr);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS )
  {
  
  }
  
  I2C_GenerateSTART(EEPROM_I2C,ENABLE);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS )
  {

  }

  I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDR,I2C_Direction_Receiver);
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS )
  {
  
  }
  
  I2C_AcknowledgeConfig(EEPROM_I2C,DISABLE); //收到一个数据后，开启非响应
  
  while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS )
  {
  
  }
  
  readTemp = I2C_ReceiveData(EEPROM_I2C);
   
  I2C_GenerateSTOP(EEPROM_I2C,ENABLE);
  
  return readTemp;

}

6.主函数

之后，在主函数中需要使用串口来收EEPROM中的数据，这个时候断电后把写入函数屏蔽掉时，串口仍然可以得到数据，这也就说明了EEPROM掉电后数据不会丢失:

int main(void)
{	
  
  uint8_t test_addr = 0x02;
  uint8_t test_writeData = 0x27;
  uint8_t test_readData =0;
  
  /*初始化USART 配置模式为 115200 8-N-1，中断接收*/
  Debug_USART_Config();
	
	/* 发送一个字符串 */
  Usart_SendString( DEBUG_USART,"这是一个EEPROM测试实验\n");
  printf("这是一个EEPROM测试实验\n");
  
  
  printf("\r\n初始化I2C\r\n");
  
  EEPROM_GPIO_Config();
  EEPROM_I2C_ModeConfig();
  
  printf("\r\nI2C初始化完毕\r\n");  
  
  EEPROM_Byte_Write(&test_writeData,test_addr);

  test_readData = EEPROM_Byte_Read(test_addr);  

  printf("test_readData =0x%x",test_readData);
	
  while(1)
	{	
		
	}	
}

（七）读写EEPROM程序升级版

当我们真正使用IIC时，不会使用以上的代码来进行写入以及读出，因为它这样不严谨，而且容易产生bug，所以我就学习了例程中的IIC：

区别1：可以修改硬件EEPROM的地址。

void I2C_EE_Init(void)
{
  I2C_GPIO_Config(); 
 
  I2C_Mode_Configu();

/* 根据头文件i2c_ee.h中的定义来选择EEPROM要写入的地址 */
#ifdef EEPROM_Block0_ADDRESS
  /* 选择 EEPROM Block0 来写入 */
  EEPROM_ADDRESS = EEPROM_Block0_ADDRESS;
#endif

#ifdef EEPROM_Block1_ADDRESS  
	/* 选择 EEPROM Block1 来写入 */
  EEPROM_ADDRESS = EEPROM_Block1_ADDRESS;
#endif

#ifdef EEPROM_Block2_ADDRESS  
	/* 选择 EEPROM Block2 来写入 */
  EEPROM_ADDRESS = EEPROM_Block2_ADDRESS;
#endif

#ifdef EEPROM_Block3_ADDRESS  
	/* 选择 EEPROM Block3 来写入 */
  EEPROM_ADDRESS = EEPROM_Block3_ADDRESS;
#endif
}

?区别二：定义了一个数字进行自减，让它在设定时间内完成事件的标志位置，如果没有，则打印出某个事件出错：

uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr)
{
  //IIC起始信号
  I2C_GenerateSTART(EEPROM_I2C, ENABLE);
  //设置超时等待时间
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV5事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(0);
  }    

  //发送EEPROM设备地址
  I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDRESS,I2C_Direction_Transmitter);
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  //检测EV6事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
  }    
      
  //发送要写入EEPROM内部地址
  I2C_SendData(EEPROM_I2C, WriteAddr);
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV8事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))  
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(2);
  } 
  //发送一字节要写入的数据
  I2C_SendData(EEPROM_I2C, *pBuffer); 
   
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV8事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
  } 
  
  //发送停止信号
  I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
  
  return 1;
}

//返回函数
static  uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode)
{
  EEPROM_ERROR("I2C 等待超时!errorCode = %d",errorCode); //相当于printf
  return 0;
}

在库函数中还学习到可以实时打印出错，报错的宏，它可以直接指向错误的地方：

#define EEPROM_DEBUG(fmt,arg...)          do{\
                                          if(EEPROM_DEBUG_ON)\
                                          printf("<<-EEPROM-DEBUG->> 											  [%d]"fmt"\n",__LINE__, ##arg);\
                                          }while(0)

有关这些找出报错的宏也有如下：

#define EEPROM_INFO(fmt,arg...)           printf("<<-EEPROM-INFO->> 													"fmt"\n",##arg)
#define EEPROM_ERROR(fmt,arg...)          printf("<<-EEPROM-ERROR->> 													"fmt"\n",##arg)

区别三：读多个数据，数据块。

 /*
  * @brief   从EEPROM里面读取一块数据 
  * @param   
  *		@arg pBuffer:存放从EEPROM读取的数据的缓冲区指针
  *		@arg WriteAddr:接收数据的EEPROM的地址
  *     @arg NumByteToWrite:要从EEPROM读取的字节数
  * @retval  无
  */
uint32_t I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
{  
    I2CTimeout = I2CT_LONG_TIMEOUT;
	//总线非空闲
    while(I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))   
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
    }
  //产生起始信号 
  I2C_GenerateSTART(EEPROM_I2C, ENABLE);
  //*((u8 *)0x4001080c) &=~0x80;
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV5事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
   }

  //发送EEPROM设备地址
  I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESSI2C_Direction_Transmitter);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
 
  //检测EV6事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C，	I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) 
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(11);
   }
  //通过重新设置PE位清除EV6事件
  I2C_Cmd(EEPROM_I2C, ENABLE);

  //发送要读取的EEPROM内部地址（即EEPROM内部存储器的地址）
  I2C_SendData(EEPROM_I2C, ReadAddr);  

  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV8事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(12);
   }
  //产生第二次IIC起始信号
  I2C_GenerateSTART(EEPROM_I2C, ENABLE);
  
     I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV5事件并清除
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(13);
   }
  //发送EEPROM设备地址
  I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS, I2C_Direction_Receiver);
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV6事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(14);
   }
  //读取设定的多少个数据
  while(NumByteToRead)  
  {
    //如果它等于1，那么就是最后一个数据了，发送非应答信号，结束传输
    if(NumByteToRead == 1)
    {
      //发送非应答信号
      I2C_AcknowledgeConfig(EEPROM_I2C, DISABLE);
      
      //发送停止信号
      I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
    }

		I2CTimeout = I2CT_LONG_TIMEOUT;
		while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED)==0)  
		{
			if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
		} 	
		{
	  //通过IIC，从设备中读取一个字节的数据
      *pBuffer = I2C_ReceiveData(EEPROM_I2C);

      //指向下一个地址
      pBuffer++; 
      
      //接收数据自减
      NumByteToRead--;
		}			
  }

  //使能应答，方便下一次传输
  I2C_AcknowledgeConfig(EEPROM_I2C, ENABLE);
  
  return 1;
}

这么写就是前面所说的，EEPROM读取数据是一个复合的IIC时序，实际上包括一个写过程和一个读过程。

读时序的第一个通讯过程中，使用 I2C 发送设备地址寻址(写方向)，接着发送要读取 的“内存地址”；第二个通讯过程中，再次使用 I2C 发送设备地址寻址（读方向），在这个过程之后，EEPROM 会向主机返回从“内存地址”开始的数据，一个字节一个字节地传输，只要主机的响应为“应答信号”，它就会一直传输下去，主机 想结束传输时，就发送“非应答信号”，并以“停止信号”结束通讯，作为从机的 EEPROM 也会停止传输。

区别四：写入一页的数据（多个数据），不需要等待EEPROM写入一个字节是否完成，原因是在于它将写入的数据临时存储在一个地方

在上边自己写的例子中，我们只传输了一个数据，并且每次写一次都需要等待它缓存进去后才会写进去第二个。但是这个函数有个缺点，就是只能写入八个数据，不灵活：

 /*
  * @brief   在EEPROM的一个写循环中可以写多个字节，但一次写入的字节数
  *          不能超过EEPROM页的大小，AT24C02每页有8个字节
  * @param   
  *		@arg pBuffer:缓冲区指针
  *		@arg WriteAddr:写地址
  *     @arg NumByteToWrite:写的字节数
  * @retval  无
  */
uint32_t I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite)
{
  I2CTimeout = I2CT_LONG_TIMEOUT;

  while(I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))  
   {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
  } 
  
  //产生IIC起始信号
  I2C_GenerateSTART(EEPROM_I2C, ENABLE);
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV5事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(5);
  } 
  
  //发送EEPROM设备地址
  I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV6事件并清除标志
  while(!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
  } 
  //发送要写入的EEPROM内部地址 （即EEPROM内部存储器的地址）
  I2C_SendData(EEPROM_I2C, WriteAddr);  

  I2CTimeout = I2CT_FLAG_TIMEOUT;

  //检测EV8事件并清除标志
  while(! I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
  //循环发送所设定的个数的数据
  while(NumByteToWrite--)  
  {
    //发送缓冲区中的数据
    I2C_SendData(EEPROM_I2C, *pBuffer); 

    //指向缓冲区下一个数据
    pBuffer++; 
  
    I2CTimeout = I2CT_FLAG_TIMEOUT;

    //检测到EV8事件并清除标志
    while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
    } 
  }

  //发送停止信号
  I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
  
  return 1;
}

为了解决以上只能写入8个数据的问题，对此做出了下面的改进，其实也就是在控制调用多少次上面的函数，在这个函数中，也有区分从哪个地址开始写，也就是对齐或者不对齐：

/* AT24C01/02 每页有 8 个字节 */
#define I2C_PageSize 8
 /*
  * @brief   将缓冲区中的数据写到I2C EEPROM中
  * @param   
  *		@arg pBuffer:缓冲区指针
  *		@arg WriteAddr:写地址
  *     @arg NumByteToWrite:写的字节数
  * @retval  无
  */
void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite)
{
  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;
  //地址运算求余，算WriteAddr是否是IIC_PageSize的整数倍，也就是是否对齐
  Addr = WriteAddr % I2C_PageSize;
  //差多少个数据可以对齐
  count = I2C_PageSize - Addr;
  //计算出要写多少整页数
  NumOfPage =  NumByteToWrite / I2C_PageSize;
  //求余，求写不满的那一页的字节数
  NumOfSingle = NumByteToWrite % I2C_PageSize;
 
  //Addr=0则说明刚好对齐
  if(Addr == 0) 
  {
    //如果要写入的数小于8个
    if(NumOfPage == 0) 
    {
      I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      I2C_EE_WaitEepromStandbyState();
    }
    //反之，大于
    else  
    {
      //先把整页写满
      while(NumOfPage--)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize); 
        I2C_EE_WaitEepromStandbyState();
        WriteAddr +=  I2C_PageSize;
        pBuffer += I2C_PageSize;
      }
      //再把剩余的写完
      if(NumOfSingle!=0)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
        I2C_EE_WaitEepromStandbyState();
      }
    }
  }
  //如果非对齐
  else 
  {
    //如果小于八个
    if(NumOfPage== 0) 
    {
      I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      I2C_EE_WaitEepromStandbyState();
    }
    //如果大于八个
    else
    {
      //地址不对齐多出的count分开处理，不加入这个运算
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / I2C_PageSize;
      NumOfSingle = NumByteToWrite % I2C_PageSize;	
      //先把所在页的剩余字节写了
      if(count != 0)
      {  
        I2C_EE_PageWrite(pBuffer, WriteAddr, count);
        I2C_EE_WaitEepromStandbyState();
          
        //writeAddr加上count后，地址久对齐到页了，方便下一页填满
        WriteAddr += count;
        pBuffer += count;
      } 
      //把整页都写了
      while(NumOfPage--)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
        I2C_EE_WaitEepromStandbyState();
        WriteAddr +=  I2C_PageSize;
        pBuffer += I2C_PageSize;  
      }
      //若有多余不满的一页数据，则写完
      if(NumOfSingle != 0)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle); 
        I2C_EE_WaitEepromStandbyState();
      }
    }
  }  
}

EEPROM 支持的页写入只是一种加速的 I2C 的传输时序，实际上并 不要求每次都以页为单位进行读写，EEPROM 是支持随机访问的(直接读写任意一个地址)， 如前面的单个字节写入。在某些存储器，如 NAND FLASH，它是必须按照 Block 写入的， 例如每个 Block 为 512 或 4096 字节，数据写入的最小单位是 Block，写入前都需要擦除整 个 Block；NOR FLASH 则是写入前必须以 Sector/Block 为单位擦除，然后才可以按字节写 入。而我们的 EEPROM 数据写入和擦除的最小单位是“字节”而不是“页”，数据写入前不需要擦除整页。

在国庆的效率真的好低好低，五天才学完一个东西T T，下次要好好督促自己！！！