![07 Numerazione capitolo](07-num-capitolo.png)
## 07 - TASTIERA MUSICALE

**CON ALCUNE RESISTENZE E PULSANTI COSTRUISCI UNA PICCOLA TASTIERA MUSICALE**

> **Scopri:** la rete di resistenze a scala, gli array
>
> **Tempo:** 45 MINUTI
> **Livello:** ■ ■ ■ ■ □
> **Basato sui progetti:** 1, 2, 3, 4, 6

**Anche se è possibile semplicemente collegare un numero di pulsanti a ingressi digitali per avere toni diversi, in questo progetto useremo una *rete di resistenze a scala*.**

![Ingredienti](07-ingredienti.png)
>**INGREDIENTI**
>*   Pulsanti (4)
>*   Piezo
>*   Resistenza da 220 Ohm
>*   Resistenza da 10 Kilo Ohm
>*   Resistenza da 1 Mega Ohm

Questa permette di leggere più pulsanti usando un solo input analogico: è una tecnica utile se ti trovi a corto di ingressi digitali. Collega i pulsanti che sono connessi in parallelo al piedino analogico 0. La maggior parte di questi pulsanti è collegata all'alimentazione attraverso una resistenza. Quando premi ogni pulsante, un livello diverso di tensione viene applicato al piedino di ingresso. Se premi due bottoni insieme, hai un unico input basato sulla relazione tra due resistenze in parallelo.

![Fig 1: Rete di resistenze](07-schema_elettrico_reteresistenze.png)  
*Fig. 1: Una rete di resistenze a scala e cinque pulsanti come ingresso analogico*

### COSTRUISCI IL CIRCUITO

![Costruzione del circuito](07-montaggio_circuito.png)
> *Fig. 2: Questa disposizione di resistenze e pulsanti che alimenta un ingresso analogico è chiamata rete di resistenze a scala*

1.  Collega la breadboard all'alimentazione e a massa come nei progetti precedenti. Collega un'estremità del piezo a massa. Collega l'altra estremità al piedino 8 di Arduino.
2.  Posiziona i pulsanti sulla breadboard come mostrato nel circuito. Questa disposizione di resistenze e pulsanti che alimenta un ingresso analogico è chiamata rete di resistenze a scala. Collega la prima resistenza direttamente all'alimentazione. Collega il secondo, il terzo e il quarto pulsante all'alimentazione attraverso, rispettivamente, resistenze da 220 ohm, 10 kilo ohm e 1 mega ohm. Collega tutte le uscite dei pulsanti insieme in un unico punto. Collegalo a massa con una resistenza da 10 kilo ohm e collegalo anche al piedino analogico 0. Ognuna di queste resistenze si comporta da partitore di tensione.

![Schema elettrico](07-schema_elettrico_circuito.png)
> *Fig. 3: Schema elettrico*

![Forbici e colla](forbici-colla.png)  
> Pensa a un contenitore per la tastiera. Mentre i vecchi sintetizzatori analogici avevano fili elettrici che spuntavano da tutte le parti, la tua tastiera è raffinata e digitale. Prepara un piccolo cartoncino per posizionare i pulsanti. Etichetta i tasti, così sai quale nota suona ogni tasto.

![Istruzioni per il contenitore](07-istruzioni_contenitore.png)

*1.  Disegna e taglia un pezzo di carta con buchi per i 4 pulsanti e il piezo. Decoralo per farlo assomigliare a una tastiera.*  
*2.  Metti il cartoncino sopra i pulsanti e il piezo. Divertiti con la tua creazione!*

### IL CODICE

#### L'array
In questo programma, hai bisogno di tenere una lista di frequenze che vuoi suonare quando schiacci ogni pulsante. Puoi iniziare con le frequenze per le note do, re, mi, fa centrali (262Hz, 294Hz, 330Hz e 349Hz). Per farlo, hai bisogno di un nuovo tipo di variabile chiamata **array**.
Un array è un modo per immagazzinare differenti valori che sono in relazione l'uno con l'altro, come le frequenze in una scala musicale, usando un solo nome. Sono uno strumento utile per avere accesso alle informazioni in modo veloce ed efficiente. Per dichiarare un array, inizia come faresti con una variabile, ma fai seguire al nome un paio di parentesi quadre: `[]`. Dopo il segno uguale, metti gli elementi tra parentesi graffe.

Per leggere o cambiare gli elementi dell'array, fai riferimento ai singoli elementi usando il nome dell'array e l'indice di ciò che vuoi indirizzare. L'indice fa riferimento all'ordine nel quale compaiono gli elementi quando è creato l'array. Il primo elemento nell'array è 0, il secondo è 1 e così via.

```cpp
int buttons[6];
// crea un array di 6 numeri interi

int buttons[0] = 2;
// assegna il valore 2 al primo elemento
// dell'array
```

#### Crea un array di frequenze
Crea un array di quattro note usando le frequenze indicate sopra. Rendi questo array una variabile globale dichiarandolo prima del `setup()`.

```cpp
int notes[] = {262, 294, 330, 349};
```

#### Comunicazione seriale
Nel `setup()`, inizia una comunicazione seriale con il computer.

```cpp
void setup() {
  Serial.begin(9600);
}
```

#### Leggi il valore analogico e invialo al monitor seriale
Nel `loop()`, dichiara una variabile locale per memorizzare il valore del piedino A0. Dato che ogni pulsante è collegato all'alimentazione tramite una resistenza di valore diverso, ognuno produce un diverso valore. Per vedere i valori, inviali al computer aggiungendo la riga `Serial.println(keyVal)`.

```cpp
void loop() {
  int keyVal = analogRead(A0);
  Serial.println(keyVal);
```

#### Usa un'istruzione if()...else per determinare quale nota suonare
Usando un'istruzione `if()...else`, puoi assegnare ogni valore a un tono diverso. I numeri inclusi nel programma d'esempio sono valori approssimativi per queste resistenze. Siccome tutte le resistenze hanno una certa tolleranza, questi potrebbero non essere perfetti. Usa le informazioni dal monitor seriale per sistemarli se necessario.

```cpp
  if(keyVal == 1023){
    tone(8, notes[0]);
  }
```

#### Suona le note che corrispondono al valore analogico
Dopo ogni istruzione `if()`, chiama la funzione `tone()`. Il programma fa riferimento all'array per determinare quale frequenza suonare. Se il valore di A0 corrisponde a una delle tue istruzioni `if()`, puoi dire ad Arduino di riprodurre un tono. È possibile che il tuo circuito sia un po' "rumoroso" e i valori possono oscillare un po' mentre si preme un interruttore. Per adattarsi a queste variazioni, è buona norma verificare un breve intervallo di valori. Se si utilizza il confronto `&&`, è possibile controllare più condizioni per vedere se sono vere.

Se premi il primo pulsante, suona `notes[0]`. Se premi il secondo, suona `notes[1]` e se premi il terzo, suona `notes[2]`. Questo è uno dei momenti in cui gli array diventano veramente utili.

```cpp
  else if(keyVal >= 990 && keyVal <= 1010){
    tone(8, notes[1]);
  }
  else if(keyVal >= 505 && keyVal <= 515){
    tone(8, notes[2]);
  }
  else if(keyVal >= 5 && keyVal <= 10){
    tone(8, notes[3]);
  }
```

#### Smetti di suonare il tono quando non è premuto nulla
Solo una frequenza può suonare su un piedino in un dato momento, quindi se premi più tasti, senti solo un suono.

Per interrompere le note quando nessun pulsante viene premuto, chiama la funzione `noTone()`, specificando il numero del piedino sul quale interrompere la riproduzione audio.

```cpp
  else{
    noTone(8);
  }
}
```

### USALO

Se le resistenze sono vicine ai valori nel programma di esempio, quando premi i tasti dovresti sentire alcuni suoni dal piezo. In caso contrario, controlla il monitor seriale per assicurarti che ciascuno dei pulsanti sia in un intervallo che corrisponde alle note nella istruzione `if()...else`. Se stai ascoltando un suono stentoreo, prova ad aumentare un po' l'intervallo.

Premi più pulsanti insieme e vedi che tipo di valori ottieni sul monitor seriale. Usa questi nuovi valori per attivare anche più suoni. Prova con diverse frequenze per ampliare la tua produzione musicale. Trovi le frequenze delle note musicali su questa pagina: [arduino.cc/frequencies](http://arduino.cc/frequencies)

![Cervello](cervello.png)
> *Se sostituisci i pulsanti e le scale di resistenze con sensori analogici, puoi usare le informazioni in più che ti forniscono per creare uno strumento più dinamico? Potresti usare il valore per cambiare la durata di una nota o, come nel progetto con il theremin, creare una scala di suoni.*

![Lente](lente.png)
> La funzione `tone()` è divertente per generare suoni, ma ha alcune limitazioni. Può creare solo onde quadre, non sinusoidi o triangoli. Le onde quadre non sembrano davvero delle onde. Come hai visto nella Fig. 1 del Progetto 06, sono una serie di impulsi acceso/spento.
>
> Prima di creare il tuo gruppo musicale tieni presente alcune cose: si può suonare solo un tono alla volta e `tone()` interferisce con `analogWrite()` sui piedini 3 e 11.

**Gli *array* sono utili per raggruppare tipi simili di informazioni; vi si accede da un numero di indice che si riferisce ai singoli elementi. Le *scale di resistenze* sono un modo semplice per aumentare gli ingressi digitali di un sistema collegandosi a un ingresso analogico.**

### CODICE COMPLETO

```cpp
/*
  Arduino Starter Kit example
  Project 7 - Keyboard

  This sketch is written to accompany Project 7 in the Arduino Starter Kit

  Parts required:
  - two 10 kilohm resistors
  - 1 megohm resistor
  - 220 ohm resistor
  - four pushbuttons
  - piezo

  created 13 Sep 2012
  by Scott Fitzgerald

  https://store.arduino.cc/genuino-starter-kit

  This example code is part of the public domain.
*/

// create an array of notes
// the numbers below correspond to the frequencies of middle C, D, E, and F
int notes[] = { 262, 294, 330, 349 };

void setup() {
  //start serial communication
  Serial.begin(9600);
}

void loop() {
  // create a local variable to hold the input on pin A0
  int keyVal = analogRead(A0);
  // send the value from A0 to the Serial Monitor
  Serial.println(keyVal);

  // play the note corresponding to each value on A0
  if (keyVal == 1023) {
    // play the first frequency in the array on pin 8
    tone(8, notes[0]);
  } else if (keyVal >= 990 && keyVal <= 1010) {
    // play the second frequency in the array on pin 8
    tone(8, notes[1]);
  } else if (keyVal >= 505 && keyVal <= 515) {
    // play the third frequency in the array on pin 8
    tone(8, notes[2]);
  } else if (keyVal >= 5 && keyVal <= 10) {
    // play the fourth frequency in the array on pin 8
    tone(8, notes[3]);
  } else {
    // if the value is out of range, play no tone
    noTone(8);
  }
}
```