SHARE
TWEET

Untitled

a guest Jan 17th, 2020 86 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. const int optoPin = 12; //questo è il pin a cui è collegato l'optoswitch
  2. const int relePin = 2;
  3. const int buzzerPin = 9;
  4. const int relePinRefill = 8;
  5. int pin;
  6. int value;
  7. bool optoState; //stato dell'opto
  8. bool lastOptoState; //stato precedente dell'opto
  9. int coins = 0;
  10. unsigned long startTime;
  11. #define TIMEOUT 10000
  12. #define BUZTIME 100
  13.  
  14. //Funzioni dei vari cicli
  15. void changeMenu();
  16. void dispMenu();
  17. void control1();
  18. void control2();
  19. //Variabili globali
  20. char menu = 0x01;
  21. char set1 = 0x00, set2 = 0x00;
  22. boolean t_butDown, t_butP, t_butUp;
  23.  
  24. //DISPLAY Mappa Hardware
  25.  
  26. #include <LiquidCrystal.h>
  27.  
  28. LiquidCrystal lcd ( 13,   //RS
  29.                     3,  //EN
  30.                     4,  //D4
  31.                     5,  //D5
  32.                     6,  //D6
  33.                     7); //D7
  34. #include <Keypad.h>
  35. const byte ROWS = 4; //number of rows on the keypad i.e. 4
  36. const byte COLS = 4; //number of columns on the keypad i,e, 3
  37. char keys[ROWS][COLS] =
  38. {
  39.   {'1', '2', '3', 'A'},
  40.   {'4', '5', '6', 'B'},
  41.   {'7', '8', '9', 'C'},
  42.   {'*', '0', '#', 'D'}
  43. };
  44. byte rowPins[ROWS] = {11, 10, A5, A4}; //Rows 0 to 3
  45. byte colPins[COLS] = {A0, A1, A2, A3}; //Columns 0 to 3
  46. // command for library forkeypad
  47. //initializes an instance of the Keypad class
  48. Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
  49. char tastobattuto;         // variabile di memorizzazione del carattere battuto
  50. byte semaforoval   = 0;    // semaforo di gestione della routine di ricezione valori da tastiera
  51. int valore         = 0;    //  numero battuto sulla tastiera
  52. int moltiplicatore = 0;    // utilizzato nel calcolo del codice battuto su tastiera
  53. int indice         = 0;    // utilizzato nel calcolo del valore battuto su tastiera
  54. int tabnum [5];            // tabella di memorizzazione dei dati battuti (max 4 cifre, 9999)
  55. byte indtab        = 0;    // indice di scorimento della tabella tabnum
  56. byte semloop       = 0;    // semaforo che indica che la routine di acquisizione dei dati da tastiera e' stata lanciata dl loop
  57. int numerosegreto  = 1982;
  58.  
  59. void tastieraecountdown ()
  60. {
  61.   if (semloop == 1)                         // se arrivo dal loop
  62.     semaforoval = 1;                         // inibisce il loop di ricezione, a meno che non sia stato premuto un tasto
  63.   tastobattuto = keypad.getKey();          // acquisisce il valore del tasto battuto, gia' trascodificato tramite la tabella chiave
  64.   for (indtab = 0; indtab < 5; indtab ++)  // pulisce i dati eventualmente gia' memorizzati
  65.     tabnum [indtab] = 0;
  66.   indtab  = 0;
  67.   valore  = 0;
  68.   if (tastobattuto)                        // se e' stato premuto un tasto
  69.   {
  70.     lcd.clear ();
  71.     delay (200);                           // 200 millisecondi di delay (per evitare una doppia battuta)
  72.     semaforoval = 0;
  73.   }
  74.   while (semaforoval == 0)
  75.     {                                       // loop di ricezione dati - data receiving loop
  76.     if (semloop == 1)
  77.                                             // se si e' in fase di loop
  78.       if (tastobattuto)                     // se  e' stato battuto un tasto
  79.       {
  80.         lcd.setCursor (indtab, 0);
  81.         lcd.print (tastobattuto);
  82.      
  83.   if ((tastobattuto >= '0') && (tastobattuto <= '9'))
  84.   {
  85.     tabnum [indtab] = tastobattuto - 48;// memorizza il valore battuto, trasformato in un numero da 0 a 9
  86.     indtab++;
  87.     if (indtab == 4)
  88.       semaforoval = 1;                  // esce dal loop di ricezione dati
  89.   }
  90.   if (tastobattuto == 'C')              // se e' stata annullata la digitazione
  91.   {
  92.     for (indtab = 0; indtab < 5; indtab ++)  // pulisce i dati eventualmente gia' memorizzati
  93.       tabnum [indtab] = 0;
  94.     indtab  = 0;
  95.     valore  = 0;
  96.     lcd.clear ();
  97.     semaforoval = 1;                    // esce dal loop di ricezione dati
  98.   }
  99.   if (tastobattuto == 'D')
  100.     semaforoval = 1;                    // esce dal loop di ricezione dati
  101.   }
  102.   if (semaforoval == 0)
  103.   {
  104.     tastobattuto = keypad.getKey();       // acquisisce il valore del successivo tasto battuto (gia' trascodificato
  105.     //                                       tramite la tabella chiave)
  106.     delay (200);                          // attende 2/10 di secondo per evitare una doppia battuta
  107.   }
  108.   }
  109.   valore = 0;
  110.   moltiplicatore = 1;
  111.   for  (indice = indtab; indice > 1; indice--)
  112.     moltiplicatore = moltiplicatore * 10;
  113.   for (indice = 0; indice <= indtab; indice++)
  114.   {
  115.     valore = valore + tabnum[indice] * moltiplicatore;
  116.     moltiplicatore = moltiplicatore / 10;
  117.   }
  118. }
  119.  
  120. void setup() {
  121.  
  122.   lcd.begin(16, 2);
  123.   pinMode(buzzerPin, OUTPUT);
  124.   pinMode(optoPin, INPUT_PULLUP);
  125.   pinMode(relePin, OUTPUT);
  126.   pinMode(relePinRefill, OUTPUT);
  127.   digitalWrite(relePin, HIGH);
  128.   digitalWrite(relePinRefill, LOW);
  129.   Serial.begin(9600); //inizio comunicazione seriale
  130.   optoState = digitalRead(optoPin);
  131.   digitalWrite(buzzerPin, HIGH);
  132.   delay(500);
  133.   digitalWrite(buzzerPin, LOW);
  134.   lcd.setCursor(0, 0);
  135.   lcd.print("LaBucciata  Slot");
  136.   delay(5000);
  137.   lcd.setCursor(0, 1);
  138.   lcd.print("Configurazione..");
  139.   delay(500);
  140.   lcd.begin(16, 2);
  141.   lcd.setCursor(5, 0);
  142.   lcd.print("Ready");
  143.   delay(400);
  144.   digitalWrite(buzzerPin, HIGH);
  145.   delay(200);
  146.   digitalWrite(buzzerPin, LOW);
  147.   delay(200);
  148.   digitalWrite(buzzerPin, HIGH);
  149.   delay(200);
  150.   digitalWrite(buzzerPin, LOW);
  151.   lcd.begin(16, 2);
  152.   keypad.addEventListener(keypadEvent);
  153.  
  154.  
  155.   t_butDown = 0x00;
  156.   t_butP  = 0x00;
  157.   t_butUp = 0x00;
  158.  
  159.  
  160. }
  161.  
  162. void loop() {
  163.   checkForCredits1();
  164.   releaseTokens();
  165.   tokensCountDown();
  166.   char keypressed = keypad.getKey();
  167.   if (keypressed != NO_KEY)
  168.   {
  169.  
  170.     Serial.print(keypressed);
  171.  
  172.   }
  173.   changeMenu();               //Menu di scambio
  174.  
  175.   dispMenu();               //Selezionare il menu
  176.  
  177.  
  178. }
  179.  
  180. void gettonikey()
  181. {
  182.   lcd.clear();
  183.       lcd.setCursor(0, 1);
  184.       lcd.print("n. gettoni");
  185.       semloop = 1;                // setta il semaforo di "loop attivo"
  186.         valore = 0;
  187.         while (valore == 0)
  188.           tastieraecountdown ();
  189.        coins = (valore);
  190. }
  191. //Funzioni
  192. void keypadEvent(KeypadEvent eKey) {
  193.   switch (keypad.getState()) {
  194.     case PRESSED:
  195.       digitalWrite(buzzerPin, HIGH);
  196.       delay(50);
  197.       digitalWrite(buzzerPin, LOW);
  198.       lcd.begin(16, 2);
  199.       lcd.setCursor(5, 0);
  200.       Serial.print(eKey);
  201.       switch (eKey) {
  202.         case '*': t_butUp = 0x01; break;
  203.         case '#': t_butDown = 0x01; break;
  204.         case 'A': t_butP = 0x01; break;
  205.       }
  206.   }
  207. }
  208. void changeMenu() {
  209.   if (t_butUp && t_butUp) {
  210.  
  211.     t_butUp = 0x00;
  212.  
  213.     lcd.clear();        //Cancella Schermo lcd
  214.  
  215.     menu++;
  216.  
  217.     if (menu > 0x02) {
  218.  
  219.       menu = 0x01;
  220.     }
  221.   }
  222.  
  223.   if (t_butDown && t_butDown) {
  224.  
  225.     t_butDown = 0x00;
  226.  
  227.     lcd.clear();
  228.  
  229.     menu--;
  230.  
  231.     if (menu < 0x01) {
  232.  
  233.       menu = 0x02;
  234.     }
  235.   }
  236.  
  237. }
  238.  
  239. void dispMenu() {
  240.  
  241.   switch (menu) {
  242.  
  243.     case 0x01:
  244.       control1();              //Funzione controllo  led1
  245.       break;
  246.     case 0x02:
  247.       control2();
  248.       break;
  249.   }
  250. }
  251.  
  252.  
  253. void control1() {
  254.   lcd.setCursor(0, 1);
  255.   lcd.print("refill");
  256.  
  257.  
  258.  
  259.   if (t_butP && t_butP) {
  260.  
  261.     t_butP = 0x00;
  262.     set1++;
  263.  
  264.  
  265.     if (set1 > 3) {
  266.  
  267.       set1 = 0x01;
  268.     }
  269.  
  270.     switch (set1) {
  271.  
  272.       case 0x01:
  273.         lcd.clear();
  274.         lcd.setCursor(0, 1);
  275.         digitalWrite(relePinRefill, HIGH);
  276.         lcd.print("refill ON");
  277.         break;
  278.       case 0x02:
  279.         lcd.clear();
  280.         lcd.setCursor(0, 1);
  281.         digitalWrite(relePinRefill, LOW);
  282.         lcd.print("refill OFF");
  283.         break;
  284.  
  285.     }
  286.   }
  287. }
  288. void control2() {
  289.   lcd.setCursor(0, 1);
  290.   lcd.print("erogazione gettoni");
  291.  
  292.  
  293.  
  294.   if (t_butP && t_butP) {
  295.  
  296.     t_butP = 0x00;
  297.     set2++;
  298.  
  299.  
  300.     if (set2 > 1) {
  301.  
  302.       set2 = 0x01;
  303.     }
  304.  
  305.     switch (set2) {
  306.  
  307.       case 0x01:
  308.       lcd.clear();
  309.       lcd.setCursor(0, 1);
  310.       lcd.print("inserisci password");
  311.       semloop = 1;                // setta il semaforo di "loop attivo"
  312.         valore = 0;
  313.         while (valore == 0)
  314.           tastieraecountdown ();    // acquisisce dati da tastiera
  315.         if (valore == numerosegreto)
  316.         {
  317.          gettonikey();
  318.         }
  319.         else
  320.         {
  321.           lcd.clear();
  322.           lcd.setCursor(0 ,1);
  323.           lcd.print("errore");
  324.         }
  325.         break;
  326.     }
  327.   }
  328. }
  329.  
  330. void checkForCredits1() {
  331.   while (Serial.available() > 0) {
  332.     value = Serial.parseInt();
  333.     if (Serial.read() == 'x') {
  334.       if (value > 0) {
  335.         coins ++;
  336.         Serial.flush();
  337.         Serial.begin(9600);
  338.       }
  339.     }
  340.   }
  341. }
  342. void releaseTokens() {
  343.   if (coins > 0) {
  344.     // Se il motore è fermo, memorizzo il momento in cui parte.
  345.     // In questo modo mi assicuro di impostare la variabile solo al fronte di salita di relePin
  346.     if (digitalRead(relePin) == HIGH) {
  347.       startTime = millis();
  348.     }
  349.     digitalWrite(relePin, LOW); //rilascio gettoni
  350.     optoState = digitalRead(optoPin);
  351.   }
  352.   else {
  353.     digitalWrite(relePin, HIGH);//STOP rilascio gettoni
  354.     lcd.setCursor(0, 0);
  355.     lcd.print("LaBucciata Slot $ $ Buona Fortuna $ $");
  356.     delay(400);
  357.     for (int positionCounter = 0; positionCounter < 1; positionCounter++) {
  358.       lcd.scrollDisplayLeft();
  359.     }
  360.  
  361.  
  362.   }
  363.  
  364.   // Solo se il motore è ancora acceso, dopo 10 secondi dall'attivazione, resetto l'uscita
  365.   if (digitalRead(relePin) == LOW) {
  366.     if (millis() - startTime > TIMEOUT ) {
  367.       digitalWrite(relePin, HIGH); //STOP rilascio gettoni
  368.       digitalWrite(buzzerPin, HIGH);
  369.       lcd.begin(16, 2);
  370.       lcd.setCursor(5, 0);
  371.       lcd.print("refill");
  372.       digitalWrite(relePinRefill, HIGH);
  373.       delay(3000);
  374.       lcd.begin(16, 2);
  375.       lcd.setCursor(0, 0);
  376.       lcd.print("gettoni mancanti:");
  377.       delay(1000);
  378.       lcd.setCursor(13, 1);
  379.       lcd.println(coins);
  380.       coins = 0;
  381.       digitalWrite(buzzerPin, LOW);
  382.       lcd.begin(16, 2);
  383.     }
  384.   }
  385.  
  386. }
  387.  
  388. void tokensCountDown() {
  389.   if (optoState != lastOptoState) { // se lo stato dell'opto è cambiato (cioè qualcosa sta passando, in entrata o uscita)
  390.     lastOptoState = optoState;
  391.     delay (100); //debounce "economico" (questo serve perchè nel passaggio di stato possono esserci fluttuazioni che portano a conteggi errati)
  392.     if (lastOptoState == LOW && coins > 0) {
  393.       coins = coins - 1 ; //decremento gettoni
  394.       startTime = millis(); //reset timer
  395.  
  396.     }
  397.   }
  398. }
RAW Paste Data
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
Top