RuiViana

KT_Ver07

Aug 5th, 2018
171
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //LENDO CODIGO RF 433,92Mz  //criado por : CREATED BY:  AFONSO CELSO TURCATO  //CODIGO LENDO SINAL RF 433,92Mz
  2. //  Modificado por mineirin
  3.  
  4. #include <EEPROM.h>                 // Biblioteca EEPROM
  5. const byte pinLearnButton = 5;      // Pino lendo o novo sinal"
  6. byte pinRF;                         // Pin 5 where RF Module is connected
  7. int comando;
  8. int value;
  9. boolean startbit;
  10. boolean dataok;
  11. boolean anticodeok;
  12. int counter;                        // received bits counter: 22 of Address + 2 of Data + 4 of EndCode (Anti-Code)
  13. int lambda;                         // on pulse clock width (if fosc = 2KHz than lambda = 500 us)
  14. int dur0, dur1;                     // pulses durations (auxiliary)
  15. unsigned long buffer = 0;           // buffer for received data storage
  16. int limitMen = 128;                 // Define tamanho de memoria EEPROM a ser usada
  17. int qtdeControl = limitMen / 4;     // Define qtos controles serao gravados
  18. unsigned long dadosMem[32];         // Matriz para guardar dados lidos da EEPROM
  19. #define gravaLed 2                  // LED indicativo de gravação
  20. int gravaEEPROM = 0;                // Indicador de gravacao de EEPROM
  21. int addrEEPROM = 0;                 // Endereco inicial da EEPROM
  22. int controlOk = 0;                  // Marca que encontrou controle na EEPROM
  23. int posicaoOk = limitMen / 4 + 1;   // Localizaçao do match Inical é maior q qq memoria
  24. int fimDeCode = 0x0A050A05;         // Valor em Hexa para estabelecer o ultimo code gravado
  25. //---------------------------------------
  26. void setup()
  27. {
  28.   EEPROM.begin(limitMen);                                         // limitMen/4 enderecos de 4 byte = 128 bytes
  29.   pinRF = 12;                                                     // pino conectado modulo RF 433
  30.   pinMode(pinRF, INPUT);
  31.   pinMode(gravaLed, OUTPUT);                                      //
  32.   pinMode(13, OUTPUT);
  33.   pinMode(pinLearnButton, INPUT_PULLUP);
  34.   Serial.begin(9600);
  35.   for (int i = 0; i < qtdeControl; i++)                           // Ler dados long da EEPROM
  36.   {
  37.     addrEEPROM = (4 * i);                                         // Increme nta o endereco por 4
  38.     EEPROM.get(addrEEPROM, dadosMem[i]);                          // Le um long de cada posicao de endereco
  39.     Serial.println(dadosMem[i], HEX);                             // Print
  40.     if (dadosMem[i] == fimDeCode)                                 // Se encontrou fim de code
  41.       break;                                                      // Sai do for
  42.   }
  43.   Serial.println (addrEEPROM);                                    // print proximo endereco disponivel
  44. }
  45. //-----------------------------------------
  46. void loop()
  47. {
  48.   if (digitalRead(pinLearnButton) == LOW)                         // Se o botao de gravaco foi pressionado
  49.   {
  50.     delay(2000);                                                  // Aguarde 2 segundos
  51.     if (digitalRead(pinLearnButton) == LOW)                       // Se o botao de gravaco continua pressionado
  52.     {
  53.       if (gravaEEPROM == 1)                                       // Gravar na EEPROM esta ativado
  54.       {
  55.         delay(2000);                                              // Aguarde 2 segundos
  56.         if (digitalRead(pinLearnButton) == LOW)                   // Se o botao de gravaco continua pressionado
  57.         {
  58.           Serial.println("limpando");                             // Informa limpando a EEPROM
  59.           for (int i = 0; i < 32; i++)                            // Grava 0 em todas posicoes da EEPROM 32 posicoes long (32 * 4)
  60.           {
  61.             EEPROM.put((4 * i), 0);                               // Grava 0 em todas posicoes
  62.           }
  63.           EEPROM.put((0), fimDeCode);                             // Grava fim de code na posicao 0
  64.           EEPROM.end();                                           // Confirma gravacao dos dados
  65.         }
  66.       }
  67.       gravaEEPROM = 1;                                            // Informa para gravar na EEPROM
  68.       digitalWrite(gravaLed, HIGH);                               // Acende LED de gravacao da EEPROM
  69.     }
  70.   }
  71.   digitalWrite(13, digitalRead(pinRF));                           // blink de onboard LED when receive something
  72.   if (!startbit)                                                  // Check the PILOT CODE until START BIT;
  73.   {
  74.     dur0 = pulseIn(pinRF, LOW);                                   // Check how long DOUT was "0" (ZERO) (refers to PILOT CODE)
  75.     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).
  76.     {
  77.       lambda = dur0 / 23;                                         // calculate wave length - lambda
  78.       dur0 = 0;
  79.       buffer = 0;
  80.       counter = 0;
  81.       dataok = false;
  82.       startbit = true;
  83.     }
  84.   }
  85.   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.
  86.   {
  87.     ++counter;
  88.     dur1 = pulseIn(pinRF, HIGH);
  89.     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".
  90.     {
  91.       buffer = (buffer << 1) + 1;                                 // add "1" on data buffer
  92.     }
  93.     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".
  94.     {
  95.       buffer = (buffer << 1);                                     // add "0" on data buffer
  96.     }
  97.     else
  98.     {
  99.       startbit = false;                                           // Reset the loop
  100.     }
  101.   }
  102.   if (counter == 28)                                              // Check if all 28 bits were received (22 of Address + 2 of Data + 4 of Anti-Code)
  103.   {
  104.  
  105.     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")
  106.     {
  107.       anticodeok = true;
  108.     }
  109.     else
  110.     {
  111.       startbit = false;                                               // Reset the loop
  112.     }
  113.     if (anticodeok)
  114.     {
  115.       dataok = true;
  116.       counter = 0;
  117.       startbit = false;
  118.       anticodeok = false;
  119.       unsigned long addr = buffer >> 6;
  120.       Serial.println(addr, HEX);                                      // exibindo o valor  Ex: 0x264750
  121.       delay(100);
  122.       if (gravaEEPROM == 0)                                           // Se nao esta habilitado gravacao na EEPROM executa
  123.       {
  124.         for (int j = 0; j < qtdeControl; j++)                         // Verifica todas posicoes de memoria
  125.         {
  126.           if (addr == dadosMem[j] )                                   // Se encontrou algum valor igual o controle
  127.           {
  128.             posicaoOk = j;                                            // Salva o valor da posicao onde encontrou igual
  129.             controlOk = 1;                                            // Informa que encontrou
  130.             break;                                                    // Sai do for
  131.           }
  132.         }
  133.       }
  134.       if (gravaEEPROM == 1)                                           // Se esta habilitado gravacao na EEPROM executa
  135.       {
  136.         gravaEEPROM = 0;                                              // Desabilita gravacao
  137.         EEPROM.put(addrEEPROM, addr);                                 // Saval o valor lido do controle
  138.         EEPROM.put(addrEEPROM + 4, fimDeCode);                        // Salva fim de code no proximo endereco
  139.         EEPROM.end();                                                 // Salva gravacoes
  140.         digitalWrite(gravaLed, LOW);                                  // Apaga LED de gravacao da EEPROM
  141.         addrEEPROM = addrEEPROM + 4;                                  // Icrementa endereco de gravacao
  142.       }
  143.     }
  144.   }
  145.   if   (controlOk == 1)                                               // Se existe gravado igual ao controle recebido
  146.   {
  147.     switch (posicaoOk)                                                // Seleciona a acao de acordo com a posicao dele na matriz
  148.     {
  149.       case 0:                                                         // Poiscao zero
  150.         //do something when var equals 0                              // faz ............
  151.         break;
  152.       case 1:                                                         // Poiscao um
  153.         //do something when var equals 2                              // faz ............
  154.         break;
  155.       case 2:                                                         // Poiscao dois
  156.         //do something when var equals 2                              // faz ............
  157.         break;
  158.  
  159.       // .....                                                        // Poiscao n
  160.       // .....                                                        // faz ............
  161.       // .....
  162.       // .....
  163.  
  164.       default:                                                        // Se não encontrou nenhum
  165.         // if nothing else matches, do the default
  166.         break;                                                        // Termina sem fazer nada
  167.     }
  168.     posicaoOk = limitMen / 4 + 1;                                     // Grava valor da memoria + 1
  169.     controlOk = 0;                                                    // Desabilita acesso ao switch
  170.   }
  171. }
RAW Paste Data