BD_EEPROM.h

/*
    Celula de 4 bytes

    Digite 'i' ou 'I'   para Incluir um  novo dado;
    Digite 'r' ou 'R'   Para delatar um dado;
    Digite 'l' ou 'L'   Para listar todos dados catalogadas;
    Digite 'z' ou 'Z'   Para gravar 0xFF em toda a EEPROM;
    Digite 'p' ou 'P'   Para listar toda EEPROM byte por byte;
    Digite 't' ou 'T'   Para testar um dado individual;
    Digite 'n' ou 'N'   Para criar os valores iniciais.  Zera todos dados;
    Digite 's' ou 'S'   Para imprimir o cabecalho inicial;
    Digite 'x' ou 'X'   Sai da rotina EEPROM
    Digite 'y' ou 'Y'   Selecionar controle remoto



*/
#include <EEPROM.h>                                               // Bibioteca para EEPROM

uint16_t RECV_PIN = D7;
IRrecv irrecv(RECV_PIN);
decode_results results;
unsigned long cod;



char controle = ' ';                                              // Dados lidos da serial
unsigned long  dadoEEPROM = 0;                                    // Dados do dado lidos da EEPROM
byte listEEPROM = 0;                                              // Dados do dado lidos da EEPROM
unsigned long  dadoLido = 0;                                      // Valor do dado lida na serial
bool leDado = false;                                              // Flag para conferencia de dado
bool encontrouDado = false;                                       // Flag para pesquisa de dado
byte contByte = 0;                                                // Contador de bytes

unsigned long EEPROMaddr = 0;                                     // Endereco de procura de dado
unsigned long addrQteCat = 320;                                   // Endereco para guardar qtde de dado catalogado
unsigned long qtdeDadoCad = 0;                                    // Quantidade de dados cadastradas
unsigned long addrCat = 0;                                        // Endereco para catalogar
unsigned long addrQtdeDel = 330;                                  // Endereco para guardar qtde de dados deletados
unsigned long qtdeDel = 0;                                        // Quantidade de dados deletados
unsigned long addrDel = 340;                                      // Endereco para guardar o endereco inicial dos dados deletados
unsigned long addrDelAtual = 0;                                   // Endereco para guardar o endereco inicial dos dados deletados
unsigned long oldAddr = 0;                                        // Endereco onde foi delatado dado
unsigned long addrDado = 0;                                       // Endereco onde foi encontrado dado
bool sai = 0;                                                    // Indicador de status do cronometro
bool tigre;
bool grava = false;

void leRC_Code();
void listaInicio();
void valoresSerial();
void valoresIniciais();
void leTeste();
void procuraEEPROM();
void cadastra();
void deleta();
void idDado(unsigned long atualDado);
void opcoes();
void listaDado();
void listaEEPROM();
void gravaEEPROM();
void SelectRC();                                                              // Selecione RC

//-------------------------------------------
void leRC_Code()
{
  Serial.println("Aperte uma tecla do RC");
  tigre = 0;
  while (tigre == 0)
  {
    yield();
    if (irrecv.decode(&results))
    {
      cod = results.value;
      tigre = 1;
      irrecv.resume();          // Receive the next value
    }
  }
  Serial.print(" Lido " ); Serial.println(cod, HEX);
  dadoLido = cod;
}
//-------------------------------------------
void SelectRC()                                                              // Selecione RC
{
    Serial.println("Selecione numero do controle remoto de 0 a 9.  ");
}
//-------------------------------------------
void listaInicio()                                                                                // Lista informacoes iniciais
{
  EEPROM.get(addrQteCat, qtdeDadoCad);                                                            // Le da EEPROM Qtde de dado cadastrado
  addrCat = qtdeDadoCad * 4;                                                                      // Atualiza endereco de dado cadastrado
  EEPROM.get(addrQtdeDel, qtdeDel);                                                               // Le da EEPROM Qtde de dado deletado
  addrDelAtual = addrDel + (4 * qtdeDel) - 4;                                                     // Atualiza endereco de dado deletado
  EEPROM.get(addrDelAtual , oldAddr);                                                             // Endereço da ultima dado deletado

  if (qtdeDadoCad > 500)                                                                          // Se qtde de dados maior que 500 (Memoria com 0xFFFF...)
  {
    Serial.println (" Inicializar dados. ");                                                      // Informa
    Serial.println (" Para inicializar digite N ");                                               // Informa
    Serial.println (" e depois reset no arduino. ");                                              // Informa
    Serial.println(" ");                                                                          // Salta linha
  }
  else
  {
    Serial.println(" ");
    Serial.print ("  Quantidade total de espaco alocado  "); Serial.println(qtdeDadoCad);         // Informa
    Serial.print ("  Quantidade total de dados deletados  "); Serial.println(qtdeDel);            // Informa
    if (oldAddr == -1)                                                                            // Sem valor 0XFFFF...
    {
      Serial.print ("            Ultimo endereco deletado  "); Serial.println(oldAddr + 1);       // Informa
    }
    else
    {
      Serial.print ("            Ultimo endereco deletado  "); Serial.println(oldAddr);           // Informa
    }
    Serial.println(" ");                                                                          // Salta linha
    Serial.println ("Dados cadastrados  ");  Serial.println(" "); listaDado();                    // Informa
    Serial.println(" ");                                                                          // Salta linha
    Serial.print ("Proximo endereco para catalogar  "); Serial.println(addrCat );                 // Informa
    Serial.print ("Digite uma opção na Serial ");                                                 // Informa
  }
  Serial.println(" ");                                                                            // Salta linha
}
// -----------------------------   setup2  ------------------------------------
void setup2 ()                                                     // Funcao setup
{
  EEPROM.begin(1024);
  Serial.println("Digite um valor");
  listaInicio();                                                  // Lista informacoes iniciais
}
// -----------------------------  loop2  ----------------------------------------
void loop2 ()                                                      // Funcao loop
{
  if (Serial.available () > 0)                                    // Se houver dados no serial monitor
  {
    controle = Serial.read();                                     // Leia a serial
    opcoes();                                                     // Cama rotina da opcoes de entradas
  }
}
//---------------------------------------------
void valoresSerial()                                              // Le valores do serial monitor
{
  byte newDado = 0;
  while (Serial.available () > 0)                                 // Enquanto houver dados na serial
  {
    yield();
    controle = Serial.read();                                     // Leia a serial

    newDado = (byte)controle << 4;
    dadoLido = dadoLido << 8;                                     // Desloque 8 bits para esquerda
    dadoLido = dadoLido | controle;                               // Or com nova leitura
    encontrouDado = false;                                        // Nao encontrou dado valido
  }
  if (newDado == 0)
  {
    irrecv.resume();          // Receive the next value
    leRC_Code();
    encontrouDado = false;                                        // Nao encontrou dado valido
  }
}
//---------------------------------------------
void valoresIniciais()                                            // Grava os valores iniciais
{
  qtdeDadoCad = 0;                                                // Zera qtde de dado cadastrado
  EEPROM.put(addrQteCat, qtdeDadoCad);                            // Grava qtde de dados cadastrados
  qtdeDel = 0;                                                    // Zera qtde de dado deletados
  EEPROM.put(addrQtdeDel, qtdeDel);                               // Grava qtde de dados deletados
  EEPROM.commit();
  listaInicio();
}                                                                 // Fim do sendIdentifyCmd
//---------------------------------
void leTeste()                                                                  // Verifica se existe dado valido
{
  valoresSerial();                                                              // Le valores do serial monitor
  procuraEEPROM();                                                              // Verifica se dado existe
  if (encontrouDado == true)                                                    // Se existe o dado executa rotinas do cronometro
  {
    Serial.println ("Dado Valido");                                             // Informa
  }
  else                                                                          // Se nao existe o dado nao executa rotinas do cronometro
  {
    Serial.println ("Dado Invalido");                                           // Informa
  }
}
//---------------------------------
void procuraEEPROM()                                                            // Procura dado cadastrado na EEPROM
{
  for (EEPROMaddr = 0; EEPROMaddr < 300;)                                       // Busca todos enderecos
  {
    EEPROM.get(EEPROMaddr, dadoEEPROM);                                         // Le o dado
    if (dadoLido == dadoEEPROM)                                                 // Se encontrou dado
    {
      encontrouDado = true;                                                     // Habilita informando que existe o dado
      addrDado = EEPROMaddr;                                                    // Endereco onde foi encontrado dado
    }
    EEPROMaddr = EEPROMaddr + 4;                                                // Incrementa de 4 o endereco para ler dado
  }
}
//---------------------------------
void cadastra()                                                                 // Incluir novos dados
{
  valoresSerial();                                                              // Le valores do serial monitor
  procuraEEPROM();                                                              // Verifica se dado existe
  if (encontrouDado == true)                                                    // Se existe o dado nao permite inclusao
  {
    Serial.println(" ");
    Serial.println("Dado ja existe.");
    Serial.println("Nao pode cadastrar novamente. ");                           // Informa
    Serial.println ("Digite uma opção na Serial ");                             // Informa
  }
  else                                                                          // Se nao existe o dado permite inclusao
  {
    if (qtdeDel > 0)                                                            // Se existe espaco de dado deletado
    {
      unsigned long newAddr = 0;                                                // Inicializa variavel temporaria
      EEPROM.get(addrDelAtual, newAddr);                                        // Le o ulyimo endereco deletado e sem uso
      qtdeDel--;                                                                // Decrementa qtde de dado deletado
      EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salva qtde de dado deletado
      EEPROM.put(newAddr, dadoLido);                                            // Salva dado lido no endereco disponivel
      EEPROM.commit();

      Serial.print ("Dado Cadastrado:  ");                                    // Informa
      idDado(dadoLido);                                                         // Lista dado lido
      Serial.println(" ");                                                      // Salta linha
      listaInicio();                                                            // Lista informacoes iniciais
      return;                                                                   // retorna ao loop
    }
    Serial.println(" ");                                                        // Salta linha
    Serial.print("Ultima EEPROM vazia:  ");                                     // Informa
    Serial.println(addrCat);                                                    // Informa
    Serial.println(" ");                                                        // Salta linha

    Serial.print ("  Dado Cadastrado:  ");                                       // Informa
    idDado(dadoLido);                                                           // Informa
    Serial.println(" ");                                                        // Salta linha
    qtdeDadoCad++;                                                              // Incrementa qtde de dados salvos

    if (addrCat >= 300)                                                         // Se o endereço for maior que 300  (mais que 75 dados)
    {
      Serial.println("EEPROM Cheia");                                           // Informa
      Serial.println("Para incluir uma nova");                                  // Informa
      Serial.println("precisa deletar uma gravada");                            // Informa
      return;                                                                   // retorna ao loop
    }
    EEPROM.put(addrCat, dadoLido);                                              // Salva dado lido no endereco disponivel
    EEPROM.put(addrQteCat, qtdeDadoCad);                                        // Salva qrde de dado lido
    EEPROM.commit();
    addrCat = addrCat + 4;                                                      // Incrementa endereco de cadastro de dado
    listaInicio();                                                              // Lista informacoes iniciais
  }
}
//---------------------------------
void deleta()                                                                 // Deletar dados
{
  valoresSerial();                                                            // Le valores do serial monitor
  procuraEEPROM();                                                            // Verifica se dado existe

  unsigned long vazio = 0xFFFFFFFF;                                           // Valor de EEPROM vazia
  if (encontrouDado == true)                                                  // Se existe o dado
  {
    Serial.print ("Deletar dado : "); idDado(dadoLido);                       // Informa
    Serial.println(" ");                                                      // Salta linha
    EEPROM.put(addrDado, vazio);                                              // Grave o valor vazio nele
    Serial.print ("Deletada dado : "); idDado(dadoLido);                      // Informa
    Serial.println(" ");                                                      // Salta linha
    EEPROM.put(addrDelAtual + 4, addrDado);                                   // Salva o endereço da dado deletado

    qtdeDel++;                                                                // Incremen ta a contagem de dado deletado

    EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salve qtde de dado deletado
    EEPROM.commit();

    listaInicio();                                                            // Lista informacoes iniciais
    return;                                                                   // Retorna ao loop
  }
  if (dadoLido != dadoEEPROM)                                                 // Se nao encontrou dado valido
  {
    Serial.println ("dado nao existente");                                    // Dado Invalido
  }
}
//------------------------------------------
void idDado(unsigned long atualDado)                                          // Rotina par imprimie valor do dado
{
  char  valor = 0;                                                            // Zera varialvel
  for (int separa = 3; separa >= 0; separa-- )                                // Executa para os 4 bytes do dado
  {
    valor = atualDado >> 8 * separa;                                          // Seleciona 8 bits
    Serial.print(valor, HEX);                                                     // Imprime
  }
}
//------------------------------------------
void opcoes()                                                                 // Opcoe digitadas no serial monitor
{
  if ((controle == 'i' ) || (controle == 'I' ))                               // Se for i Inclui dado
  {
    cadastra();                                                               // Cadastra novo dado
  }
  if ((controle == 'r' ) || (controle == 'R' ))                               // Se for r Remove dado
  {
    deleta();                                                                 // Deleta dado
  }
  if ((controle == 'l' ) || (controle == 'L' ))                               // Se for l lista dados
  {
    listaDado();                                                               // Lista dados
  }
  if ((controle == 'z' ) || (controle == 'Z' ))                               // Se for z Zera tudo
  {
    gravaEEPROM();                                                            // grava EEPROM toda
  }
  if ((controle == 'p' ) || (controle == 'P' ))                               // Se for p  EPPROM
  {
    listaEEPROM();                                                            // Lista EEPROM
  }
  if ((controle == 't' ) || (controle == 'T' ))                               // Se for t Testa
  {
    leTeste();                                                                // Entrada pra teste
  }
  if ((controle == 'n' ) || (controle == 'N' ))                               // Se for n New
  {
    valoresIniciais();                                                        // Inicializa dados
  }
  if ((controle == 's' ) || (controle == 'S' ))                               // Se for s
  {
    listaInicio();                                                            // lista tudo
  }
  if ((controle == 'x' ) || (controle == 'X' ))                               // Se for z
  {
    sai = 1;                                                                  // Sai da rotina de dados
  }
  if ((controle == 'y' ) || (controle == 'Y' ))                               // Se for y
  {
    SelectRC();                                                              // Selecione RC
  }
}
//-----------------------------------------
void listaDado()                                                               // Lista todos dados
{
//  for (int m = 0; m < (256 * 4);  )                                    // Lista dados com base na quantidade cadastrada
  for (int m = 0; m < (qtdeDadoCad * 4);  )
  {
    Serial.print(m);                                                          // Endereco do dado
    Serial.print("  ");                                                       // Salta linha
    for (int l = 3 + m; l >= 0 + m; l--)                                      // Separa byte
    {
      Serial.print(" ");                                                      // Salta linha
      listEEPROM = EEPROM.read(l);                                            // Le byte
      Serial.print(listEEPROM, HEX);                                              // imprime
    }
    Serial.println("");                                                       // Salta linha
    m = m + 4;                                                                // Incrementa endereco
  }
}
//-----------------------------------------
void listaEEPROM()                                                            // Lista 360 enderecos EEPROM em HEX
{
  for (int m = 0; m < 361; m++ )                                              // Seleciona tods bytes, um mpor vez
  {
    listEEPROM = EEPROM.read(m);                                              // Le a EEPROM
    Serial.print(m);                                                          // Imprime endereco
    Serial.print(" ");                                                        // Salta linha
    Serial.println(listEEPROM, HEX);                                          // Imprime valor em HEX
  }
}
//-----------------------------------------
void gravaEEPROM()                                                            // Grava 0xFF na EEPROM 360 enderecos
{
  for (int m = 0; m < 361; m++ )                                              // Seleciona tods bytes, um mpor vez
  {
    EEPROM.write(m, 0xFF);                                                    // Grava 0xFF na EEPROM
    Serial.print(m);                                                          // Imprime endereco
    Serial.print(" ");                                                        // Salta linha
    Serial.println(listEEPROM, HEX);                                          // Imprime valor em HEX
    EEPROM.commit();
  }
  valoresIniciais();
}