GT25C16的eeprom芯片使用

EEPROM
相关配置信息
在使用时需要置高WP和HOLD，

WP ： 拉低进入写保护
HOLD ：拉低挂起芯片，忽略总线上通信内容
状态寄存器

当RDY=0时，设备已准备好接收指令。
当RDY=1时，设备正忙。由于繁忙，设备只接受读取状态寄存器命令
WEN ： 这表示设备的写保护状态。当WEN=0时，无论WPEN、WP引脚或块保护的设置如何，都不能修改状态寄存器和整个阵列。写入启用命令（WREN）可用于将WEN设置为1。在加电阶段，WEN重置为0。
WREN命令为写使能
BP0 BP1 为写保护块，可通过

选择是否保护所选区域，内部地址为 0x000 - 0x7FF
WPEN可与WP硬件引脚一起启用写保护，注意 内存阵列不受此模式的保护。硬件写保护要求设置WP=0和WPEN=1。否则，它将被禁用。如果WP已设置为低，则WPEN不能从1更改为0。

图为写保护控制

使用时可以直接接高电平，默认不保护，此时WPEN不起作用，由WEN控制
控制寄存器

依次
写使能
写失能
读状态寄存器
写状态寄存器
读数据
写数据
具体使用

设置控制寄存器

1. #define SPI_READ           0x03
2. #define SPI_WRITE          0x02
3. #define EEP_WREN           0x06
4. #define EEP_WRDI           0x04
5. #define SPI_READ_STATUS    0x05
6. #define SPI_WRITE_STATUS   0x01

复制代码

e2读状态寄存器

1. static uint8_t EEPROM_Read_Status(void)
2. {
3.     uint8_t EEPROM_25LC160_CMD;
4.     uint8_t EEPROM_25LC160_Data;
6.     EEPROM_CS_ENABLE;           /* CS as low */
7.     EEPROM_25LC160_CMD = SPI_READ_STATUS;
8.     SPI_Send(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
9.     SPI_Receive_Process(SPI0_SFR, &EEPROM_25LC160_Data);
10.     EEPROM_CS_DISABLE;          /* CS as high */
11.     EEPROM_25LC160_Data &= 0x0F;
13.     return EEPROM_25LC160_Data;
14. }

复制代码

设置保护

1. void EEP_set_array_protection(EEPROM_Protect_E data)
2. {
3.     /* 0x00 non protection */
4.     /* 0x04 upper 1/4 (180h - 1ffh) protection */
5.     /* 0x08 upper 1/2 (100h - 1ffh) protection */
6.     /* 0x0C all (000h - 1ffh) protection */
7.     uint8_t EEPROM_25LC160_CMD;
9.     Check_EEPROM_Busy();     
10.     EEPROM_CS_ENABLE;  /* CS as low */
11.     EEPROM_25LC160_CMD = EEP_WREN;  /* Write WEL */
12.     SPI_Send(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
13.     EEPROM_CS_DISABLE; /* CS as high */
15.     delay_us(4U);
16.     EEPROM_CS_ENABLE;   /* CS as low */
17.     EEPROM_25LC160_CMD = SPI_WRITE_STATUS;
18.     SPI_Send(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
19.     EEPROM_25LC160_CMD = (uint8_t)(data);
20.     SPI_Send(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
21.     EEPROM_CS_DISABLE;  /* CS as high */
22. }

复制代码

主机发送 1字节

1. //使用轮询方式，在头次发送之后等待发送完成标志和是否繁忙
2. void SPI_Send_Process(SPI_SFRmap *SPIx, uint8_t *Databuf, uint8_t DataLength)
3. {
4.     uint8_t Databuf_Index = 0U;
6.     /* 轮询发送数据 */
7.     while (Databuf_Index < DataLength)
8.     {
9.         SPI_I2S_SendData8(SPIx, Databuf[Databuf_Index]);   /* 发送数据 */
10.         while (SET == SPI_Get_Transmit_Buf_Flag(SPIx))
11.         {
12.             ;/* Waiting for the sending buffer to be empty */
13.         }
15.         while (SET == SPI_Get_BUSY_Flag(SPIx))
16.         {
17.             ;/* 等待SPI数据发送完成 */
18.         }
19.         Databuf_Index++;
20.     }
21. }

复制代码

主机接收 1字节

1. static void SPI_Receive_Process(SPI_SFRmap *SPIx, uint8_t *Databuf)
2. {
3.     SPI_I2S_SendData8(SPI0_SFR, 0xFF);  /* 产生接收SCK */
4.     while (RESET == SPI_Get_Receive_Buf_Flag(SPI0_SFR))
5.     { /* 等待SPI0接收BUFFER不为空 */; }
6.     *Databuf = (uint8_t)SPI_I2S_ReceiveData(SPI0_SFR);
7. }

复制代码

发送接收函数

1. SPI_I2S_SendData8(SPI, data)
2. {
3.   SPI->address = data;
4. }
5. uint8_t SPI_I2S_ReceiveData(SPI)
6. {
7. uint8_t data;
8.   data = SPI->address;
9. return data;
10. }

复制代码

等待是否忙碌，状态寄存器0位

1. void Check_EEPROM_Busy(void)
2. {
3.     /* WIP(Write-In-Process),若为1则表示写入正在进行,反之则没有写入正在进行 */
4.     while (EEPROM_Read_Status()&0x01)
5.     {
6.         ;
7.     }
8. }

复制代码

写数据

1. void SPI_Write_EEPROM_Process(uint16_t Address, uint8_t *Data, uint16_t Length)
2. {
3.     uint8_t Cycle_Times = 0U;
4.     uint16_t Data_Length = Length;
5.     uint8_t Address_Offset = 0U;
6.     uint8_t EEPROM_25LC160_CMD;
7.     uint16_t EEPROM_Address = Address;
9.     /* INT_All_Enable(FALSE); */  /* 禁止所有全局可屏蔽中断使能位 */
10.     while ((Data_Length > 0U)&&(EEPROM_Address < 0x0800U))
11.     {
12.         Address_Offset = (16U - (EEPROM_Address % 16U));
13.         if (Data_Length > Address_Offset)
14.         {
15.             Cycle_Times = Address_Offset;
16.         }else{ Cycle_Times = Data_Length; }
18.         Check_EEPROM_Busy();
19.         EEPROM_CS_ENABLE;  /* CS as low */
20.         EEPROM_25LC160_CMD = EEP_WREN;  /* Write WEL */
21.         SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
22.         EEPROM_CS_DISABLE; /* CS as high */
24.         EEPROM_CS_ENABLE;  /* CS as low */
25.         EEPROM_25LC160_CMD = SPI_WRITE;
26.         SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
28.         /* 发送地址高8位 */
29.         EEPROM_25LC160_CMD = (uint8_t)(EEPROM_Address >> 8U);
30.         SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
32.         /* 发送地址低8位 */
33.         EEPROM_25LC160_CMD = (uint8_t)EEPROM_Address;
34.         SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
36.         while ((Cycle_Times > 0U)&&(Data_Length > 0U)&&(EEPROM_Address < 0x0800U))
37.         {
38.             SPI_Send_Process(SPI0_SFR, Data, 1U);
39.             Data++; Cycle_Times--; Data_Length--; EEPROM_Address++;
40.         }
41.         EEPROM_CS_DISABLE; /* CS as high */
42.     }
43.     /* INT_All_Enable(TRUE); */   /* 启用所有全局可屏蔽中断使能位 */
44. }

复制代码

读数据

1. void SPI_Read_EEPROM_Process(uint16_t Address, uint8_t *Data, uint16_t Length)
2. {
3.     uint8_t EEPROM_25LC160_CMD;
5.     /* INT_All_Enable(FALSE); */  /* 禁止所有全局可屏蔽中断使能位 */
6.     Check_EEPROM_Busy();
7.     EEPROM_CS_ENABLE;  /* CS as low */
8.     EEPROM_25LC160_CMD = SPI_READ;
9.     SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
11.     /* 发送地址高8位 */
12.     EEPROM_25LC160_CMD = (uint8_t)(Address >> 8U);
13.     SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
15.     /* 发送地址低8位 */
16.     EEPROM_25LC160_CMD = (uint8_t)Address;
17.     SPI_Send_Process(SPI0_SFR, &EEPROM_25LC160_CMD, 1U);
19.     while (Length > 0U)
20.     {
21.         SPI_Receive_Process(SPI0_SFR, Data);
22.         Data++; Length--;
23.     }
24.     EEPROM_CS_DISABLE; /* CS as high */
25.     /* INT_All_Enable(TRUE); */   /* 启用所有全局可屏蔽中断使能位 */
26. }

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

收藏一下   不知道什么时候能用到

谢谢分享，试用一下