Reginaldo Freires

Srs,

Estou precisando de ajuda. Preciso deixar a hora e data sempre atualizados. Porém sempre que faço o reset ou desligo o arduino o RTC volta na ultima hora gravada.

Obrigado.

/*==============================================================================

   ARQUIVO FONTE:      Medidor de energia.ino
   DATA DE CRIAÇÃO:    16/04/2015
   REVISÃO:            1.0
   DATA DA ULTIMA REV: 16/04/2015  (REV.: 1.0)
   MICROCONTROLADOR:   FAMILIA ARDUINO DUE

   AUTOR:              REGINALDO FREIES

================================================================================

 Pinos Display LCD:
 * LCD RS pino do digital do arduino 12 / 7
 * LCD Enable pino do digital do arduino 11 / 6
 * LCD D4 pino do digital do arduino 5
 * LCD D5 pino do digital do arduino 4
 * LCD D6 pino do digital do arduino 3
 * LCD D7 pino do digital do arduino 2
 * LCD R/W pino colocado ao comum
 * 10K resistor:
 * Alimentação em +5V e comun
 * Deixar aberto o  LCD VO (pino 3)

 Pinos Modulo SD:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4

// Definições das Bibliotecas do Projeto
=============================================================================*/

#include <rtc_clock.h>          // Biblioteca do Relogio de Tempo Real
#include <LiquidCrystal.h>      // Biblioteca do Display
#include <chip.h>               // Biblioteca do Arduino
#include <SPI.h>                // Biblioteca da Comunicação Serial
#include <SD.h>                 // Biblioteca do Carto SD
#include <MenuBackend.h>        // Biblioteca do Menu
#include <EmonLib.h>            // Biblioteca de Energia
#include <DueTimer.h>           // Biblioteca de interrupção

// Definições das variaves Gerais do Projeto
//=============================================================================
const int chipSelect = 10; //4; Pino CS do Modulo SD
int analogPin;
int sensor;
String dataString = "", TempStamp = "", StrArq = "", CabArq = "", PartNameFile = "",
       TempStampAux = "";
int TamH = 0, Minutos = 0, Segundo = 0, ZeroMin = 0;
boolean State = true;
String Nome, LcdAux;
const int buttonPinLeft = A6;      // pin for the Up button
const int buttonPinRight = A5;    // pin for the Down button
const int buttonPinEsc = A7;     // pin for the Esc button
const int buttonPinEnter = A8;   // pin for the Enter button

int buttonEnterState = LOW;            // Leitura Corrente da tecla Enter
int buttonEscState = LOW;              // Leitura Corrente da tecla Sair
int buttonLeftState = LOW;             // Leitura Corrente da tecla Esquerda
int buttonRightState = LOW;            // Leitura Corrente da tecla Direita

int lastButtonPushed = 0;

int lastButtonEnterState = LOW;   // the previous reading from the Enter input pin
int lastButtonEscState = LOW;   // the previous reading from the Esc input pin
int lastButtonLeftState = LOW;   // the previous reading from the Left input pin
int lastButtonRightState = LOW;   // the previous reading from the Right input pin


long lastEnterDebounceTime = 0;  // the last time the output pin was toggled
long lastEscDebounceTime = 0;  // the last time the output pin was toggled
long lastLeftDebounceTime = 0;  // the last time the output pin was toggled
long lastRightDebounceTime = 0;  // the last time the output pin was toggled
//long debounceDelay = 200;    // the debounce time



// Definições das variaves do Relogio de Tempo Real
//=============================================================================
RTC_clock rtc_clock(XTAL);

char* daynames[] = {"Seg", "Ter", "Qua", "Qui", "Sex", "Sab", "Dom"};
int hh, mm, ss, dow, dd, mon, yyyy;
int Ah, Am, As, Ad, Ams, Aa;
static long waitTimeG = 0;
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);



// Definições das variaves do MENU
//=============================================================================
MenuBackend menu = MenuBackend(menuUsed, menuChanged);
//initialize menuitems
MenuItem menu1Item1 = MenuItem("Hora e Data"); //Item1
MenuItem menuItem1SubItem1 = MenuItem("Hora"); //Item1SubItem1
MenuItem menuItem1SubItem2 = MenuItem("Data"); //Item1SubItem2
MenuItem menu1Item2 = MenuItem("Acionamento"); // Item2
MenuItem menuItem2SubItem1 = MenuItem("Carga 00"); //Item2SubItem1
MenuItem menuItem2SubItem2 = MenuItem("Carga 01"); //Item2SubItem2
MenuItem menuItem2SubItem3 = MenuItem("Carga 02"); //Item2SubItem3
MenuItem menu1Item3 = MenuItem("Valor Kwh"); // Item3
MenuItem menuItem3SubItem1 = MenuItem("Alt Valor"); //Item3SubItem1
MenuItem menuItem3SubItem2 = MenuItem("Informacao"); //Item3SubItem2

/*==============================================================================

    FUNÇÃO:       VOID SETUP()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    INICIALIZA FUNÇOES GERAIS

==============================================================================*/
void setup()
{

  rtc_clock.init();
  rtc_clock.set_clock(__DATE__, __TIME__);
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  Serial.begin(9600);
  while (!Serial)
  {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  Serial.print("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(10, OUTPUT);

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect))
  {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    return;
  }
  Serial.println("card initialized.");

  //configuraçao do menu
  pinMode(buttonPinLeft, INPUT);
  pinMode(buttonPinRight, INPUT);
  pinMode(buttonPinEnter, INPUT);
  pinMode(buttonPinEsc, INPUT);
  menu.getRoot().add(menu1Item1);
  menu1Item1.addRight(menu1Item2).addRight(menu1Item3);
  menu1Item1.add(menuItem1SubItem1).addRight(menuItem1SubItem2);
  menu1Item2.add(menuItem2SubItem1).addRight(menuItem2SubItem2).addRight(menuItem2SubItem3);
  menu1Item3.add(menuItem3SubItem1).addRight(menuItem3SubItem2);
  menu.toRoot();

  //configuraçao do Timer
  Timer3.attachInterrupt(GravaArq);
  Timer3.start(1000000);             // Chamada a cada 1000ms

}
/*==============================================================================

    FUNÇÃO:       VOID LOOP()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    ROTINA PRINCIPAL DO PROGRAMA

==============================================================================*/
void loop()
{
  analogReadResolution(16);

  rtc_clock.get_time(&hh, &mm, &ss);
  rtc_clock.get_date(&dow, &dd, &mon, &yyyy);

  if ((Segundo < ss) or (ss == 0))
  {
    Segundo = ss;
    if (State) MostraLCD();
  }

  readButtons(150);    // Eu parcelo a leitura do botão e a navegação em dois procedimentos porque
  navigateMenus();  //em algumas situações eu quero usar o botão para outros fins
  //(por exemplo. para alterar algumas configurações)
  if ( waitTimeG > 5000000)
  {
    State = true;
    menu.toRoot();
  }
  else if (!State)
  {
    waitTimeG++;
  }
  else
  {
    waitTimeG = 0;
  }


}
/*==============================================================================

    FUNÇÃO:       VOID DIGITPRINT()
    PARÂMETROS:   VALUE e LENGHT
    RETORNO:      NENHUM

    DESCRIÇÃO:    DIMENSIONAR VARIAVEL

==============================================================================*/
void digitprint(int value, int lenght)
{
  for (int i = 0; i < (lenght - numdigits(value)); i++)
  {
    //Serial.print("0");
    lcd.write("0");
  }
  //Serial.print(value);
  lcd.print(value);
}
/*==============================================================================

    FUNÇÃO:       VOID DIGITPRINT()
    PARÂMETROS:   I
    RETORNO:      DIGITS

    DESCRIÇÃO:    DIMENSIONAR VARIAVEL

==============================================================================*/
int numdigits(int i) {
  int digits;
  if (i < 10)
    digits = 1;
  else
    digits = (int)(log10((double)i)) + 1;
  return digits;
}
/*==============================================================================

    FUNÇÃO:       VOID MONTASTAMP()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    MONTA VARIAVEL COM DADOS DE HORA E DATA

==============================================================================*/
void MontaStamp()
{
  int X = 2;
  TempStamp     = "\0";
  PartNameFile  = "\0";
  TempStamp     = "Data: ";

  for (int i = 0; i < (X - numdigits(dd)); i++)
  {
    TempStamp     += ("0");
    PartNameFile  += ("0");
  }
  TempStamp     += String(dd);
  PartNameFile  += String(dd);
  TempStamp     += "/";

  for (int i = 0; i < (X - numdigits(mon)); i++)
  {
    TempStamp     += ("0");
    PartNameFile  += ("0");
  }
  TempStamp     += String(mon);
  PartNameFile  += String(mon);
  TempStamp     += "/";

  X = 4;
  for (int i = 0; i < (X - numdigits(yyyy)); i++)
  {
    TempStamp     += ("0");
    PartNameFile  += ("0");
  }
  TempStamp     += String(yyyy);
  PartNameFile  += String(yyyy);


  TempStamp += "; ";
  TempStamp += "Hora: ";

  X = 2;
  for (int i = 0; i < (X - numdigits(hh)); i++)
  {
    TempStamp += ("0");
  }
  TempStamp += String(hh);
  TempStamp += ":";

  for (int i = 0; i < (X - numdigits(mm)); i++)
  {
    TempStamp += ("0");
  }
  TempStamp += String(mm);
  TempStamp += ":";

  for (int i = 0; i < (X - numdigits(ss)); i++)
  {
    TempStamp += ("0");
  }
  TempStamp += String(ss);
  TempStamp += "; ";
}

/*==============================================================================

    FUNÇÃO:       VOID LERSENSOR()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    LEITURA DAS ANALOGICAS DO PROJETO

==============================================================================*/
void LerSensor()
{
  dataString = "\0";
  // read three sensors and append to the string:
  for (analogPin = 0; analogPin < 3; analogPin++)
  {
    sensor = analogRead(analogPin);
    dataString += String(sensor);
    if (analogPin < 2)
    {
      dataString += "; ";
    }
  }
  dataString += ";";
  dataString += "\n";

}
/*==============================================================================

    FUNÇÃO:       VOID MOSTRALCD()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    MOSTRAR DADOS NO DISPLAY

==============================================================================*/
void MostraLCD()
{
  // clear the screen
  lcd.clear();
  lcd.setCursor(0, 0); //
  lcd.write("Hora: ");

  digitprint(hh, 2);
  lcd.write(":");

  digitprint(mm, 2);
  lcd.write(":");

  digitprint(ss, 2);
  lcd.setCursor(0, 1); //

  lcd.print("Data:");

  //Serial.print(daynames[dow-1]);
  //lcd.print(daynames[dow-1]);

  lcd.write(" ");
  digitprint(dd, 2);

  lcd.write(".");
  digitprint(mon, 2);

  lcd.write(".");
  lcd.print(yyyy);
}
/*==============================================================================

    FUNÇÃO:       VOID STAMPARQUIVO()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    GRAVA ARQUIVO CARTÃO SD

==============================================================================*/
void StampArquivo()
{

  CabArq  = "ARQUIVO DE DADOS DO SISTEMA \r\nAutor : Reginaldo Freires\r\n";
  //CabArq  += "\n";
  //CabArq  += "Autor : Reginaldo Freires";
  //CabArq  += "\n";
  PartNameFile = PartNameFile += "_datalog.txt";
  if (SD.exists("datalog.txt"))
    //if (SD.exists(PartNameFile))
  {

    File dataFile = SD.open("datalog.txt", FILE_WRITE);
    StrArq = "\0";
    // if the file is available, write to it:
    if (dataFile)
    {
      StrArq = TempStamp + dataString;
      dataFile.println(StrArq);
      dataFile.close();
    }
    // if the file isn't open, pop up an error:
    else
    {
      Serial.println("error opening datalog.txt");
    }
  }
  else
  {

    File dataFile = SD.open("datalog.txt", FILE_WRITE);
    // if the file is available, write to it:
    if (dataFile)
    {
      dataFile.println(CabArq);
      Serial.print(CabArq);
      dataFile.close();
    }
    // if the file isn't open, pop up an error:
    else
    {
      Serial.println("error opening datalog.txt");
    }

  }
}

/*==============================================================================

    FUNÇÃO:       VOID MENUCHANGED()
    PARÂMETROS:   MENUCHANGEEVENT
    RETORNO:      NENHUM

    DESCRIÇÃO:    MONITORA AS TECLAS

==============================================================================*/
void menuChanged(MenuChangeEvent changed)
{

  MenuItem newMenuItem = changed.to; //get the destination menu

  lcd.setCursor(0, 1); //set the start position for lcd printing to the second row

  if (newMenuItem.getName() == menu.getRoot())
  {
    //lcd.print("Medicao          ");
    State = true;

  }
  else if (newMenuItem.getName() == "Hora e Data")
  {
    lcd.print("Hora e Data       ");
  }
  else if (newMenuItem.getName() == "Hora")
  {
    lcd.print("Hora            ");
  }
  else if (newMenuItem.getName() == "Data")
  {
    lcd.print("Data            ");
  }
  else if (newMenuItem.getName() == "Acionamento")
  {
    lcd.print("Acionamento              ");
  }
  else if (newMenuItem.getName() == "Carga 00")
  {
    lcd.print("Carga 00      ");
  }
  else if (newMenuItem.getName() == "Carga 01")
  {
    lcd.print("Carga 01      ");
  }
  else if (newMenuItem.getName() == "Carga 02")
  {
    lcd.print("Carga 02      ");
  }
  else if (newMenuItem.getName() == "Valor Kwh")
  {
    lcd.print("Valor Kwh          ");
  }
  else if (newMenuItem.getName() == "Alt Valor")
  {
    lcd.print("Alt Valor          ");
  }
  else if (newMenuItem.getName() == "Informacao")
  {
    lcd.print("Informacao         ");
  }
}

/*==============================================================================

    FUNÇÃO:       VOID MENUUSED()
    PARÂMETROS:   MENUUSEEVENT
    RETORNO:      NENHUM

    DESCRIÇÃO:    MONITORA AS TECLAS

==============================================================================*/
void menuUsed(MenuUseEvent used)
{

  Nome = used.item.getName();
  if (Nome == "Hora")
  {
    Ah = hh;
    AtualHora();
    goto Saida;
  }
  else if (Nome == "Data")
  {
    Ad = dd;
    AtualData();
    goto Saida;
  }
  else
  {
    lcd.setCursor(0, 0);
    lcd.print("Digite a Hora        ");
    lcd.setCursor(0, 1);
    lcd.print("Hora:");
  }
  //delay(300);  //delay to allow message reading
  //lcd.setCursor(0,0);
  //lcd.print("www.3rf.org");
Saida:
  State = true;
  menu.toRoot();

}

/*==============================================================================

    FUNÇÃO:       VOID READBUTTONS()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    MONITORA AS TECLAS

==============================================================================*/
void  readButtons(long debounceDelay)
{
  int   reading;
  buttonEnterState = LOW;            // Leitura Corrente da tecla Enter
  buttonEscState = LOW;              // Leitura Corrente da tecla Sair
  buttonLeftState = LOW;             // Leitura Corrente da tecla Esquerda
  buttonRightState = LOW;            // Leitura Corrente da tecla Direita

  //Botão Enter
  // Ler o estado do botão em varivel local:
  reading = digitalRead(buttonPinEnter);

  // verificar para ver se você apertou apenas o botão enter
  // (ou seja, a entrada foi de baixa para alta), e você esperou
  // tempo suficiente desde a última tecla pressionada para ignorar qualquer ruído:

  // Se a tecla mudou, devido ao ruído ou pressionando:
  if (reading != lastButtonEnterState) {
    // Reset do tempo de debounce da tecla
    lastEnterDebounceTime = millis();
  }

  if ((millis() - lastEnterDebounceTime) > debounceDelay) {
    // Qualquer que seja a leitura está, ele foi lá por mais tempo
    // Que o atraso de debounce, para levá-lo como o estado atual:
    buttonEnterState = reading;
    lastEnterDebounceTime = millis();
  }

  //Salvar a leitura. Da próxima vez através do laço,
  // Vai ser o lastButtonState:
  lastButtonEnterState = reading;


  //Botão Sair
  // Ler o estado do botão em varivel local:
  reading = digitalRead(buttonPinEsc);

  // verificar para ver se você apertou apenas o botão enter
  // (ou seja, a entrada foi de baixa para alta), e você esperou
  // tempo suficiente desde a última tecla pressionada para ignorar qualquer ruído:

  // Se a tecla mudou, devido ao ruído ou pressionando:
  if (reading != lastButtonEscState) {
    // Reset do tempo de debounce da tecla
    lastEscDebounceTime = millis();
  }

  if ((millis() - lastEscDebounceTime) > debounceDelay) {
    // Qualquer que seja a leitura está, ele foi lá por mais tempo
    // Que o atraso de debounce, para levá-lo como o estado atual:
    buttonEscState = reading;
    lastEscDebounceTime = millis();
  }

  //Salvar a leitura. Da próxima vez através do laço,
  // Vai ser o lastButtonState:
  lastButtonEscState = reading;


  //Botão Baixar
  // Ler o estado do botão em varivel local:
  reading = digitalRead(buttonPinRight);

  // verificar para ver se você apertou apenas o botão enter
  // (ou seja, a entrada foi de baixa para alta), e você esperou
  // tempo suficiente desde a última tecla pressionada para ignorar qualquer ruído:

  // Se a tecla mudou, devido ao ruído ou pressionando:
  if (reading != lastButtonRightState) {
    // Reset do tempo de debounce da tecla
    lastRightDebounceTime = millis();
  }

  if ((millis() - lastRightDebounceTime) > debounceDelay) {
    // Qualquer que seja a leitura está, ele foi lá por mais tempo
    // Que o atraso de debounce, para levá-lo como o estado atual:
    buttonRightState = reading;
    lastRightDebounceTime = millis();
  }

  //Salvar a leitura. Da próxima vez através do laço,
  // Vai ser o lastButtonState:
  lastButtonRightState = reading;


  //Botão Subir
  // Ler o estado do botão em varivel local:
  reading = digitalRead(buttonPinLeft);

  // verificar para ver se você apertou apenas o botão enter
  // (ou seja, a entrada foi de baixa para alta), e você esperou
  // tempo suficiente desde a última tecla pressionada para ignorar qualquer ruído:

  // Se a tecla mudou, devido ao ruído ou pressionando:
  if (reading != lastButtonLeftState) {
    // Reset do tempo de debounce da tecla
    lastLeftDebounceTime = millis();
  }

  if ((millis() - lastLeftDebounceTime) > debounceDelay) {
    // Qualquer que seja a leitura está, ele foi lá por mais tempo
    // Que o atraso de debounce, para levá-lo como o estado atual:
    buttonLeftState = reading;
    lastLeftDebounceTime = millis();;
  }

  //Salvar a leitura. Da próxima vez através do laço,
  // Vai ser o lastButtonState:
  lastButtonLeftState = reading;

  //Grava qual botão foi pressionado
  if (buttonEnterState == HIGH) {
    lastButtonPushed = buttonPinEnter;

  } else if (buttonEscState == HIGH) {
    lastButtonPushed = buttonPinEsc;

  } else if (buttonRightState == HIGH) {
    lastButtonPushed = buttonPinRight;

  } else if (buttonLeftState == HIGH) {
    lastButtonPushed = buttonPinLeft;

  } else {
    lastButtonPushed = 0;
  }

  if (lastButtonPushed  != 0)
  {
    waitTimeG = 0;
  }

}

/*==============================================================================

    FUNÇÃO:       VOID NAVIGATEMENUS()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    IDENTIFICA AS FUNÇÕES

==============================================================================*/

void navigateMenus()
{
  //MenuItem newMenuItem = changed.to;
  MenuItem currentMenu = menu.getCurrent();

  switch (lastButtonPushed)
  {
    case buttonPinEnter:
      State = false;
      if (!(currentMenu.moveDown())) { //Se o menu atual tem um subitem e foi pressionado entrar,
        //em seguida, navegue até Menu do item abaixo
        menu.use();
      }
      else
      { //Caso contrário, se o menu não tem nenhum subitem e
        //foi pressionado entrar no menu atual é usada
        menu.moveDown();
      }
      break;
    case buttonPinEsc:
      State = true;
      //if(!(newMenuItem.getName()==menu.getRoot()))
      menu.toRoot();
      break;
    case buttonPinRight:
      menu.moveRight();
      State = false;
      break;
    case buttonPinLeft:
      menu.moveLeft();
      State = false;
      break;
  }

  lastButtonPushed = 0; //resete da variavel lastButtonPushed
}
/*==============================================================================

    FUNÇÃO:       VOID GRAVAARQ()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    GRAVA ARQUIVO DATALOGER

==============================================================================*/
void GravaArq ()
{
  LerSensor();
  if ((Minutos < ss) or ((ss == 0) & ZeroMin == 0))
  {
    Minutos = ss;
    ZeroMin = 1;
    MontaStamp();
    StampArquivo();
    Serial.println(StrArq);
  }

  if (ss == 0)
  {
    Minutos = 0;
  }
  else
  {
    ZeroMin = 0;
  }

}

/*==============================================================================

    FUNÇÃO:       VOID ATUALHORA()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    AJUSTA A HORA DO RELOGIO

==============================================================================*/
void AtualHora ()
{
  bool saida = false;
  long waitTime = 0;
  int x = 1;
  lastLeftDebounceTime = 0;
  LcdAux = "Hora: " + String(Ah);
  lcd.setCursor(0, 0);
  lcd.print("Atualize a Hora      ");
  lcd.setCursor(0, 1);
  lcd.print(LcdAux);
  do
  {
    readButtons(150);
    if ((x == 1) && (lastButtonPushed))
    {


      switch (lastButtonPushed)
      {
        case buttonPinRight:
          Ah++;
          if (Ah > 23) Ah = 0;
          lcd.setCursor(0, 1);
          lcd.print("Hora:                ");
          lcd.setCursor(6, 1);
          lcd.print(Ah);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinLeft:
          Ah--;
          if (Ah < 0)  Ah = 23;
          lcd.setCursor(0, 1);
          lcd.print("Hora:                ");
          lcd.setCursor(6, 1);
          lcd.print(Ah);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinEnter:
          saida = false;
          x++;
          Am = mm;
          LcdAux = "Minuto: " + String(Am);
          lcd.setCursor(0, 0);
          lcd.print("Atualize Minuto      ");
          lcd.setCursor(0, 1);
          lcd.print(LcdAux);
          break;

      }
    }
    else  if ((x == 2) && (lastButtonPushed))
    {
      switch (lastButtonPushed)
      {
        case buttonPinRight:
          Am++;
          if (Am > 59) Am = 0;
          lcd.setCursor(0, 1);
          lcd.print("Minuto:                ");
          lcd.setCursor(8, 1);
          lcd.print(Am);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinLeft:
          Am--;
          if (Am < 0)  Am = 59;
          lcd.setCursor(0, 1);
          lcd.print("Minuto:                ");
          lcd.setCursor(8, 1);
          lcd.print(Am);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinEnter:
          saida = false;
          x++;
          As = ss;
          LcdAux = "Segundo: " + String(As);
          lcd.setCursor(0, 0);
          lcd.print("Atualize Segundo      ");
          lcd.setCursor(0, 1);
          lcd.print(LcdAux);
          break;

      }
    }
    else  if ((x == 3) && (lastButtonPushed))
    {
      switch (lastButtonPushed)
      {
        case buttonPinRight:
          As++;
          if (As > 59) As = 0;
          lcd.setCursor(0, 1);
          lcd.print("Segundo:                ");
          lcd.setCursor(9, 1);
          lcd.print(As);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinLeft:
          As--;
          if (As < 0)  As = 59;
          lcd.setCursor(0, 1);
          lcd.print("Segundo:                ");
          lcd.setCursor(9, 1);
          lcd.print(As);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinEnter:
          saida = true;
          rtc_clock.set_time(Ah, Am, As);
          break;
      }
    }
    //if (((2 * millis()) - lastLeftDebounceTime) < waitTime)
    if ( waitTime > 1000000)
    {
      saida = true;
    }
    else
    {
      waitTime++;
    }

    if (buttonEscState == HIGH)
    {
      saida = true;
    }
    lastButtonPushed = LOW;
  } while (!saida);
}

/*==============================================================================

    FUNÇÃO:       VOID ATUALDATA()
    PARÂMETROS:   NENHUM
    RETORNO:      NENHUM

    DESCRIÇÃO:    AJUSTA A DATA DO RELOGIO

==============================================================================*/
void AtualData ()
{
  bool saida = false;
  long waitTime = 0;
  int x = 1;
  lastLeftDebounceTime = 0;
  LcdAux = "Dia: " + String(Ad);
  lcd.setCursor(0, 0);
  lcd.print("Atualize o Dia      ");
  lcd.setCursor(0, 1);
  lcd.print(LcdAux);
  do
  {
    readButtons(150);
    if ((x == 1) && (lastButtonPushed))
    {
      switch (lastButtonPushed)
      {
        case buttonPinRight:
          Ad++;
          if (Ad > 31) Ad = 1;
          lcd.setCursor(0, 1);
          lcd.print("Dia:                ");
          lcd.setCursor(5, 1);
          lcd.print(Ad);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinLeft:
          Ad--;
          if (Ad < 1)  Ad = 31;
          lcd.setCursor(0, 1);
          lcd.print("Dia:                ");
          lcd.setCursor(5, 1);
          lcd.print(Ad);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinEnter:
          saida = false;
          x++;
          Ams = mon;
          LcdAux = "Mes: " + String(Ams);
          lcd.setCursor(0, 0);
          lcd.print("Atualize o Mes      ");
          lcd.setCursor(0, 1);
          lcd.print("                 ");
          lcd.setCursor(0, 1);
          lcd.print(LcdAux);
          break;

      }
    }
    else  if ((x == 2) && (lastButtonPushed))
    {
      switch (lastButtonPushed)
      {
        case buttonPinRight:
          Ams++;
          if (Ams > 12) Ams = 0;
          lcd.setCursor(0, 1);
          lcd.print("Mes:                ");
          lcd.setCursor(5, 1);
          lcd.print(Ams);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinLeft:
          Ams--;
          if (Ams < 0)  Ams = 12;
          lcd.setCursor(0, 1);
          lcd.print("Mes:                ");
          lcd.setCursor(5, 1);
          lcd.print(Ams);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinEnter:
          saida = false;
          x++;
          Aa = yyyy;
          LcdAux = "Ano: " + String(Aa);
          lcd.setCursor(0, 0);
          lcd.print("Atualize o Ano      ");
          lcd.setCursor(0, 1);
          lcd.print("                 ");
          lcd.setCursor(0, 1);
          lcd.print(LcdAux);
          break;

      }
    }
    else  if ((x == 3) && (lastButtonPushed))
    {
      switch (lastButtonPushed)
      {
        case buttonPinRight:
          Aa++;
          if (Aa > 3000) Aa = 1000;
          lcd.setCursor(0, 1);
          lcd.print("Ano:                ");
          lcd.setCursor(5, 1);
          lcd.print(Aa);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinLeft:
          Aa--;
          if (Aa < 0)  Aa = 1000;
          lcd.setCursor(0, 1);
          lcd.print("Ano:                ");
          lcd.setCursor(5, 1);
          lcd.print(Aa);
          saida = false;
          waitTime = 0;
          break;
        case buttonPinEnter:
          saida = true;
          rtc_clock.set_date(Ad, Ams, Aa);
          break;
      }
    }
    //if (((2 * millis()) - lastLeftDebounceTime) < waitTime)
    if ( waitTime > 1000000)
    {
      saida = true;
    }
    else
    {
      //lastLeftDebounceTime = (2 * millis());
      waitTime++;
    }

    if (buttonEscState == HIGH)
    {
      saida = true;
    }
    lastButtonPushed = LOW;
  } while (!saida);
}