C++ eeprom_write_word函数代码示例

static void store_permanent(void){
	int tmp;
	signed char changeflag=1;
	lcd_clrscr();
	if (eeprom_read_byte((uint8_t *)0x0) == 19){
		changeflag=0;
		// ok magic number matches accept values
		tmp=eeprom_read_word((uint16_t *)0x04);
		if (tmp != set_val[1]){
			changeflag=1;
		}
		tmp=eeprom_read_word((uint16_t *)0x02);
		if (tmp != set_val[0]){
			changeflag=1;
		}
	}
	if (changeflag){
		lcd_puts_P("setting stored");
		eeprom_write_byte((uint8_t *)0x0,19); // magic number
		eeprom_write_word((uint16_t *)0x02,set_val[0]);
		eeprom_write_word((uint16_t *)0x04,set_val[1]);
	}else{
		if (bpress> 5){
			// display software version after long press
			lcd_puts_P(SWVERSION);
			lcd_gotoxy(0,1);
			lcd_puts_P("tuxgraphics.org");
		}else{
			lcd_puts_P("already stored");
		}
	}
	delay_ms(200);
}

void calibrate(void)
{
  uint16_t min, max;
  // Timer/Counter0,1 Overflow Interrupt Enable - LED1 blinking
  TIMSK |= _BV(TOIE1);

  // Calibrate minimum value
  PORTA &= ~_BV(LED2);
  wait_for_prog();
  min = pressure();
  PORTA |= _BV(LED2);

  // Calibrate maximum value
  PORTA &= ~_BV(LED3);
  wait_for_prog();
  max = pressure();
  PORTA |= _BV(LED3) | _BV(LED1);

  // Save values in EEPROM
  eeprom_busy_wait();
  eeprom_write_word(PMINIMUM, min);

  eeprom_busy_wait();
  eeprom_write_word(PMAXIMUM, max);

  // Timer/Counter0,1 Overflow Interrupt Disable
  TIMSK &= ~_BV(TOIE1);
}

/* 
 * If there were MAX_WRONG_TRIES unsuccessful attempts to type the code,
 * block the execution for LOCKDOWN_WAIT seconds.
 */
void lock_device()
{
	if (!eeprom_read_word(WAIT_TIMER))
	{
		return;
	}
	
	avr_lcd_clear();
	avr_lcd_puts("Device locked");
	
	char buf[16];
	for (uint16_t i = eeprom_read_word(WAIT_TIMER); i > 0; i--)
	{
		uint8_t min = i / 60;
		uint8_t sec = i % 60;
		
		snprintf(buf, 16, "Wait %02d m %02d s", min, sec);
		avr_lcd_set_cursor_pos(AVR_LCD_LINE1 + 0);
		avr_lcd_puts(buf);
		_delay_ms(1000);
		
		eeprom_write_word(WAIT_TIMER, i);
	}
	
	eeprom_write_word(WAIT_TIMER, 0);
	eeprom_write_byte(WRONG_TRIES, 0);
}

void lcd_material_reset_defaults()
{
    //Fill in the defaults
    SERIAL_ECHO_START;
    SERIAL_ECHOLNPGM("Materials reset");
    char buffer[MATERIAL_NAME_LENGTH];
    for (int a= 0; a< MATERIAL_PRESETS; a++)
        {
            strncpy_P(buffer, (char PROGMEM *) presets[a].name,MATERIAL_NAME_LENGTH);		// this will pad out the whole length with 0 as needed.
            eeprom_write_block(buffer                                  , EEPROM_MATERIAL_NAME_OFFSET(a), MATERIAL_NAME_LENGTH);
            material_preset temp;
            memcpy_P((void*) &temp,&presets[a],sizeof (material_preset));
            eeprom_write_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(a)    ,temp.temperature);
            eeprom_write_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(a),temp.bed);
            eeprom_write_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(a)      ,temp.fan_speed);
            eeprom_write_word(EEPROM_MATERIAL_FLOW_OFFSET(a)           ,temp.flow);
            eeprom_write_float(EEPROM_MATERIAL_DIAMETER_OFFSET(a)      ,temp.diameter);
        }
    uint8_t e;
    for(e=0; e<EXTRUDERS; e++)
        {
            makeCustomName(e);
            strcpy(material_name[e],material_name_buf);
            lcd_material_store_current_material();
        }

    eeprom_write_byte(EEPROM_MATERIAL_COUNT_OFFSET(), MATERIAL_PRESETS);
    lcd_lib_beep_ext(500,150);
    lcd_lib_beep_ext(750,100);
}

void AlgorithmRepository::writeToEEPROM()
{
#ifndef DEBUGGING

#ifdef ENABLE_DEBUG_UART
	Comm::printf_P( PSTR("Store in EEPROM"));
#endif
	WORD addr= 0;
	eeprom_write_byte( (uint8_t *)addr++, 'J' );
	eeprom_write_byte( (uint8_t *)addr++, 'P' );
	eeprom_write_byte( (uint8_t *)addr++, ((RECEIVER_CHANNELS << 5) | OUTPUT_CHANNELS) );

	eeprom_write_block( (const void *)&programArray, (void *)addr, (size_t)sizeof( programArray ) );
	addr += sizeof( programArray );
	eeprom_write_block( (const void *)&inputChannel, (void *)addr, (size_t)sizeof( inputChannel ) );
	addr += sizeof( inputChannel );

	for( BYTE i = 0; i < RECEIVER_CHANNELS; i++)
	{
		eeprom_write_word( (uint16_t *)addr, Receiver::getChannelMin( i ));
		addr += sizeof( WORD );
		eeprom_write_word( (uint16_t *)addr, Receiver::getChannelMax( i ));
		addr += sizeof( WORD );
	}

	eeprom_write_byte( (uint8_t *) addr, Receiver::getChannelModeByte( ));
  addr++;
  eeprom_write_word((uint16_t *) addr, Adc::getLimit());
 #endif
}

void saveConfig(){
	uint16_t *__p=0;
	eeprom_write_word(__p,config_t_pomodoro);
	eeprom_write_word(__p+1,config_t_przerwa1);
	eeprom_write_word(__p+2,config_t_przerwa2);
	eeprom_write_word(__p+3,config_n_kr_przerw);
}

void  write32int (int inode, int offset, int32_t value)
{
    
    uint16_t addr;
  	
  	uint16_t value1;
  	
  	uint32_t value2;
  	
  	value1 = (uint16_t)((*(uint32_t *)&value) >> 16);
  	
  	value2 = (uint16_t)((*(uint32_t *)&value) & 0x0000ffff);
  	
  	addr = inode*INODESIZE + offset;
  	
  	eeprom_busy_wait();
  	
  	//value2 = *(uint16_t *)&value;
  	
  	eeprom_write_word((uint16_t *)addr, value2);
  	
  	
  	addr = inode*INODESIZE + offset +2 ;
  	
  	eeprom_busy_wait();
  	
  	//value2 = *(uint16_t *)&value;
  	
  	eeprom_write_word((uint16_t *)addr, value1);
   	
  	return;    		

}

void gear_lern_count(int n, int address){

   uint16_t high=0;
   uint16_t low=0;
   uint16_t current;
   int i;

   led_char(n);

      while(LEARN_SW);
      _delay_ms(100);
      while(!LEARN_SW);

#ifdef DEBUG
	  printf("START LEARN\r\n");
#endif

      current = read_puls_20();

      low  = current;
      high = current;

      for(i=0; i<10; i++){

         current = read_puls_20();												// Read result for 10 pulses

         if(current < low){                                                     // Set min & max value
            low = current;
         }
         if(current > high){
            high = current;
         }
#ifdef DEBUG
         printf("low, high > %d, %d\r\n",low, high);
#endif
      }

   if((low <= 0)||(high > 1000)){                                              // Error condition
#ifdef DEBUG
	   printf(">%d-%d\r\n", low, high);
#endif
      for(;;){
         led_char('R');
         _delay_ms(300);
         led_off();
         _delay_ms(300);
      }
   }
   eeprom_write_word((uint16_t*)address,low);									// Write low value
   address += 2;
   eeprom_write_word((uint16_t*)address, high);								    // Write high value

    for(i=0; i<3; i++){
      led_off();                                                                // Next giar number flash until
      _delay_ms(200);                                                           // clutch change position
      led_char(n);                                                              //
      _delay_ms(200);
   }
   led_off();
}

void lcd_material_store_material(uint8_t nr)
{
    eeprom_write_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(nr), material[active_extruder].temperature);
    eeprom_write_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(nr), material[active_extruder].bed_temperature);
    eeprom_write_word(EEPROM_MATERIAL_FLOW_OFFSET(nr), material[active_extruder].flow);

    eeprom_write_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(nr), material[active_extruder].fan_speed);
    eeprom_write_float(EEPROM_MATERIAL_DIAMETER_OFFSET(nr), material[active_extruder].diameter);
    //eeprom_write_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(nr), 8);
}

void lcd_material_store_current_material()
{
    for(uint8_t e=0; e<EXTRUDERS; e++)
    {
        eeprom_write_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), material[e].temperature);
        eeprom_write_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), material[e].bed_temperature);
        eeprom_write_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), material[e].fan_speed);
        eeprom_write_word(EEPROM_MATERIAL_FLOW_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), material[e].flow);
        eeprom_write_float(EEPROM_MATERIAL_DIAMETER_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), material[e].diameter);
    }
}

void data2eeprom(void)
{
	eeprom_write_byte((uint8_t *)40,19); // magic number
	eeprom_write_block((uint8_t *)gwip,(void *)41,sizeof(gwip));
	eeprom_write_block((uint8_t *)udpsrvip,(void *)45,sizeof(udpsrvip));
	eeprom_write_word((void *)49,udpsrvport);
	eeprom_write_byte((uint8_t *)51,alarmOn);
	eeprom_write_word((void *)52,heartbeat_timeout_sec);
	eeprom_write_byte((uint8_t *)54,dhcpOn);
	eeprom_write_block((uint8_t *)myip,(void *)55,sizeof(myip));
	eeprom_write_block((uint8_t *)myname,(void *)59,sizeof(myname));	
}

/// \brief Write PID factors to eeprom
void heater_save_settings() {
#ifndef BANG_BANG
    heater_t i;
    for (i = 0; i < NUM_HEATERS; i++) {
        eeprom_write_dword((uint32_t *) &EE_factors[i].EE_p_factor, heaters_pid[i].p_factor);
        eeprom_write_dword((uint32_t *) &EE_factors[i].EE_i_factor, heaters_pid[i].i_factor);
        eeprom_write_dword((uint32_t *) &EE_factors[i].EE_d_factor, heaters_pid[i].d_factor);
        eeprom_write_word((uint16_t *) &EE_factors[i].EE_i_limit, heaters_pid[i].i_limit);
        eeprom_write_word((uint16_t *) &EE_factors[i].crc, crc_block(&heaters_pid[i].p_factor, 14));
    }
#endif /* BANG_BANG */
}

/**
 * @brief Write given programming counter value to EEPROM
 * @param counter Programming counter value
 */
void counter_write(uint16_t counter) {

    uint8_t i;
    uint16_t * eeadr = 0;

    for (i = 0; i < COUNTER_REDUNCY; i++) {

        eeprom_write_word(eeadr++, counter);
        eeprom_write_word(eeadr++, ~counter);
    }

}

void save_temp_eeprom(int word)
{
	unsigned int ff_pointer = eeprom_pointer + mem_length; //öka ett steg, pekare till nästa slot
	if (ff_pointer >= eeprom_stop)
	{
		ff_pointer = eeprom_start;				//slå runt minnet
	}
	eeprom_write_word(ff_pointer, mem_pointer_sign);		//skriv alltid en mem_pointer_sign först för att garantera minnesplats
	eeprom_write_word(eeprom_pointer, word);		//skriv till eeprom
	eeprom_pointer = ff_pointer;	//avancera ett steg
	
}

void update_eeprom() {
  if (dirty) {
    if (mode == mode_alarm) {
      eeprom_write_word(&eeprom_alarm_time, alarm_time);
    } else if (mode == mode_nap) {
      eeprom_write_word(&eeprom_nap_duration, nap_duration);
    } else if (mode == mode_adjustment) {
      eeprom_write_byte(&eeprom_adjustment, adjustment);
    }
    dirty = false;
  }
}