void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) {
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
  delay(4);
}

byte readEEPROM(int deviceaddress, unsigned int eeaddress ) {
  byte rdata = 0xFF;
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress,1);
  while (!Wire.available()); rdata = Wire.read();
  //if (Wire.available()); rdata = Wire.read();
  return rdata;
}


void saveEEPROM(unsigned long value, unsigned int address){
  uint8_t val=0x00;
  for (int i = 0; i < 4; i++)  
  {
    val=(byte)(value>>(8*i));
    writeEEPROM(eeprom, address+3-i, val);
  }
  writeEEPROM(eeprom, address+4, 0x0D);
}

void clear_model(unsigned int address){
  for (int i = 0; i < 80; i++)  
  {
    if (i<16) writeEEPROM(eeprom, address+i, ' ');
    else writeEEPROM(eeprom, address+i, 0x00);
  }
}

void move_model(byte currentOption){
  
  unsigned int address = EEI2C_ADDR_MODELS + 80*currentOption;
  unsigned int address_next = EEI2C_ADDR_MODELS + 80*(currentOption+1);
  if (currentOption < (system_models - 1)) 
  {  
    for (int i = 0; i < 80*(system_models - currentOption); i++)  
      {
          writeEEPROM(eeprom, address+i, readEEPROM(eeprom, address_next + i ));
      }
  }
  system_models--;
}

void erase_model(byte currentOption){
  lcd.clear();
  lcd.print("Borrando...");
  unsigned int address = EEI2C_ADDR_MODELS + 80*currentOption;
  clear_model(address);
  move_model(currentOption);
}

void config_init(){
  
  // Check if the firmware version is the same of eeprom config
  if (
      EEPROM.read(EE_ADDR_SIGNATURE_CODE1) == SIGNATURE_CODE1 && 
      EEPROM.read(EE_ADDR_SIGNATURE_CODE2) == SIGNATURE_CODE2 && 
      EEPROM.read(EE_ADDR_SIGNATURE_CODE3) == SIGNATURE_CODE3 && 
      EEPROM.read(EE_ADDR_SIGNATURE_CODE4) == SIGNATURE_CODE4 &&
      EEPROM.read(EE_ADDR_CODE_MAYOR_VERSION) == CODE_MAYOR_VERSION &&
      EEPROM.read(EE_ADDR_CODE_MINOR_VERSION) == CODE_MINOR_VERSION
     ) {
       // loads in ram the eeprom config
       config_loadBackup_all();
     
   } else {
      // clear the eeprom
      for (int i = 0; i < EEPROM_SIZE; i++)  EEPROM.write(i, 0xFF);
      
      // writes sign codes
      EEPROM.write(EE_ADDR_SIGNATURE_CODE1,SIGNATURE_CODE1);
      EEPROM.write(EE_ADDR_SIGNATURE_CODE2,SIGNATURE_CODE2);
      EEPROM.write(EE_ADDR_SIGNATURE_CODE3,SIGNATURE_CODE3);
      EEPROM.write(EE_ADDR_SIGNATURE_CODE4,SIGNATURE_CODE4);
      EEPROM.write(EE_ADDR_CODE_MAYOR_VERSION,CODE_MAYOR_VERSION);
      EEPROM.write(EE_ADDR_CODE_MINOR_VERSION,CODE_MINOR_VERSION);
      
      // load defaults in ram and save it on eeprom
      config_loadDefaults_all();
      config_saveBackup_all();
      
      // inform of resetting action
      display_printResetting();
  } 
}

void config_loadDefaults_all(){
    config_loadDefaults_system();
    //config_loadDefaults_intervalMode(); 
}

void config_saveBackup_all(){
    config_saveBackup_system();
    //config_saveBackup_intervalMode();
}
 
void config_loadBackup_all(){
    config_loadBackup_system();
    //config_loadBackup_intervalMode();
} 
 
// Load the system config from eeprom to ram
void config_loadBackup_system(){   
  system_useBacklight = EEPROM.read(EE_ADDR_system_useBacklight);
  system_useSpeaker = EEPROM.read(EE_ADDR_system_useSpeaker);
  system_models = word(EEPROM.read(EE_ADDR_system_models + 1),EEPROM.read(EE_ADDR_system_models)); 
}

// Load the default system config to ram
void config_loadDefaults_system() {
  system_useBacklight = DEFAULT_system_useBacklight;
  system_useSpeaker = DEFAULT_system_useSpeaker;
  system_models = DEFAULT_system_models;
  EEPROM.write(EE_ADDR_BATTERY_HIGH+1,highByte(DEFAULT_BATTERY_HIGH));
  EEPROM.write(EE_ADDR_BATTERY_HIGH,lowByte(DEFAULT_BATTERY_HIGH));
  EEPROM.write(EE_ADDR_BATTERY_LOW+1,highByte(DEFAULT_BATTERY_LOW));
  EEPROM.write(EE_ADDR_BATTERY_LOW,lowByte(DEFAULT_BATTERY_LOW));
}

// Save the system config from ram to eeprom
void config_saveBackup_system(){ 
  EEPROM.write(EE_ADDR_system_useBacklight, system_useBacklight);
  EEPROM.write(EE_ADDR_system_useSpeaker, system_useSpeaker);
  EEPROM.write(EE_ADDR_system_models + 1, highByte(system_models));
  EEPROM.write(EE_ADDR_system_models, lowByte(system_models));
}

void calibrate_level_battery()
  {
      int t_bat=0;
      for(int i=1; i<=10; i++) t_bat=t_bat+analogRead(bat);
      t_bat=t_bat/10;
      int t_eeprom;
      t_eeprom=word(EEPROM.read(EE_ADDR_BATTERY_HIGH+1),EEPROM.read(EE_ADDR_BATTERY_HIGH));
      if ((t_bat>t_eeprom)||(t_eeprom>=435))
      {
        EEPROM.write(EE_ADDR_BATTERY_HIGH+1,highByte(t_bat));
        EEPROM.write(EE_ADDR_BATTERY_HIGH,lowByte(t_bat));
      }
      t_eeprom=word(EEPROM.read(EE_ADDR_BATTERY_LOW+1),EEPROM.read(EE_ADDR_BATTERY_LOW));
      if ((t_bat<t_eeprom)||(t_eeprom<=335))
      {
        EEPROM.write(EE_ADDR_BATTERY_LOW+1,highByte(t_bat));
        EEPROM.write(EE_ADDR_BATTERY_LOW,lowByte(t_bat));
      }
      batmax=word(EEPROM.read(EE_ADDR_BATTERY_HIGH+1),EEPROM.read(EE_ADDR_BATTERY_HIGH));
      batmin=word(EEPROM.read(EE_ADDR_BATTERY_LOW+1),EEPROM.read(EE_ADDR_BATTERY_LOW));
  }