STM32F103RC引脚模拟I2C操作EEPROM(24C16)的方法总结

最新推荐文章于 2023-08-09 19:51:38 发布
最新推荐文章于 2023-08-09 19:51:38 发布
阅读量2.4k 收藏 7
点赞数
分类专栏： STM32 EEPROM I2C 文章标签： STM32 EEPROM I2C 24C16
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lnniyunlong99/article/details/103332632
版权
STM32 同时被 3 个专栏收录
27 篇文章 9 订阅
订阅专栏
I2C
3 篇文章 0 订阅
订阅专栏
EEPROM
1 篇文章 0 订阅
订阅专栏

要使用24C16，首先了解一下它。

1、24C16的总容量是16K bit，转换成字节除以8，即为 2K byte。

2、DEVICE ADDRESS的前四位固定为1010，紧跟着的三位，范围是 000-111(对应十进制0-7)，代表着总共有8页。

3、WORD ADDRESS是每一页的字节数，范围是00000000-11111111(十进制0-255)，每一页有256个字节，0-255是对应的地址索引。

4、序号2说明了有8页，序号3说明了每一页有256个字节，因此 8*256 = 2048 byte，和序号1的说明是吻合的。

在给出代码之前，先看一张图

测试代码如下：

#ifndef __STM32F10X_H
#define __STM32F10X_H
#include "stm32f10x.h"
#endif

#ifndef __Z_HARDWARE_EEPROM_H
#define __Z_HARDWARE_EEPROM_H
#include "z_hardware_eeprom.h"
#endif

#ifndef __Z_HARDWARE_USART2_H
#define __Z_HARDWARE_USART2_H
#include "z_hardware_usart2.h"
#endif

#ifndef __Z_UTIL_TIME_H
#define __Z_UTIL_TIME_H
#include "z_util_time.h"
#endif

#ifndef __Z_HARDWARE_LED_H
#define __Z_HARDWARE_LED_H
#include "z_hardware_led.h"
#endif

int main(void)
{
	u16 i;
//	u16 flag;
	u8 buf[256];
	
	init_eeprom();
	init_led();
	init_hardware_usart2_dma(9600);
	delay_ms(1000);
	
	buf[0] = 00;
	func_usart2_dma_send_bytes(buf, 1);
	delay_ms(1000);
	
//TESTOK
	for(i = 0; i < 256; i ++)
	{
//		buf[i] = 0xff - i;
		buf[i] = i;
	}
	func_i2c_writebytes(buf, 1536, 256);
	func_usart2_dma_send_bytes(buf, 256);
	delay_ms(1000);

//	memset(buf, 0, 256);
//	if(func_i2c_readbytes(buf, 256, 0) == ENABLE)
//	{
//		func_usart2_dma_send_bytes(buf, 256);
//		delay_ms(1000);
//	}
//	
//	memset(buf, 0, 256);
//	if(func_i2c_readbytes(buf, 256, 256) == ENABLE)
//	{
//		func_usart2_dma_send_bytes(buf, 256);
//		delay_ms(1000);
//	}
	
//	memset(buf, 0, 256);
//	if(func_i2c_readbytes(buf, 256, 512) == ENABLE)
//	{
//		func_usart2_dma_send_bytes(buf, 256);
//		delay_ms(1000);
//	}

//	memset(buf, 0, 256);
//	if(func_i2c_readbytes(buf, 200, 128) == ENABLE)
//	{
//		func_usart2_dma_send_bytes(buf, 200);
//		delay_ms(1000);
//	}

	memset(buf, 0, 256);
	if(func_i2c_readbytes(buf, 256, 1536) == ENABLE)
	{
		func_usart2_dma_send_bytes(buf, 256);
		delay_ms(1000);
	}
	
	for(;;)
	{
		func_led_a_toggle();
		delay_ms(1000);
	}
	
}

测试效果如下：

eeprom的驱动代码如下（仅供参考）：

z_hardware_eeprom.h

#ifndef __STM32F10X_H
#define __STM32F10X_H
#include "stm32f10x.h"
#endif

#define EEPROM_HOST_ADDR 0xA0
#define EEPROM_I2C_WR	0
#define EEPROM_I2C_RD	1


void init_eeprom(void);
void func_i2c_delay_us(uint16_t  time_us);
u8 func_i2c_start(void);
void func_i2c_stop(void);
void func_i2c_ack(void);
void func_i2c_noack(void);
u8 func_get_i2c_waitack(void);
void func_i2c_sendbyte(uint8_t sendyyte);
u8 func_i2c_receivebyte(void);
u8 func_i2c_writebyte(uint8_t writebyte, uint16_t writeaddr);
u8 func_i2c_writebytes(uint8_t *_pwritebuf, uint16_t _usaddr, uint16_t _ussize);
u8 func_i2c_readbytes(uint8_t* pbuffer, uint16_t len, uint16_t addr_read);

z_hardware_eeprom.c

#ifndef __Z_HARDWARE_EEPROM_H
#define __Z_HARDWARE_EEPROM_H
#include "z_hardware_eeprom.h"
#endif

void init_eeprom(void)
{
	GPIO_InitTypeDef GPIO_InitStructure_A;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitStructure_A.GPIO_Pin = GPIO_Pin_4;//WP
  GPIO_InitStructure_A.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure_A.GPIO_Mode = GPIO_Mode_Out_OD;
  GPIO_Init(GPIOA, &GPIO_InitStructure_A);
	
	GPIO_InitStructure_A.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6;//GPIO_Pin_5   GPIO_Pin_6
  GPIO_InitStructure_A.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure_A.GPIO_Mode = GPIO_Mode_Out_OD;//GPIO_Mode_AF_OD
  GPIO_Init(GPIOA, &GPIO_InitStructure_A);
	
	GPIO_ResetBits(GPIOA , GPIO_Pin_4);//write protection disable
}

void func_i2c_delay_us(uint16_t  time_us)
{
  uint16_t i,j;
  for( i=0;i<time_us;i++ )
  {
		for( j=0;j<10;j++ );
  }
}

void func_wp_enable(void)
{
	GPIO_SetBits(GPIOA , GPIO_Pin_4);
}

void func_wp_disable(void)
{
	GPIO_ResetBits(GPIOA , GPIO_Pin_4);
}

void func_set_scl_high(void)
{
	GPIO_SetBits(GPIOA , GPIO_Pin_5);
}

void func_set_scl_low(void)
{
	GPIO_ResetBits(GPIOA , GPIO_Pin_5);
}

void func_set_sda_high(void)
{
	GPIO_SetBits(GPIOA , GPIO_Pin_6);
}

void func_set_sda_low(void)
{
	GPIO_ResetBits(GPIOA , GPIO_Pin_6);
}

u8 func_get_scl(void)
{
	return GPIO_ReadInputDataBit(GPIOA , GPIO_Pin_5);
}

u8 func_get_sda(void)
{
	return GPIO_ReadInputDataBit(GPIOA , GPIO_Pin_6);
}

u8 func_i2c_start(void)
{
	func_set_sda_high();
	func_set_scl_high();
	func_i2c_delay_us(5);
	if(!func_get_sda())
	{
		return DISABLE;
	}
	func_set_sda_low();
	func_i2c_delay_us(1);
	if(func_get_sda())
	{
		return DISABLE;
	}
	func_set_sda_low();
	func_i2c_delay_us(4);
	return ENABLE;
}

void func_i2c_stop(void)
{
	func_set_scl_low();
	func_i2c_delay_us(1);
	func_set_sda_low();
	func_i2c_delay_us(1);
	func_set_scl_high();
	func_i2c_delay_us(5);
	func_set_sda_high();
	func_i2c_delay_us(5);
}

void func_i2c_ack(void)
{	
	func_set_scl_low();
	func_i2c_delay_us(1);
	func_set_sda_low();
	func_i2c_delay_us(1);
	func_set_scl_high();
	func_i2c_delay_us(5);
	func_set_scl_low();
	func_i2c_delay_us(5);
}

void func_i2c_noack(void)
{	
	func_set_scl_low();
	func_i2c_delay_us(1);
	func_set_sda_high();
	func_i2c_delay_us(1);
	func_set_scl_high();
	func_i2c_delay_us(5);
	func_set_scl_low();
	func_i2c_delay_us(5);
}

u8 func_get_i2c_waitack(void)
{
	func_set_scl_low();
	func_i2c_delay_us(1);
	func_set_sda_high();			
	func_i2c_delay_us(1);
	func_set_scl_high();
	func_i2c_delay_us(5);
	if(func_get_sda())
	{
		func_set_scl_low();
		return DISABLE;
	}
	func_set_scl_low();
	return ENABLE;
}

void func_i2c_sendbyte(uint8_t sendyyte)
{
    uint8_t i = 8;
    while(i--)
    {
			func_set_scl_low();
			func_i2c_delay_us(5);
			if(sendyyte & 0x80)
			{
				func_set_sda_high();
			}			  
			else
			{
				func_set_sda_low(); 
			}			  
			sendyyte <<= 1;
			func_i2c_delay_us(5);
			func_set_scl_high();
			func_i2c_delay_us(10);
    }
    func_set_scl_low();
}

u8 func_i2c_receivebyte(void)  
{ 
    uint8_t i = 8;
    uint8_t receivebyte = 0;

    func_set_sda_high();				
    while(i--)
    {
			receivebyte <<= 1;      
			func_set_scl_low();
			func_i2c_delay_us(5);
			func_set_scl_high();
			func_i2c_delay_us(5);	
			if(func_get_sda())
			{
				receivebyte |= 0x01;
			}
    }
    func_set_scl_low();
    return receivebyte;
}

u8 func_i2c_writebyte(uint8_t writebyte, uint16_t writeaddr)
{
	//24C16 MAX 2048(256*8) bytes(0-2047)
	u8 cur_page;	
	if(writeaddr > 2048 - 1)
	{
		return DISABLE;
	}
	cur_page = writeaddr / 256;
	
	if(!func_i2c_start())
	{
		return DISABLE;
	}
	func_i2c_sendbyte(EEPROM_HOST_ADDR | (cur_page << 1) | EEPROM_I2C_WR);
	if(!func_get_i2c_waitack())
	{
		func_i2c_stop();
		return DISABLE;
	}
	func_i2c_sendbyte((uint8_t)(writeaddr & 0x00FF));
	func_get_i2c_waitack();	
	func_i2c_sendbyte(writebyte);
	func_get_i2c_waitack();   
	func_i2c_stop(); 
	return ENABLE;
}	

u8 func_i2c_writebytes(uint8_t *_pwritebuf, uint16_t _usaddr, uint16_t _ussize)
{
	uint16_t i;
	uint16_t cur_addr, end_addr;
	int8_t cur_page = -1;
	cur_addr = _usaddr;
	end_addr = _usaddr + _ussize;
	if(_usaddr > 2048 - 1)
	{
		return DISABLE;
	}
	if(_ussize == 0 || _ussize > 2048)
	{
		return DISABLE;
	}
	if(end_addr > 2048 - 1)// read overflow
	{
		return DISABLE;
	}
	
	for(i = cur_addr; i < end_addr; i++)
	{
		if(cur_page != i / 256 || i % 16 == 0)
		{
			cur_page = i / 256;
			func_i2c_stop();
			func_i2c_delay_us(10000);
			if(!func_i2c_start())
			{
				return DISABLE;
			}
			func_i2c_sendbyte(EEPROM_HOST_ADDR | (cur_page << 1) | EEPROM_I2C_WR);
			if(!func_get_i2c_waitack())
			{
				func_i2c_stop();
				return DISABLE;
			}
			func_i2c_sendbyte((uint8_t)(i & 0x00FF));
			func_get_i2c_waitack();
		}
		func_i2c_sendbyte(*_pwritebuf ++);
		func_get_i2c_waitack();
		if(i >= end_addr - 1)
		{
			func_i2c_stop();
			func_i2c_delay_us(10000);
		}
	}
	
	func_i2c_stop();
	return ENABLE;
}

u8 func_i2c_readbytes(uint8_t* pbuffer, uint16_t len, uint16_t addr_read)
{
	
	uint16_t cur_addr, end_addr, i;
	int8_t cur_page = -1;
	cur_addr = addr_read;
	end_addr = addr_read + len;
	if(addr_read > 2048 - 1)
	{
		return DISABLE;
	}
	if(len == 0 || len > 2048)
	{
		return DISABLE;
	}
	if(end_addr > 2048 - 1)// read overflow
	{
		return DISABLE;
	}	
	
	for(i = cur_addr; i < end_addr; i++)
	{
		if(cur_page != i / 256)
		{
			cur_page = i / 256;
			if(!func_i2c_start())
			{
				return DISABLE;
			}
			func_i2c_sendbyte(EEPROM_HOST_ADDR | (cur_page << 1) | EEPROM_I2C_WR);
			if(!func_get_i2c_waitack())
			{
				func_i2c_stop();
				return DISABLE;
			}
			func_i2c_sendbyte((uint8_t)(i & 0x00FF));    
			func_get_i2c_waitack();
			func_i2c_start();
			func_i2c_sendbyte(EEPROM_HOST_ADDR | (cur_page << 1) | EEPROM_I2C_RD);
			func_get_i2c_waitack();
		}
		*pbuffer = func_i2c_receivebyte();
		if(i >= end_addr - 1)
		{
			func_i2c_noack();
		}
		else
		{
			func_i2c_ack(); 
		}
		pbuffer++;
	}

	func_i2c_stop();
	return ENABLE;
	
}

补充的是，我使用 PA5->SCL，PA6->SDA。

Mr_Johhny
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
STM32 IIC例程 兼容 AT24C16,stm32f103c8t6最小系统,C,C++
09-11
STM32F103读取EEprom; STM32 IIC例程 兼容 AT24C16
STM32F103RC学习（一）
Cat_South_North的博客
10-29 5425
STM32F103RC学习（一）
AT24C16 读写
liangbin414的博客
03-07 9884
at24c16 有8块 256字节组成，共2K字节16K bit I2C开始信号后，第一个字节为器件地址，由1010+3位块地址+1位读写标志组成， 3位块地址刚好可以表示 8个块， 所以一次写完256字节，换到下一下块的时候，要重新更改器件地址 共有三种写入模式： 字节写入模式： MODE脚可接高电平或低电平 多字节模式：MODE接高电平，一次最多写8个字节，24c16收到数据后，地址低4...
24c16的使用方法
weixin_39162701的博客
06-21 7626
自己把24c16的使用结合代码整理了一遍 之前看pcf时发现其实有很多芯片和24c系列的芯片很像，所以就不得不整理一下了，发辫以后回顾 r如果整理的不够好，请不要喷我，我是弱菜 #include #include    //要用到_nop_()精准延时 #define uchar unsigned char #define uint unsigned int sbit scl=P2^1;/
非易失存储器读写
CT_1104的专栏
05-20 1398
24C256、IIC_SCL、IIC_SDA
24C16的读写
duobaohongtu3的专栏
06-13 6010
24C16的读写 (2009-04-10 23:11:27)转载▼标签： 杂谈 // 头文件// 使用Eeprom的设备标识符,即器件地址// 24C64最多可以定定义8个//#define I2C_FIRST_ID    0xA0    // 1010,000,0B//#define I2C_SECOND_ID    0xA2    // 1010,001,0B//#define I2C_THI...
STM32F103使用GPIO模拟I2C操作AT24C02
02-13
单片机STM32F103RCT6; IDE:keil v5，编译器版本 v5.06； 库类型：标准库； 使用GPIO模拟I2C代码; 使用AT24C02进行测试; 实现了对整数，浮点数，双精度浮点数的操作；
stm32f1cbt6io软件模拟i2c读写eeprom2_24c02_模拟I2C_STM32F103_软件模拟i2c读写eep
10-04
stm32f103软件模拟i2c读写24c02
STM32F103RCT6通过I2C读入写入EEPROM储存器24C02
12-25
库函数版本，按键选择操作方式为写入或读取，通过串口通讯发送至电脑，波特率9600，每个板子的24C02引脚接口可能不同，需要修改后使用，本工程引脚对应SCL->PC12 SDA->PC11。同样适用于F103其他型号（需修改工程）
stm32f103硬件I2C通信24C256，基于CubeMx
08-01
利用stm32F103自带的I2C与24C256模块通信成功，并解决硬件I2C的BUG。
EEPROM存储器芯片BL24C16使用例程 C语言-IO模拟IIC
最新发布
02-29
EEPROM存储器芯片BL24C16使用例程 使用IO模拟IIC通信 亲测可用 稳定可靠 C 语言
EEPROM.rar_AT24C01A_i2c stm32f103zet6
09-20
STM32F103ZET6的I2C程序，外设读写AT24C01A器件。程序中有字节读写，随机读写和块读写功能。
24C02、24C16进行字节、页读取、页存取操作
weixin_40814407的博客
09-23 6711
以下这篇文章是自己折腾了三天存储芯片后，并且能够成功进行字节操作、页操作的一篇应用型文章，不太想研究原理的可以直接采用本文的代码和注意事项。 在对24C02或者24C16进行字节、页读取、页存取前，我们需要弄清楚I²C协议、24C02/24C16存储空间、字节操作和页操作的时序 I²C协议:I²C是什么协议网上进行百度方可知道，以下只写使用代码 void i2cStart(void) ...
EEPROM（AT24C16）页写算法
热门推荐
只要思想不滑坡，想法总比问题多。
11-16 1万+
1.写在前面 学习单片机或者从事嵌入式开发的，对于EEPROM绝不会陌生，尤其的24系列的EEPROM很是经典，或者与此兼容的FRAM系列，如AT24C02、AT24C16、FM24C16等。 驱动起这个系列的EEPROM，可以说是没有任何难点，各类教程、源码、驱动都可以轻松找到并作稍微改动即可使用。但是，对于使用技巧方面，大多的教程并不会提及，而只是作为学习“入门”的一个途径...
24系列EEPROM的应用
zonewone
01-12 1713
关于IIC总线I2C总线：i2c总线是 Philips 公司首先推出的一种两线制串行传输总线。它由一根数据线（SDA）和一根 时钟线（SDL）组成。i2c总线的数据传输过程如图3所示，基本过程为：1、主机发出开始信号。2、主机接着送出1字节的从机地址信息，其中最低位为读写控制码（1为读、0为写），高7位为从机器件地址代码。3、从机发出认可信号。4、主机开始发送信息，每发完一字节后，从机发出认可
EEPROM的使用操作手册 AT24C02 AT24C04 AT24C08 AT24C16等系列操作
m0_59358683的博客
08-09 2008
EEPROM的使用操作手册 AT24C02 AT24C04 AT24C08 AT24C16等系列操作
STM32F103使用GPIO模拟IIC操作AT24C02
qq_43014583的博客
02-13 1374
使用GPIO模拟I2C的代码，操作AT24C02进行测试，并且使用时只需要修改iic_gpio.h中相关宏定义即可切换I2C时钟、端口和引脚。 实现了AT24C02对整数，浮点数，双精度浮点数的操作 STM32F103使用GPIO模拟I2C操作AT24C02 - keil工程文件。
STM32F103使用GPIO口模拟I2C通信源代码
qq_43014583的博客
02-06 1563
由于STM32内部硬件I2C通讯时跑飞，因此使用STM32 GPIO口 模拟 I2C通信如下 AT24C02 测试 单片机 : STMF103C8T6 管脚 : GPIOB Pin6 ------ SCL GPIOB Pin7 ------ SDA 使用时只需修改 RCC_APB2Periph_GPIOx；GPIOx； GPIO_Pin_x（SCL）；GPIO_Pin_x （SDA） 即可将其移植 程序适配 STM32 标准库 #define AT24C02_RCC RCC_APB2Periph_
24c01-24c16读写驱动程序
zhangxinchunleo的专栏
09-07 2023
 //24c01-24c16读写驱动程序，sbit a0=ACC^0;   //定义ACC的位，利用ACC操作速度最快sbit a1=ACC^1;sbit a2=ACC^2;sbit a3=ACC^3;sbit a4=ACC^4;sbit a5=ACC^5;sbit a6=ACC^6;sbit a7=ACC^7;void s24(void) { _nop_();scl=0;sda=1;scl=
stm32f103模拟读取24c16例子程序
09-08
下面是一个使用stm32f103模拟读取24c16的例子程序： #include "stm32f10x.h" #include "stm32f10x_i2c.h" #define EEPROM_ADDRESS 0xA0 // 24C16芯片的地址 void EEPROM_WriteByte(uint16_t address, uint8_t data) { // 初始化I2C模块 I2C_InitTypeDef i2c_init_struct; I2C_StructInit(&i2c_init_struct); i2c_init_struct.I2C_Mode = I2C_Mode_I2C; i2c_init_struct.I2C_DutyCycle = I2C_DutyCycle_2; i2c_init_struct.I2C_OwnAddress1 = 0x00; i2c_init_struct.I2C_Ack = I2C_Ack_Enable; i2c_init_struct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; i2c_init_struct.I2C_ClockSpeed = 100000; I2C_Init(I2C1, &i2c_init_struct); // 开启I2C模块 I2C_Cmd(I2C1, ENABLE); // 发送起始信号 I2C_GenerateSTART(I2C1, ENABLE); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); // 发送设备地址和写入模式 I2C_Send7bitAddress(I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); // 发送要写入的地址 I2C_SendData(I2C1, address); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)); // 发送要写入的数据 I2C_SendData(I2C1, data); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)); // 发送停止信号 I2C_GenerateSTOP(I2C1, ENABLE); while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)); } uint8_t EEPROM_ReadByte(uint16_t address) { // 初始化I2C模块 I2C_InitTypeDef i2c_init_struct; I2C_StructInit(&i2c_init_struct); i2c_init_struct.I2C_Mode = I2C_Mode_I2C; i2c_init_struct.I2C_DutyCycle = I2C_DutyCycle_2; i2c_init_struct.I2C_OwnAddress1 = 0x00; i2c_init_struct.I2C_Ack = I2C_Ack_Enable; i2c_init_struct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; i2c_init_struct.I2C_ClockSpeed = 100000; I2C_Init(I2C1, &i2c_init_struct); // 开启I2C模块 I2C_Cmd(I2C1, ENABLE); // 发送起始信号 I2C_GenerateSTART(I2C1, ENABLE); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); // 发送设备地址和写入模式 I2C_Send7bitAddress(I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); // 发送要读取的地址 I2C_SendData(I2C1, address); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)); // 重新产生起始信号，并发送设备地址和读取模式 I2C_GenerateSTART(I2C1, ENABLE); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); I2C_Send7bitAddress(I2C1, EEPROM_ADDRESS, I2C_Direction_Receiver); while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)); // 接收数据 while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)); uint8_t data = I2C_ReceiveData(I2C1); // 发送停止信号 I2C_GenerateSTOP(I2C1, ENABLE); while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)); return data; } int main(void) { uint16_t address = 0x00; // 要读取的数据在EEPROM中的地址 uint8_t data; // 在某个地址写入数据 EEPROM_WriteByte(address, 0x55); // 从该地址读取数据 data = EEPROM_ReadByte(address); while (1) { // 你的其他代码 } } 这个例子程序演示了如何使用stm32f103的I2C模块来模拟读取24C16 EEPROM芯片中的数据。首先，通过初始化I2C模块的相关配置，然后发送起始信号并将设备地址发送到I2C总线上。接着，通过I2C发送要读取的地址，并重新产生起始信号并发送设备地址和读取模式。最后，通过I2C进行数据的接收，并发送停止信号来结束通信。在主函数中，通过调用EEPROM_WriteByte函数和EEPROM_ReadByte函数来写入和读取EEPROM芯片中的数据。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值