FRAM铁电存储器FM25W256 | FM24CL04B | FM24CL16B编程实现读写存取数据

已于 2023-09-06 13:08:25 修改
阅读量3k 收藏 21
点赞数 2
分类专栏： 笔记 MCU 文章标签： 单片机 stm32 嵌入式硬件
于 2021-05-02 13:30:15 首次发布
本文章为CSDN博主Tyrion.Mon原创，未经博主允许不得转载，转载请附上原文链接以及本版权信息。
本文链接：https://blog.csdn.net/Stack_/article/details/116353030
版权
MCU 同时被 2 个专栏收录
33 篇文章 9 订阅
订阅专栏
笔记
32 篇文章 2 订阅
订阅专栏

【本文发布于https://blog.csdn.net/Stack_/article/details/116353030，未经许可不得转载，转载须注明出处】


FM25W256


一、电路

在这里插入图片描述



二、配置SPI（GD32F303）

@ CSDN Tyrion.Mon
/**
  * @brief  初始化SPI1
  * @note   SPI1_NSS -- PB12
  *         SPI1_SCK -- PB13
  *         SPI1_MI  -- PB14
  *         SPI1_MO  -- PB15
  * @param  None
  * @retval None
  * @author PWH     @ CSDN Tyrion.Mon
  * @date   2021/3
  */
void SPI1_Init(void)
{
	RCU->RCU_APB1EN.Bits.SPI1EN = 1;			//
	
	/* SCK复用输出 */
	Gd32f30x_Gpio_Init(GPIO_PB13, GPIO_MODE_OUT_50MHZ, GPIO_CTL_AF_PP);
	/* MI上拉输入 */
	Gd32f30x_Gpio_Init(GPIO_PB14, GPIO_MODE_IN, GPIO_CTL_IPU);
	/* MO复用输出 */
	Gd32f30x_Gpio_Init(GPIO_PB15, GPIO_MODE_OUT_50MHZ, GPIO_CTL_AF_PP);
	
	/* SPI1 */
	//1：主机模式
	SPI1->SPI_CTL0.Bits.MSTMOD = 1;
	//0： 2 线单向传输模式
	SPI1->SPI_CTL0.Bits.BDEN = 0;
	//0：全双工模式(当 BDEN 清零时)
	SPI1->SPI_CTL0.Bits.RO = 0;
	//0： 8 位数据帧格式
	SPI1->SPI_CTL0.Bits.FF16 = 0;
	//1： NSS 软件模式， NSS 电平取决于 SWNSS 位
	SPI1->SPI_CTL0.Bits.SWNSSEN = 1;
	SPI1->SPI_CTL0.Bits.SWNSS = 1;
	//SPI1时钟来源：APB1   psc=001 : 4分频  FRAM spi最高20M
	SPI1->SPI_CTL0.Bits.PSC = 1;
	//0：先发送最高有效位
	SPI1->SPI_CTL0.Bits.LF = 0;
	//1： SPI 为空闲状态时， CLK 引脚拉低，此时fram spi工作在mode0
	SPI1->SPI_CTL0.Bits.CKPL = 0;
	//0：在第一个时钟跳变沿采集第一个数据
	SPI1->SPI_CTL0.Bits.CKPH = 0;
	//1： RBNE 中断使能。当 RBNE 置位时，产生中断。
//	SPI1->SPI_CTL1.Bits.RBNEIE = 1;
	//1： SPI 设备使能
	SPI1->SPI_CTL0.Bits.SPIEN = 1;
}



三、命令字

在这里插入图片描述

所有写操作前都必须先发送WREN以使能写操作。

@ CSDN Tyrion.Mon
/**
  * @brief  使能/使能写操作
  * @note   
  * @param  ENABLE 允许；DISABLE 禁止
  * @retval None
  * @author PWH @ CSDN Tyrion.Mon
  * @date   2021/3
  */
static void FRAM_WriteEnable(uint8_t EN_DISEN)
{
	FRAM_Select(CS_ENABLE);
	if (EN_DISEN == ENABLE)
		SPIx_SendData(SPI1, WREN);	//使能写操作（WREN操作码使WEL置位，允许写操作）
	else
		SPIx_SendData(SPI1, WRDI);
	FRAM_Select(CS_DISABLE);
}



四、读写

读写状态寄存器

@ CSDN Tyrion.Mon
/**
  * @brief  读状态寄存器数据
  * @note   
  * @param  NONE
  * @retval 状态寄存器值 
  * @author PWH@ CSDN Tyrion.Mon
  * @date   2021/3
  */
static uint8_t FRAM_ReadSR(void)
{
	uint8_t ret;
	FRAM_Select(CS_ENABLE);
	SPIx_SendData(SPI1, RDSR);
	ret = SPIx_SendData(SPI1, 0x00);
	FRAM_Select(CS_DISABLE);
	return ret;
}

/**
  * @brief  写状态寄存器
  * @note   
  * @param  状态寄存器值
  * @retval NONE
  * @author PWH @ CSDN Tyrion.Mon
  * @date   2021/3
  */
static void FRAM_WriteSR(uint8_t val)
{
	FRAM_WriteEnable(ENABLE);	//写SR前需要使能写操作
	
	FRAM_Select(CS_ENABLE);
	SPIx_SendData(SPI1, WRSR);
	SPIx_SendData(SPI1, val);
	FRAM_Select(CS_DISABLE);
}

读写存储块

/**
  * @brief  FRAM
  * @note   
  * @param  None
  * @retval None
  * @author PWH@ CSDN Tyrion.Mon
  * @date   2021/3
  */
uint16_t FRAM_Write(uint16_t AddrOffset, uint8_t *Data, uint16_t DataLen)
{
	if ((!DataLen) || (AddrOffset > FRAM_ADDR_MAX) || ((AddrOffset + DataLen - 1) > FRAM_ADDR_MAX))
		return 0;
	
	FRAM_WriteSR(0x80);			//写SR寄存器,所有存储块取消写保护
	
	FRAM_WriteEnable(ENABLE);	//写存储块前需要使能写操作

	FRAM_Select(CS_ENABLE);
	
	SPIx_SendData(SPI1, WRITE);								//写指令
	SPIx_SendData(SPI1, (AddrOffset >> 8) & 0x00ff);		//写入起始地址高字节
	SPIx_SendData(SPI1, AddrOffset & 0x00ff);				//写入起始地址低字节
	
	do {
		SPIx_SendData(SPI1, *Data++);
	} while (--DataLen);
	
	FRAM_Select(CS_DISABLE);
	
	FRAM_WriteSR(0x8C);			//写SR寄存器,所有存储块使能写保护

	return 1;
}

/**
  * @brief  FRAM
  * @note   
  * @param  None
  * @retval Noned
  * @author PWH @ CSDN Tyrion.Mon
  * @date   2021/3
  */
uint16_t FRAM_Read(uint16_t AddrOffset, uint8_t *Data, uint16_t DataLen)
{
	if ((!DataLen) || (AddrOffset > FRAM_ADDR_MAX) || ((AddrOffset + DataLen - 1) > FRAM_ADDR_MAX))
		return 0;
	
	FRAM_Select(CS_ENABLE);
	
	SPIx_SendData(SPI1, READ);								//读指令
	SPIx_SendData(SPI1, (AddrOffset >> 8) & 0x00ff);		//写入起始地址高字节
	SPIx_SendData(SPI1, AddrOffset & 0x00ff);				//写入起始地址低字节
	
	do {
		*Data++ = SPIx_SendData(SPI1, 0x00);
	} while (--DataLen);
	
	FRAM_Select(CS_DISABLE);
	
	return 1;
}




FM24CL04B/FM24CL16B


一、电路


在这里插入图片描述

/*
 * FM24CL04B
 * 1    0    1    0    A2    A1    A0    R/W
 *
 * A2 A1 已硬件拉低， A0作页选择
 *
 * FM24CL16B
 * 1    0    1    0    A2    A1    A0    R/W
 *
 * 外部无地址选择引脚，A2 A1 A0作页选择
 *
 */

二、I2C驱动 （软 – ESP8266）

@ CSDN Tyrion.Mon

#define I2C_MASTER_SCL_PIN			GPIO_Pin_5
#define I2C_MASTER_SCL_NUM			GPIO_NUM_5
#define I2C_MASTER_SCL_MODE			GPIO_MODE_OUTPUT_OD

#define I2C_MASTER_SDA_PIN			GPIO_Pin_4
#define I2C_MASTER_SDA_NUM			GPIO_NUM_4
#define I2C_MASTER_SDA_MODE			GPIO_MODE_OUTPUT_OD

#define I2C_MASTER_SCL_CLR() 		gpio_set_level(I2C_MASTER_SCL_NUM, 0)//i2c scl
#define I2C_MASTER_SCL_SET() 		gpio_set_level(I2C_MASTER_SCL_NUM, 1)

#define I2C_MASTER_SDA_CLR() 		gpio_set_level(I2C_MASTER_SDA_NUM, 0)//i2c sda
#define I2C_MASTER_SDA_SET() 		gpio_set_level(I2C_MASTER_SDA_NUM, 1)


//延时
void I2C_Master_delay(void)
{
	uint8_t t = 1;
	while (t--);
}
//SDA配置为输出
void I2C_Master_SDA_PIN_OUTPUT(void)
{
#if 0
	gpio_config_t gpio_cfg = {
		.pin_bit_mask = I2C_MASTER_SDA_PIN,
		.mode = GPIO_MODE_OUTPUT_OD,
		.pull_up_en = 0,
		.pull_down_en = 0,
		.intr_type = GPIO_INTR_DISABLE,
	};
	gpio_config(&gpio_cfg);
#else
	gpio_set_direction(I2C_MASTER_SDA_NUM, GPIO_MODE_OUTPUT_OD);
#endif
}
//SDA配置为输入
void I2C_Master_SDA_PIN_INPUT(void)
{
#if 0
	gpio_config_t gpio_cfg = {
		.pin_bit_mask = I2C_MASTER_SDA_PIN,
		.mode = GPIO_MODE_INPUT,
		.pull_up_en = 0,
		.pull_down_en = 0,
		.intr_type = GPIO_INTR_DISABLE,
	};
	gpio_config(&gpio_cfg);
#else
	gpio_set_direction(I2C_MASTER_SDA_NUM, GPIO_MODE_INPUT);
#endif
}
//读取SDA输入电平
uint8_t I2C_Master_SDA_PIN_GET(void)
{
	return gpio_get_level(I2C_MASTER_SDA_NUM);
}
//起始信号
void I2C_Master_Start(void)
{
	I2C_Master_SDA_PIN_OUTPUT();
	I2C_MASTER_SDA_SET();
	I2C_MASTER_SCL_SET();
	I2C_Master_delay();
	I2C_MASTER_SDA_CLR();
	I2C_Master_delay();
	I2C_MASTER_SCL_CLR();
	I2C_Master_delay();
}
//结束信号
void I2C_Master_Stop(void)
{
	I2C_Master_SDA_PIN_OUTPUT();
	I2C_MASTER_SDA_CLR();
	I2C_MASTER_SCL_SET();
	I2C_Master_delay();
	I2C_MASTER_SDA_SET();
}
//发送ack
void I2C_Master_Ack(void)
{
	I2C_Master_SDA_PIN_OUTPUT();
	I2C_MASTER_SDA_CLR();
	I2C_MASTER_SCL_SET();
	I2C_Master_delay();
	I2C_MASTER_SCL_CLR();
	I2C_Master_delay();
}
//发送nack
void I2C_Master_NAck(void)
{
	I2C_Master_SDA_PIN_OUTPUT();
	I2C_MASTER_SDA_SET();
	I2C_MASTER_SCL_SET();
	I2C_Master_delay();
	I2C_MASTER_SCL_CLR();
	I2C_Master_delay();
}
//等待信号响应
uint8_t I2C_Master_WaitAck(void) //测数据信号的电平
{
	uint8_t ack;
	I2C_Master_SDA_PIN_INPUT();
	//I2C_MASTER_SDA_SET();
	//I2C_Master_delay();
	I2C_MASTER_SCL_SET();
	ack = I2C_Master_SDA_PIN_GET();
	I2C_Master_delay();
	I2C_MASTER_SCL_CLR();
	I2C_Master_delay();
	return ack;
}
//写入一个字节
void I2C_Master_Send_Byte(uint8_t dat)
{
	uint8_t i;
	I2C_Master_SDA_PIN_OUTPUT();
	for(i = 0; i < 8; i++)
	{
		if(dat & 0x80)//将dat的8位从最高位依次写入
		{
			I2C_MASTER_SDA_SET();
        }
		else
		{
			I2C_MASTER_SDA_CLR();
        }
		I2C_Master_delay();
		I2C_MASTER_SCL_SET();
		I2C_Master_delay();
		I2C_MASTER_SCL_CLR();//将时钟信号设置为低电平
		dat <<= 1;
    }
}
//写入一个字节
void I2C_Master_Send_1Byte(uint8_t slave_addr, uint8_t reg_address, uint8_t dat)
{

	I2C_Master_Start();
	I2C_Master_Send_Byte(slave_addr);
	I2C_Master_WaitAck();
	I2C_Master_Send_Byte(reg_address);
	I2C_Master_WaitAck();
	I2C_Master_Send_Byte(dat);
	I2C_Master_WaitAck();
	I2C_Master_Stop();
}
//写入n个字节
void I2C_Master_Send_Bytes(uint8_t slave_addr, uint8_t reg_address, uint8_t *dat, uint16_t len)
{
	uint16_t i = 0;

	I2C_Master_Start();
	I2C_Master_Send_Byte(slave_addr);
	I2C_Master_WaitAck();
	I2C_Master_Send_Byte(reg_address);
	I2C_Master_WaitAck();

	for (i = 0; i < len; i++)
	{
		I2C_Master_Send_Byte(dat[i++]);
		I2C_Master_WaitAck();
	}

	I2C_Master_Stop();
}
//读一个字节
void I2C_Master_Read_Byte(uint8_t *dat)
{
	uint8_t i;
	*dat = 0;
	I2C_Master_SDA_PIN_INPUT();
	for(i = 0; i < 8; i++)
	{
		I2C_MASTER_SCL_SET();
		I2C_Master_delay();
		*dat <<= 1;
		if (I2C_Master_SDA_PIN_GET())
			*dat |= 0x01;
		I2C_MASTER_SCL_CLR();
		I2C_Master_delay();
    }
}
void I2C_Master_Init(void)
{
	gpio_config_t gpio_cfg;

	gpio_cfg.pin_bit_mask = I2C_MASTER_SCL_PIN | I2C_MASTER_SDA_PIN;
	gpio_cfg.mode = I2C_MASTER_SCL_MODE;
	gpio_cfg.pull_up_en = 0;
	gpio_cfg.pull_down_en = 0;
	gpio_cfg.intr_type = GPIO_INTR_DISABLE;
	gpio_config(&gpio_cfg);

	I2C_MASTER_SCL_SET();
	I2C_MASTER_SDA_SET();
}

#define FRAM_FM24CL04B						0	//4K bit / 512字节
#define FRAM_FM24CL16B						1	//16K bit / 2K字节

#define FRAM_FM24CLxx						FRAM_FM24CL16B

#define FRAM_I2C_ADDR						0xA0
#if (FRAM_FM24CLxx == FRAM_FM24CL04B)	//2pages x 256bytes
	#define FRAM_PAGE_MAX						2
	#define FRAM_PAGE_BYTES_MAX					256
	#define FRAM_DATA_ADDR_END					0x1FF
#elif (FRAM_FM24CLxx == FRAM_FM24CL16B)	//8pages x 256bytes
	#define FRAM_PAGE_MAX						8
	#define FRAM_PAGE_BYTES_MAX					256
	#define FRAM_DATA_ADDR_END					0x7FF
#endif

/**
  * @名称: FRAM_WriteBytes
  * @描述: FM24CL04B 同一页写入多个字节	256字节x2页
  * @参数:
  * @参数:
  * @日期：2023
  * @返回: bool
  **/
bool FRAM_WriteBytes(uint8_t *pBytes, uint32_t framStartAddress, uint32_t dataLenght)
{
	uint8_t page;

	if (framStartAddress > FRAM_DATA_ADDR_END) return false;

	page = framStartAddress >> 8;
	if ((page + 1) > FRAM_PAGE_MAX) return false;

	I2C_Master_Start();

	I2C_Master_Send_Byte(FRAM_I2C_ADDR | ((page << 1) & 0x0E) | 0x00);
	I2C_Master_WaitAck();
	I2C_Master_Send_Byte(0xFF & framStartAddress);
	I2C_Master_WaitAck();

	for (uint32_t i = 0; i < dataLenght; i++)
	{
		I2C_Master_Send_Byte(pBytes[i]);
		I2C_Master_WaitAck();
	}

	I2C_Master_Stop();

	return true;
}

/**
  * @名称: FRAM_ReadBytes
  * @描述: FM24CL04B 同一页读多个字节	256字节x2页
  * @参数:
  * @参数:
  * @日期：2023
  * @返回: bool
  **/
bool FRAM_ReadBytes(uint8_t *pBytes, uint32_t framStartAddress, uint32_t dataLenght)
{
	uint8_t page;

	if (framStartAddress > FRAM_DATA_ADDR_END) return false;

	page = framStartAddress >> 8;
	if ((page + 1) > FRAM_PAGE_MAX) return false;

	I2C_Master_Start();

	I2C_Master_Send_Byte(FRAM_I2C_ADDR | ((page << 1) & 0x0E) | 0x00);
	I2C_Master_WaitAck();
	I2C_Master_Send_Byte(framStartAddress & 0xFF);
	I2C_Master_WaitAck();

	I2C_Master_Start();
	I2C_Master_Send_Byte(FRAM_I2C_ADDR | ((page << 1) & 0x0E) | 0x01);
	I2C_Master_WaitAck();
	do
	{
		I2C_Master_Read_Byte(pBytes);
		pBytes++;

		if (dataLenght == 1) {
			I2C_Master_NAck();
		}
		else {
			I2C_Master_Ack();
		}
	}while(--dataLenght);

	I2C_Master_Stop();

	return true;
}


读写示例：
uint8_t datArray[10];
FRAM_WriteBytes(datArray, 0, sizeof(datArray));		//写page0第0-9
FRAM_WriteBytes(datArray, 256, sizeof(datArray));	//写page1第0-9
FRAM_WriteBytes(datArray, 512, sizeof(datArray));	//写page2第0-9

FRAM_ReadBytes(datArray, 0, sizeof(datArray));		//读page0第0-9
FRAM_ReadBytes(datArray, 256, sizeof(datArray));	//读page1第0-9
FRAM_ReadBytes(datArray, 512, sizeof(datArray));	//读page2第0-9

三、I2C驱动 （硬 – STM32F103）


@ CSDN Tyrion.Mon
/**
  * @名称: FRAM_Init
  * @描述: FRAM IO初始化  i2c配置
  * @参数: 
  * @参数: 
  * @日期：2019
  * @返回: bool
  **/
bool FRAM_Init(void)
{
	I2C_InitTypeDef   I2C_InitStruct;
	GPIO_InitTypeDef  GPIO_InitStruct;
	
	RCC_APB2PeriphClockCmd(FRAM_GPIO_CLK,ENABLE);
	RCC_APB1PeriphClockCmd(FRAM_I2C_CLK, ENABLE);
	
	I2C_InitStruct.I2C_ClockSpeed = 100000;	
	I2C_InitStruct.I2C_Mode = I2C_Mode_I2C;
	I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;	//该参数只有在 I2C 工作在快速模式（时钟工作频率高于 100KHz）下才有意义。
	I2C_InitStruct.I2C_OwnAddress1 = 0x75;
	I2C_InitStruct.I2C_Ack = I2C_Ack_Enable; 
	I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
	I2C_Init(I2C1, &I2C_InitStruct);
	I2C_Cmd(FRAM_I2C, ENABLE);
	
	GPIO_InitStruct.GPIO_Pin =  FRAM_SCL_PIN | FRAM_SDA_PIN;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_2MHz;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;               
	GPIO_Init(FRAM_GPIO, &GPIO_InitStruct);
	GPIO_SetBits(FRAM_GPIO, FRAM_SCL_PIN);
	GPIO_SetBits(FRAM_GPIO, FRAM_SDA_PIN);
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_OD;               //先把GPIO设为推挽输出并拉倒高电平再转设为复用开漏输出，这样可以有效解决I2C设备死锁的问题???
	GPIO_Init(FRAM_GPIO, &GPIO_InitStruct);

	return true;
}
/**
  * @名称: FRAM_WriteBytes
  * @描述: FM24CL04B 同一页写入多个字节	256字节x2页
  * @参数: 
  * @参数: 
  * @日期：2019
  * @返回: bool
  **/
bool FRAM_WriteBytes(uint8_t framPage, uint8_t *pBytes, uint8_t framStartAddress, uint8_t dataLenght)
{
	if(framPage > 1 || !dataLenght) return false;
	if(framStartAddress + dataLenght > 256) return false;
	/* Send START condition */
	I2C_GenerateSTART(FRAM_I2C, ENABLE);
	/* Test on EV5 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	//EV5事件被检测到，发送设备地址
	I2C_Send7bitAddress(FRAM_I2C, 0xA0 | (FRAM_ADDRESS << 2) | (framPage << 1), I2C_Direction_Transmitter);
	/* Test on EV6 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ) == ERROR);
	//EV6事件被检测到，发送要操作的存储单元地址
	I2C_SendData (FRAM_I2C, framStartAddress);
	/* Test on EV8 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED ) == ERROR);
	do
	{
		//EV8事件被检测到，发送要存储的数据
		I2C_SendData (FRAM_I2C, *pBytes++);
		/* Test on EV8 and clear it */
		while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED ) == ERROR);
	}while(--dataLenght);
	/* Send STOP condition */
	I2C_GenerateSTOP(FRAM_I2C, ENABLE);
	return true;
}

/**
  * @名称: FRAM_ReadBytes
  * @描述: FM24CL04B 同一页读多个字节	256字节x2页
  * @参数: 
  * @参数: 
  * @返回: bool
  **/
bool FRAM_ReadBytes(uint8_t framPage, uint8_t *pBytes, uint8_t framStartAddress, uint8_t dataLenght)
{
	if(framPage > 1 || !dataLenght) return false;
	if(framStartAddress + dataLenght > 256) return false;
	/* Send START condition */
	I2C_GenerateSTART(FRAM_I2C, ENABLE);
	/* Test on EV5 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	//EV5事件被检测到，发送设备地址
	I2C_Send7bitAddress(FRAM_I2C, 0xA0 | (FRAM_ADDRESS << 2) | (framPage << 1), I2C_Direction_Transmitter);
	/* Test on EV6 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ) == ERROR);
	//EV6事件被检测到，发送要操作的存储单元地址
	I2C_SendData (FRAM_I2C, framStartAddress);
	/* Test on EV8 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED ) == ERROR);
	
	/* Send START condition */
	I2C_GenerateSTART(FRAM_I2C, ENABLE);
	/* Test on EV5 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	//EV5事件被检测到，发送设备地址
	I2C_Send7bitAddress(FRAM_I2C, 0xA0 | (FRAM_ADDRESS << 2) | (framPage << 1), I2C_Direction_Receiver);
	/* Test on EV6 and clear it */
	while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED ) == ERROR);
	
	do
	{
		if(dataLenght == 1)
		{
			I2C_AcknowledgeConfig (FRAM_I2C, DISABLE);
		}
		//EV7事件被检测到	
		while(I2C_CheckEvent(FRAM_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED ) == ERROR);
		//EV8事件被检测到，发送要存储的数据
		*pBytes++ = I2C_ReceiveData (FRAM_I2C);
	}while(--dataLenght);
	/* Send STOP condition */
	I2C_GenerateSTOP(FRAM_I2C, ENABLE);
	I2C_AcknowledgeConfig (FRAM_I2C, ENABLE);
	return true;
}



读写示例：
uint8_t FRAM_ENERGY_BANK[10];
FRAM_ReadBytes(0, FRAM_ENERGY_BANK, 0x00, 10);	//读page0第0-9个数据
FRAM_ReadBytes(1, FRAM_ENERGY_BANK, 0x00, 10);	//读page1第0-9个数据

FRAM_WriteBytes(0, FRAM_ENERGY_BANK, 0x00, 10);	//写page0第0-9个数据
FRAM_WriteBytes(1, FRAM_ENERGY_BANK, 0x00, 10);	//写page1第0-9个数据
Tyrion.Mon
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
fm24c16c语言程序,铁电存储器FM24C16的页面写和任意字节读汇编程序
weixin_39913807的博客
05-18 678
下面给出FM24C16的页面写和任意字节读汇编子程序。程序经过应用验证，效果良好(为保证稳定性，可以在相应地方加入空语句以延时)。页面写子程序：PAGE-WR： ACALL START_BITMOV A，#10100000BMOV R7，#4ACALL SHFTO；SHFTO为送位子程序，以上3行送1010到FM24C16MOV A，#20HMOV R7，#3ACALL SHFTO；以上3行确定写...
Ramtron的FRAM存储器FM24CL16达到汽车电子AEC-Q100标准
01-19
FM24CL16并已设计在这类系统中，能达到汽车应用的高可靠性高质量元件要求。” AEC-Q100计划的推出，是为了适应汽车子系统对更好的非易失性数据存储解决方案日益增长的需求。由于使用了微处理器和传
外设驱动库开发笔记25：FM25xxx FRAM存储器驱动
木南创智
03-07 4572
在我们的项目中，时常会有参数或数据需要保存。铁电存储器的优良性能和操作方便常常被我们选用。FM25xxx FRAM存储器就是我们经常使用到的一系列铁电存储器，这一篇我们将讨论FM25xxx FRAM存储器的驱动设计、实现及使用。 1、功能概述 FM25xxx FRAM存储器是非易失性存储器，采用了先进的铁电存储。铁电随机存取存储器或F-RAM是非易失性的，其读写操作与RAM类似。它提供了151年的可靠数据保留，同时消除了由串行闪存、EEPROM和其他非易失性存储器引起的复杂性、开销和系统级可靠性问题。
STM32f103RBT6单片机_SPI读写FM25CL64铁电存储器驱动C程序源代码.zip
05-16
STM32f103RBT6单片机_SPI读写FM25CL64铁电存储器驱动C程序源代码 #define FM25CL64_WREN_INST 0x06 //设置写使能锁存器 //FM25CL64寄存器定义 #define FM25CL64_WRDI_INST 0x04 //写禁止 #define FM25CL64_RDSR_INST 0x05 //读状态寄存器 #define FM25CL64_WRSR_INST 0x01 //写状态寄存器 #define FM25CL64_READ_INST 0x03 //读存储器数据 #define FM25CL64_WRITE_INST 0x02 //写存储器数据 #define FM25CL64_STATUS_REG 0x0 // #define FM25CL64_INIT_STATE 0x09 // void SPI_Flash_Init(void); u8 SPIx_ReadWriteByte(u8 TxData); void SPI_write_FM25CL64(u8 data,u16 address);//写入一个字节到
铁电存储器FM25L16B驱动
05-03
使用STM32单片机驱动铁电存储器FM25L16B的程序、实现了已下代码： void FM25L16B_Init(void); void FM25L16B_Write(u16 addr,u8 *data,u16 num); void FM25L16B_Read(u16 addr,u8 *data,u16 num); void FM25L16B_WriteByte(u16 addr,u8 data); u8 FM25L16B_ReadByte(u16 addr); u8 FM25L16B_ReadStatus(void); void FM25L16B_WriteStatus(u8 data);
铁电存储器FM25L16B
weixin_44722927的博客
05-19 408
第二次在这个地址写入“TEST123”，读出来并打印到串口上，串口助手显示“TEST”，第二次的写入未成功；在同一个地址如address=0x40写入“TEST”，在读出来，并打印到串口上。但是当在写入之前先读这段地址里的内容，再进行读写就成功，并未找到愿意，尝试在读写之后加入延时并没有用，第二次读写未成功。问题解决后会及时更新解决方式。
STM32 SPI调试 外部RAM
weixin_42461970的博客
01-04 1702
FM25L04B - 4Kb 3V SPI F-RAM----------512*8bit 存储器地址范围00000H~1FFH，共4Kb(512* 8)bit， FM25V20A - 2MbitF-RAM （Upto 40MHz）--------（256K * 8） 存储器地址范围00000H~3FFFFH，共2Mbit (256k * 8)bit， 其中256k即为 256 * 1024 = 262144 个byte（0x4 00 00，因此存储器最后字节为0x3 ff ff）...
STM32存储左右互搏 SPI总线读写FRAM MB85RS2M
最新发布
Pegasus的软件博客
01-02 1389
在中低容量存储领域，除了FLASH的使用，，还有铁电存储器FRAM的使用，相对于FLASH，FRAM写操作时不需要预擦除，所以执行写操作时可以达到更高的速度，其主要优点为没有FLASH持续写操作跨页地址需要变换的要求。相比于SRAM则具有非易失性, 因此价格方面会高一些。MB85RS2M是512K Byte（2M bit）的FRAM，能够按字节进行写入且没有写入等待时间。其管脚功能兼容FLASH：这里介绍STM32访问FRAM MB85RS2M的例程。
DSP280049C初学（5）-基于IIC的FM24CL16B存储器的使用
qq_45854134的博客
12-19 644
DSP280049C初学（5）-基于IIC的FM24CL16B存储器的使用
分享FUJITSU铁电存储器FRAM 2MBit SPI MB85RS2MTA
EVERSPIN的博客
04-22 1428
富士通型号MB85RS2MTA是采用262144字x8位的铁电随机存取存储器芯片，使用铁电工艺和硅栅CMOS工艺技术来形成非易失性存储单元。能够保持数据，而无需使用SRAM所需的备用电池。MB85RS2MTA采用串行外围设备接口SPI。 MB85RS2MTA中使用的存储单元可用于1013个读/写操作，与Flash存储器和E2PROM支持的读和写操作数量相比，有了显着改进。MB85RS2MTA不需要花费很长时间就可以写入闪存或E2PROM之类的数据，MB85RS2MTA不需要等待时间。FUJITSU代理可提供
fram.rar_STM32 FRAM存储器_stm32 fram_stm32读取fram_铁电FRAM驱动_铁电存储器
07-14
stm32f103驱动铁电存储器，测试程序，OK
基于STM8的24C16读写程序
09-04
自己写的STM8程序，通过外接按键，对24c16进行读写操作......................................................................................................................................................................................................................................................................................................................................................................................................
fm24cl16b.zip_FM24C16B_FM24CL16B_fm24c16_fm24cl16 程序_fm24cl16b的作
07-14
fm24c16存取演示程序 ,用于C8051F系统，已验证可行
STM32 FM25CL64B 铁电存储器
12-29
STM32和FM25CL64B 铁电存储器 SPI接口
AT24C16实例程序
10-04
这个是EPROM的读写程序，用51单片机读的 这个还有串口发出来显示
汽车电子中的Ramtron的FRAM存储器FM24CL16达到汽车电子AEC-Q100标准
11-29
员会针对集成电路而设的测试...FM24CL16并已设计在这类系统中，能达到汽车应用的高可靠性高质量元件要求。” AEC-Q100认证计划的推出，是为了适应汽车子系统对更好的非易失性数据存储解决方案日益增长的需求。由于使用
铁电存储器FM24C16原理及在多MCU系统中应用
12-08
1　铁电存储器技术原理、特性及应用美国Ramtron公司铁电存储器（FRAM）的核心技术是铁电晶体材料。这一特殊材料使铁电存储器同时拥有随机存取记忆体（RAM）和非易失性存储器的特性。铁电晶体的工作原理是：当在铁电...
铁电存储器FM24C16原理及其在多MCU系统中应用
12-08
美国Ramtron公司铁电存储器(FRAM)的核心技术是铁电晶体材料。这一特殊材料使铁电存储器同时拥有随机存取记忆体(RAM)和非易失性存储器的特性。铁电晶体的工作原理是：当在铁电晶体材料上加入电场，晶体中的中心原子会...
linux I2C之RTC8025、fm24cl16
chenliang0224的专栏
05-02 3073
linux I2C之RTC8025、fm24cl16。
fram铁电存储器开发
12-29
随着IT技术的不断发展，人们对于存储器的需求也越来越高。近年来，fram铁电存储器作为一种新型存储器备受关注，因其具有写入速度快、读取速度高、写入次数多等特点，被广泛应用于汽车电子系统、智能手机、工业控制设备等领域。 为了满足不断增长的市场需求，各大科研机构和企业纷纷加大了对fram铁电存储器开发的投入。他们通过不断优化生产工艺，提高芯片集成度，降低成本，以及推动技术实现规模化生产，使得fram铁电存储器的性能得到了进一步提升。同时，他们也不断改进产品设计，使得fram铁电存储器在更广泛的应用场景中能够发挥更大的作用。 除了技术创新和产品优化外，与fram铁电存储器相关的标准和规范也得到了不断完善。这些标准和规范的不断完善有助于保证fram铁电存储器的稳定性和可靠性，使其能够更好地适应不同的使用环境。 总而言之，随着fram铁电存储器开发的不断深入，随着与相关技术和设备的不断提升，这一新型存储器的性能、成本等方面都将不断得到改进和完善，从而更好地满足市场需求。fram铁电存储器的未来发展仍然充满了无限可能性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值