RuiViana

BD_EEPROM.h

May 15th, 2018
140
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.     Celula de 4 bytes
  3.  
  4.     Digite 'i' ou 'I'   para Incluir um  novo dado;
  5.     Digite 'r' ou 'R'   Para delatar um dado;
  6.     Digite 'l' ou 'L'   Para listar todos dados catalogadas;
  7.     Digite 'z' ou 'Z'   Para gravar 0xFF em toda a EEPROM;
  8.     Digite 'p' ou 'P'   Para listar toda EEPROM byte por byte;
  9.     Digite 't' ou 'T'   Para testar um dado individual;
  10.     Digite 'n' ou 'N'   Para criar os valores iniciais.  Zera todos dados;
  11.     Digite 's' ou 'S'   Para imprimir o cabecalho inicial;
  12.     Digite 'x' ou 'X'   Sai da rotina EEPROM
  13.     Digite 'y' ou 'Y'   Selecionar controle remoto
  14.  
  15.  
  16.  
  17. */
  18. #include <EEPROM.h>                                               // Bibioteca para EEPROM
  19.  
  20. uint16_t RECV_PIN = D7;
  21. IRrecv irrecv(RECV_PIN);
  22. decode_results results;
  23. unsigned long cod;
  24.  
  25.  
  26.  
  27. char controle = ' ';                                              // Dados lidos da serial
  28. unsigned long  dadoEEPROM = 0;                                    // Dados do dado lidos da EEPROM
  29. byte listEEPROM = 0;                                              // Dados do dado lidos da EEPROM
  30. unsigned long  dadoLido = 0;                                      // Valor do dado lida na serial
  31. bool leDado = false;                                              // Flag para conferencia de dado
  32. bool encontrouDado = false;                                       // Flag para pesquisa de dado
  33. byte contByte = 0;                                                // Contador de bytes
  34.  
  35. unsigned long EEPROMaddr = 0;                                     // Endereco de procura de dado
  36. unsigned long addrQteCat = 320;                                   // Endereco para guardar qtde de dado catalogado
  37. unsigned long qtdeDadoCad = 0;                                    // Quantidade de dados cadastradas
  38. unsigned long addrCat = 0;                                        // Endereco para catalogar
  39. unsigned long addrQtdeDel = 330;                                  // Endereco para guardar qtde de dados deletados
  40. unsigned long qtdeDel = 0;                                        // Quantidade de dados deletados
  41. unsigned long addrDel = 340;                                      // Endereco para guardar o endereco inicial dos dados deletados
  42. unsigned long addrDelAtual = 0;                                   // Endereco para guardar o endereco inicial dos dados deletados
  43. unsigned long oldAddr = 0;                                        // Endereco onde foi delatado dado
  44. unsigned long addrDado = 0;                                       // Endereco onde foi encontrado dado
  45. bool sai = 0;                                                    // Indicador de status do cronometro
  46. bool tigre;
  47. bool grava = false;
  48.  
  49. void leRC_Code();
  50. void listaInicio();
  51. void valoresSerial();
  52. void valoresIniciais();
  53. void leTeste();
  54. void procuraEEPROM();
  55. void cadastra();
  56. void deleta();
  57. void idDado(unsigned long atualDado);
  58. void opcoes();
  59. void listaDado();
  60. void listaEEPROM();
  61. void gravaEEPROM();
  62. void SelectRC();                                                              // Selecione RC
  63.  
  64. //-------------------------------------------
  65. void leRC_Code()
  66. {
  67.   Serial.println("Aperte uma tecla do RC");
  68.   tigre = 0;
  69.   while (tigre == 0)
  70.   {
  71.     yield();
  72.     if (irrecv.decode(&results))
  73.     {
  74.       cod = results.value;
  75.       tigre = 1;
  76.       irrecv.resume();          // Receive the next value
  77.     }
  78.   }
  79.   Serial.print(" Lido " ); Serial.println(cod, HEX);
  80.   dadoLido = cod;
  81. }
  82. //-------------------------------------------
  83. void SelectRC()                                                              // Selecione RC
  84. {
  85.     Serial.println("Selecione numero do controle remoto de 0 a 9.  ");
  86. }
  87. //-------------------------------------------
  88. void listaInicio()                                                                                // Lista informacoes iniciais
  89. {
  90.   EEPROM.get(addrQteCat, qtdeDadoCad);                                                            // Le da EEPROM Qtde de dado cadastrado
  91.   addrCat = qtdeDadoCad * 4;                                                                      // Atualiza endereco de dado cadastrado
  92.   EEPROM.get(addrQtdeDel, qtdeDel);                                                               // Le da EEPROM Qtde de dado deletado
  93.   addrDelAtual = addrDel + (4 * qtdeDel) - 4;                                                     // Atualiza endereco de dado deletado
  94.   EEPROM.get(addrDelAtual , oldAddr);                                                             // Endereço da ultima dado deletado
  95.  
  96.   if (qtdeDadoCad > 500)                                                                          // Se qtde de dados maior que 500 (Memoria com 0xFFFF...)
  97.   {
  98.     Serial.println (" Inicializar dados. ");                                                      // Informa
  99.     Serial.println (" Para inicializar digite N ");                                               // Informa
  100.     Serial.println (" e depois reset no arduino. ");                                              // Informa
  101.     Serial.println(" ");                                                                          // Salta linha
  102.   }
  103.   else
  104.   {
  105.     Serial.println(" ");
  106.     Serial.print ("  Quantidade total de espaco alocado  "); Serial.println(qtdeDadoCad);         // Informa
  107.     Serial.print ("  Quantidade total de dados deletados  "); Serial.println(qtdeDel);            // Informa
  108.     if (oldAddr == -1)                                                                            // Sem valor 0XFFFF...
  109.     {
  110.       Serial.print ("            Ultimo endereco deletado  "); Serial.println(oldAddr + 1);       // Informa
  111.     }
  112.     else
  113.     {
  114.       Serial.print ("            Ultimo endereco deletado  "); Serial.println(oldAddr);           // Informa
  115.     }
  116.     Serial.println(" ");                                                                          // Salta linha
  117.     Serial.println ("Dados cadastrados  ");  Serial.println(" "); listaDado();                    // Informa
  118.     Serial.println(" ");                                                                          // Salta linha
  119.     Serial.print ("Proximo endereco para catalogar  "); Serial.println(addrCat );                 // Informa
  120.     Serial.print ("Digite uma opção na Serial ");                                                 // Informa
  121.   }
  122.   Serial.println(" ");                                                                            // Salta linha
  123. }
  124. // -----------------------------   setup2  ------------------------------------
  125. void setup2 ()                                                     // Funcao setup
  126. {
  127.   EEPROM.begin(1024);
  128.   Serial.println("Digite um valor");
  129.   listaInicio();                                                  // Lista informacoes iniciais
  130. }
  131. // -----------------------------  loop2  ----------------------------------------
  132. void loop2 ()                                                      // Funcao loop
  133. {
  134.   if (Serial.available () > 0)                                    // Se houver dados no serial monitor
  135.   {
  136.     controle = Serial.read();                                     // Leia a serial
  137.     opcoes();                                                     // Cama rotina da opcoes de entradas
  138.   }
  139. }
  140. //---------------------------------------------
  141. void valoresSerial()                                              // Le valores do serial monitor
  142. {
  143.   byte newDado = 0;
  144.   while (Serial.available () > 0)                                 // Enquanto houver dados na serial
  145.   {
  146.     yield();
  147.     controle = Serial.read();                                     // Leia a serial
  148.  
  149.     newDado = (byte)controle << 4;
  150.     dadoLido = dadoLido << 8;                                     // Desloque 8 bits para esquerda
  151.     dadoLido = dadoLido | controle;                               // Or com nova leitura
  152.     encontrouDado = false;                                        // Nao encontrou dado valido
  153.   }
  154.   if (newDado == 0)
  155.   {
  156.     irrecv.resume();          // Receive the next value
  157.     leRC_Code();
  158.     encontrouDado = false;                                        // Nao encontrou dado valido
  159.   }
  160. }
  161. //---------------------------------------------
  162. void valoresIniciais()                                            // Grava os valores iniciais
  163. {
  164.   qtdeDadoCad = 0;                                                // Zera qtde de dado cadastrado
  165.   EEPROM.put(addrQteCat, qtdeDadoCad);                            // Grava qtde de dados cadastrados
  166.   qtdeDel = 0;                                                    // Zera qtde de dado deletados
  167.   EEPROM.put(addrQtdeDel, qtdeDel);                               // Grava qtde de dados deletados
  168.   EEPROM.commit();
  169.   listaInicio();
  170. }                                                                 // Fim do sendIdentifyCmd
  171. //---------------------------------
  172. void leTeste()                                                                  // Verifica se existe dado valido
  173. {
  174.   valoresSerial();                                                              // Le valores do serial monitor
  175.   procuraEEPROM();                                                              // Verifica se dado existe
  176.   if (encontrouDado == true)                                                    // Se existe o dado executa rotinas do cronometro
  177.   {
  178.     Serial.println ("Dado Valido");                                             // Informa
  179.   }
  180.   else                                                                          // Se nao existe o dado nao executa rotinas do cronometro
  181.   {
  182.     Serial.println ("Dado Invalido");                                           // Informa
  183.   }
  184. }
  185. //---------------------------------
  186. void procuraEEPROM()                                                            // Procura dado cadastrado na EEPROM
  187. {
  188.   for (EEPROMaddr = 0; EEPROMaddr < 300;)                                       // Busca todos enderecos
  189.   {
  190.     EEPROM.get(EEPROMaddr, dadoEEPROM);                                         // Le o dado
  191.     if (dadoLido == dadoEEPROM)                                                 // Se encontrou dado
  192.     {
  193.       encontrouDado = true;                                                     // Habilita informando que existe o dado
  194.       addrDado = EEPROMaddr;                                                    // Endereco onde foi encontrado dado
  195.     }
  196.     EEPROMaddr = EEPROMaddr + 4;                                                // Incrementa de 4 o endereco para ler dado
  197.   }
  198. }
  199. //---------------------------------
  200. void cadastra()                                                                 // Incluir novos dados
  201. {
  202.   valoresSerial();                                                              // Le valores do serial monitor
  203.   procuraEEPROM();                                                              // Verifica se dado existe
  204.   if (encontrouDado == true)                                                    // Se existe o dado nao permite inclusao
  205.   {
  206.     Serial.println(" ");
  207.     Serial.println("Dado ja existe.");
  208.     Serial.println("Nao pode cadastrar novamente. ");                           // Informa
  209.     Serial.println ("Digite uma opção na Serial ");                             // Informa
  210.   }
  211.   else                                                                          // Se nao existe o dado permite inclusao
  212.   {
  213.     if (qtdeDel > 0)                                                            // Se existe espaco de dado deletado
  214.     {
  215.       unsigned long newAddr = 0;                                                // Inicializa variavel temporaria
  216.       EEPROM.get(addrDelAtual, newAddr);                                        // Le o ulyimo endereco deletado e sem uso
  217.       qtdeDel--;                                                                // Decrementa qtde de dado deletado
  218.       EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salva qtde de dado deletado
  219.       EEPROM.put(newAddr, dadoLido);                                            // Salva dado lido no endereco disponivel
  220.       EEPROM.commit();
  221.  
  222.       Serial.print ("Dado Cadastrado:  ");                                    // Informa
  223.       idDado(dadoLido);                                                         // Lista dado lido
  224.       Serial.println(" ");                                                      // Salta linha
  225.       listaInicio();                                                            // Lista informacoes iniciais
  226.       return;                                                                   // retorna ao loop
  227.     }
  228.     Serial.println(" ");                                                        // Salta linha
  229.     Serial.print("Ultima EEPROM vazia:  ");                                     // Informa
  230.     Serial.println(addrCat);                                                    // Informa
  231.     Serial.println(" ");                                                        // Salta linha
  232.  
  233.     Serial.print ("  Dado Cadastrado:  ");                                       // Informa
  234.     idDado(dadoLido);                                                           // Informa
  235.     Serial.println(" ");                                                        // Salta linha
  236.     qtdeDadoCad++;                                                              // Incrementa qtde de dados salvos
  237.  
  238.     if (addrCat >= 300)                                                         // Se o endereço for maior que 300  (mais que 75 dados)
  239.     {
  240.       Serial.println("EEPROM Cheia");                                           // Informa
  241.       Serial.println("Para incluir uma nova");                                  // Informa
  242.       Serial.println("precisa deletar uma gravada");                            // Informa
  243.       return;                                                                   // retorna ao loop
  244.     }
  245.     EEPROM.put(addrCat, dadoLido);                                              // Salva dado lido no endereco disponivel
  246.     EEPROM.put(addrQteCat, qtdeDadoCad);                                        // Salva qrde de dado lido
  247.     EEPROM.commit();
  248.     addrCat = addrCat + 4;                                                      // Incrementa endereco de cadastro de dado
  249.     listaInicio();                                                              // Lista informacoes iniciais
  250.   }
  251. }
  252. //---------------------------------
  253. void deleta()                                                                 // Deletar dados
  254. {
  255.   valoresSerial();                                                            // Le valores do serial monitor
  256.   procuraEEPROM();                                                            // Verifica se dado existe
  257.  
  258.   unsigned long vazio = 0xFFFFFFFF;                                           // Valor de EEPROM vazia
  259.   if (encontrouDado == true)                                                  // Se existe o dado
  260.   {
  261.     Serial.print ("Deletar dado : "); idDado(dadoLido);                       // Informa
  262.     Serial.println(" ");                                                      // Salta linha
  263.     EEPROM.put(addrDado, vazio);                                              // Grave o valor vazio nele
  264.     Serial.print ("Deletada dado : "); idDado(dadoLido);                      // Informa
  265.     Serial.println(" ");                                                      // Salta linha
  266.     EEPROM.put(addrDelAtual + 4, addrDado);                                   // Salva o endereço da dado deletado
  267.  
  268.     qtdeDel++;                                                                // Incremen ta a contagem de dado deletado
  269.  
  270.     EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salve qtde de dado deletado
  271.     EEPROM.commit();
  272.  
  273.     listaInicio();                                                            // Lista informacoes iniciais
  274.     return;                                                                   // Retorna ao loop
  275.   }
  276.   if (dadoLido != dadoEEPROM)                                                 // Se nao encontrou dado valido
  277.   {
  278.     Serial.println ("dado nao existente");                                    // Dado Invalido
  279.   }
  280. }
  281. //------------------------------------------
  282. void idDado(unsigned long atualDado)                                          // Rotina par imprimie valor do dado
  283. {
  284.   char  valor = 0;                                                            // Zera varialvel
  285.   for (int separa = 3; separa >= 0; separa-- )                                // Executa para os 4 bytes do dado
  286.   {
  287.     valor = atualDado >> 8 * separa;                                          // Seleciona 8 bits
  288.     Serial.print(valor, HEX);                                                     // Imprime
  289.   }
  290. }
  291. //------------------------------------------
  292. void opcoes()                                                                 // Opcoe digitadas no serial monitor
  293. {
  294.   if ((controle == 'i' ) || (controle == 'I' ))                               // Se for i Inclui dado
  295.   {
  296.     cadastra();                                                               // Cadastra novo dado
  297.   }
  298.   if ((controle == 'r' ) || (controle == 'R' ))                               // Se for r Remove dado
  299.   {
  300.     deleta();                                                                 // Deleta dado
  301.   }
  302.   if ((controle == 'l' ) || (controle == 'L' ))                               // Se for l lista dados
  303.   {
  304.     listaDado();                                                               // Lista dados
  305.   }
  306.   if ((controle == 'z' ) || (controle == 'Z' ))                               // Se for z Zera tudo
  307.   {
  308.     gravaEEPROM();                                                            // grava EEPROM toda
  309.   }
  310.   if ((controle == 'p' ) || (controle == 'P' ))                               // Se for p  EPPROM
  311.   {
  312.     listaEEPROM();                                                            // Lista EEPROM
  313.   }
  314.   if ((controle == 't' ) || (controle == 'T' ))                               // Se for t Testa
  315.   {
  316.     leTeste();                                                                // Entrada pra teste
  317.   }
  318.   if ((controle == 'n' ) || (controle == 'N' ))                               // Se for n New
  319.   {
  320.     valoresIniciais();                                                        // Inicializa dados
  321.   }
  322.   if ((controle == 's' ) || (controle == 'S' ))                               // Se for s
  323.   {
  324.     listaInicio();                                                            // lista tudo
  325.   }
  326.   if ((controle == 'x' ) || (controle == 'X' ))                               // Se for z
  327.   {
  328.     sai = 1;                                                                  // Sai da rotina de dados
  329.   }
  330.   if ((controle == 'y' ) || (controle == 'Y' ))                               // Se for y
  331.   {
  332.     SelectRC();                                                              // Selecione RC
  333.   }
  334. }
  335. //-----------------------------------------
  336. void listaDado()                                                               // Lista todos dados
  337. {
  338. //  for (int m = 0; m < (256 * 4);  )                                    // Lista dados com base na quantidade cadastrada
  339.   for (int m = 0; m < (qtdeDadoCad * 4);  )  
  340.   {
  341.     Serial.print(m);                                                          // Endereco do dado
  342.     Serial.print("  ");                                                       // Salta linha
  343.     for (int l = 3 + m; l >= 0 + m; l--)                                      // Separa byte
  344.     {
  345.       Serial.print(" ");                                                      // Salta linha
  346.       listEEPROM = EEPROM.read(l);                                            // Le byte
  347.       Serial.print(listEEPROM, HEX);                                              // imprime
  348.     }
  349.     Serial.println("");                                                       // Salta linha
  350.     m = m + 4;                                                                // Incrementa endereco
  351.   }
  352. }
  353. //-----------------------------------------
  354. void listaEEPROM()                                                            // Lista 360 enderecos EEPROM em HEX
  355. {
  356.   for (int m = 0; m < 361; m++ )                                              // Seleciona tods bytes, um mpor vez
  357.   {
  358.     listEEPROM = EEPROM.read(m);                                              // Le a EEPROM
  359.     Serial.print(m);                                                          // Imprime endereco
  360.     Serial.print(" ");                                                        // Salta linha
  361.     Serial.println(listEEPROM, HEX);                                          // Imprime valor em HEX
  362.   }
  363. }
  364. //-----------------------------------------
  365. void gravaEEPROM()                                                            // Grava 0xFF na EEPROM 360 enderecos
  366. {
  367.   for (int m = 0; m < 361; m++ )                                              // Seleciona tods bytes, um mpor vez
  368.   {
  369.     EEPROM.write(m, 0xFF);                                                    // Grava 0xFF na EEPROM
  370.     Serial.print(m);                                                          // Imprime endereco
  371.     Serial.print(" ");                                                        // Salta linha
  372.     Serial.println(listEEPROM, HEX);                                          // Imprime valor em HEX
  373.     EEPROM.commit();
  374.   }
  375.   valoresIniciais();
  376. }
RAW Paste Data