Slot Car Lap Counter

Another Slot Car Lap Counter, but if I did it anyone can do!

Jul 26, 2023

•

3110 views

•

3 respects

•

Components and supplies

Arduino Micro

piezo speaker

16x2 LCD display with I²C interface

Copper Stripboard

Plastic container

AZDelivery IR module i2c

Tools and machines

Soldering kit

Apps and platforms

Arduino IDE 2.0 (beta)

Project description

Code

LapCounter

cpp

Some comments are in italian.

1/*Version 20230817 
2 assegnazione dei PIN su A-Micro
3 Arduino ----7--9   
4 pista   ---tr1-tr2
5 Configurazione Display LCD 16x2 
6 */
7
8// include la libreria: 
9#include<Wire.h>
10#include <LiquidCrystal_I2C.h>
11LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
12LiquidCrystal_I2C lcd2(0x26,16,2);  // set the LCD address to 0x26 for a 16 chars and 2 line display
13#define TONE_USE_INT
14#define TONE_PITCH 440
15#include <TonePitch.h>
16// -------mappatura dei pin e stato contatti
17int audio=6;
18const byte trk1 = 7; //IR attached to this pin //pin per l'interruttore sensore dei lap sulla corsia 1
19const byte trk2 = 9; //IR attached to this pin //pin per l'interruttore sensore dei lap sulla corsia 2
20int trk1State = 0; //this variable tracks the state of IR, 
21int trk2State = 0; //this variable tracks the state of IR, 
22bool checkIR1 = true;  //variable used to verify if an obstacle remain under IR1 
23bool checkIR2 = true;  //variable used to verify if an obstacle remain under IR1
24bool firstCKPT = false; //variable used in the two lane loop to be sure that the player doesn't miss a ring
25bool secondCKPT= false;  //variable used in the two lane loop to be sure that the player doesn't miss a ring
26//----variabili per menu-----
27//----Menu percorso
28int tipoPercorso=0;
29int scegliPercorso=1;
30int c1a=0; int c2a=6; int c3a=12; //cursor position in the display in the track menu 
31//----Menu gara----
32int tipoGara=0;
33int scegliGara=1;
34int c1b=0; int c2b=11;  //cursor position in the display in the race menu
35//---Gara a Giri---
36int totLap = 5; //default value for LAP race
37int trk1Lap = 0;
38int trk2Lap = 0;
39int lap0tr1 = 0;
40int lap0tr2 = 0;
41int menuGiri=1;
42int c1c=0; int c2c=4; int c3c=11;  //cursor position in the display in the lap menu
43//---Gara a Tempo---
44long timeRace = 1; //default value for timerace in minutes
45long timeRaceMillis; //timerace in millis
46long timeStart; //time when the race start
47long timeNow;
48long timeRemain; // =timeEnd-timeStart-timeNow-timeStart
49long timeEnd;//time the race will end timeStart + timeRace
50long timePassed;
51int menuTempo=1;
52//---altre variabili---
53int winnerState =0;
54unsigned long lastDebounceTime1 = 0; // the last time the output pin was toggled
55unsigned long lastDebounceTime2 = 0; // the last time the output pin was toggled
56unsigned long trk1mill = 0; // millis for trk1
57unsigned long trk2mill = 0; // millis for trk2
58unsigned long debounceDelay = 2500; // the debounce time in millis; increase if the output flickers //tempo dell'anti-rimbalzo - da regolare
59long mm1,ss1,dec1; //minutes seconds and dec for Player 1
60long mm2,ss2,dec2; //minutes seconds and dec for Player 2
61long mm,ss,dec;    //variabili per gli orologi
62String minut1,secondi1,deci1;
63String minut2,secondi2,deci2;
64String tpminut;
65String tpsecondi;
66String tpdeci;
67unsigned long trk1LapTime,trk1BestLapTime,trk1EndLapTime,trk1StartLapTime;
68unsigned long trk2LapTime,trk2BestLapTime,trk2EndLapTime,trk2StartLapTime;
69String testoP1; 
70String testoP2;
71
72//----------------------SETUP----------------------------
73void setup() {
74	pinMode(trk1,INPUT);
75	pinMode(trk2,INPUT);
76	lcd.init();lcd2.init(); //initialize the lcd
77	lcd.backlight(); lcd2.backlight();//turn on the LCD backlight
78	lcd.clear();lcd2.clear(); //clear the LCD screens and positions the cursor in the upper-left corner
79	lcd2.home();lcd2.print("LANE 1 MOVE");lcd2.setCursor(0,1);lcd2.print("LANE 2 SELECT");startSound(); //use the IR to manage the cursor
80	//-----routine per scegliere il tracciato------
81	scegliTracciato(); //go to the routine to chose the track
82	scegliCorsa();     //go to the routine to chose time or lap race
83	
84	//from here the START procedure
85	
86	lcd.clear();lcd2.clear(); //pulisco lo schermo
87	lcd.home();lcd.print("PRENDI POSIZIONE");//be ready !
88	lcd2.home();lcd2.print("PRENDI POSIZIONE");//be ready !
89	delay(10000);
90	lcd.home();lcd.print("    SEMAFORO    "); 
91	lcd2.home();lcd2.print("    SEMAFORO    ");
92	delay(3000);
93	//Richiama la routine semaforo
94	semaforo();
95	lcd.setCursor(0,0);lcd.print("P1L:       --:--");
96	lcd.setCursor(0,1);lcd.print("   best:--:--:--");
97
98	lcd2.setCursor(0,0);lcd2.print("P2L:       --:--");
99	lcd2.setCursor(0,1);lcd2.print("   best:--:--:--");
100	checkIR1 = false;
101	checkIR2 = false;
102	timeStart=millis();//last row of setup
103	trk1StartLapTime=timeStart;
104	trk2StartLapTime=timeStart;
105} 
106//-------------------------END SETUP-----------------------------------
107//-------------------------INIZIO LOOP-----------------------------------
108void loop() {
109	// Campiona lo stato dei pulsanti - premuti o non premuti?
110	trk1State = digitalRead(trk1);
111	trk2State = digitalRead(trk2);
112
113	switch (scegliPercorso) {  // Sposta il cursore
114		case 1:
115			if (tipoGara == 1) {
116				garaAGiri();  // Gara a giri per 2 giocatori su 2 corsie
117			}
118			if (tipoGara == 2) {
119				garaATempo(); // Gara a tempo per 2 giocatori su 2 corsie
120			}
121			break;
122		case 2:
123			if (tipoGara == 1) {
124				garaAGiri();  // Gara a giri per 1 giocatore in un percorso ad anello
125			}
126			if (tipoGara == 2) {
127				garaATempo(); // Gara a tempo per 1 giocatore in un percorso ad anello
128			}
129			break;
130		case 3:
131			if (tipoGara == 1) {
132				loopDoppioGiri();  // Percorso incrociato a giri per 1 giocatore
133			}
134			if (tipoGara == 2) {
135				loopDoppioTempo(); // Percorso incrociato a tempo per 1 giocatore
136			}
137			break;
138	}
139}
140
141//--------------------END LOOP-----------
142void scegliTracciato() {
143  lcd.setCursor(0, 0);
144  lcd2.setCursor(0, 0); // Posiziona il cursore
145  lcd.home();
146  lcd.print("scegli tracciato"); // Scegli il tracciato
147  lcd.setCursor(0, 1);
148  lcd.print("2trk  rly1  rly2"); // 0,1---6,1--12,1 posizione del cursore
149  lcd.setCursor(0, 1);
150  lcd.blink();
151
152  while (tipoPercorso == 0) { // Ciclo per la scelta del tipoPercorso spostando il cursore
153    delay(500);
154    
155    if (digitalRead(7) == 1) {
156      tone(audio, NOTE_G4, 50);
157      scegliPercorso = (scegliPercorso % 3) + 1; // Gestione del conteggio e della rotazione
158      
159      switch (scegliPercorso) { // Sposta il cursore quando il sensore IR è oscurato
160        case 1:
161          lcd.setCursor(c1a, 1); // Due giocatori
162          break;
163        case 2:
164          lcd.setCursor(c2a, 1); // Giocatore singolo con percorso ad anello
165          break;
166        case 3:
167          lcd.setCursor(c3a, 1); // Giocatore singolo con corsia incrociata
168          break;
169      }
170    }
171    
172    if (digitalRead(9) == 1) { // Imposta il percorso ed esce dal ciclo while
173      tipoPercorso = scegliPercorso;
174      tone(audio, NOTE_G5, 50);
175      lcd.noBlink();
176      
177      if (tipoPercorso == 1) {
178        lcd.clear();
179        lcd.setCursor(0, 0);
180        lcd.print("2 corsie classic"); // Due giocatori
181      }
182      if (tipoPercorso == 2) {
183        lcd.clear();
184        lcd.setCursor(0, 0);
185        lcd.print("1 corsia rally"); // Giocatore singolo con percorso ad anello
186      }
187      if (tipoPercorso == 3) {
188        lcd.clear();
189        lcd.setCursor(0, 0);
190        lcd.print("2 corsie rally"); // Giocatore singolo con corsia incrociata
191      }
192      delay(4000);
193    }
194  }
195  lcd.noBlink();
196}
197
198void scegliCorsa() {
199	// ----- Routine per scegliere il tipo di gara ------
200	lcd.home();
201	lcd.print("scegli tipo gara"); // Scegli il tipo di gara
202	lcd.setCursor(0, 1);
203	lcd.print("GIRI       TEMPO"); // 0,1---  11,1 posizione del cursore in base alla scelta
204	lcd.setCursor(0, 1);
205	
206	while (tipoGara == 0) {
207	lcd.blink(); // Mostra il cursore
208	delay(500);
209	
210	if (digitalRead(7) == 1) {
211		tone(audio, NOTE_G4, 50);
212		scegliGara = (scegliGara % 3) + 1; // Gestione del conteggio e della rotazione
213		
214		switch (scegliGara) {
215		case 1:
216			lcd.setCursor(c1b, 1);
217			break;
218		case 2:
219			lcd.setCursor(c2b, 1);
220			break;
221		}
222	}
223	
224	if (digitalRead(9) == 1) {
225		tipoGara = scegliGara;
226		tone(audio, NOTE_G5, 50);
227		
228		if (tipoGara == 1) {
229		lcd.clear();
230		lcd.home();
231		lcd.print("Gara a giri"); // Gara a giri
232		}
233		if (tipoGara == 2) {
234		lcd.clear();
235		lcd.setCursor(0, 0);
236		lcd.print("Gara a tempo"); // Gara a tempo
237		}
238		lcd.noBlink();
239		delay(500);
240	}
241	
242	switch (tipoGara) {
243		case 1: // Gara a giri - imposta il numero di giri
244		configuraGiri();
245		break;
246		case 2: // Gara a tempo - imposta i minuti
247		totLap = 0;
248		configuraTempo();
249		break;
250	}
251	}
252	
253	lcd.noBlink();
254}
255
256void configuraGiri() { // Ottimizzato
257	lcd.clear();
258	lcd.home();
259	lcd.print("Up  Down   Enter"); // 0,1---4,1--11,1 posizione del cursore in base alla scelta
260	lcd.blink();
261	
262	int k = 0;
263	int colonna = 0;
264	
265	while (k == 0) {
266		delay(500);
267	
268		if (digitalRead(trk1) == 1) {
269			tone(audio, NOTE_G4, 50);
270			menuGiri = (menuGiri % 3) + 1; // Gestione del conteggio e della rotazione
271			
272			switch (menuGiri) { // Sposta il cursore
273			case 1:
274				colonna = c1c;
275				break;
276			case 2:
277				colonna = c2c;
278				break;
279			case 3:
280				colonna = c3c;
281				break;
282			}
283			
284			lcd.setCursor(colonna, 0); // Imposta il cursore sulla colonna corretta
285		}
286		
287		if (digitalRead(trk2) == 1) {
288			tone(audio, NOTE_G5, 50);
289			
290			switch (menuGiri) { // Sposta il cursore
291				case 1:
292					totLap++;
293					break;
294				case 2:
295					totLap--;
296					if (totLap < 1) {
297					totLap = 1;
298					}
299					break;
300				case 3:
301					k = 1;
302					lcd.noBlink();
303					break;
304			}
305		}
306		lcd.setCursor(0, 1);
307		lcd.print("giri:  ");
308		lcd.print(totLap);
309		lcd.print(" ");
310		lcd.setCursor(colonna, 0);
311	}
312	trk1Lap = totLap;
313	trk2Lap = totLap;
314	lcd.clear();
315	lcd2.clear();
316	lcd.home();
317	lcd.print("----------------");
318	lcd2.home();
319	lcd2.print("----------------");
320	lcd.setCursor(0, 1);
321	lcd.print("GARA DA ");
322	lcd.print(totLap);
323	lcd.print(" GIRI"); 
324	lcd2.setCursor(0, 1);
325	lcd2.print("GARA DA ");
326	lcd2.print(totLap);
327	lcd2.print(" GIRI"); 
328	lcd.noBlink();
329	delay(5000);
330}
331
332void configuraTempo() {
333	lcd.clear();
334	lcd.home();
335	lcd.print("Up  Down   Enter"); // 0,1---4,1--11,1 posizione del cursore in base alla scelta
336	lcd.blink();
337	
338	int k = 0;
339	int colonna = 0;
340	
341	while (k == 0) {
342		delay(500);
343		
344		if (digitalRead(trk1) == 1) {
345			tone(audio, NOTE_G4, 50);
346			menuTempo = (menuTempo % 3) + 1; // Gestisce la rotazione
347			
348			switch (menuTempo) { // Sposta il cursore 
349				case 1:
350					lcd.setCursor(c1c, 0);
351					colonna = c1c;
352					break;
353				case 2:
354					lcd.setCursor(c2c, 0);
355					colonna = c2c;
356					break;
357				case 3:
358					lcd.setCursor(c3c, 0);
359					colonna = c3c;
360					break;
361			}
362		}
363		if (digitalRead(trk2) == 1) {
364			tone(audio, NOTE_G5, 50);
365			
366			switch (menuTempo) { // Sposta il cursore 
367				case 1:
368					timeRace++;
369					break;
370				case 2:
371					timeRace--;
372					if (timeRace < 1) {
373						timeRace = 1;
374					}
375					break;
376				case 3:
377					k = 1;
378					lcd.noBlink();
379					break;
380			}
381		}
382		lcd.setCursor(0, 1);
383		lcd.print("minuti:  ");
384		lcd.print(timeRace);
385		lcd.print(" ");
386		lcd.setCursor(colonna, 0);
387	}
388	
389	timeRaceMillis = timeRace * 60000;
390	trk1Lap = 0;
391	trk2Lap = 0;
392	lcd.clear();
393	lcd2.clear();
394	lcd.home();
395	lcd.print("----------------");
396	lcd2.home();
397	lcd2.print("----------------");
398	lcd.setCursor(0, 1);
399	lcd.print("GARA DA ");
400	lcd.print(timeRace);
401	lcd.print(" Min");
402	lcd2.setCursor(0, 1);
403	lcd2.print("GARA DA ");
404	lcd2.print(timeRace);
405	lcd2.print(" Min");
406	lcd.noBlink();
407	delay(5000);
408}
409
410//---------- SEMFORO--------
411void semaforo() {     //ottimizzato
412	lcd.clear();lcd2.clear();
413	for (int col = 1; col <15; col = col + 3) {
414		lcd.setCursor(col, 1);lcd2.setCursor(col, 1);
415		lcd.print("0");lcd2.print("0");tone(audio,NOTE_F4,50);
416		delay(1200);
417	}
418	lcd.clear();lcd2.clear();tone(audio,NOTE_C5,250);
419}
420
421//-------Clock for LAP race----------- 
422long orologioRace(){  
423	mm=timePassed/60000;
424	ss=(timePassed-mm*60000)/1000;
425	dec=(timePassed-mm*60000-ss*1000)/10;  
426	lcd.setCursor(11, 0);
427	lcd.print(mm >= 10 ? mm : "0" + String(mm));
428	lcd.print(":");
429	lcd.print(ss >= 10 ? ss : "0" + String(ss));  
430	if(tipoPercorso==1) {       //shows the contdown for the second player
431		lcd2.setCursor(11, 0);
432		lcd2.print(mm >= 10 ? mm : "0" + String(mm));
433		lcd2.print(":");
434		lcd2.print(ss >= 10 ? ss : "0" + String(ss));
435	}
436}
437//-----CLOCK for TIME RACE- COUNTDOWN-----
438long orologio() {     
439	mm = timeRemain / 60000;
440	ss = (timeRemain - mm * 60000) / 1000;
441	lcd.setCursor(11, 0);
442	lcd.print(mm >= 10 ? mm : "0" + String(mm));
443	lcd.print(":");
444	lcd.print(ss >= 10 ? ss : "0" + String(ss));  
445	if(tipoPercorso==1) {       //shows the contdown for the second player
446		lcd2.setCursor(11, 0);
447		lcd2.print(mm >= 10 ? mm : "0" + String(mm));
448		lcd2.print(":");
449		lcd2.print(ss >= 10 ? ss : "0" + String(ss));
450	}
451}
452
453//------format the BEST TIME----------
454void formattaBest(){          //ottimizzato
455	mm1 = trk1BestLapTime / 60000;
456	ss1 = (trk1BestLapTime - mm1 * 60000) / 1000;
457	dec1 = (trk1BestLapTime - mm1 * 60000 - ss1 * 1000) / 10;
458	minut1 = (mm1 < 10) ? "0" + String(mm1) : String(mm1);
459	secondi1 = (ss1 < 10) ? "0" + String(ss1) : String(ss1);
460	deci1 = (dec1 < 10) ? "0" + String(dec1) : String(dec1);
461
462	if (tipoPercorso==1 || tipoPercorso==3){
463		mm2 = trk2BestLapTime / 60000;
464		ss2 = (trk2BestLapTime - mm2 * 60000) / 1000;
465		dec2 = (trk2BestLapTime - mm2 * 60000 - ss2 * 1000) / 10;
466		minut2 = (mm2 < 10) ? "0" + String(mm2) : String(mm2);
467		secondi2 = (ss2 < 10) ? "0" + String(ss2) : String(ss2);
468		deci2 = (dec2 < 10) ? "0" + String(dec2) : String(dec2);
469	}
470}
471void formattaLast(){      //ottimizzato
472	mm1 = trk1LapTime / 60000;
473	ss1 = (trk1LapTime - mm1 * 60000) / 1000;
474	dec1 = (trk1LapTime - mm1 * 60000 - ss1 * 1000) / 10;
475	
476	minut1 = (mm1 < 10) ? "0" + String(mm1) : String(mm1);
477	secondi1 = (ss1 < 10) ? "0" + String(ss1) : String(ss1);
478	deci1 = (dec1 < 10) ? "0" + String(dec1) : String(dec1);
479}
480//---gestione dei suoni----------   OTTIMIZZATO
481void playSound(int pin, int note, int duration) {
482	tone(pin, note, duration);
483	delay(duration + 50); // Add a small delay to avoid overlapping of tones
484	noTone(pin);
485}
486
487void startSound() {
488	int duration = 80;
489	playSound(audio, NOTE_C5, duration);
490	playSound(audio, NOTE_D5, duration);
491	playSound(audio, NOTE_F5, duration);
492	playSound(audio, NOTE_A5, duration);
493	playSound(audio, NOTE_GS5, duration);
494	playSound(audio, NOTE_A5, duration);
495	playSound(audio, NOTE_F5, duration * 2);
496}
497
498void endSound() {
499	int duration = 80;
500	playSound(audio, NOTE_C5, duration);
501	playSound(audio, NOTE_E5, duration);
502	playSound(audio, NOTE_G5, duration);
503	playSound(audio, NOTE_C6, duration);
504	playSound(audio, NOTE_G5, duration);
505	playSound(audio, NOTE_C6, duration * 2);
506}
507
508void byeSound() {
509	int duration = 100;
510	playSound(audio, NOTE_C5, duration);
511	playSound(audio, NOTE_B4, duration);
512	playSound(audio, NOTE_AS4, duration);
513	playSound(audio, NOTE_A4, duration);
514	playSound(audio, NOTE_GS4, duration * 5);
515}
516
517//--------Play again menu---------
518void ricomincia() {      //ottimizzato
519	int a = 0;
520	int r = 0;
521	int m = 0;
522	
523	while (a == 0) {      //resta nel ciclo finchè a resta 0
524		if (digitalRead(7) == 1 && digitalRead(9) == 1) {  //rileva l'oscuramento di entrambi i sensori per entrare nel menu
525			tone(audio, NOTE_G5, 50);
526			lcd.clear();
527			lcd.setCursor(0, 0);
528			lcd.print("  Ricominciare?"); // Play again?
529			lcd.setCursor(0, 1);
530			lcd.print("1=SI 2=menu 3=NO");
531			delay(1000);
532		
533			while (r == 0) {     //resta nel ciclo finchè r resta 0
534				delay(500);
535				if (digitalRead(7) == 1 && digitalRead(9) == 0) {  // scelta 1 "SI" per rigiocare
536					a = 1;
537					r = 1;
538					tone(audio, NOTE_G5, 50);
539				}
540				if (digitalRead(7) == 0 && digitalRead(9) == 1) {  // scelta 2 "menu" per rigiocare
541					a = 1;
542					r = 1;
543					m = 1;
544					tone(audio, NOTE_G5, 50);
545				}
546				if (digitalRead(7) == 1 && digitalRead(9) == 1) {   //scelta "NO" per uscire
547					lcd.clear();lcd2.clear();
548					lcd.setCursor(0, 0);
549					lcd.print("  ARRIVEDERCI");
550					byeSound();
551					exit(0);
552				}
553			}
554		}
555	}
556	if (a==1 && m==0){
557		winnerState =0;
558		trk1Lap = totLap;
559		trk2Lap = totLap;
560		lap0tr1 = 0;
561		lap0tr2 = 0;
562		trk1State = 0; 
563		trk2State = 0;
564		trk1BestLapTime=0;
565		trk2BestLapTime=0;
566		checkIR1=false;
567		checkIR2=false;
568		firstCKPT=false;
569		secondCKPT=false;
570		setup();
571	}
572	if (a==1 && m==1){
573		
574		checkIR1 = true;  //variable used to verify if an obstacle remain under IR1 
575		checkIR2 = true;  //variable used to verify if an obstacle remain under IR1
576		firstCKPT = false; //variable used in the two lane loop to be sure that the player doesn't miss a ring
577		secondCKPT= false;  //variable used in the two lane loop to be sure that the player doesn't miss a ring
578		//----variabili per menu-----
579		//----Menu percorso
580		tipoPercorso=0;
581		scegliPercorso=1;
582		c1a=0;  c2a=6;  c3a=12; //cursor position in the display in the track menu 
583		//----Menu gara----
584		tipoGara=0;
585		scegliGara=1;
586		c1b=0;  c2b=11;  //cursor position in the display in the race menu
587		//---Gara a Giri---
588		totLap = 5; //default value for LAP race
589		trk1Lap = 0;
590		trk2Lap = 0;
591		lap0tr1 = 0;
592		lap0tr2 = 0;
593		menuGiri=1;
594		c1c=0;  c2c=4;  c3c=11;  //cursor position in the display in the lap menu
595		//---Gara a Tempo---
596		timeRace = 1; //default value for timerace in minutes
597		timeRaceMillis; //timerace in millis
598		timeStart; //time when the race start
599		timeNow;
600		timeRemain; // =timeEnd-timeStart-timeNow-timeStart
601		timeEnd;//time the race will end timeStart + timeRace
602		timePassed;
603		menuTempo=1;
604		//---altre variabili---
605		winnerState =0;
606		lastDebounceTime1 = 0; // the last time the output pin was toggled
607		lastDebounceTime2 = 0; // the last time the output pin was toggled
608		trk1mill = 0; // millis for trk1
609		trk2mill = 0; // millis for trk2
610		debounceDelay = 2500; // the debounce time in millis; increase if the output flickers //tempo dell'anti-rimbalzo - da regolare
611		mm1,ss1,dec1; //minutes seconds and dec for Player 1
612		mm2,ss2,dec2; //minutes seconds and dec for Player 2
613		mm,ss,dec;    //variabili per gli orologi
614		minut1,secondi1,deci1;
615		minut2,secondi2,deci2;
616		tpminut;
617		tpsecondi;
618		tpdeci;
619		trk1LapTime,trk1BestLapTime,trk1EndLapTime,trk1StartLapTime;
620		trk2LapTime,trk2BestLapTime,trk2EndLapTime,trk2StartLapTime;
621		testoP1; 
622		testoP2;
623		setup();
624	}
625}
626
627//----from here the routines for each kind of races --- MOTORI DELLE GARE---- 
628
629/*gara per due giocatori a giri (tipoPercorso=1) oppure per singolo giocatore con rally loop (tipoPercorso2). 
630 *in questo caso la parte di rilvamento giri del secondo giocatore viene esclusa con una IF sul tipo di percorso 
631 */ 
632void garaAGiri() {   //----funzionante
633	
634	// Calcola il tempo trascorso nella gara
635	timeNow = millis();
636	timePassed = timeNow - timeStart;
637	orologioRace();
638	
639	// Gestione sensore IR per il giocatore 1
640	if (trk1State == 1 && checkIR1==false) {
641		trk1mill = millis();
642		tone(audio, NOTE_C5, 50);
643		checkIR1 = true;    
644		if ((trk1mill - lastDebounceTime1) > debounceDelay) {
645			if (lap0tr1 == 1) {
646				lastDebounceTime1 = millis();
647				trk1EndLapTime = trk1mill; 
648				trk1LapTime = trk1EndLapTime - trk1StartLapTime;
649				trk1Lap = trk1Lap - 1;
650				lcd.setCursor(4,0);
651				lcd.print(trk1Lap); //scrive i giri
652				
653				if (trk1LapTime <= trk1BestLapTime || trk1BestLapTime==0 ) {   // if (trk1BestLapTime == 0 || trk1LapTime <= trk1BestLapTime) {
654					trk1BestLapTime = trk1LapTime;
655					formattaBest();
656					testoP1 = minut1 + ":" + secondi1 + ":" + deci1;
657					lcd.setCursor(8, 1);lcd.print(testoP1);
658				}
659				trk1StartLapTime = lastDebounceTime1; 
660			} 
661			if (lap0tr1 == 0){ // Primo giro
662				lap0tr1 = 1;
663				trk1Lap = totLap;
664				lastDebounceTime1 = millis();
665				trk1StartLapTime = timeStart;
666				lcd.setCursor(4,0);
667				lcd.print(trk1Lap); //scrive i giri 
668			}
669		}
670	}
671	
672	// Gestione sensore IR per il giocatore 2
673	if (tipoPercorso==1) {
674		if (trk2State == 1 && checkIR2==false) {
675			trk2mill = millis();
676			tone(audio, NOTE_E5, 50);
677			checkIR2 = true;
678		
679			if ((trk2mill - lastDebounceTime2) > debounceDelay) {
680			// Controllo primo giro
681				if (lap0tr2 == 1) {   
682					trk2Lap = trk2Lap - 1;
683					lastDebounceTime2 = millis();
684					trk2EndLapTime = trk2mill; 
685					trk2LapTime = trk2EndLapTime - trk2StartLapTime;
686					lcd2.setCursor(4,0);
687					lcd2.print(trk2Lap); //scrive i giri
688					trk2StartLapTime = lastDebounceTime2;
689					if (trk2LapTime <= trk2BestLapTime || trk2BestLapTime==0 ) {
690						trk2BestLapTime = trk2LapTime;        
691						formattaBest();
692						testoP2 = minut2 + ":" + secondi2 + ":" + deci2;
693						lcd2.setCursor(8, 1);lcd2.print(testoP2);
694					}
695				} 
696				if (lap0tr2 == 0) { // Primo giro
697					lap0tr2 = 1;
698					trk2Lap = totLap;
699					lastDebounceTime2 = millis();
700					trk1StartLapTime = timeStart;
701					lcd2.setCursor(4,0);
702					lcd2.print(trk1Lap); //scrive i giri  
703				}  
704			}
705		}
706	}
707	
708	// Riporta lo stato dei sensori a false quando non rilevano nulla
709	if (trk1State == 0) {
710		checkIR1 = false;
711	}
712	if (trk2State == 0) {
713		checkIR2 = false;
714	}
715	
716	// Controllo se uno dei partecipanti ha terminato la gara
717	if (trk1Lap == 0 || trk2Lap == 0) {
718		winnerState = 1000;
719		endSound();
720		if (trk1Lap <= 0 && trk2Lap > 0) {   //P1 vince
721			lcd.setCursor(7, 0);
722			lcd.print("WIN");
723			if (tipoPercorso==1) {
724				lcd2.setCursor(7, 0);
725				lcd2.print("Lose");
726			}
727		}
728		if (tipoPercorso==1) {
729			if (trk2Lap <= 0 && trk1Lap > 0) {   //P2 vince
730				lcd2.setCursor(7, 0);
731				lcd2.print("WIN");
732				lcd.setCursor(7, 0);
733				lcd.print("Lose");
734			}
735		}
736	}
737	
738	// Ritarda per consentire ai partecipanti di vedere i risultati prima di ricominciare
739	if (winnerState == 1000) {
740		delay(20000);
741		ricomincia();
742	}
743}
744
745//----------------
746/*gara per due giocatori a tempo (tipoPercorso=1) oppure per singolo giocatore con rally loop (tipoPercorso2). 
747 *in questo caso la parte di rilvamento giri del secondo giocatore viene esclusa con una IF sul tipo di percorso 
748 */
749void garaATempo() {    //-----------Funzionante
750	timeNow = millis();
751	
752	// Calcola i parametri relativi al tempo di gara
753	timeEnd = timeStart + timeRaceMillis;
754	timePassed = timeNow - timeStart;
755	timeRemain = timeRaceMillis - timePassed;
756	
757	// Controlla se il tempo è scaduto
758	if (timeRemain >= 0) {
759		orologio();
760	} 
761	else {
762		winnerState = 1000;
763	}
764	// Gestione sensore IR per il giocatore 1
765	if (trk1State == 1 && winnerState < 1000 && checkIR1==false) {
766		trk1mill = millis();
767		tone(audio, NOTE_C5, 50);
768		checkIR1 = true;
769	
770		if ((trk1mill - lastDebounceTime1) > debounceDelay) {
771			if (lap0tr1 == 1) {
772				lastDebounceTime1 = millis(); // Imposta il tempo corrente
773				trk1EndLapTime = trk1mill;
774				trk1LapTime = trk1EndLapTime - trk1StartLapTime;
775				trk1StartLapTime = lastDebounceTime1;
776				trk1Lap = trk1Lap + 1;
777				lcd.setCursor(4, 0);
778				lcd.print(trk1Lap);
779				
780				// Aggiorna il miglior tempo se è il primo giro o se il tempo attuale è migliore
781				if (trk1LapTime < trk1BestLapTime || trk1BestLapTime==0) {
782					trk1BestLapTime = trk1LapTime;          
783					// Mostra il miglior tempo sul display per il giocatore 1
784					formattaBest();
785					testoP1 = minut1 + ":" + secondi1 + ":" + deci1;
786					lcd.setCursor(8, 1);
787					lcd.print(testoP1);
788				}
789			} 
790				if (lap0tr1 == 0){ // Primo giro
791					lap0tr1 = 1;
792					trk1Lap = 0;
793					lastDebounceTime1 = millis(); // Imposta il tempo corrente
794					trk1StartLapTime = timeStart;
795					lcd.setCursor(4, 0);
796					lcd.print(trk1Lap);
797				}
798		}
799	}
800	
801	// Gestione sensore IR per il giocatore 2 (solo se tipoPercorso è 1)
802	if (tipoPercorso == 1 && trk2State == 1 && winnerState < 1000 && checkIR2==false) {
803		trk2mill = millis();
804		tone(audio, NOTE_G5, 50);
805		checkIR2 = true;
806	
807		if ((trk2mill - lastDebounceTime2) > debounceDelay) {
808		// Controllo primo giro
809			if (lap0tr2 == 1) {
810				lastDebounceTime2 = millis(); // Imposta il tempo corrente
811				trk2EndLapTime = trk2mill;
812				trk2LapTime = trk2EndLapTime - trk2StartLapTime;
813				trk2StartLapTime = lastDebounceTime2;
814				trk2Lap = trk2Lap + 1;
815				lcd2.setCursor(4,0);
816				lcd2.print(trk2Lap);
817			// Aggiorna il miglior tempo se è il primo giro o se il tempo attuale è migliore
818				if (trk2BestLapTime == 0 || trk2LapTime <= trk2BestLapTime) {
819					trk2BestLapTime = trk2LapTime;
820					// Mostra il miglior tempo sul display per il giocatore 2
821					formattaBest();
822					testoP2 = " " + minut2 + ":" + secondi2 + ":" + deci2;
823					lcd2.setCursor(7, 1);
824					lcd2.print(testoP2);
825				}
826			} 
827			if (lap0tr2 == 0) { // Primo giro
828				lap0tr2 = 1;
829				trk2Lap = 0;
830				lastDebounceTime2 = millis(); // Imposta il tempo corrente
831				trk2StartLapTime = timeStart;
832				lcd2.setCursor(4, 0);
833				lcd2.print(trk2Lap);
834			}
835		}	
836	}
837	
838	// Riporta lo stato dei sensori a falso quando non rilevano nulla
839	if (trk1State == 0) {
840		checkIR1 = false;
841	}
842	if (trk2State == 0) {
843		checkIR2 = false;
844	}
845	
846	// Controllo se uno dei partecipanti ha terminato la gara
847	if (winnerState == 1000 ) {
848		if (trk1Lap > trk2Lap) { //vince P1
849			lcd.setCursor(7,0);
850			lcd.print("WINNER   ");
851		}   
852		if (tipoPercorso == 1 && trk1Lap < trk2Lap) {   //vince P2
853			lcd2.setCursor(7,0);
854			lcd2.print("WINNER   ");     
855		}
856		if (tipoPercorso == 1 && trk1Lap == trk2Lap) {  //in caso di parità allo scadere del tempo aspetta la prima macchina che passa sotto il traguardo
857			while (trk2State == 0 && trk1State == 0) {
858				// Wait until one car passes the finish line
859				trk1State = digitalRead(trk1);
860				trk2State = digitalRead(trk2);
861			}
862			if (trk1State == 1) {
863				lcd.setCursor(7, 0);
864				lcd.print("WINNER   ");
865			}
866			if (trk2State == 1) {
867				lcd2.setCursor(7, 0);
868				lcd2.print("WINNER   ");
869			}
870		}
871		endSound();
872		delay(20000);
873		ricomincia();
874	}
875}
876
877//----------------------------
878void loopDoppioGiri() {   //Funzionante
879	
880	// Calcola il tempo trascorso nella gara
881	timeNow = millis();
882	timePassed = timeNow - timeStart;
883	orologioRace();
884	
885// Gestione sensore IR per il giocatore 1
886	if (trk1State == 1 && checkIR1==false) {
887		trk1mill = millis();
888		tone(audio, NOTE_C5, 50);
889		checkIR1 = true;    
890		if ((trk1mill - lastDebounceTime1) > debounceDelay) {
891			if (lap0tr1 == 1 && firstCKPT==false && secondCKPT== true) {
892				lastDebounceTime1 = millis();
893				trk1EndLapTime = trk1mill; 
894				trk1LapTime = trk1EndLapTime - trk1StartLapTime;
895				trk1StartLapTime = lastDebounceTime1;
896				firstCKPT=true;
897				secondCKPT=false;
898				trk1Lap = trk1Lap - 1;
899				lcd.setCursor(4,0);
900				lcd.print(trk1Lap); //scrive i giri
901			
902				if (trk1LapTime <= trk1BestLapTime || trk1BestLapTime==0 ) {   // if (trk1BestLapTime == 0 || trk1LapTime <= trk1BestLapTime) {
903					trk1BestLapTime = trk1LapTime;
904					formattaBest();
905					testoP1 = minut1 + ":" + secondi1 + ":" + deci1;
906					lcd.setCursor(8, 1);lcd.print(testoP1);
907				}
908			} 
909			if (lap0tr1 == 0){ // Primo giro
910				lap0tr1 = 1;
911				trk1Lap = totLap;
912				lastDebounceTime1 = millis();
913				trk1StartLapTime = timeStart;
914				lcd.setCursor(4,0);
915				lcd.print(trk1Lap); //scrive i giri
916				firstCKPT=true;
917				secondCKPT=false;
918			}
919		}
920	}
921
922  // Gestione sensore IR per il giocatore 2
923	if (trk2State == 1 && checkIR2==false) {
924		trk2mill = millis();
925		tone(audio, NOTE_E5, 50);
926		checkIR2 = true;
927  
928		if ((trk2mill - lastDebounceTime2) > debounceDelay) {
929		// Controllo primo giro
930			if (lap0tr1 == 1 && firstCKPT==true && secondCKPT== false) {
931				lastDebounceTime2 = millis();
932				trk2EndLapTime = trk2mill; 
933				trk2LapTime = trk2EndLapTime - trk1StartLapTime;
934				//trk2StartLapTime = trk1StartLapTime;
935				firstCKPT=false;
936				secondCKPT=true;
937				if (trk2LapTime <= trk2BestLapTime || trk2BestLapTime==0 ) {
938					trk2BestLapTime = trk2LapTime;        
939					formattaBest();
940					testoP2 = "inter:"+minut2 + ":" + secondi2 + ":" + deci2;
941					lcd2.setCursor(1, 1);lcd2.print(testoP2);
942				}
943			}
944		}
945	}
946
947	// Riporta lo stato dei sensori a false quando non rilevano nulla
948	if (trk1State == 0) {
949		checkIR1 = false;
950	}
951	if (trk2State == 0) {
952		checkIR2 = false;
953	}
954
955	// Controllo se uno dei partecipanti ha terminato la gara
956	if (trk1Lap == 0) {
957
958		// Visualizza il vincitore del giocatore 1
959		lcd.setCursor(7,0);
960		lcd.print("WIN");
961		winnerState = 1000;
962		endSound();
963  // Ritarda per consentire ai partecipanti di vedere i risultati prima di ricominciare
964		if (winnerState == 1000) {
965			delay(10000);
966			ricomincia();
967		}
968	}
969}
970//--------------engine for Time Race for one player with cross between two lane 
971void loopDoppioTempo() {
972	timeNow=millis();
973	//----parametri del tempo di gara  
974	timeEnd=timeStart+timeRaceMillis;
975	timePassed=timeNow-timeStart;
976	timeRemain=timeRaceMillis-timePassed;
977	//controllo se il tempo è scaduto  
978	if (timeRemain>=0) {
979		orologio();
980	}
981	else {
982		winnerState = 1000; 
983	}//fine controllo tempo scaduto
984	//---debounce e conteggio giri
985	if (trk1State == 1 && winnerState <1000 && checkIR1 == false){
986		trk1mill = millis();tone(audio,NOTE_C5,50);checkIR1 = true;
987	//filter out any noise by setting a time buffer
988		if ((trk1mill - lastDebounceTime1) > debounceDelay ){  //check debaunce car has passed IR2 before
989			if (lap0tr1 == 1 && firstCKPT==false && secondCKPT==true) {
990				trk1Lap = trk1Lap+1;
991				lastDebounceTime1 = millis(); //set the current time
992				trk1EndLapTime = trk1mill; 
993				trk1LapTime=trk1EndLapTime-trk1StartLapTime;
994				trk1StartLapTime= lastDebounceTime1;
995				firstCKPT=true;secondCKPT=false;
996				lcd.setCursor(4,0);
997				lcd.print(trk1Lap); //scrive i giri
998				if (trk1LapTime <trk1BestLapTime|| trk1BestLapTime==0) {
999					trk1BestLapTime=trk1LapTime; 
1000					formattaBest();
1001					testoP1=String (minut1 + ":" + secondi1 + ":" + deci1);
1002					lcd.setCursor(8,1);lcd.print(testoP1);
1003				} 
1004			}
1005			if (lap0tr1 == 0) {       // first LAP non rileva il primo giro
1006				lap0tr1=1; //car under IR1
1007				trk1Lap = 0;
1008				lastDebounceTime1 = millis(); //set the current time
1009				trk1StartLapTime= timeStart;
1010				firstCKPT=true;secondCKPT=false; //regular situation
1011			}
1012		}
1013	}   //close if(time buffer)
1014	if (trk2State == 1 && winnerState <1000 && checkIR2 == false) {
1015		trk2mill = millis();tone(audio,NOTE_G5,50);checkIR2 = true;
1016		//filter out any noise by setting a time buffer
1017		if ((trk2mill - lastDebounceTime2) > debounceDelay ) {
1018			if (lap0tr1 == 1&& firstCKPT==true && secondCKPT==false) {   
1019				lastDebounceTime2 = millis(); //set the current time
1020				trk2EndLapTime = trk2mill; 
1021				trk2LapTime=trk2EndLapTime-trk1StartLapTime;
1022				firstCKPT=false;secondCKPT=true;
1023				trk2StartLapTime= lastDebounceTime1;
1024				if (trk2LapTime <= trk2BestLapTime||trk2BestLapTime==0) {
1025					trk2BestLapTime=trk2LapTime;
1026					formattaBest();
1027					testoP2=String ("Part:   " + minut2 + ":" + secondi2 + ":" + deci2);
1028					lcd2.setCursor(3,1);lcd2.print(testoP2); 
1029				}
1030			}
1031		}
1032	}//close if(time buffer) 
1033	if (trk1State == 0) {checkIR1=false;}
1034	if (trk2State == 0) {checkIR2=false;}     
1035	if (winnerState == 1000) {
1036		lcd.setCursor(7,0);
1037		lcd.print("FINISH   "); 	
1038		endSound();
1039		delay(20000);ricomincia();
1040	}
1041}
1042
1043
1044
1045/* True Fase table
1046LAP	FH	SH
1047Sta	F	F
10480	T	F
1049H0	F	T
10501	T	F
1051H1	F	T
10522	T	F	
1053
1054
1055*/

/*Version 20230817 
 assegnazione dei PIN su A-Micro
 Arduino ----7--9   
 pista   ---tr1-tr2
 Configurazione Display LCD 16x2 
 */

// include la libreria: 
#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd2(0x26,16,2);  // set the LCD address to 0x26 for a 16 chars and 2 line display
#define TONE_USE_INT
#define TONE_PITCH 440
#include <TonePitch.h>
// -------mappatura dei pin e stato contatti
int audio=6;
const byte trk1 = 7; //IR attached to this pin //pin per l'interruttore sensore dei lap sulla corsia 1
const byte trk2 = 9; //IR attached to this pin //pin per l'interruttore sensore dei lap sulla corsia 2
int trk1State = 0; //this variable tracks the state of IR, 
int trk2State = 0; //this variable tracks the state of IR, 
bool checkIR1 = true;  //variable used to verify if an obstacle remain under IR1 
bool checkIR2 = true;  //variable used to verify if an obstacle remain under IR1
bool firstCKPT = false; //variable used in the two lane loop to be sure that the player doesn't miss a ring
bool secondCKPT= false;  //variable used in the two lane loop to be sure that the player doesn't miss a ring
//----variabili per menu-----
//----Menu percorso
int tipoPercorso=0;
int scegliPercorso=1;
int c1a=0; int c2a=6; int c3a=12; //cursor position in the display in the track menu 
//----Menu gara----
int tipoGara=0;
int scegliGara=1;
int c1b=0; int c2b=11;  //cursor position in the display in the race menu
//---Gara a Giri---
int totLap = 5; //default value for LAP race
int trk1Lap = 0;
int trk2Lap = 0;
int lap0tr1 = 0;
int lap0tr2 = 0;
int menuGiri=1;
int c1c=0; int c2c=4; int c3c=11;  //cursor position in the display in the lap menu
//---Gara a Tempo---
long timeRace = 1; //default value for timerace in minutes
long timeRaceMillis; //timerace in millis
long timeStart; //time when the race start
long timeNow;
long timeRemain; // =timeEnd-timeStart-timeNow-timeStart
long timeEnd;//time the race will end timeStart + timeRace
long timePassed;
int menuTempo=1;
//---altre variabili---
int winnerState =0;
unsigned long lastDebounceTime1 = 0; // the last time the output pin was toggled
unsigned long lastDebounceTime2 = 0; // the last time the output pin was toggled
unsigned long trk1mill = 0; // millis for trk1
unsigned long trk2mill = 0; // millis for trk2
unsigned long debounceDelay = 2500; // the debounce time in millis; increase if the output flickers //tempo dell'anti-rimbalzo - da regolare
long mm1,ss1,dec1; //minutes seconds and dec for Player 1
long mm2,ss2,dec2; //minutes seconds and dec for Player 2
long mm,ss,dec;    //variabili per gli orologi
String minut1,secondi1,deci1;
String minut2,secondi2,deci2;
String tpminut;
String tpsecondi;
String tpdeci;
unsigned long trk1LapTime,trk1BestLapTime,trk1EndLapTime,trk1StartLapTime;
unsigned long trk2LapTime,trk2BestLapTime,trk2EndLapTime,trk2StartLapTime;
String testoP1; 
String testoP2;

//----------------------SETUP----------------------------
void setup() {
	pinMode(trk1,INPUT);
	pinMode(trk2,INPUT);
	lcd.init();lcd2.init(); //initialize the lcd
	lcd.backlight(); lcd2.backlight();//turn on the LCD backlight
	lcd.clear();lcd2.clear(); //clear the LCD screens and positions the cursor in the upper-left corner
	lcd2.home();lcd2.print("LANE 1 MOVE");lcd2.setCursor(0,1);lcd2.print("LANE 2 SELECT");startSound(); //use the IR to manage the cursor
	//-----routine per scegliere il tracciato------
	scegliTracciato(); //go to the routine to chose the track
	scegliCorsa();     //go to the routine to chose time or lap race
	
	//from here the START procedure
	
	lcd.clear();lcd2.clear(); //pulisco lo schermo
	lcd.home();lcd.print("PRENDI POSIZIONE");//be ready !
	lcd2.home();lcd2.print("PRENDI POSIZIONE");//be ready !
	delay(10000);
	lcd.home();lcd.print("    SEMAFORO    "); 
	lcd2.home();lcd2.print("    SEMAFORO    ");
	delay(3000);
	//Richiama la routine semaforo
	semaforo();
	lcd.setCursor(0,0);lcd.print("P1L:       --:--");
	lcd.setCursor(0,1);lcd.print("   best:--:--:--");

	lcd2.setCursor(0,0);lcd2.print("P2L:       --:--");
	lcd2.setCursor(0,1);lcd2.print("   best:--:--:--");
	checkIR1 = false;
	checkIR2 = false;
	timeStart=millis();//last row of setup
	trk1StartLapTime=timeStart;
	trk2StartLapTime=timeStart;
} 
//-------------------------END SETUP-----------------------------------
//-------------------------INIZIO LOOP-----------------------------------
void loop() {
	// Campiona lo stato dei pulsanti - premuti o non premuti?
	trk1State = digitalRead(trk1);
	trk2State = digitalRead(trk2);

	switch (scegliPercorso) {  // Sposta il cursore
		case 1:
			if (tipoGara == 1) {
				garaAGiri();  // Gara a giri per 2 giocatori su 2 corsie
			}
			if (tipoGara == 2) {
				garaATempo(); // Gara a tempo per 2 giocatori su 2 corsie
			}
			break;
		case 2:
			if (tipoGara == 1) {
				garaAGiri();  // Gara a giri per 1 giocatore in un percorso ad anello
			}
			if (tipoGara == 2) {
				garaATempo(); // Gara a tempo per 1 giocatore in un percorso ad anello
			}
			break;
		case 3:
			if (tipoGara == 1) {
				loopDoppioGiri();  // Percorso incrociato a giri per 1 giocatore
			}
			if (tipoGara == 2) {
				loopDoppioTempo(); // Percorso incrociato a tempo per 1 giocatore
			}
			break;
	}
}

//--------------------END LOOP-----------
void scegliTracciato() {
  lcd.setCursor(0, 0);
  lcd2.setCursor(0, 0); // Posiziona il cursore
  lcd.home();
  lcd.print("scegli tracciato"); // Scegli il tracciato
  lcd.setCursor(0, 1);
  lcd.print("2trk  rly1  rly2"); // 0,1---6,1--12,1 posizione del cursore
  lcd.setCursor(0, 1);
  lcd.blink();

  while (tipoPercorso == 0) { // Ciclo per la scelta del tipoPercorso spostando il cursore
    delay(500);
    
    if (digitalRead(7) == 1) {
      tone(audio, NOTE_G4, 50);
      scegliPercorso = (scegliPercorso % 3) + 1; // Gestione del conteggio e della rotazione
      
      switch (scegliPercorso) { // Sposta il cursore quando il sensore IR è oscurato
        case 1:
          lcd.setCursor(c1a, 1); // Due giocatori
          break;
        case 2:
          lcd.setCursor(c2a, 1); // Giocatore singolo con percorso ad anello
          break;
        case 3:
          lcd.setCursor(c3a, 1); // Giocatore singolo con corsia incrociata
          break;
      }
    }
    
    if (digitalRead(9) == 1) { // Imposta il percorso ed esce dal ciclo while
      tipoPercorso = scegliPercorso;
      tone(audio, NOTE_G5, 50);
      lcd.noBlink();
      
      if (tipoPercorso == 1) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("2 corsie classic"); // Due giocatori
      }
      if (tipoPercorso == 2) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("1 corsia rally"); // Giocatore singolo con percorso ad anello
      }
      if (tipoPercorso == 3) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("2 corsie rally"); // Giocatore singolo con corsia incrociata
      }
      delay(4000);
    }
  }
  lcd.noBlink();
}

void scegliCorsa() {
	// ----- Routine per scegliere il tipo di gara ------
	lcd.home();
	lcd.print("scegli tipo gara"); // Scegli il tipo di gara
	lcd.setCursor(0, 1);
	lcd.print("GIRI       TEMPO"); // 0,1---  11,1 posizione del cursore in base alla scelta
	lcd.setCursor(0, 1);
	
	while (tipoGara == 0) {
	lcd.blink(); // Mostra il cursore
	delay(500);
	
	if (digitalRead(7) == 1) {
		tone(audio, NOTE_G4, 50);
		scegliGara = (scegliGara % 3) + 1; // Gestione del conteggio e della rotazione
		
		switch (scegliGara) {
		case 1:
			lcd.setCursor(c1b, 1);
			break;
		case 2:
			lcd.setCursor(c2b, 1);
			break;
		}
	}
	
	if (digitalRead(9) == 1) {
		tipoGara = scegliGara;
		tone(audio, NOTE_G5, 50);
		
		if (tipoGara == 1) {
		lcd.clear();
		lcd.home();
		lcd.print("Gara a giri"); // Gara a giri
		}
		if (tipoGara == 2) {
		lcd.clear();
		lcd.setCursor(0, 0);
		lcd.print("Gara a tempo"); // Gara a tempo
		}
		lcd.noBlink();
		delay(500);
	}
	
	switch (tipoGara) {
		case 1: // Gara a giri - imposta il numero di giri
		configuraGiri();
		break;
		case 2: // Gara a tempo - imposta i minuti
		totLap = 0;
		configuraTempo();
		break;
	}
	}
	
	lcd.noBlink();
}

void configuraGiri() { // Ottimizzato
	lcd.clear();
	lcd.home();
	lcd.print("Up  Down   Enter"); // 0,1---4,1--11,1 posizione del cursore in base alla scelta
	lcd.blink();
	
	int k = 0;
	int colonna = 0;
	
	while (k == 0) {
		delay(500);
	
		if (digitalRead(trk1) == 1) {
			tone(audio, NOTE_G4, 50);
			menuGiri = (menuGiri % 3) + 1; // Gestione del conteggio e della rotazione
			
			switch (menuGiri) { // Sposta il cursore
			case 1:
				colonna = c1c;
				break;
			case 2:
				colonna = c2c;
				break;
			case 3:
				colonna = c3c;
				break;
			}
			
			lcd.setCursor(colonna, 0); // Imposta il cursore sulla colonna corretta
		}
		
		if (digitalRead(trk2) == 1) {
			tone(audio, NOTE_G5, 50);
			
			switch (menuGiri) { // Sposta il cursore
				case 1:
					totLap++;
					break;
				case 2:
					totLap--;
					if (totLap < 1) {
					totLap = 1;
					}
					break;
				case 3:
					k = 1;
					lcd.noBlink();
					break;
			}
		}
		lcd.setCursor(0, 1);
		lcd.print("giri:  ");
		lcd.print(totLap);
		lcd.print(" ");
		lcd.setCursor(colonna, 0);
	}
	trk1Lap = totLap;
	trk2Lap = totLap;
	lcd.clear();
	lcd2.clear();
	lcd.home();
	lcd.print("----------------");
	lcd2.home();
	lcd2.print("----------------");
	lcd.setCursor(0, 1);
	lcd.print("GARA DA ");
	lcd.print(totLap);
	lcd.print(" GIRI"); 
	lcd2.setCursor(0, 1);
	lcd2.print("GARA DA ");
	lcd2.print(totLap);
	lcd2.print(" GIRI"); 
	lcd.noBlink();
	delay(5000);
}

void configuraTempo() {
	lcd.clear();
	lcd.home();
	lcd.print("Up  Down   Enter"); // 0,1---4,1--11,1 posizione del cursore in base alla scelta
	lcd.blink();
	
	int k = 0;
	int colonna = 0;
	
	while (k == 0) {
		delay(500);
		
		if (digitalRead(trk1) == 1) {
			tone(audio, NOTE_G4, 50);
			menuTempo = (menuTempo % 3) + 1; // Gestisce la rotazione
			
			switch (menuTempo) { // Sposta il cursore 
				case 1:
					lcd.setCursor(c1c, 0);
					colonna = c1c;
					break;
				case 2:
					lcd.setCursor(c2c, 0);
					colonna = c2c;
					break;
				case 3:
					lcd.setCursor(c3c, 0);
					colonna = c3c;
					break;
			}
		}
		if (digitalRead(trk2) == 1) {
			tone(audio, NOTE_G5, 50);
			
			switch (menuTempo) { // Sposta il cursore 
				case 1:
					timeRace++;
					break;
				case 2:
					timeRace--;
					if (timeRace < 1) {
						timeRace = 1;
					}
					break;
				case 3:
					k = 1;
					lcd.noBlink();
					break;
			}
		}
		lcd.setCursor(0, 1);
		lcd.print("minuti:  ");
		lcd.print(timeRace);
		lcd.print(" ");
		lcd.setCursor(colonna, 0);
	}
	
	timeRaceMillis = timeRace * 60000;
	trk1Lap = 0;
	trk2Lap = 0;
	lcd.clear();
	lcd2.clear();
	lcd.home();
	lcd.print("----------------");
	lcd2.home();
	lcd2.print("----------------");
	lcd.setCursor(0, 1);
	lcd.print("GARA DA ");
	lcd.print(timeRace);
	lcd.print(" Min");
	lcd2.setCursor(0, 1);
	lcd2.print("GARA DA ");
	lcd2.print(timeRace);
	lcd2.print(" Min");
	lcd.noBlink();
	delay(5000);
}

//---------- SEMFORO--------
void semaforo() {     //ottimizzato
	lcd.clear();lcd2.clear();
	for (int col = 1; col <15; col = col + 3) {
		lcd.setCursor(col, 1);lcd2.setCursor(col, 1);
		lcd.print("0");lcd2.print("0");tone(audio,NOTE_F4,50);
		delay(1200);
	}
	lcd.clear();lcd2.clear();tone(audio,NOTE_C5,250);
}

//-------Clock for LAP race----------- 
long orologioRace(){  
	mm=timePassed/60000;
	ss=(timePassed-mm*60000)/1000;
	dec=(timePassed-mm*60000-ss*1000)/10;  
	lcd.setCursor(11, 0);
	lcd.print(mm >= 10 ? mm : "0" + String(mm));
	lcd.print(":");
	lcd.print(ss >= 10 ? ss : "0" + String(ss));  
	if(tipoPercorso==1) {       //shows the contdown for the second player
		lcd2.setCursor(11, 0);
		lcd2.print(mm >= 10 ? mm : "0" + String(mm));
		lcd2.print(":");
		lcd2.print(ss >= 10 ? ss : "0" + String(ss));
	}
}
//-----CLOCK for TIME RACE- COUNTDOWN-----
long orologio() {     
	mm = timeRemain / 60000;
	ss = (timeRemain - mm * 60000) / 1000;
	lcd.setCursor(11, 0);
	lcd.print(mm >= 10 ? mm : "0" + String(mm));
	lcd.print(":");
	lcd.print(ss >= 10 ? ss : "0" + String(ss));  
	if(tipoPercorso==1) {       //shows the contdown for the second player
		lcd2.setCursor(11, 0);
		lcd2.print(mm >= 10 ? mm : "0" + String(mm));
		lcd2.print(":");
		lcd2.print(ss >= 10 ? ss : "0" + String(ss));
	}
}

//------format the BEST TIME----------
void formattaBest(){          //ottimizzato
	mm1 = trk1BestLapTime / 60000;
	ss1 = (trk1BestLapTime - mm1 * 60000) / 1000;
	dec1 = (trk1BestLapTime - mm1 * 60000 - ss1 * 1000) / 10;
	minut1 = (mm1 < 10) ? "0" + String(mm1) : String(mm1);
	secondi1 = (ss1 < 10) ? "0" + String(ss1) : String(ss1);
	deci1 = (dec1 < 10) ? "0" + String(dec1) : String(dec1);

	if (tipoPercorso==1 || tipoPercorso==3){
		mm2 = trk2BestLapTime / 60000;
		ss2 = (trk2BestLapTime - mm2 * 60000) / 1000;
		dec2 = (trk2BestLapTime - mm2 * 60000 - ss2 * 1000) / 10;
		minut2 = (mm2 < 10) ? "0" + String(mm2) : String(mm2);
		secondi2 = (ss2 < 10) ? "0" + String(ss2) : String(ss2);
		deci2 = (dec2 < 10) ? "0" + String(dec2) : String(dec2);
	}
}
void formattaLast(){      //ottimizzato
	mm1 = trk1LapTime / 60000;
	ss1 = (trk1LapTime - mm1 * 60000) / 1000;
	dec1 = (trk1LapTime - mm1 * 60000 - ss1 * 1000) / 10;
	
	minut1 = (mm1 < 10) ? "0" + String(mm1) : String(mm1);
	secondi1 = (ss1 < 10) ? "0" + String(ss1) : String(ss1);
	deci1 = (dec1 < 10) ? "0" + String(dec1) : String(dec1);
}
//---gestione dei suoni----------   OTTIMIZZATO
void playSound(int pin, int note, int duration) {
	tone(pin, note, duration);
	delay(duration + 50); // Add a small delay to avoid overlapping of tones
	noTone(pin);
}

void startSound() {
	int duration = 80;
	playSound(audio, NOTE_C5, duration);
	playSound(audio, NOTE_D5, duration);
	playSound(audio, NOTE_F5, duration);
	playSound(audio, NOTE_A5, duration);
	playSound(audio, NOTE_GS5, duration);
	playSound(audio, NOTE_A5, duration);
	playSound(audio, NOTE_F5, duration * 2);
}

void endSound() {
	int duration = 80;
	playSound(audio, NOTE_C5, duration);
	playSound(audio, NOTE_E5, duration);
	playSound(audio, NOTE_G5, duration);
	playSound(audio, NOTE_C6, duration);
	playSound(audio, NOTE_G5, duration);
	playSound(audio, NOTE_C6, duration * 2);
}

void byeSound() {
	int duration = 100;
	playSound(audio, NOTE_C5, duration);
	playSound(audio, NOTE_B4, duration);
	playSound(audio, NOTE_AS4, duration);
	playSound(audio, NOTE_A4, duration);
	playSound(audio, NOTE_GS4, duration * 5);
}

//--------Play again menu---------
void ricomincia() {      //ottimizzato
	int a = 0;
	int r = 0;
	int m = 0;
	
	while (a == 0) {      //resta nel ciclo finchè a resta 0
		if (digitalRead(7) == 1 && digitalRead(9) == 1) {  //rileva l'oscuramento di entrambi i sensori per entrare nel menu
			tone(audio, NOTE_G5, 50);
			lcd.clear();
			lcd.setCursor(0, 0);
			lcd.print("  Ricominciare?"); // Play again?
			lcd.setCursor(0, 1);
			lcd.print("1=SI 2=menu 3=NO");
			delay(1000);
		
			while (r == 0) {     //resta nel ciclo finchè r resta 0
				delay(500);
				if (digitalRead(7) == 1 && digitalRead(9) == 0) {  // scelta 1 "SI" per rigiocare
					a = 1;
					r = 1;
					tone(audio, NOTE_G5, 50);
				}
				if (digitalRead(7) == 0 && digitalRead(9) == 1) {  // scelta 2 "menu" per rigiocare
					a = 1;
					r = 1;
					m = 1;
					tone(audio, NOTE_G5, 50);
				}
				if (digitalRead(7) == 1 && digitalRead(9) == 1) {   //scelta "NO" per uscire
					lcd.clear();lcd2.clear();
					lcd.setCursor(0, 0);
					lcd.print("  ARRIVEDERCI");
					byeSound();
					exit(0);
				}
			}
		}
	}
	if (a==1 && m==0){
		winnerState =0;
		trk1Lap = totLap;
		trk2Lap = totLap;
		lap0tr1 = 0;
		lap0tr2 = 0;
		trk1State = 0; 
		trk2State = 0;
		trk1BestLapTime=0;
		trk2BestLapTime=0;
		checkIR1=false;
		checkIR2=false;
		firstCKPT=false;
		secondCKPT=false;
		setup();
	}
	if (a==1 && m==1){
		
		checkIR1 = true;  //variable used to verify if an obstacle remain under IR1 
		checkIR2 = true;  //variable used to verify if an obstacle remain under IR1
		firstCKPT = false; //variable used in the two lane loop to be sure that the player doesn't miss a ring
		secondCKPT= false;  //variable used in the two lane loop to be sure that the player doesn't miss a ring
		//----variabili per menu-----
		//----Menu percorso
		tipoPercorso=0;
		scegliPercorso=1;
		c1a=0;  c2a=6;  c3a=12; //cursor position in the display in the track menu 
		//----Menu gara----
		tipoGara=0;
		scegliGara=1;
		c1b=0;  c2b=11;  //cursor position in the display in the race menu
		//---Gara a Giri---
		totLap = 5; //default value for LAP race
		trk1Lap = 0;
		trk2Lap = 0;
		lap0tr1 = 0;
		lap0tr2 = 0;
		menuGiri=1;
		c1c=0;  c2c=4;  c3c=11;  //cursor position in the display in the lap menu
		//---Gara a Tempo---
		timeRace = 1; //default value for timerace in minutes
		timeRaceMillis; //timerace in millis
		timeStart; //time when the race start
		timeNow;
		timeRemain; // =timeEnd-timeStart-timeNow-timeStart
		timeEnd;//time the race will end timeStart + timeRace
		timePassed;
		menuTempo=1;
		//---altre variabili---
		winnerState =0;
		lastDebounceTime1 = 0; // the last time the output pin was toggled
		lastDebounceTime2 = 0; // the last time the output pin was toggled
		trk1mill = 0; // millis for trk1
		trk2mill = 0; // millis for trk2
		debounceDelay = 2500; // the debounce time in millis; increase if the output flickers //tempo dell'anti-rimbalzo - da regolare
		mm1,ss1,dec1; //minutes seconds and dec for Player 1
		mm2,ss2,dec2; //minutes seconds and dec for Player 2
		mm,ss,dec;    //variabili per gli orologi
		minut1,secondi1,deci1;
		minut2,secondi2,deci2;
		tpminut;
		tpsecondi;
		tpdeci;
		trk1LapTime,trk1BestLapTime,trk1EndLapTime,trk1StartLapTime;
		trk2LapTime,trk2BestLapTime,trk2EndLapTime,trk2StartLapTime;
		testoP1; 
		testoP2;
		setup();
	}
}

//----from here the routines for each kind of races --- MOTORI DELLE GARE---- 

/*gara per due giocatori a giri (tipoPercorso=1) oppure per singolo giocatore con rally loop (tipoPercorso2). 
 *in questo caso la parte di rilvamento giri del secondo giocatore viene esclusa con una IF sul tipo di percorso 
 */ 
void garaAGiri() {   //----funzionante
	
	// Calcola il tempo trascorso nella gara
	timeNow = millis();
	timePassed = timeNow - timeStart;
	orologioRace();
	
	// Gestione sensore IR per il giocatore 1
	if (trk1State == 1 && checkIR1==false) {
		trk1mill = millis();
		tone(audio, NOTE_C5, 50);
		checkIR1 = true;    
		if ((trk1mill - lastDebounceTime1) > debounceDelay) {
			if (lap0tr1 == 1) {
				lastDebounceTime1 = millis();
				trk1EndLapTime = trk1mill; 
				trk1LapTime = trk1EndLapTime - trk1StartLapTime;
				trk1Lap = trk1Lap - 1;
				lcd.setCursor(4,0);
				lcd.print(trk1Lap); //scrive i giri
				
				if (trk1LapTime <= trk1BestLapTime || trk1BestLapTime==0 ) {   // if (trk1BestLapTime == 0 || trk1LapTime <= trk1BestLapTime) {
					trk1BestLapTime = trk1LapTime;
					formattaBest();
					testoP1 = minut1 + ":" + secondi1 + ":" + deci1;
					lcd.setCursor(8, 1);lcd.print(testoP1);
				}
				trk1StartLapTime = lastDebounceTime1; 
			} 
			if (lap0tr1 == 0){ // Primo giro
				lap0tr1 = 1;
				trk1Lap = totLap;
				lastDebounceTime1 = millis();
				trk1StartLapTime = timeStart;
				lcd.setCursor(4,0);
				lcd.print(trk1Lap); //scrive i giri 
			}
		}
	}
	
	// Gestione sensore IR per il giocatore 2
	if (tipoPercorso==1) {
		if (trk2State == 1 && checkIR2==false) {
			trk2mill = millis();
			tone(audio, NOTE_E5, 50);
			checkIR2 = true;
		
			if ((trk2mill - lastDebounceTime2) > debounceDelay) {
			// Controllo primo giro
				if (lap0tr2 == 1) {   
					trk2Lap = trk2Lap - 1;
					lastDebounceTime2 = millis();
					trk2EndLapTime = trk2mill; 
					trk2LapTime = trk2EndLapTime - trk2StartLapTime;
					lcd2.setCursor(4,0);
					lcd2.print(trk2Lap); //scrive i giri
					trk2StartLapTime = lastDebounceTime2;
					if (trk2LapTime <= trk2BestLapTime || trk2BestLapTime==0 ) {
						trk2BestLapTime = trk2LapTime;        
						formattaBest();
						testoP2 = minut2 + ":" + secondi2 + ":" + deci2;
						lcd2.setCursor(8, 1);lcd2.print(testoP2);
					}
				} 
				if (lap0tr2 == 0) { // Primo giro
					lap0tr2 = 1;
					trk2Lap = totLap;
					lastDebounceTime2 = millis();
					trk1StartLapTime = timeStart;
					lcd2.setCursor(4,0);
					lcd2.print(trk1Lap); //scrive i giri  
				}  
			}
		}
	}
	
	// Riporta lo stato dei sensori a false quando non rilevano nulla
	if (trk1State == 0) {
		checkIR1 = false;
	}
	if (trk2State == 0) {
		checkIR2 = false;
	}
	
	// Controllo se uno dei partecipanti ha terminato la gara
	if (trk1Lap == 0 || trk2Lap == 0) {
		winnerState = 1000;
		endSound();
		if (trk1Lap <= 0 && trk2Lap > 0) {   //P1 vince
			lcd.setCursor(7, 0);
			lcd.print("WIN");
			if (tipoPercorso==1) {
				lcd2.setCursor(7, 0);
				lcd2.print("Lose");
			}
		}
		if (tipoPercorso==1) {
			if (trk2Lap <= 0 && trk1Lap > 0) {   //P2 vince
				lcd2.setCursor(7, 0);
				lcd2.print("WIN");
				lcd.setCursor(7, 0);
				lcd.print("Lose");
			}
		}
	}
	
	// Ritarda per consentire ai partecipanti di vedere i risultati prima di ricominciare
	if (winnerState == 1000) {
		delay(20000);
		ricomincia();
	}
}

//----------------
/*gara per due giocatori a tempo (tipoPercorso=1) oppure per singolo giocatore con rally loop (tipoPercorso2). 
 *in questo caso la parte di rilvamento giri del secondo giocatore viene esclusa con una IF sul tipo di percorso 
 */
void garaATempo() {    //-----------Funzionante
	timeNow = millis();
	
	// Calcola i parametri relativi al tempo di gara
	timeEnd = timeStart + timeRaceMillis;
	timePassed = timeNow - timeStart;
	timeRemain = timeRaceMillis - timePassed;
	
	// Controlla se il tempo è scaduto
	if (timeRemain >= 0) {
		orologio();
	} 
	else {
		winnerState = 1000;
	}
	// Gestione sensore IR per il giocatore 1
	if (trk1State == 1 && winnerState < 1000 && checkIR1==false) {
		trk1mill = millis();
		tone(audio, NOTE_C5, 50);
		checkIR1 = true;
	
		if ((trk1mill - lastDebounceTime1) > debounceDelay) {
			if (lap0tr1 == 1) {
				lastDebounceTime1 = millis(); // Imposta il tempo corrente
				trk1EndLapTime = trk1mill;
				trk1LapTime = trk1EndLapTime - trk1StartLapTime;
				trk1StartLapTime = lastDebounceTime1;
				trk1Lap = trk1Lap + 1;
				lcd.setCursor(4, 0);
				lcd.print(trk1Lap);
				
				// Aggiorna il miglior tempo se è il primo giro o se il tempo attuale è migliore
				if (trk1LapTime < trk1BestLapTime || trk1BestLapTime==0) {
					trk1BestLapTime = trk1LapTime;          
					// Mostra il miglior tempo sul display per il giocatore 1
					formattaBest();
					testoP1 = minut1 + ":" + secondi1 + ":" + deci1;
					lcd.setCursor(8, 1);
					lcd.print(testoP1);
				}
			} 
				if (lap0tr1 == 0){ // Primo giro
					lap0tr1 = 1;
					trk1Lap = 0;
					lastDebounceTime1 = millis(); // Imposta il tempo corrente
					trk1StartLapTime = timeStart;
					lcd.setCursor(4, 0);
					lcd.print(trk1Lap);
				}
		}
	}
	
	// Gestione sensore IR per il giocatore 2 (solo se tipoPercorso è 1)
	if (tipoPercorso == 1 && trk2State == 1 && winnerState < 1000 && checkIR2==false) {
		trk2mill = millis();
		tone(audio, NOTE_G5, 50);
		checkIR2 = true;
	
		if ((trk2mill - lastDebounceTime2) > debounceDelay) {
		// Controllo primo giro
			if (lap0tr2 == 1) {
				lastDebounceTime2 = millis(); // Imposta il tempo corrente
				trk2EndLapTime = trk2mill;
				trk2LapTime = trk2EndLapTime - trk2StartLapTime;
				trk2StartLapTime = lastDebounceTime2;
				trk2Lap = trk2Lap + 1;
				lcd2.setCursor(4,0);
				lcd2.print(trk2Lap);
			// Aggiorna il miglior tempo se è il primo giro o se il tempo attuale è migliore
				if (trk2BestLapTime == 0 || trk2LapTime <= trk2BestLapTime) {
					trk2BestLapTime = trk2LapTime;
					// Mostra il miglior tempo sul display per il giocatore 2
					formattaBest();
					testoP2 = " " + minut2 + ":" + secondi2 + ":" + deci2;
					lcd2.setCursor(7, 1);
					lcd2.print(testoP2);
				}
			} 
			if (lap0tr2 == 0) { // Primo giro
				lap0tr2 = 1;
				trk2Lap = 0;
				lastDebounceTime2 = millis(); // Imposta il tempo corrente
				trk2StartLapTime = timeStart;
				lcd2.setCursor(4, 0);
				lcd2.print(trk2Lap);
			}
		}	
	}
	
	// Riporta lo stato dei sensori a falso quando non rilevano nulla
	if (trk1State == 0) {
		checkIR1 = false;
	}
	if (trk2State == 0) {
		checkIR2 = false;
	}
	
	// Controllo se uno dei partecipanti ha terminato la gara
	if (winnerState == 1000 ) {
		if (trk1Lap > trk2Lap) { //vince P1
			lcd.setCursor(7,0);
			lcd.print("WINNER   ");
		}   
		if (tipoPercorso == 1 && trk1Lap < trk2Lap) {   //vince P2
			lcd2.setCursor(7,0);
			lcd2.print("WINNER   ");     
		}
		if (tipoPercorso == 1 && trk1Lap == trk2Lap) {  //in caso di parità allo scadere del tempo aspetta la prima macchina che passa sotto il traguardo
			while (trk2State == 0 && trk1State == 0) {
				// Wait until one car passes the finish line
				trk1State = digitalRead(trk1);
				trk2State = digitalRead(trk2);
			}
			if (trk1State == 1) {
				lcd.setCursor(7, 0);
				lcd.print("WINNER   ");
			}
			if (trk2State == 1) {
				lcd2.setCursor(7, 0);
				lcd2.print("WINNER   ");
			}
		}
		endSound();
		delay(20000);
		ricomincia();
	}
}

//----------------------------
void loopDoppioGiri() {   //Funzionante
	
	// Calcola il tempo trascorso nella gara
	timeNow = millis();
	timePassed = timeNow - timeStart;
	orologioRace();
	
// Gestione sensore IR per il giocatore 1
	if (trk1State == 1 && checkIR1==false) {
		trk1mill = millis();
		tone(audio, NOTE_C5, 50);
		checkIR1 = true;    
		if ((trk1mill - lastDebounceTime1) > debounceDelay) {
			if (lap0tr1 == 1 && firstCKPT==false && secondCKPT== true) {
				lastDebounceTime1 = millis();
				trk1EndLapTime = trk1mill; 
				trk1LapTime = trk1EndLapTime - trk1StartLapTime;
				trk1StartLapTime = lastDebounceTime1;
				firstCKPT=true;
				secondCKPT=false;
				trk1Lap = trk1Lap - 1;
				lcd.setCursor(4,0);
				lcd.print(trk1Lap); //scrive i giri
			
				if (trk1LapTime <= trk1BestLapTime || trk1BestLapTime==0 ) {   // if (trk1BestLapTime == 0 || trk1LapTime <= trk1BestLapTime) {
					trk1BestLapTime = trk1LapTime;
					formattaBest();
					testoP1 = minut1 + ":" + secondi1 + ":" + deci1;
					lcd.setCursor(8, 1);lcd.print(testoP1);
				}
			} 
			if (lap0tr1 == 0){ // Primo giro
				lap0tr1 = 1;
				trk1Lap = totLap;
				lastDebounceTime1 = millis();
				trk1StartLapTime = timeStart;
				lcd.setCursor(4,0);
				lcd.print(trk1Lap); //scrive i giri
				firstCKPT=true;
				secondCKPT=false;
			}
		}
	}

  // Gestione sensore IR per il giocatore 2
	if (trk2State == 1 && checkIR2==false) {
		trk2mill = millis();
		tone(audio, NOTE_E5, 50);
		checkIR2 = true;
  
		if ((trk2mill - lastDebounceTime2) > debounceDelay) {
		// Controllo primo giro
			if (lap0tr1 == 1 && firstCKPT==true && secondCKPT== false) {
				lastDebounceTime2 = millis();
				trk2EndLapTime = trk2mill; 
				trk2LapTime = trk2EndLapTime - trk1StartLapTime;
				//trk2StartLapTime = trk1StartLapTime;
				firstCKPT=false;
				secondCKPT=true;
				if (trk2LapTime <= trk2BestLapTime || trk2BestLapTime==0 ) {
					trk2BestLapTime = trk2LapTime;        
					formattaBest();
					testoP2 = "inter:"+minut2 + ":" + secondi2 + ":" + deci2;
					lcd2.setCursor(1, 1);lcd2.print(testoP2);
				}
			}
		}
	}

	// Riporta lo stato dei sensori a false quando non rilevano nulla
	if (trk1State == 0) {
		checkIR1 = false;
	}
	if (trk2State == 0) {
		checkIR2 = false;
	}

	// Controllo se uno dei partecipanti ha terminato la gara
	if (trk1Lap == 0) {

		// Visualizza il vincitore del giocatore 1
		lcd.setCursor(7,0);
		lcd.print("WIN");
		winnerState = 1000;
		endSound();
  // Ritarda per consentire ai partecipanti di vedere i risultati prima di ricominciare
		if (winnerState == 1000) {
			delay(10000);
			ricomincia();
		}
	}
}
//--------------engine for Time Race for one player with cross between two lane 
void loopDoppioTempo() {
	timeNow=millis();
	//----parametri del tempo di gara  
	timeEnd=timeStart+timeRaceMillis;
	timePassed=timeNow-timeStart;
	timeRemain=timeRaceMillis-timePassed;
	//controllo se il tempo è scaduto  
	if (timeRemain>=0) {
		orologio();
	}
	else {
		winnerState = 1000; 
	}//fine controllo tempo scaduto
	//---debounce e conteggio giri
	if (trk1State == 1 && winnerState <1000 && checkIR1 == false){
		trk1mill = millis();tone(audio,NOTE_C5,50);checkIR1 = true;
	//filter out any noise by setting a time buffer
		if ((trk1mill - lastDebounceTime1) > debounceDelay ){  //check debaunce car has passed IR2 before
			if (lap0tr1 == 1 && firstCKPT==false && secondCKPT==true) {
				trk1Lap = trk1Lap+1;
				lastDebounceTime1 = millis(); //set the current time
				trk1EndLapTime = trk1mill; 
				trk1LapTime=trk1EndLapTime-trk1StartLapTime;
				trk1StartLapTime= lastDebounceTime1;
				firstCKPT=true;secondCKPT=false;
				lcd.setCursor(4,0);
				lcd.print(trk1Lap); //scrive i giri
				if (trk1LapTime <trk1BestLapTime|| trk1BestLapTime==0) {
					trk1BestLapTime=trk1LapTime; 
					formattaBest();
					testoP1=String (minut1 + ":" + secondi1 + ":" + deci1);
					lcd.setCursor(8,1);lcd.print(testoP1);
				} 
			}
			if (lap0tr1 == 0) {       // first LAP non rileva il primo giro
				lap0tr1=1; //car under IR1
				trk1Lap = 0;
				lastDebounceTime1 = millis(); //set the current time
				trk1StartLapTime= timeStart;
				firstCKPT=true;secondCKPT=false; //regular situation
			}
		}
	}   //close if(time buffer)
	if (trk2State == 1 && winnerState <1000 && checkIR2 == false) {
		trk2mill = millis();tone(audio,NOTE_G5,50);checkIR2 = true;
		//filter out any noise by setting a time buffer
		if ((trk2mill - lastDebounceTime2) > debounceDelay ) {
			if (lap0tr1 == 1&& firstCKPT==true && secondCKPT==false) {   
				lastDebounceTime2 = millis(); //set the current time
				trk2EndLapTime = trk2mill; 
				trk2LapTime=trk2EndLapTime-trk1StartLapTime;
				firstCKPT=false;secondCKPT=true;
				trk2StartLapTime= lastDebounceTime1;
				if (trk2LapTime <= trk2BestLapTime||trk2BestLapTime==0) {
					trk2BestLapTime=trk2LapTime;
					formattaBest();
					testoP2=String ("Part:   " + minut2 + ":" + secondi2 + ":" + deci2);
					lcd2.setCursor(3,1);lcd2.print(testoP2); 
				}
			}
		}
	}//close if(time buffer) 
	if (trk1State == 0) {checkIR1=false;}
	if (trk2State == 0) {checkIR2=false;}     
	if (winnerState == 1000) {
		lcd.setCursor(7,0);
		lcd.print("FINISH   "); 	
		endSound();
		delay(20000);ricomincia();
	}
}



/* True Fase table
LAP	FH	SH
Sta	F	F
0	T	F
H0	F	T
1	T	F
H1	F	T
2	T	F	


*/

Comments

Only logged in users can leave comments

sierra070

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content