RuiViana

Controle_RFID

Apr 29th, 2018
149
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  
  3.     Digite 'i' ou 'I'   para Incluir uma nova tag;
  4.     Digite 'r' ou 'R'   Para delatar uma tag;
  5.     Digite 'l' ou 'L'   Para listar todas tags catalogadas;
  6.     Digite 'z' ou 'Z'   Para gravar 0xFF em toda a EEPROM;
  7.     Digite 'p' ou 'P'   Para listar toda EEPROM byte por byte;
  8.     Digite 't' ou 'T'   Para testar uma tag individual;
  9.     Digite 'n' ou 'N'   Para criar os valores iniciais.  Zera todas tags;
  10.     Digite 's' ou 'S'   Para imprimir o cabecalho inicial;
  11.  
  12. */
  13. #include <EEPROM.h>                                               // Bibioteca para EEPROM
  14. #include <SoftwareSerial.h>                                       // Bibioteca para a serial via software
  15.  
  16. SoftwareSerial mySerial (2, 3);                                   // Definicao dos pinos para o software serial
  17. unsigned char incomingByte;                                       // Variavel para receber dados da antena de RFID
  18.  
  19. #define LEDaz 6                                                   // LED azul aguarda leitura de tag
  20. #define LEDvm 7                                                   // LED vermelho tag invalida
  21. #define LEDvd 8                                                   // LED verde tag lida com sucesso
  22. #define LEDam 9                                                   // LED amarelo tag gravada com sucesso
  23. char controle = ' ';                                              // Dados lidos da serial
  24. unsigned long  tagEEPROM = 0;                                     // Dados da tag lidos da EEPROM
  25. byte listEEPROM = 0;                                              // Dados da tag lidos da EEPROM
  26. unsigned long  tagLida = 0;                                       // Valor da tag lida na serial
  27. bool leTag = false;                                               // Flag para conferencia de tag
  28. bool encontrouTag = false;                                        // Flag para pesquisa de tag
  29. byte contByte = 0;                                                // Contador de bytes
  30.  
  31. unsigned long EEPROMaddr = 0;                                     // Endereco de procura de tag
  32. unsigned long addrQteCat = 320;                                   // Endereco para guardar qtde de tag catalogada
  33. unsigned long qtdeTagCad = 0;                                     // Quantidade de tags cadastradas
  34. unsigned long addrCat = 0;                                        // Endereco para catalogar
  35. unsigned long addrQtdeDel = 330;                                  // Endereco para guardar qtde de tags deletadas
  36. unsigned long qtdeDel = 0;                                        // Quantidade de tags deletadas
  37. unsigned long addrDel = 340;                                      // EnAdereco para guardar o endereco inicial das tags deletadas
  38. unsigned long addrDelAtual = 0;                                   // EnAdereco para guardar o endereco inicial das tags deletadas
  39. unsigned long oldAddr = 0;                                        // Endereco onde foi delatada tag
  40. unsigned long addrTag = 0;                                        // Endereco onde foi encontrada tag
  41. int crono = 0;                                                    // Indicador de status do cronometro
  42. // -----------------------------   setup  ------------------------------------
  43. void setup ()                                                     // Funcao setup
  44. {
  45.   Serial.begin (9600);                                            // Inicialisa o monitor
  46.   mySerial.begin (9600);                                          // Inicialisa a software serial
  47.   pinMode(LEDaz, OUTPUT);                                         // Port como saida
  48.   pinMode(LEDvm, OUTPUT);                                         // Port como saida
  49.   pinMode(LEDvd, OUTPUT);                                         // Port como saida
  50.   pinMode(LEDam, OUTPUT);                                         // Port como saida
  51.   listaInicio();                                                  // Lista informacoes iniciais
  52. }
  53. // -----------------------------  loop  ----------------------------------------
  54. void loop ()                                                      // Funcao loop
  55. {
  56.   if (Serial.available () > 0)                                    // Se houver dados no serial monitor
  57.   {
  58.     controle = Serial.read();                                     // Leia a serial
  59.     opcoes();                                                     // Cama rotina da opcoes de entradas
  60.   }
  61.   digitalWrite(LEDaz, HIGH);                                      // Pronto pra ler tag
  62.   sendIdentifyCmd ();                                             // Envia comando de leitura de tag
  63.   delay (2);                                                      // Delay
  64.   while (mySerial.available () > 0)                               // Se houver leitura de tag da antena
  65.   {
  66.     tagLida = tagLida << 8;                                       // Desloque 8 bits para esquerda
  67.     incomingByte = mySerial.read ();                              // Leia a tag
  68.     Serial.println (incomingByte, HEX);                           // Imprime no monitor
  69.     tagLida = tagLida | incomingByte;                             // Or com nova leitura
  70.     contByte++;                                                   // Incrementa contador de bytes
  71.     leTag = true;                                                 // Habilita conferencia de tag
  72.   }                                                               // Fim do if - Se houver leitura de tag
  73.   delay (500);                                                    // Delay de 500 mseg
  74.  
  75.   if (leTag == true)                                              // Se esta habilitado conferir tag
  76.   {
  77.     procuraEEPROM();                                              // Verifica se tag existe
  78.     if (encontrouTag == true)                                     // Se existe a tag executa rotinas do cronometro
  79.     {
  80.       Serial.println ("Tag Valida");                              // Informa
  81.       executa();                                                  // Executa rotina do cronometro
  82.     }
  83.     else                                                          // Se nao existe a tag nao executa rotinas do cronometro
  84.     {
  85.       Serial.println ("Tag Invalida");                            // Informa
  86.       digitalWrite(LEDvm, HIGH);                                  // Informa tag Invalida
  87.     }
  88.     leTag = false;                                                // Desabilita conferencia de tag
  89.     contByte = 0;                                                 // Zera contador de bytes
  90.     encontrouTag = false;                                         // Desabilita confirmacao de tag existente
  91.   }
  92. }
  93. //---------------------------------------------
  94. void valoresSerial()                                              // Le valores do serial monitor
  95. {
  96.   while (Serial.available () > 0)                                 // Enquanto houver dados na serial
  97.   {
  98.     controle = Serial.read();                                     // Leia a serial
  99.     tagLida = tagLida << 8;                                       // Desloque 8 bits para esquerda
  100.     tagLida = tagLida | controle;                                 // Or com nova leitura
  101.     encontrouTag = false;                                         // Nao encontrou tag valida
  102.   }
  103. }
  104. //---------------------------------------------
  105. void valoresIniciais()                                            // Grava os valores iniciais
  106. {
  107.   qtdeTagCad = 0;                                                 // Zera qtde de tag cadastrada
  108.   EEPROM.put(addrQteCat, qtdeTagCad);                             // Grava qtde de tags cadastradas
  109.   qtdeDel = 0;                                                    // Zera qtde de tag deletadas
  110.   EEPROM.put(addrQtdeDel, qtdeDel);                               // Grava qtde de tags deletadas
  111.   listaInicio();
  112. }
  113. // ----------------------------- sendIdentifyCmd  ----------------------------
  114. void sendIdentifyCmd ()                                           // Funcao para comando de leitura de tag
  115. {
  116.   mySerial.write (0x7c);                                          // Sequencia de comandos para ler tag
  117.   mySerial.write (0xff);                                          //
  118.   mySerial.write (0xff);                                          //
  119.   mySerial.write (0x01);                                          //
  120.   mySerial.write (0x08);                                          //
  121.   mySerial.write (0x7d);                                          //
  122. }                                                                 // Fim do sendIdentifyCmd
  123. //-------------------------------------------
  124. void listaInicio()                                                                                // Lista informacoes iniciais
  125. {
  126.   EEPROM.get(addrQteCat, qtdeTagCad);                                                             // Le da EEPROM Qtde de tag cadastrada
  127.   addrCat = qtdeTagCad * 4;                                                                       // Atualiza endereco de tag cadastrada
  128.   EEPROM.get(addrQtdeDel, qtdeDel);                                                               // Le da EEPROM Qtde de tag deletada                                                 // Valor da quantidade de tag deletada
  129.   addrDelAtual = addrDel + (4 * qtdeDel) - 4;                                                     // Atualiza endereco de tag deletada
  130.   EEPROM.get(addrDelAtual , oldAddr);                                                             // Endereço da ultima tag deletada
  131.  
  132.   if (qtdeTagCad > 500)                                                                           // Se qtde de tags maior que 500 (Memoria com 0xFFFF...)
  133.   {
  134.     Serial.println (" Inicializar dados. ");                                                      // Informa
  135.     Serial.println (" Para inicializar digite I ");                                               // Informa
  136.     Serial.println (" e depois reset no arduino. ");                                              // Informa
  137.     Serial.println(" ");                                                                          // Salta linha
  138.   }
  139.   else
  140.   {
  141.     Serial.print ("  Quantidade total de espaco alocado  "); Serial.println(qtdeTagCad);          // Informa
  142.     Serial.print ("  Qauntidade total de tags deletadas  "); Serial.println(qtdeDel);             // Informa
  143.     if (oldAddr == -1)                                                                            // Sem valor 0XFFFF...
  144.     {
  145.       Serial.print ("            Ultimo endereco deletado  "); Serial.println(oldAddr + 1);       // Informa
  146.     }
  147.     else
  148.     {
  149.       Serial.print ("            Ultimo endereco deletado  "); Serial.println(oldAddr);           // Informa
  150.     }
  151.     Serial.println(" ");                                                                          // Salta linha
  152.     Serial.println ("Tags cadastradas  ");  Serial.println(" "); listaTag();                      // Informa
  153.     Serial.println(" ");                                                                          // Salta linha
  154.     Serial.print ("Proximo endereco para catalogar  "); Serial.println(addrCat );                 // Informa
  155.   }
  156.   Serial.println(" ");                                                                            // Salta linha
  157. }
  158. //---------------------------------
  159. void leTeste()                                                                  // Verifica se existe tag valida
  160. {
  161.   valoresSerial();                                                              // Le valores do serial monitor
  162.   procuraEEPROM();                                                              // Verifica se tag existe
  163.   if (encontrouTag == true)                                                     // Se existe a tag executa rotinas do cronometro
  164.   {
  165.     Serial.println ("Tag Valida");                                              // Informa
  166.     executa();                                                                  // Executa rotinas do cronometro
  167.   }
  168.   else                                                                          // Se nao existe a tag nao executa rotinas do cronometro
  169.   {
  170.     Serial.println ("Tag Invalida");                                            // Informa
  171.     digitalWrite(LEDvm, HIGH);                                                  // Informa tag Invalida
  172.   }
  173. }
  174. //---------------------------------
  175. void procuraEEPROM()                                                            // Procura tag cadastrada na EEPROM
  176. {
  177.   for (EEPROMaddr = 0; EEPROMaddr < 300;)                                       // Busca todos enderecos
  178.   {
  179.     EEPROM.get(EEPROMaddr, tagEEPROM);                                          // Le a tag
  180.     if (tagLida == tagEEPROM)                                                   // Se encontrou tag
  181.     {
  182.       encontrouTag = true;                                                      // Habilita informando que existe a tag
  183.       addrTag = EEPROMaddr;                                                     // Endereco onde foi encontrada tag
  184.     }
  185.     EEPROMaddr = EEPROMaddr + 4;                                                // Incrementa de 4 o endereco para ler tag
  186.   }
  187. }
  188. //---------------------------------
  189. void executa()                                                                  // Executa rotinas do cronometro
  190. {
  191.   digitalWrite(LEDvd, HIGH);                                                    // LEDs tag lida com sucesso
  192.   digitalWrite(LEDvm, LOW);
  193.   digitalWrite(LEDam, LOW);
  194.   digitalWrite(LEDaz, LOW);
  195.   delay(600);                                                                   // Teste
  196.   crono++;                                                                      // Incrfementa contagem de crono
  197.   Serial.println(crono);                                                        // Teste
  198.   if (crono > 2) crono = 0;                                                     // Se contagem crono maior que 2 volta a zero
  199.   digitalWrite(LEDaz, HIGH);                                                    // Pronto pra ler tag
  200.   digitalWrite(LEDvd, LOW);
  201.   switch (crono)                                                                // Seleciona a opcao do crono
  202.   {
  203.     case 0:
  204.       // Inicia cronometro
  205.       break;                                                                    // Saia do switch
  206.     case 1:
  207.       // Cronometro parcial
  208.       break;                                                                    // Saia do switch
  209.     case 2:
  210.       // Para cronometro
  211.       break;                                                                    // Saia do switch
  212.   }
  213. }
  214. //---------------------------------
  215. void cadastra()                                                                 // Incluir novas tags
  216. {
  217.   valoresSerial();                                                              // Le valores do serial monitor
  218.   procuraEEPROM();                                                              // Verifica se tag existe
  219.   if (encontrouTag == true)                                                     // Se existe a tag nao permite inclusao
  220.   {
  221.     Serial.println("Tag ja existe. Nao pode cadstra novamente. ");              // Informa
  222.     digitalWrite(LEDvm, HIGH);                                                  // Informa tag Invalida
  223.   }
  224.   else                                                                          // Se nao existe a tag permite inclusao
  225.   {
  226.     if (qtdeDel > 0)                                                            // Se existe espaco de tag deletada
  227.     {
  228.       unsigned long newAddr = 0;                                                // Inicializa variavel temporaria
  229.       EEPROM.get(addrDelAtual, newAddr);                                        // Le o ulyimo endereco deletado e sem uso
  230.       Serial.print("Endereco addeDel "); Serial.println(addrDelAtual);          // Informa
  231.       Serial.print("Endereco recuperado "); Serial.println(newAddr);            // Informa
  232.       qtdeDel--;                                                                // Decrementa qtde de tag deletada
  233.       EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salva qtde de tag deletada
  234.       EEPROM.put(newAddr, tagLida);                                             // Salva tag lida no endereco disponivel
  235.       idTag(tagLida);                                                           // Lista tag lida
  236.       Serial.println ("  Tag Cadastrada");                                      // Informa
  237.       Serial.println(" ");                                                      // Salta linha
  238.       digitalWrite(LEDam, HIGH);                                                // LED amarelo tag gravada com sucesso
  239.       digitalWrite(LEDvm, LOW);                                                 // Informa tag valida
  240.       listaInicio();                                                            // Lista informacoes iniciais
  241.       return;                                                                   // retorna ao loop
  242.     }
  243.     Serial.println(" ");                                                        // Salta linha
  244.     Serial.print("Ultima EEPROM vazia:  ");                                     // Informa
  245.     Serial.println(addrCat);                                                    // Informa
  246.     Serial.println(" ");                                                        // Salta linha
  247.     idTag(tagLida);                                                             // Informa
  248.     Serial.println ("  Tag Cadastrada");                                        // Informa
  249.     Serial.println(" ");                                                        // Salta linha
  250.     qtdeTagCad++;                                                               // Incrementa qtde de tags salvas
  251.  
  252.     if (addrCat >= 300)                                                         // Se o endereço for maior que 300  (mais que 75 tags)
  253.     {
  254.       Serial.println("EEPROM Cheia");                                           // Informa
  255.       Serial.println("Para incluir uma nova");                                  // Informa
  256.       Serial.println("precisa deletar uma gravada");                            // Informa
  257.       return;                                                                   // retorna ao loop
  258.     }
  259.     EEPROM.put(addrCat, tagLida);                                               // Salva tag lida no endereco disponivel
  260.     EEPROM.put(addrQteCat, qtdeTagCad);                                         // Salva qrde de tag lida
  261.     addrCat = addrCat + 4;                                                      // Incrementa endereco de cadastro de tag
  262.     digitalWrite(LEDam, HIGH);                                                  // LED amarelo tag gravada com sucesso
  263.     digitalWrite(LEDvm, LOW);                                                   // Indica tag valida
  264.     listaInicio();                                                              // Lista informacoes iniciais
  265.   }
  266. }
  267. //---------------------------------
  268. void deleta()                                                                 // Deletar tags
  269. {
  270.   valoresSerial();                                                            // Le valores do serial monitor
  271.   procuraEEPROM();                                                            // Verifica se tag existe
  272.  
  273.   unsigned long vazio = 0xFFFFFFFF;                                           // Valor de EEPROM vazia
  274.   if (encontrouTag == true)                                                   // Se existe a tag
  275.   {
  276.     Serial.print ("Deletar tag : "); idTag(tagLida);                          // Informa
  277.     Serial.println(" ");                                                      // Salta linha
  278.     EEPROM.put(addrTag, vazio);                                               // Grave o valor vazio nele
  279.     Serial.print ("Deletada tag : "); idTag(tagLida);                         // Informa
  280.     Serial.println(" ");                                                      // Salta linha
  281.     EEPROM.put(addrDelAtual + 4, addrTag);                                    // Salva o endereço da tag deletada
  282.  
  283.     qtdeDel++;                                                                // Incremen ta a contagem de tag deletada
  284.  
  285.     EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salve qtde de tag deletada
  286.  
  287.     digitalWrite(LEDam, HIGH);                                                // LED amarelo tag gravada com sucesso
  288.     digitalWrite(LEDvm, LOW);                                                 // Tag valida
  289.     listaInicio();                                                            // Lista informacoes iniciais
  290.     return;                                                                   // Retorna ao loop
  291.   }
  292.   if (tagLida != tagEEPROM)                                                   // Se nao encontrou tag valida
  293.   {
  294.     Serial.println ("Tag nao existente");                                     // Tag Invalida
  295.     digitalWrite(LEDam, LOW);                                                 // Tag Invalida
  296.     digitalWrite(LEDvm, HIGH);                                                // Tag Invalida
  297.   }
  298. }
  299. //------------------------------------------
  300. void idTag(unsigned long atualTag)                                            // Rotina par imprimie valor da tag
  301. {
  302.   char  valor = 0;                                                            // Zera varialvel
  303.   for (int separa = 3; separa >= 0; separa-- )                                // Executa para os 4 bytes da tag
  304.   {
  305.     valor = atualTag >> 8 * separa;                                           // Seleciona 8 bits
  306.     Serial.print(valor);                                                      // Imprime
  307.   }
  308. }
  309. //------------------------------------------
  310. void opcoes()                                                                 // Opcoe digitadas no serial monitor
  311. {
  312.   if ((controle == 'i' ) || (controle == 'I' ))                               // Se for i Inclui Tag
  313.   {
  314.     cadastra();                                                               // Cadastra nova tag
  315.   }
  316.   if ((controle == 'r' ) || (controle == 'R' ))                               // Se for r Remove tag
  317.   {
  318.     deleta();                                                                 // Deleta tag
  319.   }
  320.   if ((controle == 'l' ) || (controle == 'L' ))                               // Se for l lista tags
  321.   {
  322.     listaTag();                                                               // Lista tags
  323.   }
  324.   if ((controle == 'z' ) || (controle == 'Z' ))                               // Se for z Zera tudo
  325.   {
  326.     gravaEEPROM();                                                            // grava EEPROM toda
  327.   }
  328.   if ((controle == 'p' ) || (controle == 'P' ))                               // Se for p  EPPROM
  329.   {
  330.     listaEEPROM();                                                            // Lista EEPROM
  331.   }
  332.   if ((controle == 't' ) || (controle == 'T' ))                               // Se for t Testa
  333.   {
  334.     leTeste();                                                                // Entrada pra teste
  335.   }
  336.   if ((controle == 'n' ) || (controle == 'N' ))                               // Se for n New
  337.   {
  338.     valoresIniciais();                                                        // Inicializa dados
  339.   }
  340.   if ((controle == 's' ) || (controle == 'S' ))                               // Se for s
  341.   {
  342.     listaInicio();                                                            // lista tudo
  343.   }
  344. }
  345. //-----------------------------------------
  346. void listaTag()                                                               // Lista todas tags
  347. {
  348.   for (int m = 0; m < (qtdeTagCad * 4);  )                                    // Lista tags com base na quantidade cadastrada
  349.   {
  350.     Serial.print(m);                                                          // Endereco da tag
  351.     Serial.print("  ");                                                       // Salta linha
  352.     for (int l = 3 + m; l >= 0 + m; l--)                                      // Separa byte
  353.     {
  354.       Serial.print(" ");                                                      // Salta linha
  355.       listEEPROM = EEPROM.read(l);                                            // Le byte
  356.       Serial.write(listEEPROM);                                               // imprime
  357.     }
  358.     Serial.println("");                                                       // Salta linha
  359.     m = m + 4;                                                                // Incrementa endereco
  360.   }
  361. }
  362. //-----------------------------------------
  363. void listaEEPROM()                                                            // Lista 360 enderecos EEPROM em HEX
  364. {
  365.   for (int m = 0; m < 361; m++ )                                              // Seleciona tods bytes, um mpor vez
  366.   {
  367.     listEEPROM = EEPROM.read(m);                                              // Le a EEPROM
  368.     Serial.print(m);                                                          // Imprime endereco
  369.     Serial.print(" ");                                                        // Salta linha
  370.     Serial.println(listEEPROM, HEX);                                          // Imprime valor em HEX
  371.   }
  372. }
  373. //-----------------------------------------
  374. void gravaEEPROM()                                                            // Grava 0xFF na EEPROM 360 enderecos
  375. {
  376.   for (int m = 0; m < 361; m++ )                                              // Seleciona tods bytes, um mpor vez
  377.   {
  378.     EEPROM.write(m, 0xFF);                                                    // Grava 0xFF na EEPROM
  379.     Serial.print(m);                                                          // Imprime endereco
  380.     Serial.print(" ");                                                        // Salta linha
  381.     Serial.println(listEEPROM, HEX);                                          // Imprime valor em HEX
  382.   }
  383.   valoresIniciais();
  384. }
RAW Paste Data