STM32F429入门（二十）：IIC通讯协议（硬件）

最新推荐文章于 2024-03-30 15:34:40 发布

郑烯烃快去学习

最新推荐文章于 2024-03-30 15:34:40 发布

阅读量5.1k

点赞数 5

分类专栏： STM32F429开发笔记文章标签： stm32 物联网

本文链接：https://blog.csdn.net/Alkaid2000/article/details/120620062

版权

STM32F429开发笔记专栏收录该内容

31 篇文章 23 订阅

订阅专栏

一、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的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。

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）”的不同数据位写入参数，通过读取这些寄存器标志来了解通讯状态。

主机发送器

先生成起始位：

之后会产生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）软件设计

设置引脚

#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，下次要好好督促自己！！！

郑烯烃快去学习

关注

5
点赞
踩
28

收藏

觉得还不错? 一键收藏
打赏
0
评论
STM32F429入门（二十）：IIC通讯协议（硬件）

一、I2C协议I2C 通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。（一）I2C物理层的特点：电阻一般选择4.7k。它的物理层有如下特点：(1) 它是一个支持多设备的总线。“总线”指多个设备共用的信号线。在一个 I2C 通讯总线中，可连接多个 I2C 通讯设备，支持多个通讯主机及多个通.
复制链接

扫一扫