STM32F429IIT6单片机I2C的使用（代码）--EEPROM使用安森美的AT24C256（借鉴野火教程）

最新推荐文章于 2023-10-15 16:57:33 发布
原创 最新推荐文章于 2023-10-15 16:57:33 发布 · 1.2k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单片机 #stm32 #c语言

环境为KEIL5

.h文件

#ifndef _I2C_EE_24C256_H
#define _I2C_EE_24C256_H

#include "stm32f4xx_i2c.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include <stdio.h>
	
#define I2C_OWNADDR  																0X0A
#define I2C_CLOCK_SPEED 														   400000
#define I2C_PageSize           											            64
//定义用哪个I2C
#define EEPROM_I2C1 					  										I2C1
#define EEPROM_I2C1_CLK				  										RCC_APB1Periph_I2C1
//定义GPIO相关
//SDA  PB7  165
#define		EEPROM_I2C1_SDA_GPIO_PORT	  							GPIOB
#define   EEPROM_I2C1_SDA_PIN												GPIO_Pin_7
#define 	EEPROM_I2C1_SDA_GPIO_CLK									RCC_AHB1Periph_GPIOB
#define		EEPROM_I2C1_SDA_GPIO_SOURCE								GPIO_PinSource7
#define		EEPROM_I2C1_SDA_AF												GPIO_AF_I2C1

//SCL  PB8  167
#define		EEPROM_I2C1_SCL_GPIO_PORT	  							GPIOB
#define   EEPROM_I2C1_SCL_PIN												GPIO_Pin_8
#define 	EEPROM_I2C1_SCL_GPIO_CLK									RCC_AHB1Periph_GPIOB
#define		EEPROM_I2C1_SCL_GPIO_SOURCE								GPIO_PinSource8
#define		EEPROM_I2C1_SCL_AF												GPIO_AF_I2C1

#define EEPROM_ADDRESS 															0XA0
/*等待超时时间*/
#define I2CT_FLAG_TIMEOUT         ((uint32_t)0x1000)
#define I2CT_LONG_TIMEOUT         ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))

/*信息输出,可设置输出模式以及debug开关*/
#define EEPROM_DEBUG_ON         0

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

void EEPROM_GPIO_Init(void);
uint32_t I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite);
void I2C_EE_WaitEepromStandbyState(void)   ;
uint32_t I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead);
uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr);
void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite);
uint8_t I2C_Test(void);
#endif

.c文件

#include "i2c_ee_24c256.h"

uint8_t I2c_Buf_Write[128];
uint8_t I2c_Buf_Read[128];
uint8_t I2c_Buf_Read1[128];
uint8_t EEP_Firstpage =0x00;
uint8_t EEP_SecondPage =0x40;

static __IO uint32_t  I2CTimeout = I2CT_LONG_TIMEOUT;   


static uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode);

//gpio初始化
void EEPROM_GPIO_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStruct;
	
	//使能I2C1的GPIO  PB7  PB8时钟
	//GPIO时钟
	RCC_AHB1PeriphClockCmd(EEPROM_I2C1_SDA_GPIO_CLK|EEPROM_I2C1_SCL_GPIO_CLK,ENABLE);
	
	//连接PB7到SDA-----复用功能
	GPIO_PinAFConfig(EEPROM_I2C1_SDA_GPIO_PORT,EEPROM_I2C1_SDA_GPIO_SOURCE,EEPROM_I2C1_SDA_AF);
	//连接PB8到SCL
	GPIO_PinAFConfig(EEPROM_I2C1_SCL_GPIO_PORT,EEPROM_I2C1_SCL_GPIO_SOURCE,EEPROM_I2C1_SCL_AF);
	
	//GPIO初始化
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
	GPIO_InitStruct.GPIO_OType = GPIO_OType_OD;//推挽输出
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	
	//配置SDA为复用功能
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;//复用
	GPIO_InitStruct.GPIO_Pin = EEPROM_I2C1_SDA_PIN;
	GPIO_Init(EEPROM_I2C1_SDA_GPIO_PORT,&GPIO_InitStruct);//初始化配置
	
	//配置SCL为复用功能
	GPIO_InitStruct.GPIO_Pin = EEPROM_I2C1_SCL_PIN;
	GPIO_Init(EEPROM_I2C1_SCL_GPIO_PORT,&GPIO_InitStruct);
	
	
	I2C_InitTypeDef I2C_InitStruct;
	//I2C时钟
	RCC_APB1PeriphClockCmd(EEPROM_I2C1_CLK,ENABLE);
	
	I2C_InitStruct.I2C_Mode=I2C_Mode_I2C;
	I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;
	I2C_InitStruct.I2C_ClockSpeed = I2C_CLOCK_SPEED;
	I2C_InitStruct.I2C_OwnAddress1 =	I2C_OWNADDR;	//I2C1自己的地址
	I2C_InitStruct.I2C_Ack = I2C_Ack_Enable;
	I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;//7位模式
	I2C_Init(EEPROM_I2C1,&I2C_InitStruct);
	//使能
	I2C_Cmd(EEPROM_I2C1,ENABLE);
	
}

/**
  * @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;

  Addr = WriteAddr % I2C_PageSize;
  count = I2C_PageSize - Addr;
  NumOfPage =  NumByteToWrite / I2C_PageSize;
  NumOfSingle = NumByteToWrite % I2C_PageSize;
 
  /* If WriteAddr is I2C_PageSize aligned  */
  if(Addr == 0) 
  {
    /* If NumByteToWrite < I2C_PageSize */
    if(NumOfPage == 0) 
    {
      I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      I2C_EE_WaitEepromStandbyState();
    }
    /* If NumByteToWrite > I2C_PageSize */
    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();
      }
    }
  }
  /* If WriteAddr is not I2C_PageSize aligned  */
  else 
  {
    /* If NumByteToWrite < I2C_PageSize */
    if(NumOfPage== 0) 
    {
      I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      I2C_EE_WaitEepromStandbyState();
    }
    /* If NumByteToWrite > I2C_PageSize */
    else
    {
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / I2C_PageSize;
      NumOfSingle = NumByteToWrite % I2C_PageSize;	
      
      if(count != 0)
      {  
        I2C_EE_PageWrite(pBuffer, WriteAddr, count);
        I2C_EE_WaitEepromStandbyState();
        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();
      }
    }
  }  
}


////byte write 写一个字节数据  可以根据参考手册里的时序图写过程
//void I2C1_Byte_Write(uint8_t* data,uint8_t writeAddr)
//{
//	//产生一个开始信号
//	I2C_GenerateSTART(EEPROM_I2C1,ENABLE);
//	//产生开始信号之后，出发检测事件EV5,检测该事件的状态是否为SUCCESS
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_MODE_SELECT)!=SUCCESS)
//	{
//		//清除标志位
//		
//	}
//	//发送eeprom设备地址，24C256	
//	I2C_Send7bitAddress(EEPROM_I2C1,EEPROM_ADDRESS,I2C_Direction_Transmitter);
//	//检测EV6事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)!=SUCCESS)
//	{
//	}
//	//发送eeprom内部存储器地址地址分为两个字节分别发送
//	//先发高八位
//	I2C_SendData(EEPROM_I2C1,writeAddr&0xff00>>8);
//	//检测EV8事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!=SUCCESS)
//	{
//	}
//	//发送低八位
//	I2C_SendData(EEPROM_I2C1,writeAddr&0x00ff>>8);
//	//检测EV8事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!=SUCCESS)
//	{
//	}
//	
//	//发送要写入的数据
//	I2C_SendData(EEPROM_I2C1,*data);
//	//检测EV8事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!=SUCCESS)
//	{
//	}
//	//发送停止信号
//	I2C_GenerateSTOP(EEPROM_I2C1,ENABLE);
//}

/**
  * @brief   在EEPROM的一个写循环中可以写多个字节，但一次写入的字节数
  *          不能超过EEPROM页的大小，每页有64个字节
  * @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_I2C1, I2C_FLAG_BUSY))  
   {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
  } 
  
  /* Send START condition */
  I2C_GenerateSTART(EEPROM_I2C1, ENABLE);
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(5);
  } 
  
  /* Send EEPROM address for write */
  I2C_Send7bitAddress(EEPROM_I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
  } 
	
  /* Send the EEPROM's internal address to write to */    
  //I2C_SendData(EEPROM_I2C1, WriteAddr);  
	//发送高八位
	I2C_SendData(EEPROM_I2C1,WriteAddr&0xff00>>8);
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
	
	//发送低八位
	I2C_SendData(EEPROM_I2C1,WriteAddr&0x00ff>>8);
	I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
	
  /* While there is data to be written */
  while(NumByteToWrite--)  
  {
    /* Send the current byte */
    I2C_SendData(EEPROM_I2C1, *pBuffer); 
    /* Point to the next byte to be written */
    pBuffer++; 
    I2CTimeout = I2CT_FLAG_TIMEOUT;
    /* Test on EV8 and clear it */
    while (!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
    } 
  }

  /* Send STOP condition */
  I2C_GenerateSTOP(EEPROM_I2C1, ENABLE);
  
  return 1;
}

////	selective read  读一个字节
//uint8_t I2C1_Selective_Read(uint16_t writeAddr)
//{
//	//将要返回的值暂时存起来
//	uint8_t recieveDataTemp;
//	
//	//产生开始信号
//	I2C_GenerateSTART(EEPROM_I2C1,ENABLE);
//	//产生开始信号之后，出发检测事件EV5,检测该事件的状态是否为SUCCESS
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_MODE_SELECT)!=SUCCESS)
//	{
//		
//	}
//	
//	//先寻址，发送eeprom的设备地址
//	I2C_Send7bitAddress(EEPROM_I2C1,EEPROM_ADDRESS,I2C_Direction_Transmitter);
//	//检测EV6事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)!=SUCCESS)
//	{
//	}
//	
//	//发送eeprom内部存储器地址地址分为两个字节分别发送
//	//先发高八位
//	I2C_SendData(EEPROM_I2C1,writeAddr&0xff00>>8);
//	//检测EV8事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!=SUCCESS)
//	{
//	}
//	//发送低八位
//	I2C_SendData(EEPROM_I2C1,writeAddr&0x00ff>>8);
//	//检测EV8事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED)!=SUCCESS)
//	{
//	}
//	
//	//再次产生起始信号
//	//产生开始信号
//	I2C_GenerateSTART(EEPROM_I2C1,ENABLE);
//	//产生开始信号之后，出发检测事件EV5,检测该事件的状态是否为SUCCESS
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_MODE_SELECT)!=SUCCESS)
//	{
//		
//	}
//	
//	//发送设备地址，但是是read方向
//	I2C_Send7bitAddress(EEPROM_I2C1,EEPROM_ADDRESS,I2C_Direction_Receiver);
//	//检测EV6事件，read方向
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)!=SUCCESS)
//	{
//	}
//	//产生一个noack信号
//	I2C_AcknowledgeConfig(EEPROM_I2C1,DISABLE);
//	//检测EV7事件
//	while(I2C_CheckEvent(EEPROM_I2C1,I2C_EVENT_MASTER_BYTE_RECEIVED)!=SUCCESS)
//	{
//	}
//	//开始接收数据
//	recieveDataTemp =  I2C_ReceiveData(EEPROM_I2C1);
//	//停止信号
//	I2C_GenerateSTOP(EEPROM_I2C1,ENABLE);
//	//返回读到的数据
//	return recieveDataTemp;
//}
/**
  * @brief   写一个字节到I2C EEPROM中
  * @param   
  *		@arg pBuffer:缓冲区指针
  *		@arg WriteAddr:写地址 
  * @retval  无
  */
uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr)
{
  /* Send STRAT condition */
  I2C_GenerateSTART(EEPROM_I2C1, ENABLE);

  I2CTimeout = I2CT_FLAG_TIMEOUT;

  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(0);
  }    

  /* Send EEPROM address for write */
  I2C_Send7bitAddress(EEPROM_I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
  }    
      
  /* Send the EEPROM's internal address to write to */
  //发送高八位
	I2C_SendData(EEPROM_I2C1,WriteAddr&0xff00>>8);
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
	
	//发送低八位
	I2C_SendData(EEPROM_I2C1,WriteAddr&0x00ff>>8);
	I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
  /* Send the byte to be written */
  I2C_SendData(EEPROM_I2C1, *pBuffer); 
   
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
  } 
  
  /* Send STOP condition */
  I2C_GenerateSTOP(EEPROM_I2C1, ENABLE);
  
  return 1;
}

/**
  * @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;

  //*((u8 *)0x4001080c) |=0x80; 
    while(I2C_GetFlagStatus(EEPROM_I2C1, I2C_FLAG_BUSY))   
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
    }
  /* Send START condition */
  I2C_GenerateSTART(EEPROM_I2C1, ENABLE);
  //*((u8 *)0x4001080c) &=~0x80;
  
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
   }

  /* Send EEPROM address for write */
  I2C_Send7bitAddress(EEPROM_I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
 
  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) 
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(11);
   }
  /* Clear EV6 by setting again the PE bit */
  I2C_Cmd(EEPROM_I2C1, ENABLE);

  /* Send the EEPROM's internal address to write to */
  //发送高八位
	I2C_SendData(EEPROM_I2C1,ReadAddr&0xff00>>8);
  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
	
	//发送低八位
	I2C_SendData(EEPROM_I2C1,ReadAddr&0x00ff>>8);
	I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) 
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 
		
	 
  /* Send STRAT condition a second time */  
  I2C_GenerateSTART(EEPROM_I2C1, ENABLE);
  I2CTimeout = I2CT_FLAG_TIMEOUT;

  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_MODE_SELECT))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(13);
   }
  /* Send EEPROM address for read */
  I2C_Send7bitAddress(EEPROM_I2C1, EEPROM_ADDRESS, I2C_Direction_Receiver);
  
     I2CTimeout = I2CT_FLAG_TIMEOUT;

  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
    {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(14);
   }
  /* While there is data to be read */
  while(NumByteToRead)  
  {
    if(NumByteToRead == 1)
    {
      /* Disable Acknowledgement */
      I2C_AcknowledgeConfig(EEPROM_I2C1, DISABLE);
      
      /* Send STOP Condition */
      I2C_GenerateSTOP(EEPROM_I2C1, ENABLE);
    }

		
		I2CTimeout = I2CT_LONG_TIMEOUT;
		while(I2C_CheckEvent(EEPROM_I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)==0)  
		{
			if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
		} 	
		{
		  /* Read a byte from the device */
      *pBuffer = I2C_ReceiveData(EEPROM_I2C1);

      /* Point to the next location where the byte read will be saved */
      pBuffer++; 
      
      /* Decrement the read bytes counter */
      NumByteToRead--;
		}			
  }

  /* Enable Acknowledgement to be ready for another reception */
  I2C_AcknowledgeConfig(EEPROM_I2C1, ENABLE);
  
  return 1;
}




/**
  * @brief  Wait for EEPROM Standby state 
  * @param  无
  * @retval 无
  */
void I2C_EE_WaitEepromStandbyState(void)      
{
  vu16 SR1_Tmp = 0;

  do
  {
    /* Send START condition */
    I2C_GenerateSTART(EEPROM_I2C1, ENABLE);
    /* Read EEPROM_I2C SR1 register */
    SR1_Tmp = I2C_ReadRegister(EEPROM_I2C1, I2C_Register_SR1);
    /* Send EEPROM address for write */
    I2C_Send7bitAddress(EEPROM_I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  }while(!(I2C_ReadRegister(EEPROM_I2C1, I2C_Register_SR1) & 0x0002));
  
  /* Clear AF flag */
  I2C_ClearFlag(EEPROM_I2C1, I2C_FLAG_AF);
  /* STOP condition */    
  I2C_GenerateSTOP(EEPROM_I2C1, ENABLE); 
}




static  uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode)
{
  /* Block communication and all processes */
  EEPROM_ERROR("I2C 等待超时!errorCode = %d",errorCode);
  
  return 0;
}

uint8_t I2C_Test(void)
{
	u16 i,j;

	EEPROM_INFO("写入的数据 \n");
    
	for ( i=0,j=20; i<=128; i++,j++ ) //填充缓冲
  {   
    I2c_Buf_Write[i] = j;
   
   }
		//将I2c_Buf_Write中顺序递增的数据写入EERPOM中 
		I2C_EE_BufferWrite( I2c_Buf_Write, EEP_Firstpage, 128);
	 //读数据  必须要分开一页一页读
	 I2C_EE_BufferRead(I2c_Buf_Read, 1, 1);
	 printf("\n#########第一页#########\n");
	 for (i=0; i<64; i++)
	 printf("0x%02X ", I2c_Buf_Read[i]);	 
	 I2C_EE_BufferRead(I2c_Buf_Read1, EEP_SecondPage, 64);
	 printf("\n#########第二页#########\n");
	 for (i=0; i<62; i++)
	 printf("0x%02X ", I2c_Buf_Read1[i]);

	return 1;
}

mian.c文件

#include "stm32f4xx.h"
#include "stm32f4xx_it.h"
#include "./led/led.h"
#include "./usart/usart_debug.h"
#include "./i2c/i2c_ee_24c256.h"

int main(void)
	{
	
	//LED_GPIO_Config();
	//uint8_t arr[] = "vsdvs";
	Debug_Usart_Init();
		printf("\nUSART初始化完成\n");
		//Usart8_Init();
	//UART8_Config();
	//发回控制台
	EEPROM_GPIO_Init();
	printf("\nEEPROM初始化完成\n");

	I2C_Test();

	while(1)
	{
		
		//delay(600);
	}
	
}

调试口串为USART0，配置一下USART0，重定向即可，不需要使用中断，调试信息就可以打印到串口助手上了。

I2C_Test()为调试方法，可自定义内容。

注意AT24C256每一页可以写64个字节，换成别的型号需要查看该芯片一页可以写多少个字节，并且AT24C256发送内部存储器地址时需要先发高八位，再发低八位，其他芯片可能不是这样，需要根据每一款芯片的发送方式修改程序。

精选资源
STM32H743IIT6单片机 SDIO-基本数据读写实验例程源码.zip
03-25
本实验例程主要关注STM32H743IIT6单片机通过SDIO（Secure Digital Input/Output）接口与外部SD卡进行基本的数据读写操作。SDIO是一种通信协议，允许微控制器与兼容SD标准的存储设备进行高速数据交换。在嵌入式系统中...
精选资源
STM32H743IIT6单片机 QSPI-W25Q64使用MDMA读取实验例程源码.zip
03-25
STM32H743IIT6是一款基于ARM Cortex-M7内核的高性能微控制器，由意法半导体（STMicroelectronics）生产。该芯片在单片机市场中因其高速处理能力、丰富的外设接口和低功耗特性而受到广泛应用。在本实验例程中，我们将...
STM32F429硬件I2C读写EEPROM
06-11
STM32F429硬件I2C读写EEPROM。已验证无bug。STM32F429
【STM32】AT24C256硬件I2C读写，基于HAL库
我的博客
10-15 8975
STM32F103C8T6单片机使用HAL库配合CubeMX对AT24C256模块进行读写，存储容量256Kb即32KB（32K字节）。模块的原理图如下驱动协议是IIC，考虑开启硬件IIC进行通信，笔者选择使用IIC2。
驱动AT24C256
01-19
基于LPC2292的AT24C256驱动程序，详细的介绍了II2C的使用方法！
STM32 AT24C256驱动IO模拟
11-21
STM32 ， AT24C256驱动IO模拟，本人亲测，完全没问题！！绝对好用
第23章 I2C—读写EEPROM—零死角玩转STM32-F429系列
aicai1841的博客
08-25 707
第23章 I2C—读写EEPROM 全套200集视频教程和1000页PDF教程请到秉火论坛下载：www.firebbs.cn 野火视频教程优酷观看网址：http://i.youku.com/firege 本章参考资料：《STM32F4xx 中文参考手册》、《STM32F4xx规格书》、库帮助文档《stm32f4xx_dsp_stdperiph_lib_um....
精选资源
STM32H743IIT6 串口（USART）配置教程 - STM32CubeMX实战教程配置详细步骤
最新发布
04-09
本文将详细介绍如何使用STM32CubeMX工具对STM32H743IIT6的串口进行配置。 首先，需要打开STM32CubeMX软件，创建一个新项目。在选择芯片型号时，选择STM32H743IIT6。接下来，进行工程设置，包括工程名称、工程路径、...
精选资源
STM32H743IIT6单片机 基于AT070TN83芯片的LTDC液晶驱动源码.zip
03-25
在"STM32H743IIT6单片机 基于AT070TN83芯片的LTDC液晶驱动源码"这个项目中，开发者可能包含了以下关键知识点： 1. **STM32H743IIT6的GPIO配置**：LTDC需要连接到微控制器的多个GPIO引脚来控制液晶屏的背光、数据线...
精选资源
STM32H743IIT6单片机 QSPI-W25Q64移植Fatfs（HAL库直接读写）实验例程源码.zip
03-25
STM32H743IIT6是一款基于ARM Cortex-M7内核的高性能微控制器，由意法半导体（STMicroelectronics）生产。该芯片在STM32系列中属于H7系列，具有高处理速度、丰富的外设接口以及强大的计算能力，广泛应用于工业控制、...
I2C.zip_AT24C256 stm32_at24c256_i2c stm32f103_stm32f103 AT24C256
07-15
stm32f103读写AT24C256的C语言程序
STM32F429 模拟I2C
03-09
硬件I2C出现数据读取不稳错误，采用GPIO模拟I2C，附件含有全部源码，测试OK
stm32f429 i2c.rar
11-08
使用stm32f429igt6开发板，利用硬件i2c驱动mpu6050。程序逻辑为读取id，确保程序正确。另外是分别读取加速度和陀螺仪的寄存器值。
关于STM32F1使用硬件i2c读写AT24C256实验遇到的问题
01-24
关于STM32使用硬件i2c读写AT24C256实验遇到的问题，这个代码只是一部分，下载后需要将他放在官方HAL库en.stm32cubef1 V1.7.0-》Projects-》STM32F103RB-Nucleo-》Examples-》I2C目录下，参照帖子里关于这个工程的问题总结，对遇到的问题进行了分析解决，帖子名字“关于STM32使用硬件i2c读写AT24C256实验遇到的问题”
at24c256_driver.zip_at24c256_at24c256 读写 程序_at24c64
07-14
基于STM32103 AT24C64~256驱动程序
使用STM32F103C8T6实现AT24C01-AT24C256系列芯片读写功能
weixin_53801451的博客
07-18 3671
AT24C系列芯片是常见的EEPROM存储芯片，常用于保存参数及掉电记忆存储数据。
STM32F429--I2C通信(读写EEPROM，串口返回测试数据)
ABCisCOOL的博客
06-15 1557
野火学习笔记--I2C
STM32调试问题：无法读写 AT24C256 数据
qq_42965739的博客
01-05 5294
最近做的一个项目，不定时记录下调试过程中遇到的问题 1、 问题描述 硬件：使用STM32F407ZGT6的IIC1 PB8、PB9读写 EEPROM 24C256 软件：基于原子的标准例程 实验24 IIC实验：STM32F407ZGT6的IIC1 PB8、PB9读写 EEPROM 24C02，做对应的修改，把EE_TYPE修改为我们硬件使用的 24C256 问题：EEPROM 能写...
stm32-IIC/EEPROM（AT24C256）代码及原理讲解
热门推荐
qq_52900974的博客
12-18 1万+
stm32-IIC/EEPROM（AT24C256）代码及原理讲解
STM32F429IIT6驱动的Linux微控制器-PC系统介绍
资源摘要信息:"基于STM32F429IIT6开发的uc-PC平台，是一种具备主线Linux 4.13.3操作系统的微控制器个人计算机。它具有VGA显示端口和USB接口，类似于传统计算机的硬件配置，能够在嵌入式系统中提供类似PC的使用体验和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值