RuiViana

ServeChopp_V10.ino

Nov 3rd, 2018
203
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #define Rui
  2.  
  3. #define solenoidPin  3
  4. #define buzzer      14
  5. #define SS_PIN      10
  6. #define RST_PIN      9
  7.  
  8. #include <EEPROM.h>
  9. #include <Wire.h>
  10. #include <LiquidCrystal_I2C.h>
  11. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Inicializa o display no endereco 0x27
  12. #include <SPI.h>
  13. #include <MFRC522.h>
  14. MFRC522 rfid(SS_PIN, RST_PIN);
  15. MFRC522::MIFARE_Key key;
  16. MFRC522::StatusCode status;
  17.  
  18. byte clientesMax = 170;
  19. byte clienteLgh = 4;
  20. byte clienteCnt = 0;
  21. int addr = 0;
  22. int addrCli = 0;
  23. bool clientef = false;
  24. bool clienteNew = false;
  25. bool erro01 = false;
  26.  
  27. byte  block;
  28. byte  buffer1[18];
  29. byte  len;
  30. byte  nuidPICC[4];
  31. byte  sensorInterrupt     = 0;
  32. byte  flowMeterSensorPin  = 2;
  33. byte  fechouConta = 1;
  34. volatile byte pulseCount;
  35. float calibrationFactor = 4.5;
  36. float flowRate;
  37. float saldoInicial  = 0.00;                           // saldo inicial do cliente, quando ele chega na máquina;
  38. unsigned int  flowMilliLitres;
  39. unsigned int timerParado     = 0;
  40. unsigned int timerPegarTroco = 0;
  41. int ledState = LOW;
  42. unsigned long totalMilliLitres;
  43. unsigned long previousMillis = 0;
  44. unsigned long oldTime;
  45. unsigned long uidCliente = 0;
  46. long saldo           = 0;
  47. word  lastMl      = 0;
  48. long meuSaldo   = 0;
  49. const long interval = 1000;
  50. //-----------------------------------------------------------------------------
  51. void setup()
  52. {
  53.   attachInterrupt(digitalPinToInterrupt(flowMeterSensorPin), pulseCounter, FALLING);
  54.   Serial.begin(115200);
  55.   pinMode(solenoidPin,    OUTPUT);
  56.   pinMode(buzzer,         OUTPUT);
  57.   digitalWrite(solenoidPin,   LOW);
  58.   pinMode(flowMeterSensorPin,      INPUT);
  59.   digitalWrite(flowMeterSensorPin, HIGH);
  60.   pulseCount        = 0;
  61.   flowRate          = 0.0;
  62.   flowMilliLitres   = 0;
  63.   totalMilliLitres  = 0;
  64.   oldTime           = 0;
  65.   SPI.begin();
  66.   rfid.PCD_Init();
  67.   lcd.begin (16, 2);
  68.   lcd.setCursor(0, 0);
  69.   lcd.setBacklight(HIGH);
  70.   lcd.print("INICIALIZANDO");
  71.   lcd.setCursor(0, 1);
  72.   lcd.print("O SISTEMA");
  73.   delay(200);
  74.   bipe(1, 20);
  75. }
  76. //-----------------------------------------------------------------------------
  77. void loop()
  78. {
  79.   Serial.println("\n\n--- VERIFICAÇÕES INICIAIS ---");
  80.   long transferidor = 0 ;
  81.   if (leCartao() == 0)
  82.     return;
  83.   bipe(1, 20);
  84.   addr = 0;
  85.   findCliente();
  86.   if ( clientef == true)
  87.   {
  88.     EEPROM.get(addr + 4, transferidor );
  89.   }
  90.   for (int i = 3; i > -1; i--)
  91.   {
  92.     saldo = saldo << 8;
  93.     saldo = saldo + (buffer1[i]);
  94.   }
  95.   Serial.print("\nsaldo do Cliente NA TAG: ");
  96.   Serial.println((float)saldo / 100);
  97.   Serial.print("saldo da eeprom:         ");
  98.   saldo += transferidor;
  99.   Serial.println((float)transferidor / 100);
  100.   Serial.print("saldoacumulado:         ");
  101.   Serial.println((float)saldo / 100);
  102.   zerarSaldo();
  103.   if (erro01) {
  104.     rfid.PICC_HaltA();
  105.     rfid.PCD_StopCrypto1();
  106.     return;
  107.   }
  108.  
  109.   lcd.clear();
  110.   lcd.print("SALDO: R$ ");
  111.   lcd.print((float)saldo / 100, 2);
  112.   if (saldo > 0)
  113.     digitalWrite(solenoidPin, HIGH);
  114.   else
  115.   {
  116.     Serial.println("CARTÃO SEM SALDO. FIM.");
  117.     fechouConta = 1;
  118.     lcd.setCursor(0, 0);
  119.     lcd.print("FIM DE OPERACAO ");
  120.     lcd.setCursor(0, 1);
  121.     lcd.print("CARTAO SEM SALDO");
  122.     bipe(4, 50);
  123.     rfid.PICC_HaltA();                                                          // Halt PICC
  124.     rfid.PCD_StopCrypto1();
  125.     delay(2000);
  126.     return;
  127.   }
  128.   saldoInicial = saldo;
  129.   fechouConta = 0;
  130.   Serial.println("--- FIM DAS VERIFICAÇÕES INICIAIS ---\n");
  131.   Serial.println("=== INÍCIO DE OPERAÇÃO ===");
  132.   while (fechouConta == 0)
  133.   {
  134.     if ((millis() - oldTime) > 100)
  135.     {
  136.       detachInterrupt(sensorInterrupt);
  137.       flowRate = ((100.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
  138.       oldTime = millis();
  139.       flowMilliLitres = (flowRate / 60) * 100;
  140.       totalMilliLitres += flowMilliLitres;
  141.       if (lastMl != totalMilliLitres)                                                 // ===> CLIENTE ESTÁ SE SERVINDO
  142.       {
  143.         fechouConta = 0;
  144.         lastMl = totalMilliLitres;
  145.         saldo = saldo - (long)(lastMl * 0.23);
  146.         if (saldo < 1)                    // 1 Centavo
  147.           fimDeOperacao();
  148.       }
  149.       else
  150.         timerParado++;
  151.       lcd.setCursor(0, 0);
  152.       lcd.print("CONSUMO: ");
  153.       lcd.print(totalMilliLitres);
  154.       lcd.print("ml     ");
  155.       lcd.setCursor(0, 1);
  156.       lcd.print("SALDO: R$ ");
  157.       lcd.print((float)saldo / 100, 2);
  158.       if (timerParado > 40)
  159.       {
  160.         fimDeOperacao();
  161.       }
  162.       pulseCount = 0;
  163.       attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
  164.     }                                                                                   // if((millis() - oldTime) > 100)
  165.   }                                                                                     // while(!fechouConta)
  166. }
  167. //--------------------------------------------------------------------------------------
  168. void fimDeOperacao()                                                                    // GRAVAR SALDO
  169. {
  170.   fechouConta = 1;
  171.   timerParado = 0;
  172.   totalMilliLitres = 0;
  173.   attachInterrupt(digitalPinToInterrupt(flowMeterSensorPin), pulseCounter, FALLING);
  174.   digitalWrite(solenoidPin,   LOW);                                            // FECHA SOLENOIDE
  175.   for (int i = 0; i < 4; i++)                                                   // PISCA SALDO
  176.   {
  177.     lcd.setCursor(0, 1);
  178.     lcd.print("                ");
  179.     delay(200);
  180.     lcd.setCursor(0, 1);
  181.     lcd.print("SALDO: R$ ");
  182.     lcd.print((float)saldo / 100, 2);
  183.     delay(200);
  184.   }
  185.   meuSaldo = (long)(saldo);                                     //(long)(35.27 * 100);       // DEBUG
  186.   for (int i = 0; i < 4; i++)
  187.   {
  188.     buffer1[i] = (buffer1[i] << 8) + (meuSaldo & 0xFF);
  189.     meuSaldo = meuSaldo >> 8;
  190.   }
  191.   bipe(3, 20);
  192.   if (saldo < 1)  // 1 centavo
  193.     return;
  194.   long uidTroco = 0;         // VERIFICA SE A UID DA TAG QUE RECEBE O TROCO É A MESMA QUE SE SERVIU AGORA.
  195.   for (byte i = 0; i < 4; i++)
  196.   {
  197.     nuidPICC[i] = rfid.uid.uidByte[i];
  198.     uidTroco = uidTroco << 8;
  199.     uidTroco = uidTroco + (long)nuidPICC[i];
  200.   }
  201.   //  Serial.print("uidCliente: ");
  202.   //  Serial.println(uidCliente, HEX);
  203.   //  Serial.print("uidTroco: ");
  204.   //  Serial.println(uidTroco, HEX);
  205.   //  if (uidCliente != uidTroco)
  206.   //  {
  207.   //    lcd.clear();
  208.   //    lcd.print("CARTAO DIFERENTE");
  209.   //    lcd.setCursor(0, 1);
  210.   //    lcd.print("TROCO ARMAZENADO");
  211.   //    delay(2000);
  212.   //    rfid.PICC_HaltA();
  213.   //    rfid.PCD_StopCrypto1();
  214.   //    return;
  215.   //  }            // FIM VERIFICA SE A UID DA TAG QUE RECEBE O TROCO É A MESMA QUE SE SERVIU AGORA.
  216.   block = 4;
  217.   status = rfid.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(rfid.uid));
  218.   if (status != MFRC522::STATUS_OK)
  219.   {
  220.     Serial.println("fimDeOperacao: FALHA NA AUTENTICAÇÃO");
  221.     addr = 0;
  222.     if ( clientef == false)
  223.     {
  224.       salvaCliente();
  225.       if ( clienteNew == false)
  226.         Serial.println("Deu merda");
  227.       else
  228.         addr = addrCli;
  229.     }
  230.     long shiftSaldo = saldo;
  231.     byte totalSaldo = 0;
  232.     Serial.print("addr: "); Serial.println(addr);
  233.     for (int i = 0 ; i <= 3; i++)
  234.     {
  235.       totalSaldo = shiftSaldo & 0x000000FF;
  236. #ifdef Rui
  237.       //EEPROM.update(addr+4 + i, totalSaldo);           // <<<------------------------------------------------
  238. #else
  239.       EEPROM.update(addr + 4 + i, totalSaldo);         // <<<------------------------------------------------
  240. #endif
  241.       shiftSaldo = shiftSaldo >> 8;
  242.     }
  243.     Serial.println("TROCO GRAVADO NA EEPROM.");
  244.     Serial.println("=== OPERAÇÃO FINALIZADA ===\n\n");
  245.     rfid.PICC_HaltA();                                                          // Halt PICC
  246.     rfid.PCD_StopCrypto1();                                                     // Stop encryption on PCD
  247.     return;
  248.   }
  249. #ifdef Rui
  250.   // status = rfid.MIFARE_Write(block, buffer1, 16);       // <<<------------------------------------------------
  251. #else
  252.   status = rfid.MIFARE_Write(block, buffer1, 16);       // <<<------------------------------------------------
  253. #endif
  254.   if (status != MFRC522::STATUS_OK)
  255.   {
  256.     Serial.print(F("MIFARE_Write() failed: "));
  257.     Serial.println(rfid.GetStatusCodeName(status));
  258.     return;
  259.   }
  260.   else
  261.   {
  262.     for (int i = 0 ; i <= 7; i++)
  263.     {
  264.       #ifdef Rui
  265. //      EEPROM.update(addr  + i, 0xFF);                  // <<<------------------------------------------------
  266. #else
  267.       EEPROM.update(addr  + i, 0xFF);                  // <<<------------------------------------------------
  268. #endif    
  269.     }
  270.     Serial.println("TROCO GRAVADO DA TAG E EEPROM ZERADA COM SUCESSO.");
  271.   }
  272.   rfid.PICC_HaltA();                                                          // Halt PICC
  273.   rfid.PCD_StopCrypto1();                                                     // Stop encryption on PCD
  274.   saldo       = 0;
  275.   lcd.setCursor(0, 0);
  276.   lcd.print  ("MUITO OBRIGADO  ");
  277.   lcd.setCursor(0, 1);
  278.   lcd.print  ("SISTEMA TAPHERR ");
  279.   timerPegarTroco = 0;
  280.   bipe(2, 100);
  281.   Serial.println("=== OPERAÇÃO FINALIZADA ===\n\n");
  282.   delay(3000);
  283.   lcd.clear();
  284. }
  285. //------------------------------------------------------------------------
  286. byte leCartao()
  287. {
  288.   Serial.println("Aproxime o cartão");
  289.   uidCliente = -1;
  290.   while ((!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()))
  291.   {
  292.     lcd.setCursor(0, 0);
  293.     lcd.print("SISTEMA TAPHERR ");
  294.     lcd.setCursor(0, 1);
  295.     lcd.print("APROXIME CARTAO ");
  296.     if (rfid.PICC_IsNewCardPresent() && rfid.PICC_ReadCardSerial())
  297.     {
  298.       break;
  299.     }
  300.   }
  301.   MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
  302.   if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&                           // CARTÃO É DO TIPO CORRETO?
  303.       piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
  304.       piccType != MFRC522::PICC_TYPE_MIFARE_4K)
  305.     return 0;                                                                 // CARTÃO NÃO É DO TIPO CORRETO
  306.   for (byte i = 0; i < 4; i++)                                                // GRAVA A UID E NA EEPROM
  307.   {
  308.     nuidPICC[i] = rfid.uid.uidByte[i];
  309.     uidCliente = uidCliente << 8;
  310.     uidCliente = uidCliente + (long)nuidPICC[i];
  311.   }
  312.   for (byte i = 0; i < 6; i++)
  313.   {
  314.     key.keyByte[i] = 0xFF;
  315.   }
  316.   block = 4;
  317.   len = 18;
  318.   status = rfid.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 4, &key, &(rfid.uid)); //line 834 of MFRC522.cpp file
  319.   if (status != MFRC522::STATUS_OK)
  320.     return;
  321.   status = rfid.MIFARE_Read(block, buffer1, &len);
  322.   if (status != MFRC522::STATUS_OK)
  323.     return;
  324.   Serial.print("UID: ");
  325.   Serial.println(uidCliente, HEX);
  326.   return 1;
  327. }
  328. //------------------------------------------------------------------------
  329. void zerarSaldo()
  330. {
  331.   erro01 = false;
  332.   //  meuSaldo = (long)(0);
  333.   for (int i = 0; i < 4; i++)
  334.   {
  335.     buffer1[i] = 0;
  336.   }
  337.   status = rfid.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(rfid.uid));
  338.   if (status != MFRC522::STATUS_OK)
  339.   {
  340.     erro01 = true;
  341.     Serial.print(F("PCD_Authenticate() failed: "));
  342.     Serial.println(rfid.GetStatusCodeName(status));
  343.     lcd.setCursor(0, 1);
  344.     lcd.print  ("FALHA AUTENTICAC ");
  345.     Serial.println("zerarSaldo: FALHA AO AUTENTICAR O CARTÃO");
  346.     delay(1000);
  347.     return;
  348.   } else
  349.     Serial.println("zerarSaldo: AUTENTICADO COM SUCESSO.");
  350. #ifdef Rui
  351.   //status = rfid.MIFARE_Write(block, buffer1, 16);     // <<<------------------------------------------------
  352. #else
  353.   status = rfid.MIFARE_Write(block, buffer1, 16);     // <<<------------------------------------------------
  354. #endif
  355.   if (status != MFRC522::STATUS_OK)
  356.   {
  357.     erro01 = true;
  358.     Serial.print(F("MIFARE_Write() failed: "));
  359.     Serial.println(rfid.GetStatusCodeName(status));
  360.     lcd.setCursor(0, 1);
  361.     lcd.print  ("FALHA ZERAR SALDO");
  362.     Serial.println("zerarSaldo: FALHA AO ESCREVER NO CARTÃO");
  363.     delay(1000);
  364.     return;
  365.   }
  366.   else
  367.     Serial.println("zerarSaldo: CARTÃO ZERADO COM SUCESSO.");
  368. }
  369. //------------------------------------------------------------------------
  370. void pulseCounter()
  371. {
  372.   pulseCount++;
  373.   fechouConta = 0;
  374. }
  375. //------------------------------------------------------------------------
  376. void bipe(byte bipes, word _delay)
  377. {
  378.   for (byte i = 1; i < bipes + 1; i++)
  379.   {
  380.     digitalWrite(buzzer, HIGH);
  381.     delay(_delay);
  382.     digitalWrite(buzzer, LOW);
  383.     delay(_delay);
  384.   }
  385. }
  386. //--------------------------------------------------------------------------
  387. void findCliente()
  388. {
  389.   long compara = 0;
  390.   while (addr < 1024)
  391.   {
  392.     EEPROM.get(addr, compara);
  393.     if ( compara == uidCliente)
  394.     {
  395.       //      Serial.print("Cliente encontrado no end. : "); Serial.println(addr);
  396.       clientef = true;
  397.       return;
  398.     }
  399.     addr += 8;
  400.   }
  401.   addr = 0;
  402.   Serial.println("Cliente não encontrado : ");
  403.   clientef = false;
  404.   return;
  405. }
  406. //--------------------------------------------------------------------------
  407. void salvaCliente()
  408. {
  409.   long NewCliente = 0;
  410.   long procura = 0;
  411.   while (addrCli < 1024)
  412.   {
  413.     EEPROM.get(addrCli, procura);
  414.     if ( procura == 0xFFFFFFFF)
  415.     {
  416.       //      Serial.print("Cliente espaço no end. : "); Serial.println(addrCli);
  417.       clienteNew = true;
  418.       long shiftCli = uidCliente;
  419.       for (int i = 0 ; i <= 3; i++)
  420.       {
  421.         NewCliente = shiftCli & 0x000000FF;
  422.         #ifdef Rui
  423.         //EEPROM.update(addrCli + i, NewCliente);           // <<<------------------------------------------------
  424.         #else
  425.         EEPROM.update(addrCli + i, NewCliente);           // <<<------------------------------------------------
  426.         #endif
  427.         shiftCli = shiftCli >> 8;
  428.       }
  429.       Serial.print(F("NewCliente na EEPROM "));
  430.       return;
  431.     }
  432.     addrCli += 8;
  433.   }
  434.   addrCli = 0;
  435.   Serial.println("Cliente não salvo : ");
  436.   clienteNew = false;
  437.   return;
  438. }
RAW Paste Data