Controle_RFID

/*

    Digite 'i' ou 'I'   para Incluir uma nova tag;
    Digite 'r' ou 'R'   Para delatar uma tag;
    Digite 'l' ou 'L'   Para listar todas tags 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 uma tag individual;
    Digite 'n' ou 'N'   Para criar os valores iniciais.  Zera todas tags;
    Digite 's' ou 'S'   Para imprimir o cabecalho inicial;

*/
#include <EEPROM.h>                                               // Bibioteca para EEPROM
#include <SoftwareSerial.h>                                       // Bibioteca para a serial via software

SoftwareSerial mySerial (2, 3);                                   // Definicao dos pinos para o software serial
unsigned char incomingByte;                                       // Variavel para receber dados da antena de RFID

#define LEDaz 6                                                   // LED azul aguarda leitura de tag
#define LEDvm 7                                                   // LED vermelho tag invalida
#define LEDvd 8                                                   // LED verde tag lida com sucesso
#define LEDam 9                                                   // LED amarelo tag gravada com sucesso
char controle = ' ';                                              // Dados lidos da serial
unsigned long  tagEEPROM = 0;                                     // Dados da tag lidos da EEPROM
byte listEEPROM = 0;                                              // Dados da tag lidos da EEPROM
unsigned long  tagLida = 0;                                       // Valor da tag lida na serial
bool leTag = false;                                               // Flag para conferencia de tag
bool encontrouTag = false;                                        // Flag para pesquisa de tag
byte contByte = 0;                                                // Contador de bytes

unsigned long EEPROMaddr = 0;                                     // Endereco de procura de tag
unsigned long addrQteCat = 320;                                   // Endereco para guardar qtde de tag catalogada
unsigned long qtdeTagCad = 0;                                     // Quantidade de tags cadastradas
unsigned long addrCat = 0;                                        // Endereco para catalogar
unsigned long addrQtdeDel = 330;                                  // Endereco para guardar qtde de tags deletadas
unsigned long qtdeDel = 0;                                        // Quantidade de tags deletadas
unsigned long addrDel = 340;                                      // EnAdereco para guardar o endereco inicial das tags deletadas
unsigned long addrDelAtual = 0;                                   // EnAdereco para guardar o endereco inicial das tags deletadas
unsigned long oldAddr = 0;                                        // Endereco onde foi delatada tag
unsigned long addrTag = 0;                                        // Endereco onde foi encontrada tag
int crono = 0;                                                    // Indicador de status do cronometro
// -----------------------------   setup  ------------------------------------
void setup ()                                                     // Funcao setup
{
  Serial.begin (9600);                                            // Inicialisa o monitor
  mySerial.begin (9600);                                          // Inicialisa a software serial
  pinMode(LEDaz, OUTPUT);                                         // Port como saida
  pinMode(LEDvm, OUTPUT);                                         // Port como saida
  pinMode(LEDvd, OUTPUT);                                         // Port como saida
  pinMode(LEDam, OUTPUT);                                         // Port como saida
  listaInicio();                                                  // Lista informacoes iniciais
}
// -----------------------------  loop  ----------------------------------------
void loop ()                                                      // 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
  }
  digitalWrite(LEDaz, HIGH);                                      // Pronto pra ler tag
  sendIdentifyCmd ();                                             // Envia comando de leitura de tag
  delay (2);                                                      // Delay
  while (mySerial.available () > 0)                               // Se houver leitura de tag da antena
  {
    tagLida = tagLida << 8;                                       // Desloque 8 bits para esquerda
    incomingByte = mySerial.read ();                              // Leia a tag
    Serial.println (incomingByte, HEX);                           // Imprime no monitor
    tagLida = tagLida | incomingByte;                             // Or com nova leitura
    contByte++;                                                   // Incrementa contador de bytes
    leTag = true;                                                 // Habilita conferencia de tag
  }                                                               // Fim do if - Se houver leitura de tag
  delay (500);                                                    // Delay de 500 mseg

  if (leTag == true)                                              // Se esta habilitado conferir tag
  {
    procuraEEPROM();                                              // Verifica se tag existe
    if (encontrouTag == true)                                     // Se existe a tag executa rotinas do cronometro
    {
      Serial.println ("Tag Valida");                              // Informa
      executa();                                                  // Executa rotina do cronometro
    }
    else                                                          // Se nao existe a tag nao executa rotinas do cronometro
    {
      Serial.println ("Tag Invalida");                            // Informa
      digitalWrite(LEDvm, HIGH);                                  // Informa tag Invalida
    }
    leTag = false;                                                // Desabilita conferencia de tag
    contByte = 0;                                                 // Zera contador de bytes
    encontrouTag = false;                                         // Desabilita confirmacao de tag existente
  }
}
//---------------------------------------------
void valoresSerial()                                              // Le valores do serial monitor
{
  while (Serial.available () > 0)                                 // Enquanto houver dados na serial
  {
    controle = Serial.read();                                     // Leia a serial
    tagLida = tagLida << 8;                                       // Desloque 8 bits para esquerda
    tagLida = tagLida | controle;                                 // Or com nova leitura
    encontrouTag = false;                                         // Nao encontrou tag valida
  }
}
//---------------------------------------------
void valoresIniciais()                                            // Grava os valores iniciais
{
  qtdeTagCad = 0;                                                 // Zera qtde de tag cadastrada
  EEPROM.put(addrQteCat, qtdeTagCad);                             // Grava qtde de tags cadastradas
  qtdeDel = 0;                                                    // Zera qtde de tag deletadas
  EEPROM.put(addrQtdeDel, qtdeDel);                               // Grava qtde de tags deletadas
  listaInicio();
}
// ----------------------------- sendIdentifyCmd  ----------------------------
void sendIdentifyCmd ()                                           // Funcao para comando de leitura de tag
{
  mySerial.write (0x7c);                                          // Sequencia de comandos para ler tag
  mySerial.write (0xff);                                          //
  mySerial.write (0xff);                                          //
  mySerial.write (0x01);                                          //
  mySerial.write (0x08);                                          //
  mySerial.write (0x7d);                                          //
}                                                                 // Fim do sendIdentifyCmd
//-------------------------------------------
void listaInicio()                                                                                // Lista informacoes iniciais
{
  EEPROM.get(addrQteCat, qtdeTagCad);                                                             // Le da EEPROM Qtde de tag cadastrada
  addrCat = qtdeTagCad * 4;                                                                       // Atualiza endereco de tag cadastrada
  EEPROM.get(addrQtdeDel, qtdeDel);                                                               // Le da EEPROM Qtde de tag deletada                                                 // Valor da quantidade de tag deletada
  addrDelAtual = addrDel + (4 * qtdeDel) - 4;                                                     // Atualiza endereco de tag deletada
  EEPROM.get(addrDelAtual , oldAddr);                                                             // Endereço da ultima tag deletada

  if (qtdeTagCad > 500)                                                                           // Se qtde de tags maior que 500 (Memoria com 0xFFFF...)
  {
    Serial.println (" Inicializar dados. ");                                                      // Informa
    Serial.println (" Para inicializar digite I ");                                               // Informa
    Serial.println (" e depois reset no arduino. ");                                              // Informa
    Serial.println(" ");                                                                          // Salta linha
  }
  else
  {
    Serial.print ("  Quantidade total de espaco alocado  "); Serial.println(qtdeTagCad);          // Informa
    Serial.print ("  Qauntidade total de tags deletadas  "); 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 ("Tags cadastradas  ");  Serial.println(" "); listaTag();                      // Informa
    Serial.println(" ");                                                                          // Salta linha
    Serial.print ("Proximo endereco para catalogar  "); Serial.println(addrCat );                 // Informa
  }
  Serial.println(" ");                                                                            // Salta linha
}
//---------------------------------
void leTeste()                                                                  // Verifica se existe tag valida
{
  valoresSerial();                                                              // Le valores do serial monitor
  procuraEEPROM();                                                              // Verifica se tag existe
  if (encontrouTag == true)                                                     // Se existe a tag executa rotinas do cronometro
  {
    Serial.println ("Tag Valida");                                              // Informa
    executa();                                                                  // Executa rotinas do cronometro
  }
  else                                                                          // Se nao existe a tag nao executa rotinas do cronometro
  {
    Serial.println ("Tag Invalida");                                            // Informa
    digitalWrite(LEDvm, HIGH);                                                  // Informa tag Invalida
  }
}
//---------------------------------
void procuraEEPROM()                                                            // Procura tag cadastrada na EEPROM
{
  for (EEPROMaddr = 0; EEPROMaddr < 300;)                                       // Busca todos enderecos
  {
    EEPROM.get(EEPROMaddr, tagEEPROM);                                          // Le a tag
    if (tagLida == tagEEPROM)                                                   // Se encontrou tag
    {
      encontrouTag = true;                                                      // Habilita informando que existe a tag
      addrTag = EEPROMaddr;                                                     // Endereco onde foi encontrada tag
    }
    EEPROMaddr = EEPROMaddr + 4;                                                // Incrementa de 4 o endereco para ler tag
  }
}
//---------------------------------
void executa()                                                                  // Executa rotinas do cronometro
{
  digitalWrite(LEDvd, HIGH);                                                    // LEDs tag lida com sucesso
  digitalWrite(LEDvm, LOW);
  digitalWrite(LEDam, LOW);
  digitalWrite(LEDaz, LOW);
  delay(600);                                                                   // Teste
  crono++;                                                                      // Incrfementa contagem de crono
  Serial.println(crono);                                                        // Teste
  if (crono > 2) crono = 0;                                                     // Se contagem crono maior que 2 volta a zero
  digitalWrite(LEDaz, HIGH);                                                    // Pronto pra ler tag
  digitalWrite(LEDvd, LOW);
  switch (crono)                                                                // Seleciona a opcao do crono
  {
    case 0:
      // Inicia cronometro
      break;                                                                    // Saia do switch
    case 1:
      // Cronometro parcial
      break;                                                                    // Saia do switch
    case 2:
      // Para cronometro
      break;                                                                    // Saia do switch
  }
}
//---------------------------------
void cadastra()                                                                 // Incluir novas tags
{
  valoresSerial();                                                              // Le valores do serial monitor
  procuraEEPROM();                                                              // Verifica se tag existe
  if (encontrouTag == true)                                                     // Se existe a tag nao permite inclusao
  {
    Serial.println("Tag ja existe. Nao pode cadstra novamente. ");              // Informa
    digitalWrite(LEDvm, HIGH);                                                  // Informa tag Invalida
  }
  else                                                                          // Se nao existe a tag permite inclusao
  {
    if (qtdeDel > 0)                                                            // Se existe espaco de tag deletada
    {
      unsigned long newAddr = 0;                                                // Inicializa variavel temporaria
      EEPROM.get(addrDelAtual, newAddr);                                        // Le o ulyimo endereco deletado e sem uso
      Serial.print("Endereco addeDel "); Serial.println(addrDelAtual);          // Informa
      Serial.print("Endereco recuperado "); Serial.println(newAddr);            // Informa
      qtdeDel--;                                                                // Decrementa qtde de tag deletada
      EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salva qtde de tag deletada
      EEPROM.put(newAddr, tagLida);                                             // Salva tag lida no endereco disponivel
      idTag(tagLida);                                                           // Lista tag lida
      Serial.println ("  Tag Cadastrada");                                      // Informa
      Serial.println(" ");                                                      // Salta linha
      digitalWrite(LEDam, HIGH);                                                // LED amarelo tag gravada com sucesso
      digitalWrite(LEDvm, LOW);                                                 // Informa tag valida
      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
    idTag(tagLida);                                                             // Informa
    Serial.println ("  Tag Cadastrada");                                        // Informa
    Serial.println(" ");                                                        // Salta linha
    qtdeTagCad++;                                                               // Incrementa qtde de tags salvas

    if (addrCat >= 300)                                                         // Se o endereço for maior que 300  (mais que 75 tags)
    {
      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, tagLida);                                               // Salva tag lida no endereco disponivel
    EEPROM.put(addrQteCat, qtdeTagCad);                                         // Salva qrde de tag lida
    addrCat = addrCat + 4;                                                      // Incrementa endereco de cadastro de tag
    digitalWrite(LEDam, HIGH);                                                  // LED amarelo tag gravada com sucesso
    digitalWrite(LEDvm, LOW);                                                   // Indica tag valida
    listaInicio();                                                              // Lista informacoes iniciais
  }
}
//---------------------------------
void deleta()                                                                 // Deletar tags
{
  valoresSerial();                                                            // Le valores do serial monitor
  procuraEEPROM();                                                            // Verifica se tag existe

  unsigned long vazio = 0xFFFFFFFF;                                           // Valor de EEPROM vazia
  if (encontrouTag == true)                                                   // Se existe a tag
  {
    Serial.print ("Deletar tag : "); idTag(tagLida);                          // Informa
    Serial.println(" ");                                                      // Salta linha
    EEPROM.put(addrTag, vazio);                                               // Grave o valor vazio nele
    Serial.print ("Deletada tag : "); idTag(tagLida);                         // Informa
    Serial.println(" ");                                                      // Salta linha
    EEPROM.put(addrDelAtual + 4, addrTag);                                    // Salva o endereço da tag deletada

    qtdeDel++;                                                                // Incremen ta a contagem de tag deletada

    EEPROM.put(addrQtdeDel, qtdeDel);                                         // Salve qtde de tag deletada

    digitalWrite(LEDam, HIGH);                                                // LED amarelo tag gravada com sucesso
    digitalWrite(LEDvm, LOW);                                                 // Tag valida
    listaInicio();                                                            // Lista informacoes iniciais
    return;                                                                   // Retorna ao loop
  }
  if (tagLida != tagEEPROM)                                                   // Se nao encontrou tag valida
  {
    Serial.println ("Tag nao existente");                                     // Tag Invalida
    digitalWrite(LEDam, LOW);                                                 // Tag Invalida
    digitalWrite(LEDvm, HIGH);                                                // Tag Invalida
  }
}
//------------------------------------------
void idTag(unsigned long atualTag)                                            // Rotina par imprimie valor da tag
{
  char  valor = 0;                                                            // Zera varialvel
  for (int separa = 3; separa >= 0; separa-- )                                // Executa para os 4 bytes da tag
  {
    valor = atualTag >> 8 * separa;                                           // Seleciona 8 bits
    Serial.print(valor);                                                      // Imprime
  }
}
//------------------------------------------
void opcoes()                                                                 // Opcoe digitadas no serial monitor
{
  if ((controle == 'i' ) || (controle == 'I' ))                               // Se for i Inclui Tag
  {
    cadastra();                                                               // Cadastra nova tag
  }
  if ((controle == 'r' ) || (controle == 'R' ))                               // Se for r Remove tag
  {
    deleta();                                                                 // Deleta tag
  }
  if ((controle == 'l' ) || (controle == 'L' ))                               // Se for l lista tags
  {
    listaTag();                                                               // Lista tags
  }
  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
  }
}
//-----------------------------------------
void listaTag()                                                               // Lista todas tags
{
  for (int m = 0; m < (qtdeTagCad * 4);  )                                    // Lista tags com base na quantidade cadastrada
  {
    Serial.print(m);                                                          // Endereco da tag
    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.write(listEEPROM);                                               // 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
  }
  valoresIniciais();
}