STM32硬件I2C测试读写EEPROM

已于 2024-01-10 18:53:48 修改
阅读量1k 收藏 11
点赞数 14
分类专栏： STM32开发 文章标签： stm32 单片机 嵌入式硬件
于 2024-01-10 18:51:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sugang1990/article/details/135510378
版权

STM32硬件I2C测试读写EEPROM

一、测试环境

使用正点原子STM32F103，精英V2开发板上 I2C1（B6，B7）测试eeprom 读写数据，网上都说stm32硬件I2C有问题，不提倡使用硬件I2C。

在这里插入图片描述

二、程序测试

1.主程序实现

main.c代码如下：

#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "lcd.h"
#include "usart.h"
#include "i2c.h"


uint8_t I2C_EE_Test(void);

int main(void)
{
	delay_init();	    	 //延时函数初始化	  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
	uart_init(115200);	 	//串口初始化为115200
	LED_Init();		  		//初始化与LED连接的硬件接口
	I2C1_Init();

	printf("stm32 i2c master test:\r\n");

	I2C_EE_Test();

	while(1)
	{
		LED0=!LED0;//提示系统正在运行	
		delay_ms(300);	   
	}
}

uint8_t I2C_EE_Test(void)
{	
	uint8_t ReadData[256]={0};
	uint8_t WriteDdta[256]={0};
	uint16_t i;

	//初始化写入数组
	for(i = 0; i < 256; i++)
	{
		WriteDdta[i]=i; 
	}

	//向EEPROM从地址为0开始写入256个字节的数据 
	I2C_EE_BufferWrite(WriteDdta, 0, 256);
	//等待EEPROM写入数据完成 
	EEPROM_WaitForWriteEnd();	 
	//向EEPROM从地址为0开始读出256个字节的数据
	EEPROM_Read(ReadData, 0, 256);

	for (i=0; i<256; i++)
	{	
		if(ReadData[i] != WriteDdta[i])
		{
			EEPROM_ERROR("0x%02X ", ReadData[i]);
			EEPROM_ERROR("错误:I2C EEPROM写入与读出的数据不一致\n\r");
			return 0;
		}
		
		printf("0x%02X ", ReadData[i]);
		if(i%16 == 15)    
			printf("\n\r");   
	}
	
	EEPROM_INFO("I2C(AT24C02)读写测试成功\n\r");
	return 1;
}

void Delay(__IO uint32_t nCount)	 //简单的延时函数
{
	for(; nCount != 0; nCount--);
}

2.I2C1驱动

i2c.c代码如下：

#include "i2c.h"

//设置等待时间
static __IO uint32_t  I2CTimeout = I2CT_LONG_TIMEOUT;   

//等待超时，打印错误信息
static uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode);

void I2C1_Init(void)
{
	GPIO_InitTypeDef    GPIO_InitStuctrue;
	I2C_InitTypeDef     I2C_InitStuctrue;

	//开启GPIO外设时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	//开启IIC外设时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

	//SCL引脚-复用开漏输出
	GPIO_InitStuctrue.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStuctrue.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStuctrue.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStuctrue);

	//SDA引脚-复用开漏输出
	GPIO_InitStuctrue.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStuctrue.GPIO_Pin = GPIO_Pin_7;
	GPIO_InitStuctrue.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStuctrue);

	//IIC结构体成员配置
	I2C_InitStuctrue.I2C_Ack = I2C_Ack_Enable;
	I2C_InitStuctrue.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
	I2C_InitStuctrue.I2C_ClockSpeed = EEPROM_I2C_BAUDRATE;
	I2C_InitStuctrue.I2C_DutyCycle = I2C_DutyCycle_2;
	I2C_InitStuctrue.I2C_Mode = I2C_Mode_I2C;
	I2C_InitStuctrue.I2C_OwnAddress1 = STM32_I2C_OWN_ADDR;
	I2C_Init(I2C1, &I2C_InitStuctrue);
	I2C_Cmd(I2C1, ENABLE);

}

//向EEPROM写入一个字节
void  EEPROM_Byte_Write(uint8_t addr,uint8_t data)
{
	//发送起始信号
	I2C_GenerateSTART(EEPROM_I2C,ENABLE);
	//检测EV5事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT)==ERROR);
	//发送设备写地址
	I2C_Send7bitAddress(EEPROM_I2C,EEPROM_I2C_Address,I2C_Direction_Transmitter);
	//检测EV6事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)==ERROR);
	//发送要操作设备内部的地址
	I2C_SendData(EEPROM_I2C,addr);
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING )==ERROR);
  	I2C_SendData(EEPROM_I2C,data);
	//检测EV8_2事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED )==ERROR);
	//发送停止信号
	I2C_GenerateSTOP(EEPROM_I2C,ENABLE);
	
}

//向EEPROM写入多个字节
uint32_t  EEPROM_Page_Write(uint8_t addr,uint8_t *data,uint16_t Num_ByteToWrite)
{
	
	 I2CTimeout = I2CT_LONG_TIMEOUT;
	//判断IIC总线是否忙碌
	while(I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))   
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
	} 
	//重新赋值
	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送起始信号
	I2C_GenerateSTART(EEPROM_I2C,ENABLE);
	//检测EV5事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT)==ERROR)
	{
		 if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(2);
	} 
	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送设备写地址
	I2C_Send7bitAddress(EEPROM_I2C,EEPROM_I2C_Address,I2C_Direction_Transmitter);
	//检测EV6事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)==ERROR)
	{
		 if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
	} 

	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送要操作设备内部的地址
	I2C_SendData(EEPROM_I2C,addr);
	//检测EV8事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING )==ERROR)
	{
		 if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
	} 

	while(Num_ByteToWrite)
	{
		I2C_SendData(EEPROM_I2C,*data);
		I2CTimeout = I2CT_FLAG_TIMEOUT;
		while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING )==ERROR)
		{
				if((I2CTimeout--) == 0) return   I2C_TIMEOUT_UserCallback(5);
		} 
		 Num_ByteToWrite--;
		 data++;
	}

	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//检测EV8_2事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
	} 
	//发送停止信号
	I2C_GenerateSTOP(EEPROM_I2C,ENABLE);
	 return 1;
}

//向EEPROM读取多个字节
uint32_t EEPROM_Read(uint8_t *data,uint8_t addr,uint16_t Num_ByteToRead)
{
	 I2CTimeout = I2CT_LONG_TIMEOUT;
	//判断IIC总线是否忙碌
	while(I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))   
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
	} 
	
	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送起始信号
	I2C_GenerateSTART(EEPROM_I2C,ENABLE);
	//检测EV5事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
	} 
	
	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送设备写地址
	I2C_Send7bitAddress(EEPROM_I2C,EEPROM_I2C_Address,I2C_Direction_Transmitter);
	//检测EV6事件等待从机应答
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
	}
  
	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送要操作设备内部存储器的地址
	I2C_SendData(EEPROM_I2C,addr);
	//检测EV8事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
	}
	I2CTimeout = I2CT_FLAG_TIMEOUT;
	//发送起始信号
	I2C_GenerateSTART(EEPROM_I2C,ENABLE);
	//检测EV5事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
	}
	I2CTimeout = I2CT_FLAG_TIMEOUT;	 
	//发送设备读地址
	I2C_Send7bitAddress(EEPROM_I2C,EEPROM_I2C_Address,I2C_Direction_Receiver);
	//检测EV6事件
	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
	}
	 
	while(Num_ByteToRead--)
	{
		//是否是最后一个字节，若是则发送非应答信号
	if( Num_ByteToRead==0)
	{
		//发送非应答信号
		I2C_AcknowledgeConfig(EEPROM_I2C,DISABLE);
		//发送停止信号
		I2C_GenerateSTOP(EEPROM_I2C,ENABLE);
	}
	 
	I2CTimeout = I2CT_FLAG_TIMEOUT;	 
	//检测EV7事件
   	while( I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_RECEIVED )==ERROR)
	{
		if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
	}
	 
	*data=I2C_ReceiveData(EEPROM_I2C);
	data++; 
	 
	}
	
	//重新开启应答信号
	I2C_AcknowledgeConfig(EEPROM_I2C,ENABLE);
  	return 1;
}
void I2C_EE_BufferWrite(uint8_t* pBuffer,uint8_t WriteAddr, uint16_t NumByteToWrite)
{
  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;
  //I2C_PageSize=8
  Addr = WriteAddr % I2C_PageSize;
  count = I2C_PageSize - Addr;
  NumOfPage =  NumByteToWrite / I2C_PageSize;
  NumOfSingle = NumByteToWrite % I2C_PageSize;
 
  /* 写入数据的地址对齐，对齐数为8 */
  if(Addr == 0) 
  {
    /* 如果写入的数据个数小于8 */
    if(NumOfPage == 0) 
    {
      EEPROM_Page_Write(WriteAddr, pBuffer, NumOfSingle);
      EEPROM_WaitForWriteEnd();
    }
    /* 如果写入的数据个数大于8 */
    else  
    {
			//按页写入
      while(NumOfPage--)
      {
        EEPROM_Page_Write(WriteAddr, pBuffer, I2C_PageSize); 
    	  EEPROM_WaitForWriteEnd();
        WriteAddr +=  I2C_PageSize;
        pBuffer += I2C_PageSize;
      }
      //不足一页(8个)单独写入
      if(NumOfSingle!=0)
      {
        EEPROM_Page_Write(WriteAddr, pBuffer, NumOfSingle);
        EEPROM_WaitForWriteEnd();
      }
    }
  }
  /*写的数据的地址不对齐*/
  else 
  {
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / I2C_PageSize;
      NumOfSingle = NumByteToWrite % I2C_PageSize;	
      
      if(count != 0)
      {  
        EEPROM_Page_Write(WriteAddr, pBuffer, count);
        EEPROM_WaitForWriteEnd();
        WriteAddr += count;
        pBuffer += count;
      } 
      
      while(NumOfPage--)
      {
        EEPROM_Page_Write(WriteAddr, pBuffer, I2C_PageSize);
        EEPROM_WaitForWriteEnd();
        WriteAddr +=  I2C_PageSize;
        pBuffer += I2C_PageSize;  
      }
      if(NumOfSingle != 0)
      {
        EEPROM_Page_Write(WriteAddr, pBuffer, NumOfSingle); 
        EEPROM_WaitForWriteEnd();
      }
    } 
}

uint32_t EEPROM_WaitForWriteEnd(void)
{
	I2CTimeout = I2CT_FLAG_TIMEOUT;	
	
	do
	{
		I2CTimeout = I2CT_FLAG_TIMEOUT;
		//发送起始信号
		I2C_GenerateSTART(EEPROM_I2C,ENABLE);
		//检测EV5事件
		while( I2C_GetFlagStatus(EEPROM_I2C,I2C_FLAG_SB )==RESET)
		{
					if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
			}
		I2CTimeout = I2CT_FLAG_TIMEOUT;	
		//发送设备写地址
		I2C_Send7bitAddress(EEPROM_I2C,EEPROM_I2C_Address,I2C_Direction_Transmitter);
		
	}while( (I2C_GetFlagStatus(EEPROM_I2C,I2C_FLAG_ADDR )==RESET) && (I2CTimeout--) );
	
	//发送停止信号
	I2C_GenerateSTOP(EEPROM_I2C,ENABLE);
	return 1;
}



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

i2c.h代码如下：

#ifndef __I2C_H
#define __I2C_H
#include <stdio.h>
#include "sys.h"

//IIC1
#define  EEPROM_I2C                       I2C1
#define  EEPROM_I2C_BAUDRATE              400000

//STM32自身地址1 与从机设备地址不相同即可(7位地址)
#define   STM32_I2C_OWN_ADDR             0x6f
//EEPROM设备地址
#define   EEPROM_I2C_Address             0XA0
#define   I2C_PageSize                     8

//等待次数
#define I2CT_FLAG_TIMEOUT         ((uint32_t)0x1000)
#define I2CT_LONG_TIMEOUT         ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))

/*信息输出*/
#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 I2C1_Init(void);
void EEPROM_Byte_Write(uint8_t addr,uint8_t data);	
uint32_t  EEPROM_WaitForWriteEnd(void);	
uint32_t  EEPROM_Page_Write(uint8_t addr,uint8_t *data,uint16_t Num_ByteToWrite);																					
uint32_t  EEPROM_Read(uint8_t *data,uint8_t addr,uint16_t Num_ByteToRead);
void I2C_EE_BufferWrite(uint8_t* pBuffer,uint8_t WriteAddr, uint16_t NumByteToWrite);

#endif

3.使用逻分抓I2C数据

在这里插入图片描述

4.测试结果

在这里插入图片描述

三、gitee路径

https://gitee.com/sugang2022/stm32f103zet6.git
sugang1990
关注
  • 14
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32F10x_硬件I2C读写EEPROM
11-13
在STM32F10x中，硬件I2C接口提供了完整的I2C协议支持，包括7位或10位地址模式、快速模式（400kHz）和快速加模式（1MHz）。使用STM32的标准外设库（HAL库或LL库），可以方便地配置和控制硬件I2C。 接下来，我们将...
用stm32硬件I2C和模拟I2C读写EEPROM
08-31
硬件I2C读写流程如下： 1. 发送启动条件。 2. 发送EEPROM的7位地址和读/写位（读取时为0，写入时为1）。 3. 对于写入，发送要写入的地址和数据；对于读取，等待应答信号，然后读取数据。 4. 发送停止条件。 模拟I2C...
HAL库STM32常用外设教程（九）—— I2C通信（读写EEPROM）
That_Assassin的博客
03-30 6867
I2C(Inter-Integrated Circuit)接口，有时也写作IIC，是一种串行数字总线接口。I2C接口只有两根信号线，总线上可以连接多个设备，硬件实现简单，可拓展性强。I2C通信协议可以通过普通GPIO引脚进行软件模拟。I2C接口主要用于通信速率要求不高，以及多个器件之间通信的应用场景。本文讲解了I2C的基础知识，其中涉及了I2C的通信原理、HAL库驱动程序、I2C的三种发送模式（轮询（阻塞）、中断、DMA）。
STM32G030C8T6：EEPROM读写实验（I2C通信）--M24C64
AnChenliang_1002的博客
05-31 1111
本专栏记录STM32开发各个功能的详细过程，方便自己后续查看，当然也供正在入门STM32单片机的兄弟们参考；本小节的目标是，系统主频64 MHZ,采用高速外部晶振，实现PB11,PB10 引脚模拟I2C 时序，对M24C08 的EEPROM 进行读。原理：通过模拟I2C接(PB10:CLK,PB11:DTA)与M24C08 EEPROM进行读写实验。涉及到的知识：配置I2C通信，STM32CubeMX的使用。
STM32 使用硬件I2C接口读写EEPROM
04-15 2630
CPU作为老板，发钱需要自己转帐，收钱需要自己看信息，是一种悲哀。 上一篇《STM32 使用IO口模拟I2C时序》，我们讲述了“论老板如何自己发钱和收钱”。 这一篇《STM32 使用硬件I2C接口读写EEPROM》，我们来讲述“论老板如何雇佣员工帮忙发钱和收钱”。 我们先来招聘一个职位： 岗位职责： 1、自动产生I2C时序，向其他芯片发送（发钱）或者接收（收钱）数据。 任职要求： 1...
STM32硬件I2C与软件模拟I2C超详解
热门推荐
k666499436的博客
05-12 5万+
I2C协议时序详细解剖，硬件I2C的实现，已经软件模拟I2C的实现，以及EEPROM的详细介绍
STM32F1 - I2C读写EEPROM
Enjoy
02-19 291
I2C硬件模块 读写 AT24C02
STM32系统学习——I2C （读写EEPROM）
夏夜晚风_的博客
11-15 3559
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 ...
STM32I2C读写EEPROM实验
m0_47235364的博客
11-22 215
2）支持多种数据传输方式：STM32 I2C总线支持不同的数据传输方式，如使用7位或10位地址、读取或写入数据，以及使用不同的数据传输模式（如批处理、字节模式等）。4）易于使用：STM32 I2C总线通过硬件支持，使得I2C通信的配置和操作非常简单。3）支持高速模式：STM32 I2C总线支持高达400kHz的高速模式，这使得它非常适合数据传输速度较快的应用。1）支持多主机模式：STM32 I2C总线支持多主机模式，可以进行多个设备之间的通信。（3）使能时钟：外部晶振，配置时钟。写时序：（每次写一位）
STM32模拟I2C时序读写EEPROM精简版
XYZ
01-20 9232
平台：STM32ZET6（核心板）+ST-LINK/V2+SD卡+USB串口线+外部EEPROM（不需要上拉电阻） 工程介绍：主要文件在USER组中，bsp_i2c_ee.c，bsp_i2c_ee.h，bsp_eeprom.c，bsp_eeprom.h和main.c，其中bsp_i2c_ee.c中主要时基本的模拟I2C时序，而bsp_eeprom.c中主要利用前一个文件中定义的基本操作，进行EE...
STM32学习之I2C协议（读写EEPROM）
图个吉利儿的博客
03-04 1368
关于STM32学习分享 第七章 I2C协议（读写EEPROM） 文章目录关于STM32学习分享前言二、代码1.i2c.c2.i2c.h3.main.c总结 前言 开始！开始！单片机的I2C协议（读写EEPROM）。 # 一、I2C协议（读写EEPROM） 1、SCL 2、SDA 二、代码 1.i2c.c 代码如下（示例）： #include "i2c.h" //IIC配置 void I2C_EE_Config(void) { I2C_InitTypeDef I2C_InitStructur
STM32学习之I2C读写EEPROM学习
ren18281713749的博客
07-27 1151
I2C通信协议之间常用连接方式如下： 一个I2C只使用两条总线线路，一条双向串行数据线，一条串行时钟线，数据线用来表示数据，时钟线用来同步数据收发。 每个连接到总线的设备都有一个独立的地址，主机利用这个地址进行不同设备之间的访问。 总线通过上拉电阻连接到电源。当I2C设备空闲时，会输出高阻态，而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。 多个主机同时使用总线时，为了...
STM32-F407-硬件I2C读取EEPROM数据
12-31
在这个项目中，我们关注的是如何利用STM32F407的硬件I2C接口来读取外部EEPROM的数据。硬件I2C（Inter-Integrated Circuit）是一种串行通信协议，常用于连接低速外围设备，如EEPROM、传感器等。 首先，我们需要了解...
STM32-I2C-EEPROM.zip
04-11
STM32-I2C-EEPROM.zip 是一个与嵌入式系统开发相关的压缩包，主要涉及STM32微控制器和I2C通信协议与EEPROM的交互。STM32是意法半导体（STMicroelectronics）推出的一系列基于ARM Cortex-M内核的微控制器，广泛应用于...
I2C—读写EEPROM_keil_读写EEPROM_I2C—读写EEPROM_stm32eeprom_partszrq_
10-04
总结来说，STM32通过I2C与EEPROM的交互涉及硬件配置、I2C协议的软件实现以及读写操作流程。理解并熟练掌握这些步骤对于进行STM32的嵌入式开发至关重要。在实际项目中，开发者可能还会遇到其他挑战，如EEPROM的容量...
STM32高级运动控制系统教程
stm32d1219的博客
07-22 1363
本教程详细介绍了如何在STM32嵌入式系统中实现高级运动控制系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的高级运动控制系统。在未来的发展中，高级运动控制系统可以进一步结合人工智能和大数据分析技术，提升系统的智能化程度，为运动设备的监测和控制提供更强大的技术支持。希望本教程能够为读者提供有价值的参考和指导，助力高级运动控制系统的开发与实现。
STM32智能医疗监控系统教程
stm32d1219的博客
07-21 1426
本教程详细介绍了如何在STM32嵌入式系统中实现智能医疗监控系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能医疗监控系统。
STM32嵌入式人工智能边缘计算应用教程
最新发布
2401_84204806的博客
07-23 855
本教程详细介绍了如何在STM32嵌入式系统中实现嵌入式人工智能边缘计算系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的嵌入式人工智能边缘计算系统。
stm32 i2c读写eeprom hal
07-27
你可以使用STM32的HAL库来实现I2C读写EEPROM。首先，确保已经正确配置了I2C外设和相关引脚。然后，按照以下步骤进行操作： 1. 初始化I2C外设：使用`HAL_I2C_Init()`函数初始化I2C外设。 2. 配置EEPROM地址：在发送I2C读写请求之前，需要设置EEPROM的地址。这可以通过向I2C外设发送一个写入EEPROM地址的I2C Start信号，然后发送EEPROM地址字节来实现。 3. 发送数据：如果要向EEPROM写入数据，可以使用`HAL_I2C_Master_Transmit()`函数发送数据。如果要从EEPROM读取数据，可以使用`HAL_I2C_Master_Receive()`函数接收数据。 下面是一个示例代码，演示如何使用HAL库进行I2C读写EEPROM： ```c #include "stm32xxxx.h" // 根据具体的芯片型号选择头文件 #define EEPROM_ADDRESS 0xA0 // EEPROM的I2C地址 // 初始化I2C外设 void I2C_Init(void) { // I2C外设初始化代码 // ... } // 向EEPROM写入数据 void EEPROM_Write(uint16_t address, uint8_t* data, uint16_t size) { // 发送I2C Start信号和EEPROM地址 HAL_I2C_Master_Transmit(&hi2c1, EEPROM_ADDRESS, (uint8_t*)&address, 2, HAL_MAX_DELAY); // 发送数据到EEPROM HAL_I2C_Master_Transmit(&hi2c1, EEPROM_ADDRESS, data, size, HAL_MAX_DELAY); } // 从EEPROM读取数据 void EEPROM_Read(uint16_t address, uint8_t* data, uint16_t size) { // 发送I2C Start信号和EEPROM地址 HAL_I2C_Master_Transmit(&hi2c1, EEPROM_ADDRESS, (uint8_t*)&address, 2, HAL_MAX_DELAY); // 从EEPROM接收数据 HAL_I2C_Master_Receive(&hi2c1, EEPROM_ADDRESS, data, size, HAL_MAX_DELAY); } ``` 请注意，上述代码中的`hi2c1`是I2C外设的句柄，具体根据你的芯片型号和使用的外设进行修改。此外，还需要根据EEPROM的具体规格和通信协议进行相应的配置。 希望以上信息对你有所帮助！如有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值