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:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
/*
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(" ");
	}
*/
}