Guest User

Untitled

a guest
Jan 17th, 2020
98
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