Guardar y cargar datos despues de corte de corriente

International Español Hardware
#1

Hola Buenas tardes. Necesitaría que me ayudaran con un proyecto que emprendí, es un control de luces programable (esta parte esta hecha), la complicación esta en que deseo colocarle un sistema que permita mantener la hora y los datos ingresados ante un posible corte de luz que no duraría mas de un par de minutos. Estuve viendo con los sistemas rtc pero no logro entender como hacer para guardar los datos necesarios para realizar la tarea que necesito. Si pudieran ayudarme se los agradeceria. A continuación dejo el sketch. Desde ya muchas gracias

ARDUINO UNO.

LCD 2 X 16 I2C.

3 PULSADORES.

#include <TimerOne.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
  RTC_DS1307 RTC;

LiquidCrystal_I2C lcd (0x3F, 16, 2);
const int PULSADOR_MODO = 2;
const int PULSADOR_UP = 3;
const int PULSADOR_DOWN = 4;
const int LUZ = 5;
int horas=0;
int minutos=0;
volatile int segundos=0;
volatile boolean actualizar=true;

int horas_inicio=0;
int minutos_inicio=0;
boolean alarmaOn=false;
boolean luz_iniciada =false;
boolean indicador_encendido =false;

int horas_final=0;
int minutos_final=0;



char texto[10];
int modo = 0;
const int N=8;


void setup(){
  Wire.begin();  
  lcd.begin(16,2);
  lcd.clear();
  lcd.backlight();

  pinMode(PULSADOR_MODO, INPUT);
  pinMode(PULSADOR_UP, INPUT);
  pinMode(PULSADOR_DOWN, INPUT);
  pinMode(LUZ, OUTPUT);
  
  Timer1.initialize(1000000);
  Timer1.attachInterrupt(manejadoraTimer);
}

void manejadoraTimer(){
    segundos++;
    actualizar=true;
}

void actualizarReloj(){
  minutos += segundos / 60;
  segundos = segundos % 60;

  horas += minutos / 60;
  minutos = minutos % 60;

  horas = horas % 24;
}


void incrementarHoras(){
  horas ++;
  horas = horas % 24; 
  actualizar=true; 
}

void decrementarHoras(){
  horas --;
  if(horas<0){
    horas = 23;  
  }  
  actualizar=true;
}

void incrementarHorasInicio(){
  horas_inicio++;
  horas_inicio = horas_inicio % 24; 
  actualizar=true; 
}

void incrementarHorasFinal(){
  horas_final++;
  horas_final = horas_final % 24; 
  actualizar=true; 
}


void decrementarHorasInicio(){
  horas_inicio--;
  if(horas_inicio<0){
    horas_final = 23;  
  }  
  actualizar=true;
}

void decrementarHorasFinal(){
  horas_final--;
  if(horas_final<0){
    horas_final = 23;  
  }  
  actualizar=true;
}

void incrementarMinutosInicio(){
  minutos_inicio ++;
  minutos_inicio = minutos_inicio % 60; 
  actualizar=true; 
}


void incrementarMinutosFinal(){
  minutos_final ++;
  minutos_final = minutos_final % 60; 
  actualizar=true; 
}


void decrementarMinutosInicio(){
  minutos_inicio --;
  if(minutos_inicio<0){
    minutos_inicio = 59;  
  }  
  actualizar=true;
}

void decrementarMinutosFinal(){
  minutos_final --;
  if(minutos_final<0){
    minutos_final = 59;  
  }  
  actualizar=true;
}

void incrementarMinutos(){
  minutos ++;
  minutos = minutos % 60; 
  actualizar=true; 
}

void decrementarMinutos(){
  minutos --;
  if(minutos<0){
    minutos = 59;  
  }  
  actualizar=true;
}

void fijarCursorModo(){
  switch(modo){
    case 0: 
      lcd.noBlink();
    break;
    case 1: 
      lcd.setCursor(0, 0);
      lcd.blink();
    break;
    case 2: 
      lcd.setCursor(3, 0);
      lcd.blink();
    break;
    case 3:
    lcd.setCursor (11, 0);
    lcd.blink();
    break;
    case 4: 
      lcd.setCursor(0, 1);
      lcd.blink();
    break;  
    case 5: 
      lcd.setCursor(3, 1);
      lcd.blink();
    break;
    case 6:
      lcd.setCursor(6, 1);
      lcd.blink();
    break;
    case 7:
    lcd.setCursor (9, 1);
    lcd.blink();
    break;
    
  }
}

void loop(){

  if(digitalRead(PULSADOR_MODO)==HIGH){
    modo++;
    modo = modo % N;
    fijarCursorModo();
    while(digitalRead(PULSADOR_MODO)==HIGH);
  }

  switch(modo){
    //RELOJ
    case 1: 
      if(digitalRead(PULSADOR_UP)==HIGH){
        incrementarHoras();
        while(digitalRead(PULSADOR_UP)==HIGH);
      }
      if(digitalRead(PULSADOR_DOWN)==HIGH){
        decrementarHoras();
        while(digitalRead(PULSADOR_DOWN)==HIGH);
      }
    break;
    case 2: 
    if(digitalRead(PULSADOR_UP)==HIGH){
        incrementarMinutos();
        while(digitalRead(PULSADOR_UP)==HIGH);
      }
      if(digitalRead(PULSADOR_DOWN)==HIGH){
        decrementarMinutos();
        while(digitalRead(PULSADOR_DOWN)==HIGH);
      }
    break;
    //ALARMA
    case 3:
    if(digitalRead(PULSADOR_UP)==HIGH){
        alarmaOn=!alarmaOn;
        actualizar=true;
        while(digitalRead(PULSADOR_UP)==HIGH);
      } 
      
    break;
    case 4:
    if(digitalRead(PULSADOR_UP)==HIGH){
        incrementarHorasInicio();
        while(digitalRead(PULSADOR_UP)==HIGH);
      }
      if(digitalRead(PULSADOR_DOWN)==HIGH){
        decrementarHorasInicio();
        while(digitalRead(PULSADOR_DOWN)==HIGH);
      }
      
     
      
    break;
    case 5: 
      if(digitalRead(PULSADOR_UP)==HIGH){
        incrementarMinutosInicio();
        while(digitalRead(PULSADOR_UP)==HIGH);
      }
      if(digitalRead(PULSADOR_DOWN)==HIGH){
        decrementarMinutosInicio();
        while(digitalRead(PULSADOR_DOWN)==HIGH);
      }
    break;
    case 6: 
      if(digitalRead(PULSADOR_UP)==HIGH){
        incrementarHorasFinal();
        while(digitalRead(PULSADOR_UP)==HIGH);
      }
      if(digitalRead(PULSADOR_DOWN)==HIGH){
        decrementarHorasFinal();
        while(digitalRead(PULSADOR_DOWN)==HIGH);
      }
    break;
    case 7: 
      if(digitalRead(PULSADOR_UP)==HIGH){
        incrementarMinutosFinal();
        while(digitalRead(PULSADOR_UP)==HIGH);
      }
      if(digitalRead(PULSADOR_DOWN)==HIGH){
        decrementarMinutosFinal();
        while(digitalRead(PULSADOR_DOWN)==HIGH);
      }
    break;
    
    
  }

  if(actualizar == true){
    actualizarReloj();
    lcd.clear();
    lcd.noBlink();
    //RELOJ
    lcd.setCursor(0,0);
    sprintf(texto, "%02d:%02d:%02d",horas,minutos, segundos); 
    lcd.print(texto);
    //INICIO
    lcd.setCursor(0,1);
    sprintf(texto, "%02d:%02d",horas_inicio,minutos_inicio); 
    lcd.print(texto);
    
    
    //FINAL
     lcd.setCursor(6,1);
    sprintf(texto, "%02d:%02d",horas_final,minutos_final); 
    lcd.print(texto);
    lcd.setCursor (12, 1);
    //lcd.print(" OFF");
    

    if(alarmaOn ==true){
      lcd.setCursor(10, 0);
      lcd.print(" ON");
    }
    else{
      lcd.setCursor(10, 0);
      lcd.print(" OFF");  
    }
     if(alarmaOn ==true){
      if(segundos==0 && horas == horas_inicio && minutos == minutos_inicio){
        digitalWrite(LUZ, HIGH);
        
        luz_iniciada = false;
        indicador_encendido = true ;
      };
      
    }
    if (indicador_encendido ==true){
     lcd.setCursor(12, 1);
     lcd.print(" ON");
    
      }
    
              
    if(luz_iniciada==false){
      if(segundos==0 && horas >= horas_final && minutos >= minutos_final){
        digitalWrite(LUZ, LOW);
       indicador_encendido = false;
      }
    }
    if (indicador_encendido == false){
        lcd.setCursor(12, 1);
        lcd.print(" OFF");
      
      }
    actualizar = false;
    fijarCursorModo();
    
  }
  
}

[CODE].
#2

La hora se mantiene con un RTC. eso no requiere mas que conectarlo y usar la librería adecuada y agregar las lineas que sincronizan el RTC con el Arduino cada X horas.

Lo segundo requiere de una especia de UPS o battery backup del arduino, tal que cuando se quede sin energia detectes ese corte de energía, vuelques los datos a la EEPROM del arduino y hagas los demas combios y luego pases a modo emergencia.

#3

Hola gracias por tu respuesta. Tendrias algun ejemplo por que te entiendo la idea pero no me doy cue ta de cómo hacerlo

#4

Gracias. Voy a probar eso

#5

Hola nuevamente, estuve trantando de guardar los valores en la eeprom pero estoy teniendo bastantes complicaciones al momento de hacerlo. Lo que necesito lograr es salvar los valores ingresados en este sector

lcd.setCursor(0,1);
    sprintf(texto, "%02d:%02d",horas_inicio,minutos_inicio); 
    lcd.print(texto);
    
    
    //FINA4,
     lcd.setCursor(6,1);
    sprintf(texto, "%02d:%02d",horas_final,minutos_final); 
    lcd.print(texto);

y volver a mostrarlos cuando la corriente se reestablezca, pero no e podido lograrlo, e tratado de usar una funcion en la que al ser llamada guarde la info. pero desgraciadamente no consegui nada.

void guardarinfo(){


  EEPROM.put(eepromcaja1,horas_inicio);
  EEPROM.put(eepromcaja2,minutos_inicio);
  EEPROM.put(eepromcaja3, horas_final);
  EEPROM.put(eepromcaja4, minutos_final);
  EEPROM.put(eepromcaja5,indicador);

desde este punto:

if(alarmaOn ==true){
      lcd.setCursor(10, 0);
      lcd.print(" ON");
      
      
     if (indicador ==0){
          indicador =1;
      guardarinfo();
        
      }

el problema es que reinicia y no guarda nada, mientras el valor de alarmaON sea off. Osea si reinicia el valor de Esta variable vuelve a ser False y no muestra nada, pero si lo cambio manualmente, aparece el valor, pero yo necesito que al reiniciarse el sistema ya este en ON y que tambien permita cambiarlo si el usuario.
Desde ya muchas gracias

#6

Hi,
Lo que puedes hacer es usar un flag y cuando haya una interrupcion de energia escribe flag = 1 y las escribe en un byte de la memoria con la otra infomacion que quires guardar. Cuando reinicias lee esta variable y si es flag = 1 te va a indicar que hubo una interupcion. Una vez que lee la informacion guardada entoces flag = 0.
En uno de mis projectos yo haga los mismo cuando determino que la fuente de energia falla.

#7

hola gracias por la respuesta, el tema es que no puedo guardar y mostrar los datos que seria hora_inicio y final y minutos inicio y final y estos son ingresados mediante unos pulsados, todo los ejemplos para guardar en memoria eeprom, son con datos que ingresar mediante una variables ya asignadas en el setup. osea los datos ya esta pre cargados en el programa y nos no son ingresados por el usuario que seria mi caso. NO se si me explico en el embrollo en que estoy. Muchas gracias

#8

Te lo han dicho varias veces, pero te lo digo de otra manera. ¿Has probado a poner dentro del setup esto?

  EEPROM.get(eepromcaja1,horas_inicio);
  EEPROM.get(eepromcaja2,minutos_inicio);
  EEPROM.get(eepromcaja3, horas_final);
  EEPROM.get(eepromcaja4, minutos_final);
  EEPROM.get(eepromcaja5,indicador);
#9

hola estuve probando lo que me dijiste y la verdad no logro hacer que guarde y muestre. Ya no se que mas hacer y no se donde estoy cometiendo el error. abajo incluyo parte del código que uso principalmente la parte en que guardo en el setup y muestro los datos y demás

set up.

void setup(){
  Wire.begin();
  Serial.begin (9600); 
  lcd.begin(16,2);
  lcd.clear();
  lcd.backlight();

  pinMode(PULSADOR_MODO, INPUT);
  pinMode(PULSADOR_UP, INPUT);
  pinMode(PULSADOR_DOWN, INPUT);
  pinMode(LUZ, OUTPUT);
  digitalWrite (LUZ, HIGH);
  Timer1.initialize(1000000);
  Timer1.attachInterrupt(manejadoraTimer);


    
    
EEPROM.get (caja1, horas_inicio);
EEPROM.get (caja2, minutos_inicio);
EEPROM.get (caja3, horas_final);
EEPROM.get (caja4, minutos_final);
EEPROM.get (caja5, bandera);
if  (bandera == 1){
  
lcd.setCursor(0,1);
    sprintf(texto, "%02d:%02d",horas_inicio,minutos_inicio); 
    lcd.print(texto);
        //Serial.print (horas_inicio, minutos_inicio);
    
    //FINAL
     lcd.setCursor(6,1);
    sprintf(texto, "%02d:%02d",horas_final,minutos_final); 
    lcd.print(texto);
  
    
    
    }  

}

funciona de guardado

void guardarinfo(){
EEPROM.put (caja1, horas_inicio);
EEPROM.put (caja2, minutos_inicio);
EEPROM.put (caja3, horas_final);
EEPROM.put (caja4, minutos_final);
EEPROM.put (caja5, bandera);

}

sector donde llama a la funcion

if (Estado == true){
  lcd.setCursor(12, 0);
      lcd.print(" G");
      bandera = 1;
      if(bandera = 0){
        bandera = 1;
   guardarinfo();
      }
  }
    else {
    lcd.setCursor(12, 0);
      lcd.print(" NG");
      bandera = 0;
    
    }

Sinceramente ya no se que mas hacer y no logro comprender los ejemplos que hay en internet.

#10