• STM32之I2C对EEPROM 页读写、连续读写操作

    页写入

    原理

    stm32的EEPROM（24C02）的一页只有8个字节  组织架构是256 * 8bits = 2k（bits）

     步骤：

    1、起始信号

    2、检查总线是否忙碌

    3、发送EEPROM设备地址和发送方向

    4、发送要写入的单元格地址

    5、开始发送数据

    6、发送完响应noack 停止发送   

    7、结束信号

    注意：以上的每一步都需要响应EV事件

    代码

    1. //-----------------------对EEPROM进行页写入----------------------------------
    2. // buffer : 要写入的缓冲区数据
    3. // addr   ：要写入的单元格地址
    4. // num	 ：要写入的数据数量  不能超过页大小 8位
    5. uint16_t EEPROM_Page_write(u8 *buffer, u8 addr, uint8_t num)
    6. {
    7. 	//查询总线是否忙碌
    8. 	TimeOut_count = I2C_time_out;
    9. 	while (I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))
    10. 	{
    11. 		if ((TimeOut_count--) == 0)
    12. 			return I2C_timeout_callback(4);
    13. 	}
    14.  
    15. 	//发送起始信号
    16. 	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
    17.  
    18. 	//等待EV5事件响应
    19. 	TimeOut_count = I2C_time_out;
    20. 	while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    21. 	{
    22. 		if ((TimeOut_count--) == 0)
    23. 			return I2C_timeout_callback(5);
    24. 	}
    25.  
    26. 	//发送要写入的EEPROM的地址和读写方向
    27. 	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS, I2C_Direction_Transmitter);
    28.  
    29. 	//等待EV事件响应
    30. 	TimeOut_count = I2C_time_out;
    31. 	while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS)
    32. 	{
    33. 		if ((TimeOut_count--) == 0)
    34. 			return I2C_timeout_callback(6);
    35. 	}
    36.  
    37. 	//发送要写入EEPROM的单元地方
    38. 	I2C_SendData(EEPROM_I2C, addr);
    39.  
    40. 	//等待EV事件响应
    41. 	TimeOut_count = I2C_time_out;
    42. 	while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS)
    43. 	{
    44. 		if ((TimeOut_count--) == 0)
    45. 			return I2C_timeout_callback(7);
    46. 	}
    47.  
    48. 	while (num--)
    49. 	{
    50. 		//发送要写入的数据
    51. 		I2C_SendData(EEPROM_I2C, *buffer);
    52.  
    53. 		//要写入的数据指针递增
    54. 		buffer++;
    55.  
    56. 		//等待EV事件响应
    57. 		TimeOut_count = I2C_time_out;
    58. 		while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS)
    59. 		{
    60. 			if ((TimeOut_count--) == 0)				return I2C_timeout_callback(8);
    61. 		}
    62. 	}
    63.  
    64. 	//发送停止信号
    65. 	I2C_GenerateSTOP(I2C1, ENABLE);
    66.  
    67. 	//写完马上读会出错  在写入时是不能读的
    68. 	Wait_for_StandBy();
    69.  
    70. 	return 0;
    71. }

    连续写

    原理

     这里介绍了 AT24C02的内存内部架构是 32页的8byte组成的  32*8byte = 256 byte

    所以stm32这I2C对EEPROM最多写入256个byte

    关于连续写入会遇到的几个问题：

    1、写入的单元格地址不一定是每一页的起始位，导致后面连续页写入位置对不齐，导致数据写入失败

    2、 将连续的写入最后凑不满一页的几个字节单独写入，有助于提高效率

     关于解决的方法就是：算出对不齐的位数，从要写入的数据中选出可以凑满一页的数据先行讲那一页进行凑满，后续再按正常对齐的方式进行写入。

    代码

    1. //buffer ： 要写入的数据
    2. //addr   ： 要写入的单元格地址
    3. //num    ： 要写入的数据数量
    4. uint16_t I2c_Buffer_write(u8 *buffer, u8 addr, u16 num)
    5. {
    6. 	u16 Num_Page, Num_Single, count, aaddr;	
    7.  
    8. 	//算出是否对齐位置  
    9. 	count = addr % EEPROM_PAGE_SIZE;		
    10. 	//没对齐的话  aaddr代表需要单独写入的位数  为了凑齐一页的数量
    11. 	aaddr = EEPROM_PAGE_SIZE - count;			
    12.  
    13. 	//如果对齐了
    14. 	if (count == 0)
    15. 	{
    16. 		//算出需要插入的页数  和凑不满一页的单独数
    17. 		Num_Page = num / EEPROM_PAGE_SIZE;
    18. 		Num_Single = num % EEPROM_PAGE_SIZE;
    19.  
    20. 		//若凑不满一页  则直接写入
    21. 		if (Num_Page == 0)
    22. 		{
    23. 			EEPROM_Page_write(buffer, addr, Num_Single);
    24. 			Wait_for_StandBy();
    25. 		}
    26. 		else
    27. 		{
    28. 			//先写入需要的页数
    29. 			while (Num_Page--)
    30. 			{
    31. 				EEPROM_Page_write(buffer, addr, EEPROM_PAGE_SIZE);
    32. 				Wait_for_StandBy();
    33.  
    34. 				//每写一页都需要将  数据指针和单元格地址指针进行位移
    35. 				buffer += EEPROM_PAGE_SIZE;
    36. 				addr += EEPROM_PAGE_SIZE;
    37. 			}
    38. 			//如果有凑不满一页的位数
    39. 			if (Num_Single)
    40. 			{
    41. 				EEPROM_Page_write(buffer, addr, Num_Single);
    42. 				Wait_for_StandBy();
    43. 			}
    44. 		}
    45. 	}
    46. 	//若没有对齐
    47. 	else
    48. 	{
    49. 		//算出凑满第一页后还需要写入的位数
    50. 		num = num - aaddr;
    51. 		//算出凑满后还需要写入的页数
    52. 		Num_Page = num / EEPROM_PAGE_SIZE;
    53. 		//算出多余的凑不满一页的位数
    54. 		Num_Single = num % EEPROM_PAGE_SIZE;
    55. 		
    56. 		//若凑满一页后 不满一页的的话 直接写入
    57. 		if (Num_Page == 0)
    58. 		{
    59. 			EEPROM_Page_write(buffer, addr, aaddr);
    60. 			Wait_for_StandBy();
    61. 		}
    62. 		else
    63. 		{
    64. 			//若有凑不满一页的
    65. 			if(count)
    66. 			{
    67. 				//先写入凑满一页的位数
    68. 				EEPROM_Page_write(buffer, addr, aaddr);
    69. 				Wait_for_StandBy();
    70.  
    71. 				//对数据指针和地址指针进行位移
    72. 				buffer += aaddr;
    73. 				addr += aaddr;
    74. 			}
    75.  
    76. 			//接下来的操作跟对齐的操作一样
    77. 			while (Num_Page--)
    78. 			{
    79. 				EEPROM_Page_write(buffer, addr, EEPROM_PAGE_SIZE);
    80. 				Wait_for_StandBy();
    81.  
    82. 				buffer += EEPROM_PAGE_SIZE;
    83. 				addr += EEPROM_PAGE_SIZE;
    84. 			}
    85.  
    86. 			if (Num_Single)
    87. 			{
    88. 				EEPROM_Page_write(buffer, addr, Num_Single);
    89. 				Wait_for_StandBy();
    90. 			}
    91. 		}
    92. 	}
    93. 	return 1;
    94. }

    连续读

    原理

     从上面第一张步骤：

    1、发送起始信号

    2、发送要接收的EEPROM地址和发送方向

    3、发送要接收的单元格地址

    4、发送要写入的EEPROM地址和接收方向

    5、开始接收数据

    6、接收完毕发送noack应答结束传输

    7、发送结束信号

    注意：以上的每一步都需要响应EV事件

    代码

    1. // EPPROM_Random_Read  :  连续读取
    2. // addr : 要读取的单元格地址
    3. // DATA ：读取的内容存放区
    4. // num  ：要读取的数据数量
    5. uint32_t EPPROM_Random_Read(u8 addr, u8 *Data, u16 num)
    6. {
    7. 	//*((u8 *)0x4001080c) |=0x80;
    8. 	while (I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))
    9. 	{
    10. 		if ((TimeOut_count--) == 0)
    11. 			return I2C_timeout_callback(99);
    12. 	}
    13. 	//发送起始信号
    14. 	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
    15.  
    16. 	//等待EV5事件响应
    17. 	TimeOut_count = I2C_time_out;
    18. 	while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    19. 	{
    20. 		if ((TimeOut_count--) == 0)
    21. 			return I2C_timeout_callback(21);
    22. 	}
    23.  
    24. 	//发送要写入的EEPROM的地址和读写方向   先选择写方向写入单元格地址
    25. 	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS, I2C_Direction_Transmitter);
    26.  
    27. 	//等待EV6事件响应
    28. 	TimeOut_count = I2C_time_out;
    29. 	while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS)
    30. 	{
    31. 		if ((TimeOut_count--) == 0)
    32. 			return I2C_timeout_callback(22);
    33. 	}
    34.  
    35. 	//发送要读取EEPROM的单元地方
    36. 	I2C_SendData(EEPROM_I2C, addr);
    37.  
    38. 	//等待EV8_2事件响应
    39. 	TimeOut_count = I2C_time_out;
    40. 	while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS)
    41. 	{
    42. 		if ((TimeOut_count--) == 0)
    43. 			return I2C_timeout_callback(23);
    44. 	}
    45.  
    46. 	//---------------------------------------------------------------------------------------------------------
    47. 	//-----------------------产生第二次起始信号---------------------------------------------------------
    48.  
    49. 	//发送起始信号
    50. 	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
    51.  
    52. 	//等待EV事件响应
    53. 	TimeOut_count = I2C_time_out;
    54. 	while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    55. 	{
    56. 		if ((TimeOut_count--) == 0)
    57. 			return I2C_timeout_callback(24);
    58. 	}
    59.  
    60. 	//*********************************读方向************************************************
    61. 	//发送要写入的EEPROM的地址和读方向
    62. 	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS, I2C_Direction_Receiver);
    63.  
    64. 	//等待EV事件响应
    65. 	TimeOut_count = I2C_time_out;
    66. 	while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS)
    67. 	{
    68. 		if ((TimeOut_count--) == 0)
    69. 			return I2C_timeout_callback(25);
    70. 	}
    71.  
    72. 	while (num--)
    73. 	{
    74. 		if (num == 0)
    75. 		{
    76. 			I2C_AcknowledgeConfig(EEPROM_I2C, DISABLE);
    77. 		}
    78. 		else
    79. 		{
    80. 			I2C_AcknowledgeConfig(EEPROM_I2C, ENABLE);
    81. 		}
    82.  
    83. 		//等待EV事件响应
    84. 		TimeOut_count = I2C_time_out;
    85. 		while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS)
    86. 		{
    87. 			if ((TimeOut_count--) == 0)
    88. 				return I2C_timeout_callback(26);
    89. 		}
    90.  
    91. 		*Data = I2C_ReceiveData(EEPROM_I2C);
    92.  
    93. 		// printf(" data = %d \r\n",*Data);
    94. 		Data++;
    95. 	}
    96. 	
    97. 	return 1;
    98. }

    主函数

    1.  
    2. #define  Test_num   256
    3.  
    4. /**
    5.   * @brief  主函数
    6.   * @param  无
    7.   * @retval 无
    8.   */
    9. int main(void)
    10. {
    11. 		u16 i;
    12.     u8 buff[Test_num];
    13.     u8 data[Test_num];
    14. 	
    15. 	//初始化要写入的数据
    16. 	for(i = 0 ; i < Test_num ; i++)
    17. 	{
    18. 		buff[i] = i;
    19. 	}
    20. 	
    21.   /*初始化USART 配置模式为 115200 8-N-1，中断接收*/
    22.   Debug_USART_Config();
    23. 		
    24. 	//初始化I2C
    25. 	I2C_EE_init();
    26.  
    27. 	/*调用printf函数，因为重定向了fputc，printf的内容会输出到串口*/
    28. 	printf("\r\n IIC实验 \r\n");	
    29.  
    30.    I2c_Buffer_write(buff , 0x45 , Test_num);
    31. 		
    32. 	 EPPROM_Random_Read(0x45 , data, Test_num);
    33. 	
    34. 	printf(" \r\n EEPROM读写实验结束 data =  \n");
    35.  
    36.   for ( i = 0; i < Test_num; i++)
    37.   {
    38.     printf("%d ",data[i]);
    39.   }
    40.  
    41.  
    42.   while(1)
    43. 	{	
    44. 		
    45. 	}	
    46.  
    47. }

    结果截图

     

  • 相关阅读:
    LeetCode-791. 自定义字符串排序【哈希表，字符串，排序】
    Android上传私有插件到私有MAVEN-PUBLISH
    Tomcat颁布自定义SSL(Https)证书
    Docker：Elasticsearch安装配置IK分词器
    [附源码]计算机毕业设计校园商铺Springboot程序
    基于python命令流及代码的Plaxis自动化建模
    吴恩达深度学习笔记：深度学习引言1.1-1.5
    【uvm】参数化Class中的静态属性
    【PHP】sign加签方法示例
    VUE3 TypeError: defineConfig is not a function
  • 原文地址：https://blog.csdn.net/weixin_47321452/article/details/127436174