// Write predefined object to EEPROM
static uint8_t eepromWriteOD(subidx_t *pSubidx, uint8_t Len, uint8_t *pBuf)
{
uint16_t Base;
Base = pSubidx->Base;
switch(pSubidx->Type)
{
case objBool:
case objInt8:
case objUInt8:
Len = sizeof(uint8_t);
break;
case objInt16:
case objUInt16:
Len = sizeof(uint16_t);
break;
case objInt32:
case objUInt32:
Len = sizeof(uint32_t);
break;
case objString:
case objArray:
eeprom_write(&Len, Base, 1);
if(Len == 0)
return MQTTSN_RET_ACCEPTED;
Base++;
break;
default:
return MQTTSN_RET_REJ_NOT_SUPP;
}
eeprom_write(pBuf, Base, Len);
return MQTTSN_RET_ACCEPTED;
}
//////////////////////////////////////////////////////////
// xpl_init_instance_id
// Get the instance id from EEPROM, and set to 'default'
// if no ID is present in the EEPROM
void xpl_init_instance_id(void) {
char count;
xpl_node_configuration = 0;
// Get the instance ID from EEPROM
// Maximum size = 16 chars + 1 null char
for (count = 0; count < 16; count++){
xpl_instance_id[count] = eeprom_read(count+XPL_EEPROM_INSTANCE_ID_OFFSET);
// When we encounter the null, stop reading
if (xpl_instance_id[count] == '\0') {
xpl_node_configuration |= NODE_CONFIGURED;
break;
}
// When the first char is 0xFF, flash is uninitialised
if (count == 0 && xpl_instance_id[0] == 0xFF) {
sprintf(xpl_instance_id, "default");
eeprom_write(XPL_EEPROM_OUPUTS_COUNT,'0');
eeprom_write(XPL_EEPROM_INPUTS_COUNT,'0');
break;
}
}
output_count = eeprom_read(XPL_EEPROM_OUPUTS_COUNT);
input_count = eeprom_read(XPL_EEPROM_INPUTS_COUNT);
}
void SMS_Format(void)
{
u8 i;
u16 BaseAddr;
#ifdef SMS_DEBUG_ON
u8 index;
#endif
for (i=0;i<SMS_MAX;i++)
{
BaseAddr=SMS_Base_Addr(i); ///<获得第i个存储区的基地址
eeprom_write(&i,BaseAddr,1);
eeprom_write("\0",BaseAddr+SMS_INDEX_LEN,1);
eeprom_write("\0",BaseAddr+SMS_INDEX_LEN+SMS_TITLE_MAX_LEN,1);
}
///用于验证格式化的结果
#ifdef SMS_DEBUG_ON
for (i=0;i<SMS_MAX;i++)
{
BaseAddr=SMS_Base_Addr(i); ///<获得第i个存储区的基地址
eeprom_read(&index,BaseAddr,1);
printf("%d->%d\r\n",i,index);
}
printf("格式化短信息存储区成功\r\n");
#endif
}
void save_int_to_eeprom( unsigned char add, unsigned int data )
{
eeprom_write( add, Hi( data ) ); //and save msb
DelayMs( 10 );
eeprom_write( add + 1, Lo( data ) ); //and lsb
DelayMs( 10 );
}
/* 保存本地设备信息 */
void local_device_info_save()
{
UINT8 i, ret;
struct kfish_ctrl info;
/* cfg avail */
/* get device name */
ret = eeprom_write(EEPROM_OFS_DEV_NAME, (UINT8 *)__device_name,
strlen(__device_name) + 1);
DBG_PRINT("mod dev name %s, modify %d bytes\n", __device_name, ret);
/* get controller info */
for(i=0; i<__local_ctrl_num; i++){
DBG_PRINT("save %d\n", i);
memcpy((char *)&info, (char *)&__local_ctrl[i], sizeof(struct kfish_ctrl));
/* clear dynamic */
memset((char *)info.ctrl.swi.rsv, 0, 8);
ret = eeprom_write(EEPROM_OFS_CTRL(i), (UINT8*)&info, sizeof(struct kfish_ctrl));
if(ret > 0){
DBG_PRINT("save, modify %d bytes\n", ret);
}else{
DBG_PRINT("save, info not changed\n");
}
}
EEPROM_put(EEPROM_OFS_DEV_INFOAVAIL, DEVICE_INFO_MAGIC);
}
void write_alerts()
{
eeprom_write(0,a.min);
eeprom_write(1,a.hour);
eeprom_write(2,a.ae);
for (i=3; i<10; i++) eeprom_write(i, a.dow[i-3]);
eeprom_write(10,t_delay);
}
/*---------------------------------------------------------------------------*/
void
node_id_burn(unsigned short id)
{
unsigned char buf[2];
buf[0] = 0xad;
buf[1] = 0xde;
eeprom_write(NODE_ID_EEPROM_OFFSET, buf, 2);
buf[0] = id >> 8;
buf[1] = id & 0xff;
eeprom_write(NODE_ID_EEPROM_OFFSET + 2, buf, 2);
}
/*==============================================================================
Name : write_sensor_settings_to_eeprom
--------------------------------------------------------------------------------
Purpose : Save sensor parameter settings to EEPROM
Input :
Output :
Notes :
==============================================================================*/
void write_sensor_settings_to_eeprom(void)
{
uint8_t i;
for(i = 0u; i < num_sensors; i++)
{
eeprom_write((EEPROM_LIB_CONFIG_START_ADDRESS + 7u + (i * 2u)),
sensors[i].threshold);
eeprom_write((EEPROM_LIB_CONFIG_START_ADDRESS + 8u + (i * 2u)),
sensors[i].type_aks_pos_hyst);
}
}
int
main(void)
{
u2_init();
putstr("\nFactory Test, Board Rev 3.0\n");
bool ok = true;
unsigned char maj = HW_REV_MAJOR;
unsigned char min = HW_REV_MINOR;
ok = eeprom_write(I2C_ADDR_MBOARD, MBOARD_REV_MSB, &maj, 1);
ok &= eeprom_write(I2C_ADDR_MBOARD, MBOARD_REV_LSB, &min, 1);
putstr("\nset_hw_rev\n");
if (ok)
printf("OK: set h/w rev to %d.%d\n", HW_REV_MAJOR, HW_REV_MINOR);
else {
printf("FAILED to set h/w rev to %d.%d\n", HW_REV_MAJOR, HW_REV_MINOR);
hal_finish();
return 0;
}
if(test_sd())
puts("SD OK\n");
else {
puts("SD FAIL\n");
//hal_finish();
//return 0;
}
if(test_ram())
puts("RAM OK\n");
else {
puts("RAM FAIL\n");
hal_finish();
return 0;
}
print_mac_addr(ethernet_mac_addr()->addr);
newline();
clocks_mimo_config(MC_WE_LOCK_TO_SMA);
while (!clocks_lock_detect()) {
puts("No Lock");
mdelay(1000);
}
puts("Clock Locked\n");
}
Status qNVRAM_setDefaults(nvram_t * p){
p->rateController[ROLL].K = 0.01;
p->rateController[ROLL].Ti = 1/0.1;
p->rateController[ROLL].Td = 0.0;
p->rateController[ROLL].Nd = 5.0;
p->rateController[PITCH].K = 0.01;
p->rateController[PITCH].Ti = 1/0.1;
p->rateController[PITCH].Td = 0.0;
p->rateController[PITCH].Nd = 5.0;
p->attiController[ROLL].K = 1.0;
p->attiController[ROLL].Ti = 1/0.02;
p->attiController[ROLL].Td = 0.0;
p->attiController[ROLL].Nd = 4.0;
p->attiController[PITCH].K = 1.0;
p->attiController[PITCH].Ti = 1/0.02;
p->attiController[PITCH].Td = 0.0;
p->attiController[PITCH].Nd = 4.0;
// =========================================================
p->rateController[YAW].K = 0.05;
p->rateController[YAW].Ti = 1/0.1;
p->rateController[YAW].Td = 0.000;
p->rateController[YAW].Nd = 5;
p->attiController[YAW].K = 5;
p->attiController[YAW].Ti = 1/0.05;
p->attiController[YAW].Td = 0.0;
p->attiController[YAW].Nd = 4;
return eeprom_write(EEPROM_ADDRESS,(uint8_t*)p,0x0000,sizeof(nvram_t));
}
/***********************************************************************
module : [WIFI]
function : [设置连接服务器密码]
return : [无]
comment : [全局普通函数]
machine : [EH-0818]
language : [CHN]
keyword : [WIFI]
date : [11/08/24]
author : [chen-zhengkai]
************************************************************************/
void setPassword()
{
char password[20] = {0};
char retStr[20] = {0};
char ret = -2; //设置失败
if (eeprom_read(password, 16, EEPROM_OFFSET_SEVPASSWORD)) {
ret = -1;
}
if (ret != -1) {
InputData((char*)"密码", password, 1);
if (password[0] != 0) { //判断字符串不为空
if (eeprom_write(password, 16, EEPROM_OFFSET_SEVPASSWORD)) {
ret = -2; //设置失败
}
else {
ret = 0; //设置成功
}
}
}
if (!ret) {
strcpy(retStr, "设置成功");
}
else if (ret == -1) {
strcpy(retStr, "EEPROM访问失败");
}
else if (ret == -2) {
strcpy(retStr, "设置失败");
}
DispStr_CE(0,6,retStr,DISP_CENTER|DISP_CLRSCR);
DispStr_CE(0,8,"按任意键继续",DISP_CENTER);
delay_and_wait_key( 3, EXIT_KEY_ALL, 0 );
}
void xmux_config_write_test_data()
{
/* pid map table */
{
struct xmux_pid_map_table *t;
t = &g_eeprom_param.pid_map_table_area.pid_map_table;
build_pid_map_table();
eeprom_write(EEPROM_OFF_PID_MAP_TABLE, t, sizeof(*t));
}
/* psi */
{
struct xmux_output_psi_data *data;
data = &g_eeprom_param.output_psi_area.output_psi;
data->pkt_nr = 10;
data->psi_ents[0].offset = 0;
data->psi_ents[0].nr_ts_pkts = 10;
memset(data->ts_pkts, 0x47, 10);
xmux_config_save_output_psi_data();
}
/* pid trans info */
{
build_pid_trans_info();
xmux_config_save_pid_trans_info_all();
}
}
int
net_cs8900a_write_halfword (struct device_desc *dev, uint32 addr, uint16 data)
{
struct net_device *net_dev = (struct net_device *) dev->dev;
struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data;
int offset = (uint16) (addr - dev->base);
int ret = ADDR_HIT;
switch (offset) {
case Tx_Frame_Port:
frame_write (dev, data);
break;
case IO_TxCMD:
io->tx_cmd = data;
break;
case IO_TxLength:
io->tx_length = data;
break;
case PP_Address:
io->pp_address = data;
break;
case PP_Data:
if (io->pp_address >= 0x100 && io->pp_address < 0x140) {
ctrl_status_write (dev, data);
}
switch (io->pp_address) {
case PP_IntNum:
io->int_num = data;
break;
case PP_EEPROMCommand:
io->eeprom_cmd = data;
eeprom_write (dev, data);
break;
case PP_EEPROMData:
if (io->eeprom_writable == 1)
io->eeprom_data = data;
break;
case PP_IA:
case PP_IA + 2:
case PP_IA + 4:
io->ieee_addr[io->pp_address - PP_IA] = data & 0xff;
io->ieee_addr[io->pp_address - PP_IA + 1] =
(data >> 8) & 0xff;
break;
case PP_TxCMD:
io->tx_cmd = data;
break;
case PP_TxLength:
io->tx_length = data;
break;
}
break;
default:
break;
}
return ret;
}
void xmux_config_save_net_param(struct xmux_net_param *net)
{
net->csc = wu_csc(net, sizeof(*net) - 1);
g_eeprom_param.net = *net;
eeprom_write(EEPROM_OFF_NET, net, sizeof(*net));
hex_dump("save net", &g_eeprom_param.net, sizeof(*net));
}
static void eeprom_rw_test_1()
{
int i, cnt = 0;
uint8_t *wbuf = &g_eeprom_param;
uint8_t *rbuf = &tmp_eeprom_param;
while (1) {
// write something
for (i = 0; i < 1024; i++)
wbuf[i] = i;
memset(wbuf, cnt, NBYTES);
cnt++;
eeprom_write(0, wbuf, NBYTES);
// read back
memset(rbuf, 0xFF, NBYTES);
eeprom_read(0, rbuf, NBYTES);
// check
for (i = 0; i < NBYTES; i++) {
if (rbuf[i] != wbuf[i]) {
trace_err("check failed begin at %#x!", i);
hex_dump("write", &wbuf[i], NBYTES - i);
hex_dump("read", &rbuf[i], NBYTES - i);
break;
}
}
if (i == NBYTES) {
trace_info("check passed");
}
sleep(2);
//break;
}
exit(0);
}
static void
test_write(void)
{
printf("Debug: test eeprom_write ... ");
/*
* Write twice, 8 bytes per write
*/
eeprom_write (CONFIG_SYS_I2C_EEPROM_ADDR, EEPROM_TEST_OFFSET,
testbuf, 8);
eeprom_write (CONFIG_SYS_I2C_EEPROM_ADDR, EEPROM_TEST_OFFSET+8,
testbuf, 16);
printf("done\n");
pll_debug(EEPROM_TEST_OFFSET);
}
void eeprom_store_data()
{
uint8_t buf[200] = {0}; // initialize with zeros
int len = ts.pub_msg_cbor(buf + EEPROM_HEADER_SIZE, sizeof(buf) - EEPROM_HEADER_SIZE, eeprom_data_objects, sizeof(eeprom_data_objects)/sizeof(uint16_t));
uint32_t crc = _calc_crc(buf + EEPROM_HEADER_SIZE, len);
// store EEPROM_VERSION, number of bytes and CRC
*((uint16_t*)&buf[0]) = (uint16_t)EEPROM_VERSION;
*((uint16_t*)&buf[2]) = (uint16_t)(len); // length of data
*((uint32_t*)&buf[4]) = crc;
//printf("Data (len=%d): ", len);
//for (int i = 0; i < len; i++) printf("%.2x ", buf[i + EEPROM_HEADER_SIZE]);
//printf("Header: %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x\n",
// buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
if (len == 0) {
printf("EEPROM: Data could not be stored, ThingSet error: %d\n", len);
}
else if (eeprom_write(0, buf, len + EEPROM_HEADER_SIZE) < 0) {
printf("EEPROM: Write error.\n");
}
else {
printf("EEPROM: Data successfully stored.\n");
}
}
BOOL handle_vendorcommand(BYTE cmd)
{
WORD addr=SETUP_VALUE(),len=SETUP_LENGTH();
switch ( cmd ) {
case VC_EPSTAT:
{
xdata BYTE* pep= ep_addr(SETUPDAT[2]);
if (pep) {
EP0BUF[0] = *pep;
EP0BCH=0;
EP0BCL=1;
return TRUE;
}
}
break;
case VC_EEPROM:
{
// wait for ep0 not busy
switch (SETUP_TYPE) {
case 0xc0:
while (len) { // still have bytes to read
// can't read more than 64 bytes at a time
BYTE cur_read = len > 64 ? 64 : len;
while (EP0CS&bmEPBUSY); // can't do this until EP0 is ready
eeprom_read(0x51, addr, cur_read, EP0BUF );
EP0BCH=0;
SYNCDELAY();
EP0BCL=cur_read;
len -= cur_read;
addr += cur_read;
}
break;
case 0x40:
while (len) {
BYTE cur_write;
EP0BCL = 0; // allow pc transfer in
while(EP0CS & bmEPBUSY); // wait
cur_write=EP0BCL;
if ( !eeprom_write(0x51, addr, cur_write, EP0BUF ) ) return FALSE;
addr += cur_write;
len -= cur_write;
}
break;
default:
return FALSE; // bad type
}
printf ( "All OK\n" );
return TRUE;
}
break;
default:
{
printf ( "Need to implement vendor command: %02x\n", cmd );
return FALSE;
}
}
return FALSE;
}
static result_t do_i2c_test(uint8 slot)
{
#define MDC_IIC_TEST_STR "MDC IIC TEST"
uint8 buf[16] = {0};
int retval;
iic_device_t device;
if(SLOT_1 == slot){
device = MDC_SLOT1_IIC;
}else if(SLOT_2 == slot){
device = MDC_SLOT2_IIC;
}else{
return MDC_TEST_FAIL;
}
retval = eeprom_write(device, 0, (uint8 *)MDC_IIC_TEST_STR, strlen(MDC_IIC_TEST_STR));
if(retval == strlen(MDC_IIC_TEST_STR)){
retval = eeprom_read(device, 0, buf, strlen(MDC_IIC_TEST_STR));
if(retval == strlen(MDC_IIC_TEST_STR)){
if(!strcmp((char *)buf, MDC_IIC_TEST_STR)){
return MDC_TEST_PASS;
}
}
}
return MDC_TEST_FAIL;
}
//**************************************************************************
void eeprom_apply_settings(void)
{
if(eeprom_read(contrast_address)!=Settings.contrast)
{
display_off();
delay_ms(200);
display_on();
}
// -------------------------------------------------------------------
if(eeprom_read(Display_reverse_address)!=Settings.Display_reverse)
{
display_off();
delay_ms(200);
display_on();
}
// -------------------------------------------------------------------
if(eeprom_read(v4_target_pump_address)!=Settings.v4_target_pump)
{
reset_TIM_prescallers_and_Compare();
}
// -------------------------------------------------------------------
if(eeprom_read(Geiger_voltage_address) !=Settings.Geiger_voltage)
{
dac_reload(); //перезагрузить в ЦАП новое напряжение отсечки накачки
}
// -------------------------------------------------------------------
if(eeprom_read(LSI_freq_address) !=Settings.LSI_freq)
{
if(Settings.LSI_freq != 0x00) // если запустился кварц, попытки сохранения игнорировать
{
eeprom_write(LSI_freq_address,Settings.LSI_freq); NVIC_SystemReset();
}
}
}
void readMAC(void) {
uint8_t eeprom_rd_buffer[32];
// If the eeprom (first sector) matches our version string, use the configuration
// found in the eeprom, otherwise generate a random MAC and persist it for this board.
printf("main: loading from eeprom read sz=%d address=%04x\n", sizeof(eeprom_rd_buffer), EEPROM_CONFIG_BASE);
eeprom_read(EEPROM_CONFIG_BASE, (unsigned char *)&eeprom_rd_buffer, sizeof(eeprom_rd_buffer));
if (strcmp(version, (char*)&eeprom_rd_buffer ) == 0) {
printf("main: using stored configuration\n");
} else {
printf("main: setting new MAC with DHCP\n");
memset((void *)&eeprom_rd_buffer, 0, sizeof(eeprom_rd_buffer));
memcpy((unsigned char *)&eeprom_rd_buffer[0], version, strlen(version)+1);
// use microchip OUI database range, since it's a microchip part
eeprom_rd_buffer[24] = 0x00;
eeprom_rd_buffer[25] = 0x04;
eeprom_rd_buffer[26] = 0xA3;
eeprom_rd_buffer[27] = (unsigned char) rand31pmc_ranlui() & 0xFF;
eeprom_rd_buffer[29] = (unsigned char) rand31pmc_ranlui() & 0xFF;
eeprom_rd_buffer[30] = (unsigned char) rand31pmc_ranlui() & 0xFF;
printf("main: writing to eeprom\n");
eeprom_write(EEPROM_CONFIG_BASE, (unsigned char *)&eeprom_rd_buffer, sizeof(eeprom_rd_buffer));
}
memcpy((unsigned char *)ð_mac_addr, (char*)&eeprom_rd_buffer[24], sizeof(eth_mac_addr));
}
static void SaveSubindex(uint16_t sidxn, subidx_t *pSubidx)
{
uint16_t addr = sidxn;
addr *= sizeof(subidx_t);
addr += eelistOdbu;
eeprom_write((uint8_t *)pSubidx, addr, sizeof(subidx_t));
}
int saveenv(void)
{
return eeprom_write (CONFIG_SYS_DEF_EEPROM_ADDR,
CONFIG_ENV_OFFSET,
(uchar *)env_ptr,
CONFIG_ENV_SIZE);
}
/***********************************************************************
module : [WIFI]
function : [设置连接服务器SSID]
return : [无]
comment : [全局普通函数]
machine : [EH-0818]
language : [CHN]
keyword : [WIFI]
date : [11/08/24]
author : [chen-zhengkai]
************************************************************************/
void setServerSSID()
{
char pUserName[20] = {0};
char retStr[20] = {0};
char ret = -2; //设置失败
//strcpy(dspBuf, "端口设置成功");
if (eeprom_read(pUserName, 16, EEPROM_OFFSET_SERVERSSID)) {
ret = -1;
}
if (ret != -1) {
InputData((char*)"SSID", pUserName, 1);
if (pUserName[0] != 0) { //判断字符串不为空
if (eeprom_write(pUserName, 16, EEPROM_OFFSET_SERVERSSID)) {
ret = -2; //设置失败
}
else {
ret = 0; //设置成功
}
}
}
if (!ret) {
strcpy(retStr, "设置成功");
}
else if (ret == -1) {
strcpy(retStr, "EEPROM访问失败");
}
else if (ret == -2) {
strcpy(retStr, "设置失败");
}
DispStr_CE(0,6,retStr,DISP_CENTER|DISP_CLRSCR);
DispStr_CE(0,8,"按任意键继续",DISP_CENTER);
delay_and_wait_key( 3, EXIT_KEY_ALL, 0 );
}
void pick_block(int16_t page) {
if (page == current_page) {
return;
}
if (current_page != -1) {
flush_block();
}
if (page >= pages_initialized) {
uint8_t buf[16];
for (int16_t i = 0; i < 16; ++i) {
buf[i] = 0xff;
}
for (int16_t i = 0; i < 512; i += 16) {
flash_buf_write(0, i, buf, 16);
}
for ( ; pages_initialized <= page; ) {
flash_put_buffer(0, pages_initialized);
pages_initialized++;
}
eeprom_write(EEP_MAXPAGE_L, (uint8_t)(pages_initialized & 0xff));
eeprom_write(EEP_MAXPAGE_H, (uint8_t)(pages_initialized >> 8));
putProg("Pages initialized: ");
putInt(pages_initialized);
putCRLF();
}
/* ------------------------------------------------------------------------- */
int
do_eecl (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
uchar data[HYMOD_EEPROM_SIZE];
uint addr = CONFIG_SYS_I2C_EEPROM_ADDR;
switch (argc) {
case 1:
addr |= HYMOD_EEOFF_MAIN;
break;
case 2:
if (strcmp (argv[1], "main") == 0) {
addr |= HYMOD_EEOFF_MAIN;
break;
}
if (strcmp (argv[1], "mezz") == 0) {
addr |= HYMOD_EEOFF_MEZZ;
break;
}
/* fall through ... */
default:
cmd_usage(cmdtp);
return 1;
}
memset (data, 0, HYMOD_EEPROM_SIZE);
eeprom_write (addr, 0, data, HYMOD_EEPROM_SIZE);
return 0;
}
/*
* Set and print backplane ip...
*/
int do_set_bpip(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char *buf;
char str[32];
ulong crc;
if (argc < 2) {
puts("ERROR!\n");
return -1;
}
printf("Setting bp_ip to %s\n", argv[1]);
buf = malloc(CONFIG_ENV_SIZE_2);
memset(buf, 0, CONFIG_ENV_SIZE_2);
sprintf(str, "bp_ip=%s", argv[1]);
strcpy(buf+4, str);
crc = crc32(0, (uchar *)(buf+4), CONFIG_ENV_SIZE_2 - 4);
*(ulong *)buf = crc;
if (eeprom_write(CONFIG_SYS_I2C_EEPROM_ADDR_2,
0, (uchar *)buf, CONFIG_ENV_SIZE_2))
puts("\nError writing backplane EEPROM!\n");
free(buf);
return 0;
}
/***********************************************************************
module : [WIFI]
function : [设置连接服务器端口]
return : [无]
comment : [全局普通函数]
machine : [EH-0818]
language : [CHN]
keyword : [WIFI]
date : [11/08/24]
author : [chen-zhengkai]
************************************************************************/
void setServerPort()
{
char serverPort[10] = {0};
char retStr[20] = {0};
char ret = -2; //设置失败
//strcpy(dspBuf, "端口设置成功");
if (eeprom_read(serverPort, 8, EEPROM_OFFSET_SERVERPORT)) {
ret = -1;
}
if (ret != -1) {
InputData((char*)"服务器端口", serverPort, 0);
if (serverPort[0] != 0) { //判断字符串不为空
if (eeprom_write(serverPort, 8, EEPROM_OFFSET_SERVERPORT)) {
ret = -2; //设置失败
}
else {
ret = 0; //设置成功
}
}
}
if (!ret) {
strcpy(retStr, "设置成功");
}
else if (ret == -1) {
strcpy(retStr, "EEPROM访问失败");
}
else if (ret == -2) {
strcpy(retStr, "设置失败");
}
DispStr_CE(0,6,retStr,DISP_CENTER|DISP_CLRSCR);
DispStr_CE(0,8,"按任意键继续",DISP_CENTER);
delay_and_wait_key( 3, EXIT_KEY_ALL, 0 );
}
/**
* @brief
* This method processes function 21
* This method writes a word array to EEPROM assigned by the master
*
* @return u8BufferSize Response to master length
* @ingroup register
*/
int8_t ModbusProcess_FC21()
{
//uint8_t u8func = au8Buffer[ FUNC ]; // get the original FUNC code
uint8_t requestDataLen = _au8Buffer[ FILE_DATA_LEN ];
uint16_t startAddrsBytes = (word(_au8Buffer[ FILE_REC_HI ], _au8Buffer[ FILE_REC_LO ])) << 1;
_lastAddress = startAddrsBytes;
uint16_t recLenBytes = (word(_au8Buffer[ FILE_REC_LEN_HI ], _au8Buffer[ FILE_REC_LEN_LO ])) << 1;
_lastCount = recLenBytes;
uint8_t u8CopyBufferSize;
uint8_t i;
// uint16_t temp;
// build header
//au8Buffer[ NB_HI ] = 0;
//au8Buffer[ NB_LO ] = u8regsno;
_u8BufferSize = requestDataLen + 1;
// write EEPROM
for (i = 0; i < recLenBytes; i++)
{
eeprom_write(startAddrsBytes + i, _au8Buffer[ FILE_FIRST_BYTE + i ]);
}
// wait for write end
while(WR)
continue;
u8CopyBufferSize = _u8BufferSize; // +2;
ModbusSendTxBuffer();
return u8CopyBufferSize;
}
int rrcp_autodetectchip_try_to_write_eeprom (uint16_t addr1, uint16_t addr2)
{
uint8_t tmp11=0, tmp12=0, tmp21=0, tmp22=0;
eeprom_read(addr1,&tmp11);
eeprom_read(addr2,&tmp12);
eeprom_write(addr1,tmp11+0x055);
eeprom_write(addr2,tmp11+0x0aa);
tmp21=tmp11;
tmp22=tmp11;
eeprom_read(addr1,&tmp21);
eeprom_read(addr2,&tmp22);
eeprom_write(addr1,tmp11);
eeprom_write(addr2,tmp12);
return ((tmp21==(uint8_t)(tmp11+0x055))&&(tmp22==(uint8_t)(tmp11+0x0aa)));
}
