/* * EEPROM Quick macro reading */ uchar usbFunctionRead(uchar *data, uchar len) { uchar i = len; usbMsgPtr_t r = usbMsgPtr; /* EEPROM data */ /*do{ uchar c = eeprom_read_byte(r); *data++ = c; r++; }while(--i);*/ eeprom_read_block(data, (void *)r, i); usbMsgPtr = r + i; return len; }
void lcd_material_set_material(uint8_t nr, uint8_t e) { material[e].temperature = eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(nr)); material[e].bed_temperature = eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(nr)); material[e].flow = eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(nr)); material[e].fan_speed = eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(nr)); material[e].diameter = eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(nr)); eeprom_read_block(material_name[e], EEPROM_MATERIAL_NAME_OFFSET(nr), MATERIAL_NAME_LENGTH); material_name[e][MATERIAL_NAME_LENGTH] = '\0'; if (material[e].temperature > HEATER_0_MAXTEMP - 15) material[e].temperature = HEATER_0_MAXTEMP - 15; if (material[e].bed_temperature > BED_MAXTEMP - 15) material[e].bed_temperature = BED_MAXTEMP - 15; lcd_material_store_current_material(); }
bool EeFsOpen() { eeprom_read_block((uint8_t *)&eeFs, 0, sizeof(eeFs)); #ifdef SIMU if (eeFs.version != EEFS_VERS) { printf("bad eeFs.version (%d instead of %d)\n", eeFs.version, EEFS_VERS); fflush(stdout); } if (eeFs.mySize != sizeof(eeFs)) { printf("bad eeFs.mySize (%d instead of %d)\n", (int)eeFs.mySize, (int)sizeof(eeFs)); fflush(stdout); } #endif return eeFs.version == EEFS_VERS && eeFs.mySize == sizeof(eeFs); }
static char* lcd_material_select_callback(uint8_t nr) { uint8_t count = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET()); if (nr == 0) strcpy_P(card.longFilename, PSTR("< RETURN")); else if (nr == count + 1) strcpy_P(card.longFilename, PSTR("Customize")); else if (nr == count + 2) strcpy_P(card.longFilename, PSTR("Export to SD")); else if (nr == count + 3) strcpy_P(card.longFilename, PSTR("Import from SD")); else{ eeprom_read_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(nr - 1), 8); card.longFilename[8] = '\0'; } return card.longFilename; }
//******************************************************************************************* // // Function : menu_init // Description : initial I/O direction for all key, // initial timer1 for countdown timer // //******************************************************************************************* void menu_init ( void ) { // setup countdown initial value sec_count = 0; eeprom_read_block ( count_time, ee_count_time, 3 ); count_time[3] = 0; // setup menu and standby display flag1.byte = 0; flag2.byte = 0; menu_index = 0; submenu_index = 0; menu_stack = 0; submenu_stack = 0; setting_cursor = 0; standby_cursor = 1; }
uint8_t MixerTable_ReadFromEEProm(void) { uint8_t crc; // calculate checksum in eeprom crc = EEProm_Checksum(EEPROM_ADR_MIXERTABLE, sizeof(Mixer) - 1); // check crc if( crc != eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXERTABLE + sizeof(Mixer) - 1)) ) return 0; // check revision if(eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXERTABLE)) != EEMIXER_REVISION) return 0; // read mixer table eeprom_read_block((void *) &Mixer, (void*)(EEPROM_ADR_MIXERTABLE), sizeof(Mixer)); return 1; }
void lcd_material_read_current_material() { for(uint8_t e=0; e<EXTRUDERS; e++) { material[e].temperature = eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e)); material[e].bed_temperature = eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e)); material[e].flow = eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e)); material[e].fan_speed = eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e)); material[e].diameter = eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e)); strcpy_P(material_name[e],PSTR("???")); eeprom_read_block(material_name[e], EEPROM_MATERIAL_NAME_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), MATERIAL_NAME_LENGTH); material_name[e][MATERIAL_NAME_LENGTH] = '\0'; } }
void load_events() { // initialize random number generator; it has to be done only once (after reset) srand(current_time()); events_count = eeprom_read_byte(&events_count_ee); // initialize - for testing purposes /* if (events_count == 0) { send_string("add_default\r\n"); add_default_events(); } */ if (events_count == 0) { send_line("No events => MANUAL_MODE"); event_mode = MANUAL_MODE; return; } // load events into ram eeprom_read_block(&events, &events_ee, sizeof(struct Event) * EVENTS_SIZE); // prepare prepare_actual_events(); // print events print_events(); // check current state of pins // if the device is power off, and later power on - it doesn't know what should be current state of pins int32_t time = current_time(); send_string(" start time: "); char formatted_date[30]; timeToString(time, formatted_date); send_string(formatted_date); send_enter(); current_state(); }
int main(int argc, const char *argv[]) { // Point stdout to serial stream (for testing to see adc value) stdout = &mystdout; // Initialize usart init_usart(BAUDRATE, TRANSMIT_RATE, DATA_BITS, STOP_BITS, PARITY_BITS); // printf("The first recipe is shown below!\n\n\n"); char recipe_name[RECIPE_NAME_LENGTH]; eeprom_read_block((void*)&recipe_name, (const void*)0x00, RECIPE_NAME_LENGTH); printf("Recipe Name: '%s'\n", recipe_name); return 0; }
// declares config and config_EEPROM CFG_DECLARATION #define enableUsbLines() PORTD |= (1<<0) #define disableUsbLines() PORTD &= ~(1<<0); void readConfig(uint8_t newConfig[CONFIG_BYTE_WIDTH + 2]) { // read config from EEPROM eeprom_read_block(config, config_EEPROM, CONFIG_BYTE_WIDTH + 2); if(config[0] != CONFIG_DEVICE || config[1] != CONFIG_VERSION) { /* if EEPROM does not conform to current version and device set to default config */ CONFIG_SET_DEFAULTS(newConfig) } else { for(int i = 0; i < (CONFIG_BYTE_WIDTH + 2); i++) newConfig[i] = config[i]; } }
// Return the key for a variable. // AP_Var::Key AP_Var::key(void) { Var_header var_header; if (_group) { // group members don't have keys return k_key_none; } if (_key && k_key_not_located) { // if not located, key is in memory return _key & k_key_mask; } // Read key from EEPROM, note that _key points to the space // allocated for storage; the header is immediately before. // eeprom_read_block(&var_header, (void *)(_key - sizeof(var_header)), sizeof(var_header)); return var_header.key; }
int main (void) { term_io_init (); // Delay a bit at startup to give use time to launch screen and watch the // initial values of thigs after reprogramming or changing the ID. _delay_ms (3042); for ( ; ; ) { void const *id_address = 0; // ID is at start of EEPROM size_t const id_size = 8; // ID is this many bytes long uint64_t id; // ID itself (to be read) eeprom_read_block (&id, id_address, id_size); // Print the ID value one byte at a time. WARNING: endianness can cause // confusion when you interpret id as a single uint64_t. For example, // if your ID happens to be 0x0123456789abcdef, then to declare a // literal uint64_t that will compare equal to it you would need to write // '0xefcdab8967452301ULL' (or 'UINT64_C (0xefcdab8967452301)' if you're // using the better integer literal macros from stdint.h). WARNING: // also, AVR libc doesn't support 64 bit printf/scanf conversions. printf ("ID: "); for ( uint8_t ii = 0 ; ii < id_size ; ii++ ) { printf ("%02" PRIx8, ((uint8_t *) (&id))[ii] ); } printf ("\n"); // This block is used to verify that writing the first 8 bytes of the // flash doesn't change the others: after running this program, then // changing the ID with the make target, then restarting this program, // the value should still be 42 the first time we hit this point. uint8_t *byte_8_offset = (uint8_t *) 8; uint8_t byte_offset_8_value = eeprom_read_byte (byte_8_offset); printf ( "Current value of byte at offset 8: %" PRIu8 "\n", byte_offset_8_value ); eeprom_write_byte (byte_8_offset, 42); _delay_ms (1042); // Delay a little bit between repetitions of the ID } }
int main(void) { wdt_disable(); /* Clear WDRF in MCUSR */ MCUSR &= ~(1<<WDRF); /* Write logical one to WDCE and WDE */ /* Keep old prescaler setting to prevent unintentional time-out */ WDTCSR |= (1<<WDCE) | (1<<WDE); /* Turn off WDT */ WDTCSR = 0x00; //DDRA |= 0x07; //PORTA &= ~7; //DDRC |= 0x07; //DDRC |= 0xC0; eeprom_read_block(&state, &state_ee, sizeof(state)); aes_handler_init(); bus_handler_init(); serial_init(); bus_init(); cmd_init(); buttons_init(); leds_init(); timer0_init(); sei(); leds_set(0,LED_SHORT_FLASH); while( 1 ){ if( timer0_timebase ){ timer0_timebase--; bus_tick(); serial_tick(); buttons_tick(); leds_tick(); } bus_process(); serial_process(); //aes128_enc(data, &ctx); /* encrypting the data block */ } }
bool lcd_material_verify_material_settings() { SERIAL_ECHO_START; uint8_t max_mats = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET()); SERIAL_ECHOPAIR("Checking ", (unsigned long) max_mats); SERIAL_ECHOPAIR(" presets and ", (unsigned long) EXTRUDERS); SERIAL_ECHOLNPGM (" extruder settings:"); if (max_mats < 2 || max_mats > EEPROM_MATERIAL_SETTINGS_MAX_COUNT) return false; byte cnt =0; while(cnt < max_mats+EXTRUDERS) { SERIAL_ECHOPAIR("Checking preset # ",(unsigned long) cnt); if (eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(cnt)) > HEATER_0_MAXTEMP) return false; if (eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(cnt)) > BED_MAXTEMP) return false; if (eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(cnt)) > 100) return false; if (eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(cnt)) > 1000) return false; if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) > 10.0) return false; if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) < 0.1) return false; strcpy_P (material_name_buf,"???"); eeprom_read_block(material_name_buf, EEPROM_MATERIAL_NAME_OFFSET(cnt), MATERIAL_NAME_LENGTH); material_name_buf[MATERIAL_NAME_LENGTH] = '\0'; if (cnt >= max_mats ) { SERIAL_ECHOPAIR(".....verified extruder setting # ",(unsigned long) cnt-max_mats);} else { SERIAL_ECHOPAIR(".....verified preset # ",(unsigned long) cnt);} SERIAL_ECHO(" ("); SERIAL_ECHO(material_name_buf); SERIAL_ECHO(")"); SERIAL_ECHOLN(""); cnt++; } return true; }
void send_packet(uint8_t aes_key_nr, uint8_t data_len) { // set device ID (base station has ID 0 by definition) bufx[0] = 0; // update packet counter packetcounter++; if (packetcounter % PACKET_COUNTER_WRITE_CYCLE == 0) { eeprom_write_dword((uint32_t*)0, packetcounter); } setBuf32(1, packetcounter); // set CRC32 uint32_t crc = crc32(bufx, data_len + 6); setBuf32(data_len + 6, crc); // load AES key (0 is first AES key) if (aes_key_nr >= AES_KEY_EEPROM_COUNT) { aes_key_nr = AES_KEY_EEPROM_COUNT - 1; } eeprom_read_block (aes_key, (uint8_t *)(EEPROM_POS_AES_KEY + aes_key_nr * 32), 32); // show info decode_data(data_len + 6); UART_PUTF(" AES key: %u\r\n", aes_key_nr); UART_PUTF(" CRC32: %02lx\r\n", crc); UART_PUTS(" Unencrypted: "); printbytearray(bufx, data_len + 10); // encrypt and send uint8_t aes_byte_count = rfm12_sendbuf(data_len + 10); UART_PUTS("Send encrypted: "); printbytearray(bufx, aes_byte_count); UART_PUTS("\r\n"); }
char GenerateStandaloneTransData(char xPumpID, char *PNozzle){//[1,2,3..16]->[1,2,3..0] char ProductName[15];//,strPPU[7],strPVolume[8],strPMoney[8]; char iPumpID,iProdID=0,TermID;//,PPumpID[8]; char Result=GS_NONE; char strSend[30]; char FIPAddr; iPumpID=(xPumpID&0x0F); FIPAddr=GetFIPAddr(iPumpID); if (FIPAddr>0){ FIPAddr=FIPAddr-1; iProdID=PNozzle[RecPumpData[FIPAddr].Grade]; if (iProdID>0) eeprom_read_block((void*) &ProductName, (const void*) &DefProductName[iProdID-1],sizeof(DefProductName[iProdID-1])); else sprintf_P(ProductName,PSTR("N/A")); TermID=eeprom_read_byte(&DefIFT_ID); //Shift,TransNum,Date,Time sprintf_P(strShift,PSTR("%d"),RecPumpData[FIPAddr].Shift); sprintf_P(strTranNo,PSTR("%s"),RecPumpData[FIPAddr].strTransNum); sprintf_P(strDate,PSTR("%s"),RecPumpData[FIPAddr].strTransDate); sprintf_P(strTime,PSTR("%s"),RecPumpData[FIPAddr].strTransTime); //TermID,FIP_ID,Product sprintf_P(strIslandID,PSTR("%d"),TermID); sprintf_P(strFIP_ID,PSTR("%.2d"),xPumpID); sprintf_P(strDescription,PSTR("%s"),ProductName); //Price Volume Money sprintf_P(strPrice,PSTR("%s"),RecPumpData[FIPAddr].Price); sprintf_P(strVolume,PSTR("%s"),RecPumpData[FIPAddr].Volume); sprintf_P(strAmount,PSTR("%s"),RecPumpData[FIPAddr].Money); MOPType=MOP_CASH; IsPrinting=True; Result=GS_GENERATED; } //ProductName //iProdID=PNozzle[RecPumpData[iPumpID].Nozzle]; //BAsedOnGrade return Result; }
// Load the variable from EEPROM, if supported // bool AP_Param::load(void) { uint8_t group_element = 0; const struct GroupInfo *ginfo; uint8_t idx; const struct AP_Param::Info *info = find_var_info(&group_element, &ginfo, &idx); if (info == NULL) { // we don't have any info on how to load it return false; } struct Param_header phdr; // create the header we will use to match the variable if (ginfo != NULL) { phdr.type = PGM_UINT8(&ginfo->type); } else { phdr.type = PGM_UINT8(&info->type); } phdr.key = PGM_UINT8(&info->key); phdr.group_element = group_element; // scan EEPROM to find the right location uint16_t ofs; if (!scan(&phdr, &ofs)) { return false; } if (phdr.type != AP_PARAM_VECTOR3F && idx != 0) { // only vector3f can have non-zero idx for now return false; } AP_Param *ap; ap = this; if (idx != 0) { ap = (AP_Param *)((uintptr_t)ap) - (idx*sizeof(float)); } // found it eeprom_read_block(ap, (void*)(ofs+sizeof(phdr)), type_size((enum ap_var_type)phdr.type)); return true; }
bool lcd_material_verify_material_settings() { bool hasUPET = false; uint8_t cnt = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET()); if (cnt < 2 || cnt > EEPROM_MATERIAL_SETTINGS_MAX_COUNT) return false; while(cnt > 0) { cnt --; if (eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(cnt)) > HEATER_0_MAXTEMP) return false; // if (eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(cnt)) > BED_MAXTEMP) // return false; if (eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(cnt)) > 100) return false; if (eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(cnt)) > 1000) return false; if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) > 10.0) return false; if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) < 0.1) return false; eeprom_read_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(cnt), 8); if (strcmp_P(card.longFilename, PSTR("UPET")) == 0) hasUPET = true; } cnt = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET()); if (!hasUPET && cnt < EEPROM_MATERIAL_SETTINGS_MAX_COUNT) { strcpy_P(card.longFilename, PSTR("UPET")); eeprom_write_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(cnt), 5); eeprom_write_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(cnt), 250); // eeprom_write_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(cnt), 60); eeprom_write_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(cnt), 50); eeprom_write_word(EEPROM_MATERIAL_FLOW_OFFSET(cnt), 100); eeprom_write_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt), 2.85); eeprom_write_byte(EEPROM_MATERIAL_COUNT_OFFSET(), cnt + 1); } return true; }
int main(void) { wdt_disable(); /* Clear WDRF in MCUSR */ MCUSR &= ~(1<<WDRF); /* Write logical one to WDCE and WDE */ /* Keep old prescaler setting to prevent unintentional time-out */ WDTCSR |= (1<<WDCE) | (1<<WDE); /* Turn off WDT */ WDTCSR = 0x00; DDRC |= 0xC0; eeprom_read_block(&state, &state_ee, sizeof(state)); leds_init(); buttons_init(); adc_init(); power_init(); door_init(); aes_handler_init(); bus_handler_init(); bus_init(); cmd_init(); timer0_init(); sei(); while( 1 ){ if( timer0_timebase ){ timer0_timebase--; bus_tick(); door_tick(); power_tick(); cmd_tick(); buttons_tick(); leds_tick(); } bus_process(); door_process(); power_process(); } }
int restore_mbr(void ) { mbr_t mbr; eeprom_read_block(&mbr, EEPROM_MBR_OFFSET, sizeof(mbr)); memcpy(&mbr_config, &mbr.mbr_config, sizeof(mbr_config_t)); #ifdef MBR_DEBUG debug_printf("mbr.identifier %c%c (0x%x 0x%x 0x%x)\n", mbr.identifier[0], mbr.identifier[1], mbr.identifier[0], mbr.identifier[1], mbr.identifier[2] ); #endif #ifdef BOOTLOADER_SUPPORT if (mbr.identifier[0] != 'e' || mbr.identifier[1] != '6' || mbr.identifier[2] != '\0') return 1; #endif return 0; }
void GenerateTransactionNum(char *sTransNumber){//Create and Save TransactionNumber to EEPROM char i,PTransNum[7],cNum,xNum=0,xAdd=0,Length=0; FillChar(PTransNum,sizeof(PTransNum),0);//"999999"->"000000" eeprom_read_block((void*) &PTransNum, (const void*) &DefTransactionNumber,sizeof(DefTransactionNumber)); xAdd=1; xNum=0; Length=strlen(PTransNum); for(i=0;i<Length;i++){//[000009] 999999 123456 xNum=PTransNum[Length-i-1]-'0'; cNum='0'+((xNum+xAdd)%10); xAdd=((xNum+xAdd)/10); PTransNum[Length-i-1]=cNum; sTransNumber[Length-i-1]=cNum; } sTransNumber[Length]=0; PTransNum[Length]=0; eeprom_write_block((const void*)&PTransNum,(void*)&DefTransactionNumber,sizeof(DefTransactionNumber)); }
static char* lcd_menu_material_settings_store_callback(uint8_t nr) { char* c = lcd_cache_new.getData(LCD_CACHE::RAWSTRING).rawstring ; uint8_t count = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET()); if (nr == 0) strcpy_P(c, PSTR("< RETURN")); else if (nr > count) strcpy_P(c, PSTR("New preset")); else { eeprom_read_block(material_name_buf, EEPROM_MATERIAL_NAME_OFFSET(nr - 1), MATERIAL_NAME_LENGTH); material_name_buf[MATERIAL_NAME_LENGTH] = '\0'; strncpy (c,material_name_buf,MATERIAL_NAME_LENGTH+1); return c; } return c; }
bool readEEPROM() { uint8_t i; #ifdef MULTIPLE_CONFIGURATION_PROFILES if(global_conf.currentSet>2) global_conf.currentSet=0; #else global_conf.currentSet=0; #endif eeprom_read_block((void*)&conf, (void*)(global_conf.currentSet * sizeof(conf) + sizeof(global_conf)), sizeof(conf)); if(calculate_sum((uint8_t*)&conf, sizeof(conf)) != conf.checksum) { blinkLED(6,100,3); #if defined(BUZZER) alarmArray[7] = 3; #endif LoadDefaults(); // force load defaults return false; // defaults loaded, don't reload constants (EEPROM life saving) } // 500/128 = 3.90625 3.9062 * 3.9062 = 15.259 1526*100/128 = 1192 for(i=0;i<5;i++) { lookupPitchRollRC[i] = (1526+conf.rcExpo8*(i*i-15))*i*(int32_t)conf.rcRate8/1192; } for(i=0;i<11;i++) { int16_t tmp = 10*i-conf.thrMid8; uint8_t y = 1; if (tmp>0) y = 100-conf.thrMid8; if (tmp<0) y = conf.thrMid8; lookupThrottleRC[i] = 10*conf.thrMid8 + tmp*( 100-conf.thrExpo8+(int32_t)conf.thrExpo8*(tmp*tmp)/(y*y) )/10; // [0;1000] lookupThrottleRC[i] = conf.minthrottle + (int32_t)(MAXTHROTTLE-conf.minthrottle)* lookupThrottleRC[i]/1000; // [0;1000] -> [conf.minthrottle;MAXTHROTTLE] } #if defined(POWERMETER) pAlarm = (uint32_t) conf.powerTrigger1 * (uint32_t) PLEVELSCALE * (uint32_t) PLEVELDIV; // need to cast before multiplying #endif #if GPS GPS_set_pids(); // at this time we don't have info about GPS init done recallGPSconf(); // Load gps parameters #endif #if defined(ARMEDTIMEWARNING) ArmedTimeWarningMicroSeconds = (conf.armedtimewarning *1000000); #endif return true; // setting is OK }
int8_t eeprom_save_config(void *mac, void *ip, void *netmask, void *gateway) /* {{{ */ { (void) ip; (void) netmask; (void) gateway; /* save new ip addresses */ struct eeprom_config_base_t cfg_base; /* the eeprom section must contain valid data, if any parameter is NULL */ eeprom_read_block(&cfg_base, EEPROM_CONFIG_BASE, sizeof(struct eeprom_config_base_t)); if (mac != NULL) memcpy(&cfg_base.mac, mac, 6); #if (!UIP_CONF_IPV6 && (!defined(BOOTP_SUPPORT) \ || defined(BOOTP_TO_EEPROM_SUPPORT))) \ || defined(OPENVPN_SUPPORT) || defined(IPV6_STATIC_SUPPORT) if (ip != NULL) memcpy(&cfg_base.ip, ip, IPADDR_LEN); #endif #if !UIP_CONF_IPV6 && (!defined(BOOTP_SUPPORT) \ || defined(BOOTP_TO_EEPROM_SUPPORT)) if (netmask != NULL) memcpy(&cfg_base.netmask, netmask, 4); if (gateway != NULL) memcpy(&cfg_base.gateway, gateway, 4); #endif /* not UIP_CONF_IPV6 and (not BOOTP or BOOTP_TO_EEPROM) */ /* calculate new checksum */ uint8_t checksum = crc_checksum(&cfg_base, sizeof(struct eeprom_config_base_t) - 1); cfg_base.crc = checksum; /* save config */ eeprom_write_block(EEPROM_CONFIG_BASE, &cfg_base, sizeof(struct eeprom_config_base_t)); return 0; } /* }}} */
int main() { uchar buffer,i,lastkey = 0; // Fetch password from EEPROM and send it eeprom_read_block(messageBuffer, stored_password, sizeof(messageBuffer)); messagePtr = 0; messageState = STATE_SEND; for(i=0; i<sizeof(keyboard_report); i++) // clear report initially ((uchar *)&keyboard_report)[i] = 0; wdt_enable(WDTO_1S); // enable 1s watchdog timer init_uart0(); usbInit(); usbDeviceDisconnect(); // enforce re-enumeration for(i = 0; i<250; i++) { // wait 500 ms wdt_reset(); // keep the watchdog happy _delay_ms(2); } usbDeviceConnect(); // TCCR0B |= (1 << CS01); // timer 0 at clk/8 will generate randomness sei(); // Enable interrupts after re-enumeration while(1) { wdt_reset(); // keep the watchdog happy usbPoll(); buffer = UDR0; lastkey = buffer; // characters are sent when messageState == STATE_SEND and after receiving // the initial LED state from PC (good way to wait until device is recognized) if(usbInterruptIsReady() && messageState == STATE_SEND) { messageState = buildReport(lastkey); usbSetInterrupt((void *)&keyboard_report, sizeof(keyboard_report)); } } return 0; }
//---------------------------------------------------------------------------- //Auslesen der im eeprom gespeicherten Z�hlerst�nde void read_eeprom (uint8_t addr) { uint32_t hilf; uint16_t S0_address = 0; if(addr == 0)S0_address = EEPROM_S0_0_STORE; if(addr == 1)S0_address = EEPROM_S0_1_STORE; if(S0_address == 0)return; S0_DEBUG("EEPROM Read address:%i\r\n",S0_address); // Counter aus Speicher auslesen eeprom_busy_wait (); eeprom_read_block(&hilf,(unsigned char *)S0_address,sizeof(uint32_t)); CountInt[addr]=hilf; if(CountInt[addr]==0xFFFFFFFF)CountInt[addr]=0; }
/** * \brief This is the implementation of the 15.4 MAC Reset Request * primitive. * \param setDefaultPIB True if the default PIB values should be set. * \return Integer denoting success or failure. * \retval 0 Failure. * \retval 1 Success. * * Sets all PIB values to default. */ void sicslowmac_resetRequest (bool setDefaultPIB) { if(setDefaultPIB){ /* initialize all of the MAC PIB variables to their default values */ macCoordShortAddress = 0xffff; macDSN = rand() % 256; macSrcPANId = SOURCE_PAN_ID; macDstPANId = DEST_PAN_ID; macShortAddress = 0xffff; /* Setup the address of this device by reading a stored address from eeprom. */ /** \todo This might be read from the serial eeprom onboard Raven. */ AVR_ENTER_CRITICAL_REGION(); eeprom_read_block ((void *)&macLongAddr, EEPROMMACADDRESS, 8); byte_reverse((uint8_t *) &macLongAddr, 8); AVR_LEAVE_CRITICAL_REGION(); } }
static void monitor_insert_reedkontakt_state(uint8_t gruppe, uint8_t state) { eds_block_p it = eds_find_next_block((eds_block_p)0, EDS_userpanel_reedkontakte_BLOCK_ID); if (!it) { load_error_page(ERROR_CONF_REEDKONTAKTE_MISSING); return; } userpanel_reedkontakte_t c; eeprom_read_block(&c, (it+2), sizeof(c)); // Ist ein EEPROM-Zugriff, daher langsamer! uint8_t i; for (i = 0; i < 24; i++) { if (gruppe == c.reed[i]) { //canix_syslog_P(SYSLOG_PRIO_DEBUG, PSTR("g%d %d"), i, state); monitor_reedkontakt_state[i] = state; } } }
Cstorage::Cstorage(Cat45db041* flashdrv) { u08 buf[pageSize]; this->flashdrv = flashdrv; // Check if FLASH storage has been initialized flashdrv->read(buf, configBasePage); memcpy((u08*) &flash, buf, sizeof(flash)); if (flash.magic != FLASH_MAGIC_NUM_0) { #ifndef LOADER eraseFlash(); #endif } // Check if storage has been initilized. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { eeprom_read_block(&eeprom, 0, sizeof(eeprom)); if (eeprom.magic != EEPROM_MAGIC_NUM_0) { #ifndef LOADER eraseEeprom(); #endif } } }
void mem_init() { bool invalid = false; ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { eeprom_read_block(&mem_config, &g_config_memory, sizeof(proto::Config)); // Validity check (empty EEPROM is 0xFFFF) if(mem_config.active_axes > 100 || mem_config.num_keyframes >= proto::MAX_KEYFRAMES) { invalid = true; mem_config.active_axes = 4; mem_config.num_keyframes = 0; } } if(invalid) printf("No valid configuration found in EEPROM\n"); }