// 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))); }