STM32CubeMX GPIO模拟I2C读写M24C64

最新推荐文章于 2024-10-13 00:20:12 发布
最新推荐文章于 2024-10-13 00:20:12 发布
阅读量1w 收藏 70
点赞数 10
分类专栏： STM32CubeMX  GPIO模拟I2C读写M24C64 文章标签： STM32CubeMX  GPIO模拟I2C读写M24C64

STM32CubeMX GPIO模拟I2C读写M24C64

一、先了解一下硬件的连接，I2C_SDA和I2C_SCL分别接STM32的PB9、PB6
在这里插入图片描述
二、粗阅一下M24C64的数据手册,得知器件地址和存储器地址，器件地址是8bit，而存储器地址是16bit
在这里插入图片描述
三、下面是M24C64的写时序
在这里插入图片描述
四、下面是M24C64的读时序
在这里插入图片描述
五、下面是程序编写流程
在这里插入图片描述
六、看看时序参数在这里插入图片描述在这里插入图片描述
七、好啦！需要的知识点差不多都提到了开始搬砖
1、用STM32CubeMX配置生成工程，并打开工程。（具体怎么用这个软件这里不讲）
2、在我的工程里是这样配置的
《1》配置USART3，用打印读出来的数据与写入的是否一致
《2》配置PB6、PB9为开漏输出模式，配置如下：

void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_7, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6|GPIO_PIN_9, GPIO_PIN_RESET);

  /*Configure GPIO pin : PG7 */
  GPIO_InitStruct.Pin = GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

  /*Configure GPIO pins : PB6 PB9 */
  GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_9;						//PB6    PB9
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;				//开漏输出
  GPIO_InitStruct.Pull = GPIO_NOPULL;											//上下拉模式配置为既不上拉也不下拉
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;//IO口速度配置
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);									//初始化
}
在这里插入代码片

八、编写读程序，下面的代码是（安富莱电子 www.armfly.com）串行EEPROM 24xx驱动模块的代码，
代码如下：

/***********************************************************************************************
*
*
*
*
*
*
*
*
***************************************************************************************************/
#include "stm32f4xx_hal.h"


#define EE_MODEL_NAME		"AT24C64"
#define EE_DEV_ADDR			0xA0			/* 设备地址 */
#define EE_PAGE_SIZE		32				/* 页面大小(字节) */
#define EE_SIZE				(8*1024)		/* 总容量(字节) */
#define EE_ADDR_BYTES		2			 	/* 地址字节个数 */

// 定义I2C总线连接的GPIO端口, 用户只需要修改下面3行代码即可任意改变SCL和SDA的引脚 
#define GPIO_PORT_I2C	GPIOB			     // GPIO端口 
#define I2C_SCL_PIN		GPIO_PIN_6			 // 连接到SCL时钟线的GPIO 
#define I2C_SDA_PIN		GPIO_PIN_9			 // 连接到SDA数据线的GPIO 

/* 定义读写SCL和SDA的宏 */
#define I2C_SCL_1()  GPIO_PORT_I2C->BSRR = I2C_SCL_PIN							// SCL = 1 
#define I2C_SCL_0()  GPIO_PORT_I2C->BSRR = (uint32_t)I2C_SCL_PIN << 16U  		// SCL = 0 

#define I2C_SDA_1()  GPIO_PORT_I2C->BSRR = GPIO_PIN_9   						// SDA = 1 
#define I2C_SDA_0()  GPIO_PORT_I2C->BSRR = (uint32_t)GPIO_PIN_9 << 16U  		// SDA = 0 

#define I2C_SDA_READ()  (GPIO_PORT_I2C->IDR & GPIO_PIN_9)						// 读SDA口线状态 
#define I2C_SCL_READ()  (GPIO_PORT_I2C->IDR & I2C_SCL_PIN)						// 读SCL口线状态 


static void i2c_Delay(void)
{
	uint8_t i;
	for (i = 0; i < 40; i++);
}
void i2c_Start(void)
{
	// 当SCL高电平时，SDA出现一个下跳沿表示I2C总线启动信号 
	
	I2C_SDA_1();
	I2C_SCL_1();
	i2c_Delay();
	I2C_SDA_0();
	i2c_Delay();
	
	I2C_SCL_0();
	i2c_Delay();
}

void i2c_Stop(void)
{
	// 当SCL高电平时，SDA出现一个上跳沿表示I2C总线停止信号 
	I2C_SDA_0();
	I2C_SCL_1();
	i2c_Delay();
	I2C_SDA_1();
	i2c_Delay();
}
void i2c_SendByte(uint8_t _ucByte)
{
	uint8_t i;
	
	// 先发送字节的高位bit7 
	for (i = 0; i < 8; i++)
	{
		if (_ucByte & 0x80)
		{
			I2C_SDA_1();
		}
		else
		{
			I2C_SDA_0();
		}
		i2c_Delay();
		I2C_SCL_1();
		i2c_Delay();
		I2C_SCL_0();
		if (i == 7)
		{
			 I2C_SDA_1(); 	// 释放总线
		}
		_ucByte <<= 1;		// 左移一个bit 
		i2c_Delay();
	}
}
uint8_t i2c_ReadByte(void)
{
	uint8_t i;
	uint8_t value;

	/* 读到第1个bit为数据的bit7 */
	value = 0;
	for (i = 0; i < 8; i++)
	{
		value <<= 1;
		I2C_SCL_1();
		i2c_Delay();
		if (I2C_SDA_READ())
		{
			value++;
		}
		I2C_SCL_0();
		i2c_Delay();
	}
	return value;
}


uint8_t i2c_WaitAck(void)
{
	uint8_t re;

	I2C_SDA_1();	/* CPU释放SDA总线 */
//	i2c_Delay();
	I2C_SCL_1();	/* CPU驱动SCL = 1, 此时器件会返回ACK应答 */
	i2c_Delay();

	if (I2C_SDA_READ())	/* CPU读取SDA口线状态 */
	{
		re = 1;
	}
	else
	{
		re = 0;
	}

	I2C_SCL_0();
	i2c_Delay();
	return re;
}

void i2c_Ack(void)
{
	I2C_SDA_0();	/* CPU驱动SDA = 0 */
	i2c_Delay();
	I2C_SCL_1();	/* CPU产生1个时钟 */
	i2c_Delay();
	I2C_SCL_0();
	i2c_Delay();
	I2C_SDA_1();	/* CPU释放SDA总线 */
}

void i2c_NAck(void)
{
	I2C_SDA_1();	/* CPU驱动SDA = 1 */
	i2c_Delay();
	I2C_SCL_1();	/* CPU产生1个时钟 */
	i2c_Delay();
	I2C_SCL_0();
	i2c_Delay();
}

uint8_t i2c_CheckDevice(uint8_t _Address)
{
	uint8_t ucAck;

	if (I2C_SDA_READ() && I2C_SCL_READ())
	{
		i2c_Start();		/* 发送启动信号 */

		/* 发送设备地址+读写控制bit（0 = w， 1 = r) bit7 先传 */
		i2c_SendByte(_Address | I2C_WR);
		ucAck = i2c_WaitAck();	/* 检测设备的ACK应答 */

		i2c_Stop();			/* 发送停止信号 */

		return ucAck;
	}
	return 1;	/* I2C总线异常 */
}

uint8_t ee_CheckOk(void)
{
	if (i2c_CheckDevice(EE_DEV_ADDR) == 0)
	{
		return 1;
	}
	else
	{
		/* 失败后，切记发送I2C总线停止信号 */
		i2c_Stop();
		return 0;
	}
}
uint8_t ee_WriteBytes(uint8_t *_pWriteBuf, uint16_t _usAddress, uint16_t _usSize)
{
	uint16_t i,m;
	uint16_t usAddr;
	usAddr = _usAddress;
	for (i = 0; i < _usSize; i++)
	{
		/* 当发送第1个字节或是页面首地址时，需要重新发起启动信号和地址 */
		if ((i == 0) || (usAddr & (EE_PAGE_SIZE - 1)) == 0)
		{
			/*　第０步：发停止信号，启动内部写操作　*/
			i2c_Stop();

			/* 通过检查器件应答的方式，判断内部写操作是否完成, 一般小于 10ms
				CLK频率为200KHz时，查询次数为30次左右
			*/
			for (m = 0; m < 1000; m++)
			{
				/* 第1步：发起I2C总线启动信号 */
				i2c_Start();

				/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
				
//				#if EE_ADDR_A8 == 1
//					i2c_SendByte(EE_DEV_ADDR | I2C_WR | ((_usAddress >> 7) & 0x0E));	/* 此处是写指令 */
//				#else				
					i2c_SendByte(EE_DEV_ADDR | I2C_WR);
//				#endif
        
				/* 第3步：发送一个时钟，判断器件是否正确应答 */
				if (i2c_WaitAck() == 0)
				{
					break;
				}
			}
			if (m  == 1000)
			{
				goto cmd_fail;	/* EEPROM器件写超时 */
			}
			/* 第4步：发送字节地址，24C02只有256字节，因此1个字节就够了，如果是24C04以上，那么此处需要连发多个地址 */
			if (EE_ADDR_BYTES == 1)
			{
				i2c_SendByte((uint8_t)usAddr);
				if (i2c_WaitAck() != 0)
				{
					goto cmd_fail;	/* EEPROM器件无应答 */
				}
			}
			else
			{
				i2c_SendByte(usAddr >> 8);
				if (i2c_WaitAck()!= 0)
				{
					goto cmd_fail;	/* EEPROM器件无应答 */
				}

				i2c_SendByte(usAddr);
				if (i2c_WaitAck() != 0)
				{
					goto cmd_fail;	/* EEPROM器件无应答 */
				}
			}
		}

		/* 第6步：开始写入数据 */
		i2c_SendByte(_pWriteBuf[i]);

		/* 第7步：发送ACK */
		if (i2c_WaitAck() != 0)
		{
			goto cmd_fail;	/* EEPROM器件无应答 */
		}
		usAddr++;	/* 地址增1 */
	}

	/* 命令执行成功，发送I2C总线停止信号 */
	i2c_Stop();

	/* 通过检查器件应答的方式，判断内部写操作是否完成, 一般小于 10ms
		CLK频率为200KHz时，查询次数为30次左右
	*/
	for (m = 0; m < 1000; m++)
	{
		/* 第1步：发起I2C总线启动信号 */
		i2c_Start();

		/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */	
		#if EE_ADDR_A8 == 1
			i2c_SendByte(EE_DEV_ADDR | I2C_WR | ((_usAddress >> 7) & 0x0E));	/* 此处是写指令 */
		#else		
			i2c_SendByte(EE_DEV_ADDR | I2C_WR);	/* 此处是写指令 */
		#endif

		/* 第3步：发送一个时钟，判断器件是否正确应答 */
		if (i2c_WaitAck() == 0)
		{
			break;
		}
	}
	if (m  == 1000)
	{
		goto cmd_fail;	/* EEPROM器件写超时 */
	}

	/* 命令执行成功，发送I2C总线停止信号 */
	i2c_Stop();	

	return 1;

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
	/* 发送I2C总线停止信号 */
	i2c_Stop();
	return 0;
}
uint8_t ee_ReadBytes(uint8_t *_pReadBuf, uint16_t _usAddress, uint16_t _usSize)
{
	uint16_t i;

	/* 采用串行EEPROM随即读取指令序列，连续读取若干字节 */

	/* 第1步：发起I2C总线启动信号 */
	i2c_Start();

	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
	
	i2c_SendByte(EE_DEV_ADDR | I2C_WR);	/* 此处是写指令 */

	/* 第3步：发送ACK */
	if (i2c_WaitAck() != 0)
	{	
		goto cmd_fail;	/* EEPROM器件无应答 */
	}
	/* 第4步：发送字节地址，24C02只有256字节，因此1个字节就够了，如果是24C04以上，那么此处需要连发多个地址 */
	if (EE_ADDR_BYTES == 1)
	{
		i2c_SendByte((uint8_t)_usAddress);
		if (i2c_WaitAck() != 0)
		{
			goto cmd_fail;	/* EEPROM器件无应答 */
		}
	}
	else
	{
		i2c_SendByte(_usAddress >> 8);
		if (i2c_WaitAck() != 0)
		{
			goto cmd_fail;	/* EEPROM器件无应答 */
		}

		i2c_SendByte(_usAddress);
		if (i2c_WaitAck() != 0)
		{
			goto cmd_fail;	/* EEPROM器件无应答 */
		}
	}

	/* 第6步：重新启动I2C总线。下面开始读取数据 */
	i2c_Start();

	/* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */	
	
	i2c_SendByte(EE_DEV_ADDR | I2C_RD);	/* 此处是写指令 */

	/* 第8步：发送ACK */
	if (i2c_WaitAck() != 0)
	{
		goto cmd_fail;	/* EEPROM器件无应答 */
	}

	/* 第9步：循环读取数据 */
	for (i = 0; i < _usSize; i++)
	{
		_pReadBuf[i] = i2c_ReadByte();	/* 读1个字节 */

		/* 每读完1个字节后，需要发送Ack， 最后一个字节不需要Ack，发Nack */
		if (i != _usSize - 1)
		{
			i2c_Ack();	/* 中间字节读完后，CPU产生ACK信号(驱动SDA = 0) */
		}
		else
		{
			i2c_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
		}
	}
	/* 发送I2C总线停止信号 */
	i2c_Stop();

	return 1;	/* 执行成功 */

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
	/* 发送I2C总线停止信号 */
	i2c_Stop();
	return 0;
}

九、main函数

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_hal.h"
#include "usart.h"
#include "gpio.h"

/* USER CODE BEGIN Includes */
#include "bsp_eeprom_24xx.h"

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/
#define EEPROM_WriteAddress1    0x00
#define EEPROM_ReadAddress1     0x00
#define BufferSize1             (countof(Tx1_Buffer)-1)

/* Private macro -------------------------------------------------------------*/
#define countof(a) (sizeof(a) / sizeof(*(a)))

/* Private variables ---------------------------------------------------------*/
uint8_t Tx1_Buffer[] = "123456789abcdef";
uint8_t Rx1_Buffer[BufferSize1] = "";

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);

/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */    
int fputc(int ch, FILE *f)
{
  /* Place your implementation of fputc here */
  /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
  HAL_UART_Transmit(&huart3, (uint8_t *)&ch, 1, 0xFFFF);
  return ch;
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  *
  * @retval None
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
  uint16_t  i, m;
  uint8_t xTbuffer[256],xRbuffer[256];
  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART3_UART_Init();
  /* USER CODE BEGIN 2 */
	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_7,GPIO_PIN_SET); 
	HAL_Delay(100);
	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_7,GPIO_PIN_RESET); 
	  
	for(i=0;i<200;i++)
	{
	xTbuffer[i]=i;
	xRbuffer[i]=0;
	}
	ee_WriteBytes((uint8_t *)xTbuffer, 0, 40);	
	HAL_Delay(2000);
	printf(" \r\n");
	printf("\r\n");
	ee_ReadBytes((uint8_t *)xRbuffer, 0, 40);
	for (i = 0; i < 40; i++)
	{
		printf("xRbuffer %d  %d \r\n",i,xRbuffer[i]);
	}
	HAL_Delay(2000);
	printf("\r\n");
	printf("\r\n");
	printf("I2C CESHI\r\n");

	m=ee_WriteBytes(Tx1_Buffer,0,BufferSize1);

	printf("I2C_WriteByte  %d   %s\r\n",m,(uint8_t*)&Tx1_Buffer[0]);

	m=ee_ReadBytes(Rx1_Buffer,0,BufferSize1);

	printf("I2C_ReadByte  %d  %s\r\n",m,(uint8_t*)&Rx1_Buffer[0]);

	printf(" Rx1_Buffer is:%s,\t the BufferSize1 is%d\r\n",Rx1_Buffer,BufferSize1);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}

下面贴几个波形
1、向M24C64发送地址0xA0的时序图，图中的波形比好看；因为I2C总线的上拉电阻是1K，应答在第八个时钟后面，如图中红圈中蓝色的小波形
在这里插入图片描述
2.把应答位置的波形放大，如下图，那个绿色是小波形式怎么产生的呢？
在这里插入图片描述

	void i2c_SendByte(uint8_t _ucByte)
{
	uint8_t i;
	// 先发送字节的高位bit7 
	for (i = 0; i < 8; i++)
	{
		if (_ucByte & 0x80)
		{
			I2C_SDA_1();
		}
		else
		{
			I2C_SDA_0();
		}
		i2c_Delay();
		I2C_SCL_1();
		i2c_Delay();
		I2C_SCL_0();
		if (i == 7)
		{
			 I2C_SDA_1(); 	// 释放总线      这里产生的一个小波形
		}
		_ucByte <<= 1;		// 左移一个bit 
		i2c_Delay();
	}
}

产生的原因在发送完地址后释放总线是产生的，当I2C_SDA_1为高时，器件给出应答把I2C_SDA_1拉低，而产生的一个小波形，所以读到的应答应该是低电平。
在这里插入图片描述
因为I2C总线的上拉电阻是10K，波形上升沿不好看！！！！！！！！！！！
在这里插入图片描述

qq_43225938
关注
专栏目录
EEPROM 24C64读写程序
04-18
EEPROM 24C64读写程序
24c64 读写 程序
12-09
24c64 c51 读写, 我是参考这个调试成功的. 留意一下atmel的 24c64的规格书, 每次写入完要间隔一段时间好像是20多ms, 否则出错. 我就是在这个地方转了很久.
EEPROM存储电路（M24C64芯片）
weixin_30404405的博客
08-11 5644
电可擦写可编程只读存储器（Electrically Erasable Programmable Read-only Memory, EEPROM）实现掉电情况下保存数据，设计温湿度变送器采用M24C64芯片．芯片的1，2，3脚确定器件地址．5脚SDA和6脚SCL分别为串行数据引脚和串行同步时钟信号引脚，为IIC总线接口，均连接上拉电阻．7脚WP为写保护引脚，当接入高电平时，芯片数据均...
汽车级EEPROM 存储器 M24C64-DRMN3TP/K是电可擦除可编程只读存储器?它的功能特性有哪些?
12-22 758
M24C64-DRMN3TP/K是一款64 Kbit串行EEPROM汽车级设备，工作温度高达125°C。符合汽车标准AEC-Q100 1级规定的极高可靠性。
I2C（IIC）协议讲解
最新发布
caiji0169的博客
10-13 1446
I2C（Inter-Integrated Circuit）作为一种广泛应用于嵌入式系统、传感器等领域的通信协议，以其双线设计（SCL时钟线与SDA数据线）实现了主从设备的高效通信。本文从I2C的硬件架构出发，详细分析了在Linux系统中的I2C软件框架，涵盖了如何通过控制器驱动与设备驱动进行数据传输。我们将通过具体的读写操作与时序图，深入解析I2C协议的工作机制与信号传输原理，帮助你全面理解这一核心通信协议的实现细节。
eeprom_M24C64_M24C64EEPROM_page_
09-30
M24C64 eeprom驱动代码，基于stm8s实现，M24XX系列eeprom需要根据page大小做适配，IIC端口根据自己情况适配即可
STM32G030C8T6：EEPROM读写实验（I2C通信）--M24C64
AnChenliang_1002的博客
05-31 1600
本专栏记录STM32开发各个功能的详细过程，方便自己后续查看，当然也供正在入门STM32单片机的兄弟们参考；本小节的目标是，系统主频64 MHZ,采用高速外部晶振，实现PB11,PB10 引脚模拟I2C 时序，对M24C08 的EEPROM 进行读。原理：通过模拟I2C接(PB10:CLK,PB11:DTA)与M24C08 EEPROM进行读写实验。涉及到的知识：配置I2C通信，STM32CubeMX的使用。
rtthread iic读取M24C64的测试程序
杨飞的博客
02-23 1267
先加软件包 下面两个参数根据实际情况修改 修改board.h里面的引脚定义 添加驱动 /********EEPROM掉电保存*********/ uint8_t IIC2_WriteBuffer_Test[16], IIC2_ReadBuffer_Test[16]; void iic_write_test(void)//iic写 { uint16_t i; for(i=0; i<16; i++) IIC2_WriteBuffer_Test[i
24c64驱动
paradise_sunny的博客
12-02 1639
/* File : 24clxx.c This file is part of eeprom driver for 24clxx,such as at24c02/at24c16. COPYRIGHT © 2014 - 2016, Change Logs: Date Author Notes Depend on: i2c_bitops.c Note: 24c04 24c08 24c16 地址为8位，超过0xff地址后，注意页的选择读写 24c32 及以上地
EEPROM 存储芯片 m24c64 官方英文数据手册
03-11
这个文档是ST公司的EEPROM存储芯片M24C64的芯片手册，存储空间64kbit，手册手册为英文官方版本。
M24C64手册
01-01
24C64芯片手册。它采用IIC通信协议，可存储64K的数据。
M24C64芯片介绍
05-07
资料详细介绍了M24C64芯片体系结构，是英文版的，需要些时间阅读，我也是刚学习这个芯片，希望能给大家带来帮助。
IIC读写24C64存储IC的驱动程序
10-27
单片机开发项目经常用到的存储器读写驱动，24C64是一款用IIC读写数据的IC
stm32与24c64
10-09
stm32控制器通过I2C操作AT24c64的代码。 简单的库操作，完善的注解。
stm32f0 24C64 FM24C64程序
09-06
stm32f0 24C64 FM24C64程序 亲自测试 没有问题 移植非常方便
24c64C储存单元使用说明及程序控制.pdf
10-23
24C64提供 65536 个位，它们是以字节方式进行组织的。通过设置不同的地址，可以实现多达 8 个芯片共享两线总线。 它被广泛应用于工业、 化工等需要低功耗与低电压的领域。同时，它还提供诸如 4.5V~5.5V、2.7V~5.5V、2.5V~5.5V与 1.8V~5.5V 各种工作电压范围的芯片，从而使其应用更加通用。
9.基于STM32CubeMx软件模拟I2C通信
tao_sc的博客
03-30 2029
使用： MEM_Write (ReceiveString,0x01,4); HAL_Delay (1000); MEM_Read (I2CString,0x01,4); 驱动程序（最后两个自己编写，其余底层驱动官方提供） #include "i2c.h" //#define DELAY_TIME 20 #define DELAY_TIME 20 //PB6_SCL //PB7_SDA /** * @brief SDA线输入模式配置 * @param None * @re
STM32基础回顾——详解I²C（GPIO模拟I2C）
m0_56145255的博客
02-21 7982
文章目录前言IIC协议数据有效性开始信号和结束信号应答信号完整传输流程EEPROM介绍结构组成设备地址写AT24Cxx读AT24CxxIIC模拟硬件设计IIC模拟软件设计源码解析运行结果源码 前言 这一篇博客是根据自己的需要，以及为了面试岗位的需求，所以专门来再次学习一遍SPI和IIC两个常用的通信协议。这里使用的开发板是STM32F03_MIN 也希望这篇博客能对你有一定的帮助！ IIC协议 I²C ，通常被读作“I方C”，它是一种多主从架构的串行通信总线。在1980年由飞利浦公司设计，用于让主板，嵌
M24C64-EEPROM
yeweiliang_93的博客
09-08 1134
M24C64-EEPROM摘要及其I2C实现
stm32cubemx gpio模拟输入
10-17
在STM32CubeMX中，模拟输入可以通过GPIO的模式设置来实现。具体步骤如下： 1. 打开STM32CubeMX软件，选择对应的芯片型号。 2. 在Pinout & Configuration选项卡中，选择需要配置的GPIO引脚。 3. 在右侧的Mode下拉菜单中选择Analog模式。 4. 在Configuration下拉菜单中选择Analog模式对应的功能，例如ADC或DAC等。 5. 根据需要进行其他配置，例如上拉/下拉电阻、输出类型等。 6. 点击Generate Code按钮生成代码。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值