API tools faq
paste
Advertisement
RuiViana

ServeChopp_V10.ino

RuiViana
Nov 3rd, 2018
309
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.68 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!