API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 17th, 2020
126
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.26 KB | None | 0 0
raw download clone embed print report
  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. }
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!