Arduino : costruiamo un semplice gioco di memoria

Arduino è una schedina versatile, si presta e si adatta alla nostra fantasia.

Immaginiamo di voler costruire un gioco di memoria, in cui posizioniamo 9 led e 9 pulsanti.

facciamo accendere i led in maniera casuale ed attendiamo che il giocatore riproponga la combinazione tramite i tasti. Possiamo complicare i giocatori più bravi aumentando il numero di posizioni da indovinare ogni volta.

Casomai associamo i vari led anche ad un suono così da avere una doppia associazione audio-visiva.

Mettiamoci all’opera:

Materiali consigliati :

1) scheda arduino

2) 1 led verde, 1 led rosso, 9 led gialli

3) 1 buzzer

4) 9 pulsanti

5) 1 mux

6) varie resistenze da 1k, 56k, 220 ohm, trimmer 20k

7) resistenza variabile 20k, display lcd 16×2

8) fili vari ed eventuali preferibilmente colorati

9) un supporto per piastricciare ( chi è ordinato può organizzarsi con una breadboard )

10) saldatore e stagno per chi si vuole divertire davvero.

progetto : Memory Game

La griglia di led:

Gli ingressi e le uscite di arduino sono un numero esiguo e per poter pilotare comodamente più uscite possiamo usare un componente chiamato mux.
grazie ad un mux facilmente reperibile in commercio e di basso costo possiamo collegare 8 led al positivo e mettere una resistenza ad un negativo comune di 200 ohm .
Questo vuol dire che andremo a posizionare i 9 pin, collegandone 8 con il positivo alle 8 uscite del mux, ed il nono direttamente ad arduino. Il negativo dei led può essere raccolto tutto sulla resistenza che poi è collegata al meno.
Quindi avremo : sull’arduino 4 pin che pilotano il mux, 3 per l’indirizzamento(muxanpin), ed il quarto che indica quando accendere il led (muxacompin) ed un quinto pin che pilota direttamente il nono led.
( 5 ingressi/uscite sono andati 🙂 )
Il mux ha 3 ingressi che stabiliscono quale uscita attivare, in binario 3 cifre raggiungono esattamente il numero 8, quindi se consideriamo i 3 ingressi come dei numeri binari, possiamo decidere dove indirizzare il nostro segnale.

La griglia di tasti:

Per raccogliere l’informazione su che tasto è premuto potremmo separare i tasti con delle resistenze, impostare dei voltaggi alle estremità e capire così quale bottone è stato premuto leggendo il voltaggio.
Per praticità ho diviso i pulsanti in gruppi di 3, ( oscillazioni di tensione minori e disponibilità di ingressi analogici ).
I bottoni da un lato vengono collegati al pin di lettura analogica di arduino. Tale lettura viene tenuta “alta” collegandola ad una resistenza da 56k con il positivo.
i bottoni dall’altro lato, vengono collegati in serie tramite delle resistenze, mettendo da una estremità il segno meno e dall’altra il segno più con una resistenza per distinguerla dal valore “alto”.
In pratica in una colonna di 3 bottoni, il lato sinistro è collegato tra di loro con il pin della lettura e la resistenza di pullup, il lato destro in alto il meno, tra i bottoni una restistenza da 1k, per finire con 1k che va al segnale positivo.
In questo modo, quando viene premuto il primo pulsante , entra in gioco la resistenza da 56k ed il pin lettore legge il valore di 0(meno) anziche 1024(più) perchè collegata direttamente al meno e con 56k o 3k al più. Se premiamo il secondo bottone, abbiamo una reistenza di 1k verso il meno, e 2 k verso il più, quindi leggeremo un valore di circa 1/3 di 1024 ovvero intorno ai 350. per lo stesso motivo il terzo bottone ci darà i 2/3.
Quindi: quando il pin analogico legge 1024 ( nessun tasto premuto ), quando legge 0 ( primo tasto premuto ) , e così via per 350 circa e 700 circa.

Il buzzer audio

E’ possibile modulare la frequenza di uscita di un pin per produrre un suono, indicando appositamente una frequenza si può produrre una nota.

Il display lcd

il display lcd è molto documentato sulla rete, è semplice da collegare e da usare, può mostrare un punteggio parziale o un punteggio migliore…

Il codice

Il codice è stato scritto nella maniera più semplice possibile, ripetendo istruzioni pur di semplificare al massimo la lettura per persone che non sono programmatori per professione.

Codice:

/*
Arduino ed un simpatico gioco di memoria
*/

// la seguente libreria serve per poter scrivere sul display lcd
#include <LiquidCrystal.h>

// l'inizializzazione del display serve per capire quali ingressi uscite saranno usate.

LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

// Impostazioni e settaggi iniziali :

int speakerPin = 9; // il pin usato per suonare le note
int tempo = 500; // la durata di una nota
int muxa1Pin = 11; // il primo pin del mux 4051
int muxa2Pin = 12;
int muxa3Pin = 13;
int muxacomPin = 10; // il pin che comanda quando mandare energia al mux ovvero ai led
int pinLed9 = 8; // il nono led
int sizeSequenza = 1; // numero suoni da indovinare, iniziamo da 1
int sequenza[15]; // numero massimo di suoni da indovinare
int stato = 0; // 0=in attesa di risposta
int progressivoRisposta = 0; // suono da indovinare, posizione corrente (tra 1 e sizesequenza )
int errorLedPin = 1; // pin del led rosso che segnala l'errore
int levelLedPin = 0; // pin del led verde che segnala l'avanzamento di livello
int punteggioMigliore = 0;
int punteggioCorrente = 0;

// fase di inizializzazione in cui si ci prepara all'esecuzione

void setup() {
	lcd.begin(16, 2);
	
	// indica il tipo di lcd 16 caratteri e 2 righe
	lcd.print("Starting...");
	randomSeed(analogRead(1));
	
	// utilizza l'ingresso analogico 1 per generare sequenze casuali
	pinMode(errorLedPin, OUTPUT);
	pinMode(levelLedPin, OUTPUT);
	digitalWrite(errorLedPin, HIGH);
	digitalWrite(levelLedPin, HIGH);
	pinMode(speakerPin, OUTPUT);
	pinMode(muxa1Pin, OUTPUT);
	pinMode(muxa2Pin, OUTPUT);
	pinMode(muxa3Pin, OUTPUT);
	pinMode(muxacomPin, OUTPUT);
	pinMode(pinLed9, OUTPUT);

	// crea la sequenza iniziale da indovinare
	creaSequenza();
	int tempoold = tempo;
	tempo = 100;
	
	// spegne il led degli errori
	digitalWrite(errorLedPin, LOW);
	
	// fa una musichetta iniziale
	for (int a = 0; a < 9; a++)
	suonaNota(a);
	tempo = tempoold;
	
	// spegne il led verde per il prox livello
	digitalWrite(levelLedPin, LOW);
	lcd.setCursor(0, 0);
	lcd.print("liv.1 ");
	
	// suona e visulizza la sequenza da indovinare
	suonaSequenza();
}

void loop() {
	verificaTastiera();
	delay(1); // delay per dare stabilità
}

void creaSequenza() {
	// sorteggia uno dei nove tasti per tante volte quanto è il livello
	for (int a = 0; a < sizeSequenza; a++) {
		sequenza[a] = random(9);
	}
}

void suonaSequenza() {
	// suona e mostra la sequenza
	for (int a = 0; a < sizeSequenza; a++) {
		suonaNota(sequenza[a]);
		delay(tempo / 5);
	}
}

void playTone(int tone, int duration) {
	for (long i = 0; i < duration * 1000L; i += tone * 2) {
		digitalWrite(speakerPin, HIGH);
		delayMicroseconds(tone);
		digitalWrite(speakerPin, LOW);
		delayMicroseconds(tone);
	}
}

void playNote(char note, int duration) {
	// data una nota (notazione inglese) la suona per la durata
	char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C', 'D' };
	int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956, 856 };
	for (int i = 0; i < 9; i++) {
		if (names[i] == note) {
			playTone(tones[i], duration);
		}
	}
}

void setMux(int canale) {
	// canale è uno dei 9 tasti
	// il mux deve indirizzare il canale sulle 8 uscite tramite i 3 pin.
	// ad ogni uscita corrisponde una combinazione.

	if (canale == 0) {
		digitalWrite(muxa1Pin, LOW);
		digitalWrite(muxa2Pin, LOW);
		digitalWrite(muxa3Pin, LOW);
	}

	if (canale == 1) {
		digitalWrite(muxa1Pin, HIGH);
		digitalWrite(muxa2Pin, LOW);
		digitalWrite(muxa3Pin, LOW);
	}
	
	if (canale == 2) {
		digitalWrite(muxa1Pin, LOW);
		digitalWrite(muxa2Pin, HIGH);
		digitalWrite(muxa3Pin, LOW);
	}

	if (canale == 3) {
		digitalWrite(muxa1Pin, HIGH);
		digitalWrite(muxa2Pin, HIGH);
		digitalWrite(muxa3Pin, LOW);
	}
	
	if (canale == 4) {
		digitalWrite(muxa1Pin, LOW);
		digitalWrite(muxa2Pin, LOW);
		digitalWrite(muxa3Pin, HIGH);
	}
	
	if (canale == 5) {
		digitalWrite(muxa1Pin, HIGH);
		digitalWrite(muxa2Pin, LOW);
		digitalWrite(muxa3Pin, HIGH);
	}

	if (canale == 6) {
		digitalWrite(muxa1Pin, LOW);
		digitalWrite(muxa2Pin, HIGH);
		digitalWrite(muxa3Pin, HIGH);
	}

	if (canale == 7) {
		digitalWrite(muxa1Pin, HIGH);
		digitalWrite(muxa2Pin, HIGH);
		digitalWrite(muxa3Pin, HIGH);
	}
}

void suonaNota(int n) {
	// n = la posizione da suonare da 0 a 8
	if (n == 0) {
		setMux(0);
		// indirizza il mux sull'uscita 0
		// accende il led mandando l'alimentazione al mux
		digitalWrite(muxacomPin, HIGH);
		// suona il do basso
		playNote('c', tempo);
		// spegne il led disattivando il mux
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 1) {
		setMux(6);
		digitalWrite(muxacomPin, HIGH);
		playNote('d', tempo);
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 2) {
		// poiche' abbiamo 9 pin il nono viene gestito direttamente non tramite il mux
		digitalWrite(pinLed9, HIGH);
		playNote('e', tempo);
		digitalWrite(pinLed9, LOW);
	}

	if (n == 3) {
		setMux(4);
		digitalWrite(muxacomPin, HIGH);
		playNote('f', tempo);
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 4) {
		setMux(3);
		digitalWrite(muxacomPin, HIGH);
		playNote('g', tempo);
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 5) {
		setMux(5);
		digitalWrite(muxacomPin, HIGH);
		playNote('a', tempo);
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 6) {
		setMux(2);
		digitalWrite(muxacomPin, HIGH);
		playNote('b', tempo);
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 7) {
		setMux(1);
		digitalWrite(muxacomPin, HIGH);
		playNote('C', tempo);
		digitalWrite(muxacomPin, LOW);
	}

	if (n == 8) {
		setMux(7);
		digitalWrite(muxacomPin, HIGH);
		playNote('D', tempo);
		digitalWrite(muxacomPin, LOW);
	}
}

void tastoPremuto(int tasto) {
	// accetta pressione di tasti solo se lo stato è a 0
	// e se c'e' una risposta da dare
	if (stato == 0 && progressivoRisposta < sizeSequenza) {
		suonaNota(tasto);
		if (tasto == sequenza[progressivoRisposta]) {
			// se il tasto è giusto
			// nota indovinata passa alla successiva
			progressivoRisposta++;
			punteggioCorrente++;
			lcd.setCursor(progressivoRisposta + 4, 0);
			// aggiunge un puntino ad indicare l'avanzamento
			lcd.print(".");
			if (progressivoRisposta == sizeSequenza) {
				// fine sequenza, indovinata tutta, vai con la prossima
				livelloSuccessivo();
			}
		} else
			errore();
		// se il tasto è sbagliato ricomincia
		aggiornaPunteggioDisplay();
	}
}

void aggiornaPunteggioDisplay() {
	lcd.setCursor(0, 1);
	lcd.print("pun.");
	// allinea a dx
	if (punteggioCorrente < 10)
	lcd.print(" ");
	if (punteggioCorrente < 100)
	lcd.print(" ");
	lcd.print(punteggioCorrente);
	lcd.print(" best.");
	if (punteggioMigliore < 10)
	lcd.print(" ");
	if (punteggioMigliore < 100)
	lcd.print(" ");
	lcd.print(punteggioMigliore);
	lcd.print(" ");
}

void livelloSuccessivo() {
	// accende il verde
	digitalWrite(levelLedPin, HIGH);
	
	// suona la musichetta di successo
	playTone(1400, 100);
	playTone(1200, 100);
	playTone(1000, 200);
	delay(200);
	
	// azzera la nota corrente da indovinare
	progressivoRisposta = 0;
	punteggioCorrente += sizeSequenza;
	
	// aumenta la difficoltà
	sizeSequenza++;

	lcd.setCursor(4, 0);
	lcd.print(sizeSequenza);
	lcd.print(" "); // pulisce i puntini
	delay(2000);
	
	// crea una nuova sequenza
	creaSequenza();
	digitalWrite(levelLedPin, LOW);
	suonaSequenza();
}

void errore() {
	digitalWrite(errorLedPin, HIGH);
	delay(200);
	
	// suona una musichetta di insuccesso
	playTone(2400, 200);
	playTone(2800, 300);
	delay(1000);
	progressivoRisposta = 0;
	
	// controlla se si è fatto il record
	if (punteggioCorrente > punteggioMigliore)
	punteggioMigliore = punteggioCorrente;
	
	// azzera i contatori
	punteggioCorrente = 0;
	sizeSequenza = 1;
	lcd.setCursor(0, 0);
	lcd.print("liv.1 ");
	creaSequenza();
	delay(500);
	digitalWrite(errorLedPin, LOW);
	suonaSequenza();
}

void verificaTastiera() {
	// il prossimo blocco legge 3 volte di seguito
	// e prosegue solo se il segnale letto è stabile
	// per segnale stabile si intende un segnale che varia di poco nel tempo (2ms)

	int sensorValueTastiera = analogRead(A0);
	delay(2);
	int sensorValueTastier2 = analogRead(A0);
	delay(2);
	int sensorValueTastier3 = analogRead(A0);

	if ((abs(sensorValueTastiera - sensorValueTastier2)
		+ abs(sensorValueTastier3 - sensorValueTastier2)) > 20) {
		sensorValueTastiera = 1024;
	}

	int sensor2ValueTastiera = analogRead(A2);
	delay(2);
	int sensor2ValueTastier2 = analogRead(A2);
	delay(2);
	int sensor2ValueTastier3 = analogRead(A2);

	if ((abs(sensor2ValueTastiera - sensor2ValueTastier2)
		+ abs(sensor2ValueTastier3 - sensor2ValueTastier2)) > 20) {
		sensor2ValueTastiera = 1024;
	}

	int sensor3ValueTastiera = analogRead(A4);
	delay(2);
	int sensor3ValueTastier2 = analogRead(A4);
	delay(2);
	int sensor3ValueTastier3 = analogRead(A4);

	if ((abs(sensor3ValueTastiera - sensor3ValueTastier2)
		+ abs(sensor3ValueTastier3 - sensor3ValueTastier2)) > 20) {
		sensor3ValueTastiera = 1024;
	}

	// in base alle resistenze è possibile conoscere il tasto premuto
	// l'ingresso A0 ha letto un valore prossimo allo 0,
	// quindi il bottone ha cortocircuitato la lettura
	// direttamente sul segno negativo

	if (sensorValueTastiera < 20)
		tastoPremuto(0);

	// vale lo stesso per il sensore A2 che legge la seconda colonna di bottoni
	if (sensor2ValueTastiera < 20)
		tastoPremuto(1);

	if (sensor3ValueTastiera < 20)
		tastoPremuto(2);

	// se viene premuto il bottone più in basso, le resistenza faranno leggere un voltaggio
	// piu' alto di zero interpretabile in base ai valori tra i 250 e 400

	if (sensorValueTastiera > 250 && sensorValueTastiera < 400)
		tastoPremuto(3);

	if (sensor2ValueTastiera > 250 && sensor2ValueTastiera < 400)
		tastoPremuto(4);

	if (sensor3ValueTastiera > 250 && sensor3ValueTastiera < 400)
		tastoPremuto(5);

	if (sensorValueTastiera > 500 && sensorValueTastiera < 700)
		tastoPremuto(6);

	if (sensor2ValueTastiera > 500 && sensor2ValueTastiera < 700)
		tastoPremuto(7);

	if (sensor3ValueTastiera > 500 && sensor3ValueTastiera < 700)
		tastoPremuto(8);

	/*
	// questa parte di codice serve solo per debuggare
	// in pratica mostra il valore letto
	// da uno degli ingressi sul display

	if (sensorValueTastiera<1000 ) {
		lcd.setCursor(7,0);
		lcd.print("a1");
		lcd.print(sensorValueTastiera);
		lcd.print(" ");
	}

	if (sensor2ValueTastiera<1000 ) {
		lcd.setCursor(7,0);
		lcd.print("a2");
		lcd.print(sensor2ValueTastiera);
		lcd.print(" ");
	}

	if (sensor3ValueTastiera<1000 ) {
		lcd.setCursor(7,0);
		lcd.print("a3");
		lcd.print(sensor3ValueTastiera);
		lcd.print(" ");
	}
*/
}