KT_Ver07

//LENDO CODIGO RF 433,92Mz  //criado por : CREATED BY:  AFONSO CELSO TURCATO  //CODIGO LENDO SINAL RF 433,92Mz
//  Modificado por mineirin

#include <EEPROM.h>                 // Biblioteca EEPROM
const byte pinLearnButton = 5;      // Pino lendo o novo sinal"
byte pinRF;                         // Pin 5 where RF Module is connected
int comando;
int value;
boolean startbit;
boolean dataok;
boolean anticodeok;
int counter;                        // received bits counter: 22 of Address + 2 of Data + 4 of EndCode (Anti-Code)
int lambda;                         // on pulse clock width (if fosc = 2KHz than lambda = 500 us)
int dur0, dur1;                     // pulses durations (auxiliary)
unsigned long buffer = 0;           // buffer for received data storage
int limitMen = 128;                 // Define tamanho de memoria EEPROM a ser usada
int qtdeControl = limitMen / 4;     // Define qtos controles serao gravados
unsigned long dadosMem[32];         // Matriz para guardar dados lidos da EEPROM
#define gravaLed 2                  // LED indicativo de gravação
int gravaEEPROM = 0;                // Indicador de gravacao de EEPROM
int addrEEPROM = 0;                 // Endereco inicial da EEPROM
int controlOk = 0;                  // Marca que encontrou controle na EEPROM
int posicaoOk = limitMen / 4 + 1;   // Localizaçao do match Inical é maior q qq memoria
int fimDeCode = 0x0A050A05;         // Valor em Hexa para estabelecer o ultimo code gravado
//---------------------------------------
void setup()
{
  EEPROM.begin(limitMen);                                         // limitMen/4 enderecos de 4 byte = 128 bytes
  pinRF = 12;                                                     // pino conectado modulo RF 433
  pinMode(pinRF, INPUT);
  pinMode(gravaLed, OUTPUT);                                      //
  pinMode(13, OUTPUT);
  pinMode(pinLearnButton, INPUT_PULLUP);
  Serial.begin(9600);
  for (int i = 0; i < qtdeControl; i++)                           // Ler dados long da EEPROM
  {
    addrEEPROM = (4 * i);                                         // Increme nta o endereco por 4
    EEPROM.get(addrEEPROM, dadosMem[i]);                          // Le um long de cada posicao de endereco
    Serial.println(dadosMem[i], HEX);                             // Print
    if (dadosMem[i] == fimDeCode)                                 // Se encontrou fim de code
      break;                                                      // Sai do for
  }
  Serial.println (addrEEPROM);                                    // print proximo endereco disponivel
}
//-----------------------------------------
void loop()
{
  if (digitalRead(pinLearnButton) == LOW)                         // Se o botao de gravaco foi pressionado
  {
    delay(2000);                                                  // Aguarde 2 segundos
    if (digitalRead(pinLearnButton) == LOW)                       // Se o botao de gravaco continua pressionado
    {
      if (gravaEEPROM == 1)                                       // Gravar na EEPROM esta ativado
      {
        delay(2000);                                              // Aguarde 2 segundos
        if (digitalRead(pinLearnButton) == LOW)                   // Se o botao de gravaco continua pressionado
        {
          Serial.println("limpando");                             // Informa limpando a EEPROM
          for (int i = 0; i < 32; i++)                            // Grava 0 em todas posicoes da EEPROM 32 posicoes long (32 * 4)
          {
            EEPROM.put((4 * i), 0);                               // Grava 0 em todas posicoes
          }
          EEPROM.put((0), fimDeCode);                             // Grava fim de code na posicao 0
          EEPROM.end();                                           // Confirma gravacao dos dados
        }
      }
      gravaEEPROM = 1;                                            // Informa para gravar na EEPROM
      digitalWrite(gravaLed, HIGH);                               // Acende LED de gravacao da EEPROM
    }
  }
  digitalWrite(13, digitalRead(pinRF));                           // blink de onboard LED when receive something
  if (!startbit)                                                  // Check the PILOT CODE until START BIT;
  {
    dur0 = pulseIn(pinRF, LOW);                                   // Check how long DOUT was "0" (ZERO) (refers to PILOT CODE)
    if ((dur0 > 9200) && (dur0 < 13800) && !startbit)             // If time at "0" is between 9200 us (23 cycles of 400us) and 13800 us (23 cycles of 600 us).
    {
      lambda = dur0 / 23;                                         // calculate wave length - lambda
      dur0 = 0;
      buffer = 0;
      counter = 0;
      dataok = false;
      startbit = true;
    }
  }
  if (startbit && !dataok && counter < 28)                        // If Start Bit is OK, then starts measure os how long the signal is level "1" and check is value is into acceptable range.
  {
    ++counter;
    dur1 = pulseIn(pinRF, HIGH);
    if ((dur1 > 0.5 * lambda) && (dur1 < (1.5 * lambda)))         // If pulse width at "1" is between "0.5 and 1.5 lambda", means that pulse is only one lambda, so the data � "1".
    {
      buffer = (buffer << 1) + 1;                                 // add "1" on data buffer
    }
    else if ((dur1 > 1.5 * lambda) && (dur1 < (2.5 * lambda)))    // If pulse width at "1" is between "1.5 and 2.5 lambda", means that pulse is two lambdas, so the data � "0".
    {
      buffer = (buffer << 1);                                     // add "0" on data buffer
    }
    else
    {
      startbit = false;                                           // Reset the loop
    }
  }
  if (counter == 28)                                              // Check if all 28 bits were received (22 of Address + 2 of Data + 4 of Anti-Code)
  {

    if ((bitRead(buffer, 0) == 1) && (bitRead(buffer, 1) == 0) && (bitRead(buffer, 2) == 1) && (bitRead(buffer, 3) == 0))   // Check if Anti-Code is OK (last 4 bits of buffer equal "0101")
    {
      anticodeok = true;
    }
    else
    {
      startbit = false;                                               // Reset the loop
    }
    if (anticodeok)
    {
      dataok = true;
      counter = 0;
      startbit = false;
      anticodeok = false;
      unsigned long addr = buffer >> 6;
      Serial.println(addr, HEX);                                      // exibindo o valor  Ex: 0x264750
      delay(100);
      if (gravaEEPROM == 0)                                           // Se nao esta habilitado gravacao na EEPROM executa
      {
        for (int j = 0; j < qtdeControl; j++)                         // Verifica todas posicoes de memoria
        {
          if (addr == dadosMem[j] )                                   // Se encontrou algum valor igual o controle
          {
            posicaoOk = j;                                            // Salva o valor da posicao onde encontrou igual
            controlOk = 1;                                            // Informa que encontrou
            break;                                                    // Sai do for
          }
        }
      }
      if (gravaEEPROM == 1)                                           // Se esta habilitado gravacao na EEPROM executa
      {
        gravaEEPROM = 0;                                              // Desabilita gravacao
        EEPROM.put(addrEEPROM, addr);                                 // Saval o valor lido do controle
        EEPROM.put(addrEEPROM + 4, fimDeCode);                        // Salva fim de code no proximo endereco
        EEPROM.end();                                                 // Salva gravacoes
        digitalWrite(gravaLed, LOW);                                  // Apaga LED de gravacao da EEPROM
        addrEEPROM = addrEEPROM + 4;                                  // Icrementa endereco de gravacao
      }
    }
  }
  if   (controlOk == 1)                                               // Se existe gravado igual ao controle recebido
  {
    switch (posicaoOk)                                                // Seleciona a acao de acordo com a posicao dele na matriz
    {
      case 0:                                                         // Poiscao zero
        //do something when var equals 0                              // faz ............
        break;
      case 1:                                                         // Poiscao um
        //do something when var equals 2                              // faz ............
        break;
      case 2:                                                         // Poiscao dois
        //do something when var equals 2                              // faz ............
        break;

      // .....                                                        // Poiscao n
      // .....                                                        // faz ............
      // .....
      // .....

      default:                                                        // Se não encontrou nenhum
        // if nothing else matches, do the default
        break;                                                        // Termina sem fazer nada
    }
    posicaoOk = limitMen / 4 + 1;                                     // Grava valor da memoria + 1
    controlOk = 0;                                                    // Desabilita acesso ao switch
  }
}