#include "e2p.h"
|
|
#include "delay.h"
|
#include "uart.h"
|
#include "gpio.h"
|
|
#include "devicegpioinit.h" //**24.5.27
|
|
E2P_TEST_DATA_T e2p_test_data_g;
|
//eeprom ¶ÁÊÇ1¸ö×Ö½Ú50us¡£
|
|
#define EEPROM_ADDR_BYTES1
|
|
#ifdef EEPROM_ADDR_BYTES2
|
#define EEPROM_PAGE_SIZE 64
|
#else
|
#define EEPROM_PAGE_SIZE 256
|
#endif
|
|
|
uint32_t test_addr_temp[3] = {10,20,30};
|
|
void E2p_IO_Init(void)
|
{
|
// CMU_PERCLK_SetableEx(PADCLK, ENABLE); //PADʱÖÓ£¨GPIO£©Ê¹Äܺ¯Êý
|
// OutputIO(E2P_PWR_PORT,E2P_PWR_PIN,OUT_PUSHPULL);
|
// OutputIO(E2P_CS1_PORT,E2P_CS1_PIN,OUT_PUSHPULL);
|
// OutputIO(E2P_CS2_PORT,E2P_CS2_PIN,OUT_PUSHPULL);
|
// E2P_PWR_OFF;
|
// FM25V02_CS_HIGH;
|
}
|
|
|
//E2Pд²âÊÔ
|
void E2p_Write_Test(uint8_t data_8,uint16_t data_16,uint32_t data_32,float data_f,double data_d)
|
{
|
// E2p_GPIO_Clk_Init();
|
E2P_PWR_ON;
|
FM25V02_data_write(data_8,test_addr_temp[0]);
|
FM25V02_data_write_uint16(test_addr_temp[1],data_16);
|
FM25V02_data_write_uint32(test_addr_temp[2],data_32);
|
E2P_PWR_OFF;
|
}
|
//E2P¶Á²âÊÔ
|
void E2p_Read_Test(void)
|
{
|
// E2p_GPIO_Clk_Init();
|
E2P_PWR_ON;
|
e2p_test_data_g.test_u8 = FM25V02_data_read(test_addr_temp[0]);
|
e2p_test_data_g.test_u16 = FM25V02_data_read_uint16(test_addr_temp[1]);
|
e2p_test_data_g.test_u32 = FM25V02_data_read_uint32(test_addr_temp[2]);
|
printf("0x%02X 0x%02X 0x%02x",e2p_test_data_g.test_u8,e2p_test_data_g.test_u16,e2p_test_data_g.test_u32);
|
E2P_PWR_OFF;
|
}
|
|
|
void EEPROM_Wait_Busy(void)
|
{
|
while ((FM25V02_stat_read()&0x01)==0x01); //wait BUSY=0
|
}
|
|
/******************************************
|
* func: FM25V02_data_write
|
* desc: write 1 byte data to fram
|
* input:
|
* data - 1 byte data
|
* addr16 - destination address for write
|
* output: none
|
* return: none
|
*****************************************/
|
//void FM25V02_data_write(uint32_t addr16,uint8_t data)
|
void FM25V02_data_write(uint8_t data,uint32_t addr16)
|
{
|
u32 addr_fit;
|
addr_fit = addr16 ;
|
// haddr = (addr16 >> 8) & 0x7f;//high 7 bit address
|
// laddr = (addr16 & 0xff); //low 8 bit address
|
|
// delay_us(10);
|
FM25V02_CS_LOW(CS_1);
|
// FM_ReadWriteByte(FM_WREN);
|
if(FM_ReadWriteByte(FM_WREN)==1){}
|
FM25V02_CS_HIGH;
|
|
// delay_us(10);
|
|
FM25V02_CS_LOW(CS_1);
|
if(FM_ReadWriteByte(FM_WRITE)==1){}
|
|
#ifndef EEPROM_ADDR_BYTES2
|
FM_ReadWriteByte((u8)((addr_fit)>>16));
|
#endif
|
FM_ReadWriteByte((u8)((addr_fit)>>8));
|
FM_ReadWriteByte((u8)((addr_fit)));
|
FM_ReadWriteByte(data);
|
FM25V02_CS_HIGH;
|
|
// Test_GPIO_High;
|
|
EEPROM_Wait_Busy();
|
|
// Test_GPIO_Low;
|
}
|
|
/******************************************
|
* func: FM25V02_data_read
|
* desc: read 1 byte data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return: 1 byte data read from fram
|
*****************************************/
|
uint8_t FM25V02_data_read(uint32_t addr16)
|
{
|
uint8_t data;
|
u32 addr_fit;
|
addr_fit = addr16 ;
|
// haddr = (addr16 >> 8) & 0x7f;//high 7 bit address
|
// laddr = (addr16 & 0xff); //low 8 bit address
|
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_READ);
|
#ifndef EEPROM_ADDR_BYTES2
|
FM_ReadWriteByte((u8)(addr_fit>>16));
|
#endif
|
FM_ReadWriteByte((u8)(addr_fit>>8));
|
FM_ReadWriteByte((u8)(addr_fit));
|
data = FM_ReadWriteByte(0xFF);//data = FM_ReadWriteByte(0xff);
|
FM25V02_CS_HIGH;
|
|
return data;
|
}
|
|
/******************************************
|
* func: FM25V02_stat_write
|
* desc: write 1 byte status data to fram
|
* input:
|
* data - 1 byte state data to fram status register
|
* output: none
|
* return: none
|
*****************************************/
|
void FM25V02_stat_write(uint8_t stat)
|
{
|
// delay_us(10);
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_WREN);
|
FM25V02_CS_HIGH;
|
|
// delay_us(10);
|
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_WRSR);
|
FM_ReadWriteByte(stat);
|
FM25V02_CS_HIGH;
|
|
}
|
|
/******************************************
|
* func: FM25V02_stat_read
|
* desc: read 1 byte status data from fram
|
* input: none
|
* output: none
|
* return: 1 byte status data read from fram
|
*****************************************/
|
uint8_t FM25V02_stat_read(void)
|
{
|
uint8_t stat;
|
|
delay_us(10);
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_RDSR);
|
stat = FM_ReadWriteByte(0xff);
|
FM25V02_CS_HIGH;
|
|
return stat;
|
}
|
|
/******************************************
|
* func: FM25V02_sleep
|
* desc: take fram into sleep mode
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void FM25V02_sleep(void)
|
{
|
delay_us(10);
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_SLEEP);
|
FM25V02_CS_HIGH;
|
}
|
|
|
/******************************************
|
* func: FM25V02_ID_read
|
* desc: read 9 byte ID data from fram
|
* input: none
|
* output: 9 byte ID data read from fram,write to dst
|
* return: none
|
*****************************************/
|
void FM25V02_ID_read(uint8_t *dst)
|
{
|
uint8_t i;
|
|
delay_us(10);
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_RDID);
|
for(i = 0;i < 9;i ++)
|
{
|
dst[i] = FM_ReadWriteByte(0xff);
|
}
|
FM25V02_CS_HIGH;
|
}
|
|
|
|
/******************************************
|
* func: FM25V02_data_read_float
|
* desc: read float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
float FM25V02_data_read_float(uint32_t addr16)
|
{
|
//float_un f;
|
float_un k;
|
k.data[0] = FM25V02_data_read(addr16);
|
k.data[1] = FM25V02_data_read(addr16+1);
|
k.data[2] = FM25V02_data_read(addr16+2);
|
k.data[3] = FM25V02_data_read(addr16+3);
|
return (k.flo);
|
}
|
|
/******************************************
|
* func: FM25V02_data_write_float
|
* desc: write float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
void FM25V02_data_write_float(uint32_t addr16, float data)
|
{
|
float_un f;
|
f.flo = data;
|
|
EEPROM_MultipleWrite(f.data,addr16,4);
|
|
}
|
|
|
/******************************************
|
* func: FM25V02_data_read_float
|
* desc: read float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
double FM25V02_data_read_double(uint32_t addr16)
|
{
|
double_un d;
|
d.data[0] = FM25V02_data_read(addr16);
|
d.data[1] = FM25V02_data_read(addr16+1);
|
d.data[2] = FM25V02_data_read(addr16+2);
|
d.data[3] = FM25V02_data_read(addr16+3);
|
d.data[4] = FM25V02_data_read(addr16+4);
|
d.data[5] = FM25V02_data_read(addr16+5);
|
d.data[6] = FM25V02_data_read(addr16+6);
|
d.data[7] = FM25V02_data_read(addr16+7);
|
if( (d.data[0]==0xff) && (d.data[1]==0xff)&&(d.data[2]==0xff) && (d.data[3]==0xff)&&(d.data[4]==0xff) && (d.data[5]==0xff)&&(d.data[6]==0xff) && (d.data[7]==0xff))
|
d.dou=0;
|
return (d.dou);
|
}
|
|
/******************************************
|
* func: FM25V02_data_read_float
|
* desc: read float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
void FM25V02_data_write_double(uint32_t addr16, double data)
|
{
|
double_un d;
|
d.dou = data;
|
|
|
EEPROM_MultipleWrite(d.data,addr16,8);
|
|
}
|
|
|
/******************************************
|
* func: FM25V02_data_read_float
|
* desc: read float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
u32 FM25V02_data_read_uint32(uint32_t addr16)
|
{
|
|
u32_un t;
|
t.data[0] = FM25V02_data_read(addr16);
|
t.data[1] = FM25V02_data_read(addr16+1);
|
t.data[2] = FM25V02_data_read(addr16+2);
|
t.data[3] = FM25V02_data_read(addr16+3);
|
return (t.uio);
|
}
|
|
/******************************************
|
* func: FM25V02_data_write_float
|
* desc: write float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
void FM25V02_data_write_uint32(uint32_t addr16, uint32_t data)
|
{
|
u32_un t;
|
t.uio = data;
|
|
EEPROM_MultipleWrite(t.data,addr16,4);
|
|
|
}
|
|
/******************************************
|
* func: FM25V02_data_read_uint32_Check
|
* desc: read float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
u32 FM25V02_data_read_uint32_Check(uint32 addr16)
|
{
|
u32_un t;
|
u32_un t1;
|
u32_un t2;
|
|
EEPROM_MultipleRead_Continue(t.data,addr16,4);
|
|
delay_us(100);
|
EEPROM_MultipleRead_Continue(t1.data,addr16,4);
|
|
if(t.uio == t1.uio)
|
{
|
if(t.uio <= 900000000)
|
{
|
return t.uio;
|
}
|
else
|
{
|
t.uio = 0xffffffff;
|
return t.uio;
|
}
|
}
|
else
|
{
|
delay_us(100);
|
EEPROM_MultipleRead_Continue(t2.data,addr16,4);
|
|
if(t.uio == t1.uio || t.uio == t2.uio)
|
{
|
if(t.uio <= 900000000)
|
{
|
return t.uio;
|
}
|
else
|
{
|
t.uio = 0xffffffff;
|
return t.uio;
|
}
|
}
|
else if(t1.uio == t2.uio)
|
{
|
if(t1.uio <= 900000000)
|
{
|
return t1.uio;
|
}
|
else
|
{
|
t1.uio = 0xffffffff;
|
return t1.uio;
|
}
|
}
|
else
|
{
|
t1.uio = 0xffffffff;
|
return t1.uio;
|
}
|
}
|
}
|
/******************************************
|
* func: FM25V02_data_write_float
|
* desc: write float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
void FM25V02_data_write_uint32_WRCheck(uint32 addr16, uint32 data)
|
{
|
u32_un t;
|
u8 count_i;
|
u32_un t1;
|
|
for(count_i=0; count_i<3; count_i++)
|
{
|
t.uio = data;
|
EEPROM_MultipleWrite(t.data,addr16,4);
|
delay_ms(1);
|
EEPROM_MultipleRead_Continue(t1.data,addr16,4);
|
delay_ms(1);
|
if(t1.uio == data)
|
{
|
break;
|
}
|
else if(count_i == 2)
|
{
|
t.uio = 0xffffffff;
|
EEPROM_MultipleWrite(t.data,addr16,4);
|
}
|
}
|
}
|
|
/******************************************
|
* func: FM25V02_data_read_float
|
* desc: read float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
u16 FM25V02_data_read_uint16(uint32_t addr16)
|
{
|
|
u16_un t;
|
t.data[0] = FM25V02_data_read(addr16);
|
t.data[1] = FM25V02_data_read(addr16+1);
|
return (t.uso);
|
}
|
|
/******************************************
|
* func: FM25V02_data_write_float
|
* desc: write float data from fram
|
* input:
|
* addr16 - destination address for read 1byte data
|
* output: none
|
* return:
|
*****************************************/
|
void FM25V02_data_write_uint16(uint32_t addr16, uint16_t data)
|
{
|
u16_un t;
|
t.uso = data;
|
|
EEPROM_MultipleWrite(t.data,addr16,2);
|
|
}
|
|
|
u8 EEPROM_MultipleWrite(u8 *data,u32 addr,u16 bytes)
|
{
|
u8 flag;
|
u8 *ptr_data;
|
u16 i;
|
u32 addr_temp;
|
u32 index,byte_write_num_left,bytewrite;
|
//u32 banknum1,banknum2;
|
//ÏÈÅжÏÊý¾ÝÊÇ·ñ´¦ÓÚ256µÄÕâ¸öÇø¼äÄØ
|
if(bytes > 4000 )
|
return 0;
|
ptr_data = data;
|
flag = 0;
|
addr_temp = addr;
|
byte_write_num_left = bytes;
|
if(byte_write_num_left > 0) //ÐèҪдµÄÊý¾Ý»¹ÓÐÊ£Óà
|
{
|
|
index = (addr_temp/EEPROM_PAGE_SIZE) + 1;
|
if( ((index * EEPROM_PAGE_SIZE) - addr_temp) >= byte_write_num_left)
|
{
|
bytewrite = byte_write_num_left;
|
|
}else
|
{
|
bytewrite = (index * EEPROM_PAGE_SIZE) - addr_temp;
|
}
|
flag = 1;
|
}else
|
{
|
flag = 0;
|
|
}
|
|
|
|
while(flag)
|
{
|
|
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_WREN);
|
FM25V02_CS_HIGH;
|
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_WRITE);
|
#ifndef EEPROM_ADDR_BYTES2
|
FM_ReadWriteByte((u8)((addr_temp)>>16));
|
#endif
|
FM_ReadWriteByte((u8)((addr_temp)>>8));
|
FM_ReadWriteByte((u8)(addr_temp));
|
for(i = 0;i < bytewrite;i ++)
|
FM_ReadWriteByte(*ptr_data ++);
|
FM25V02_CS_HIGH;
|
|
|
|
addr_temp = addr_temp + bytewrite;
|
byte_write_num_left = byte_write_num_left - bytewrite;
|
if(byte_write_num_left > 0) //ÐèҪдµÄÊý¾Ý»¹ÓÐÊ£Óà
|
{
|
|
index = (addr_temp/EEPROM_PAGE_SIZE) + 1;
|
if( ((index * EEPROM_PAGE_SIZE) - addr_temp) >= byte_write_num_left)
|
{
|
bytewrite = byte_write_num_left;
|
|
}else
|
{
|
bytewrite = (index * EEPROM_PAGE_SIZE) - addr_temp;
|
}
|
flag = 1;
|
}else
|
{
|
flag = 0;
|
|
}
|
EEPROM_Wait_Busy();
|
|
}
|
return flag;
|
}
|
|
|
void EEPROM_MultipleRead(u8 *data, u32 addr, u16 bytes)
|
{
|
|
u16 index;
|
u32 addr_index;
|
|
addr_index = addr;
|
for(index = 0; index < bytes; index ++)
|
{
|
data[index] = FM25V02_data_read(addr_index ++);
|
}
|
|
}
|
|
/******************************************
|
* func: EEPROM_MultipleRead_Continue
|
* desc: EEPROM read multiple bytes
|
* input:
|
* data - 1 byte data
|
* addr16 - destination address for write
|
* bytes - Number of bytes
|
* output: none
|
* return: none
|
*****************************************/
|
void EEPROM_MultipleRead_Continue(u8 *data, u32 addr, u16 bytes)
|
{
|
u16 index;
|
u32 addr_index;
|
u16 length;
|
addr_index = addr;
|
length = bytes;
|
|
FM25V02_CS_LOW(CS_1);
|
FM_ReadWriteByte(FM_READ);
|
FM_ReadWriteByte((u8)(addr_index>>16));
|
FM_ReadWriteByte((u8)(addr_index>>8));
|
FM_ReadWriteByte((u8)(addr_index));
|
for(index = 0; index < length;index++)
|
{
|
data[index] = FM_ReadWriteByte(0xff);//data = FM_ReadWriteByte(0xff);
|
}
|
|
FM25V02_CS_HIGH;
|
}
|
