![11 Numerazione capitolo](11-num-capitolo.png)
## 11 - SFERA DI CRISTALLO

**CREA UNA SFERA DI CRISTALLO PER PREDIRE IL FUTURO**

> **Scopri:** i display LCD, istruzioni switch/case, random()
>
> **Tempo:** 1 ORA
> **Livello:** ■ ■ ■ ■ ■
> **Basato sui progetti:** 1, 2, 3

**Le sfere di cristallo possono aiutare a "prevedere" il futuro. Fai una domanda alla sfera onnisciente, e capovolgila per rivelare la risposta. Le risposte saranno predeterminate, ma puoi scriverci ciò che più ti piace. Utilizzerai Arduino per scegliere tra un totale di 8 risposte. L'interruttore di inclinazione nel kit ti aiuterà a simulare l'azione di scuotere la sfera per ottenere le risposte.**

![Ingredienti](11-ingredienti.png)  
> **INGREDIENTI**
>*   Pulsante (Interruttore di inclinazione)
>*   Resistenza da 10 Kilo Ohm
>*   Resistenza da 220 Ohm
>*   Potenziometro
>*   Schermo LCD

Il display LCD può essere utilizzato per visualizzare caratteri alfanumerici. Quello nel kit ha 16 colonne e 2 righe, per un totale di 32 caratteri. Ci sono tante connessioni sulla scheda: queste sono utilizzate per l'alimentazione e la comunicazione, così lo schermo sa cosa scrivere. Non sarà necessario collegarle tutte. Guarda la Fig. 1 per i piedini da collegare.

![Piedini schermo LCD](11-immagine_piedini_lcd.png)  
*Fig. 1: I piedini sullo schermo LCD che sono usati nel progetto e le etichette*

### COSTRUISCI IL CIRCUITO

![Schema del circuito e montaggio](11-immagine_circuito_sfera.png)

Il circuito non è complesso, ma ci sono un sacco di fili. Fai attenzione che il cablaggio sia corretto.

1.  Collega alimentazione e massa a un lato della breadboard.
2.  Posiziona l'interruttore di inclinazione sulla breadboard e collega un filo a 5V. Collega l'altro lato a massa attraverso una resistenza da 10 kilo ohm e al piedino 6 di Arduino. Lo stai collegando come ingresso digitale, proprio come hai fatto in diversi altri progetti.
3.  Il piedino register select (RS) controlla dove i caratteri compaiono sullo schermo. Il piedino read/write (R/W) mette lo schermo in modalità lettura o scrittura. In questo progetto userai la modalità scrittura. L'abilitazione (E) dice all'LCD che riceverà un comando. I piedini dei dati (D0-D7) sono usati per mandare i dati dei caratteri allo schermo. Ne userai solo 4 (D4-D7). Infine, c'è una connessione per regolare il contrasto del display. Userai un potenziometro per controllarlo.
4.  La libreria LiquidCrystal che viene fornita con il software Arduino gestisce la comunicazione con questi piedini e semplifica il processo di scrittura del software per visualizzare i caratteri. I due piedini esterni dell'LCD (Vss e LED-) devono essere collegati a massa. Poi, collega il piedino R/W a massa. Questo mette lo schermo in modalità scrittura. L'alimentazione dell'LCD (Vcc) deve collegarsi direttamente a 5V. Il piedino LED+ sullo schermo si collega all'alimentazione tramite una resistenza da 220 ohm.
5.  Collega: il piedino 2 di Arduino a LCD D7, il piedino 3 di Arduino a LCD D6, il piedino 4 di Arduino a LCD D5, il piedino 5 di Arduino a LCD D4. Questi sono i piedini dei dati che dicono allo schermo quali caratteri mostrare.
6.  Collega E dello schermo al piedino 11 di Arduino. RS sull'LCD va collegato al piedino 12. Questo piedino permette di scrivere sull'LCD.
7.  Metti il potenziometro sulla breadboard, collegandone un piedino all'alimentazione e l'altro a massa. Il piedino centrale dovrebbe essere collegato a V0 dell'LCD. Questo ti permette di regolare il contrasto dello schermo.

![Schema elettrico](11-schema_elettrico_sfera.png)
*Fig.3: In questo schema la disposizione dei piedini dell'LCD non corrisponde all'ordine fisico illustrato in Fig. 2. In uno schema, i piedini sono riorganizzati secondo un raggruppamento logico per rendere lo schema più chiaro possibile. Questo crea un po' di confusione ai neofiti.*

### IL CODICE

#### Prepara la libreria LiquidCrystal
Per prima cosa, devi importare la libreria `LiquidCrystal`. Poi, avvia la libreria in un modo simile a come hai fatto con la libreria Servo, dicendogli quali piedini verranno utilizzati per comunicare.

```cpp
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
```

#### Crea variabili e costanti
Ora che hai impostato la libreria, crea alcune variabili e costanti. Crea una costante per memorizzare il numero di piedino dell'interruttore, una variabile per lo stato attuale dell'interruttore, una variabile per lo stato precedente dell'interruttore e un'altra per scegliere quale risposta mostrerà lo schermo.

```cpp
const int switchPin = 6;
int switchState = 0;
int prevSwitchState = 0;
int reply;
```

#### Imposta il piedino dell'interruttore con la funzione pinMode()
Nel `setup()`. Avvia la libreria dell'LCD e digli quanto è largo lo schermo.

```cpp
void setup() {
  lcd.begin(16, 2);
  pinMode(switchPin, INPUT);
```

> **La descrizione della libreria LCD**
> [arduino.cc/lcdlibrary](http://arduino.cc/lcdlibrary)

#### Stampa la tua prima riga
Ora è tempo di scrivere un breve benvenuto alla sfera di cristallo. La funzione `print()` scrive sullo schermo LCD. Stai per scrivere le parole "Interroga" sulla riga superiore dello schermo. Il cursore è già automaticamente posizionato all'inizio della riga superiore.

```cpp
  lcd.print("Interroga");
```

#### Muovi il cursore
Per scrivere sulla riga successiva, devi dire allo schermo dove muovere il cursore. Le coordinate della prima colonna sulla seconda riga sono 0,1 (ricordiamo che i computer partono da zero. 0,0 è la prima colonna della prima riga). Usa la funzione `lcd.setCursor()` per muovere il cursore nel posto giusto e digli di scrivere "la sfera!".

```cpp
  lcd.setCursor(0, 1);
  lcd.print("la sfera!");
}
```

#### Scegli una risposta a caso
Ora, quando parte il programma, compare "Interroga la sfera!" sul tuo schermo.
Nel `loop()`, controlla l'interruttore e metti il valore nella variabile `switchState`.

Usa un'istruzione `if()` per determinare se l'interruttore è in una posizione differente rispetto a prima. Se ora è **LOW**, è tempo di scegliere una risposta a caso.
La funzione `random()` restituisce un numero in base al parametro che hai fornito. Per iniziare, avrai un totale di 8 risposte possibili. Ogni volta che è chiamata l'istruzione `random(8)`, darà un numero tra 0 e 7. Immagazzina il numero nella variabile `reply`.

```cpp
void loop() {
  switchState = digitalRead(switchPin);

  if (switchState != prevSwitchState) {
    if (switchState == LOW) {
      reply = random(8);
```

> **La descrizione di random**
> [arduino.cc/random](http://arduino.cc/random)

#### Pulisci lo schermo e stampa la risposta
Pulisci lo schermo con la funzione `lcd.clear()`, che riporta il cursore alla posizione 0,0: la prima colonna nella prima riga dell'LCD. Stampa la riga "La sfera dice:" e prepara il cursore per la risposta.

```cpp
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("La sfera dice:");
      lcd.setCursor(0, 1);
```

#### Predire il futuro
L'istruzione `switch()` esegue diversi pezzi di codice a seconda del parametro che specifichi. Ognuno di questi pezzi è chiamato `case`. L'istruzione `switch()` controlla il valore della variabile `reply`; qualunque sia il suo valore determina quale case viene eseguito.

Nelle istruzioni case, il codice è lo stesso, ma i messaggi sono differenti. Per esempio, nel `case 0` il codice dice `lcd.print("Si")`. Dopo la funzione `lcd.print()` c'è un altro comando: `break`. Dice ad Arduino dov'è la fine del `case`. Quando raggiunge `break`, salta alla fine dell'istruzione switch. Crea un totale di 8 istruzioni case: quattro risposte positive, due negative e due che ti chiedono di provare ancora.

```cpp
      switch(reply){
        case 0:
          lcd.print("Si");
          break;
        case 1:
          lcd.print("Probabile");
          break;
        case 2:
          lcd.print("Certo");
          break;
        case 3:
          lcd.print("Bene");
          break;
        case 4:
          lcd.print("Forse");
          break;
        case 5:
          lcd.print("Chiedi ancora");
          break;
        case 6:
          lcd.print("Improbabile");
          break;
        case 7:
          lcd.print("No");
          break;
      }
    }
  }
```

> **Descrizione di Switch Case**
> [arduino.cc/switchcase](http://arduino.cc/switchcase)

L'ultima cosa da fare nel `loop()` è assegnare il valore di `switchState` alla variabile `prevSwitchState`. Questo ti permette di tracciare i cambiamenti dell'interruttore la prossima volta che viene eseguito il loop.

```cpp
  prevSwitchState = switchState;
}
```

### USALA

Per usare la sfera magica, alimenta Arduino. Controlla lo schermo e assicurati che dica "Interroga la sfera!" Se non vedi la scritta, prova a girare il potenziometro, che regola il contrasto dello schermo.

Fai una domanda alla sfera di cristallo e prova a ribaltare l'interruttore. Dovresti ricevere una risposta alla tua domanda. Se la risposta non ti piace, chiedi ancora.

![Forbici e colla](forbici-colla.png)
> Prova ad aggiungere le tue parole all'istruzione `print()`, ma devi essere consapevole del fatto che puoi usare solo 16 caratteri per riga. Puoi anche provare ad aggiungere altre risposte. Assicurati, quando aggiungi i case supplementari, di modificare il numero di opzioni che casualmente popoleranno la variabile reply.

![Lente](lente.png)
> *Gli LCD funzionano modificando le proprietà elettriche di un liquido posto tra i vetri polarizzati. Il vetro permette solo ad alcuni tipi di luce di passare attraverso. Quando il liquido tra i vetri viene caricato elettricamente, inizia a formarsi in un stato semi-solido. Questo nuovo stato ruota in una direzione diversa rispetto al vetro polarizzato, impedendo alla luce di passare attraverso, creando così i caratteri che vedi sullo schermo.*

![Cervello](cervello.png)
> *Le funzioni che abbiamo visto qui per modificare il testo dello schermo LCD sono abbastanza semplici. Una volta fatta pratica, guarda le altre funzioni della libreria. Prova a far scorrere il testo o aggiornalo continuamente. Per saperne di più su come funziona la libreria LiquidCrystal, visita il sito: [arduino.cc/lcd](http://arduino.cc/lcd)*

**Un display LCD consente di visualizzare il testo su uno schermo, utilizzando la libreria `LiquidCrystal`. Con le istruzioni `switch...case` controlla il flusso dei programmi confrontando una variabile con dei valori specifici.**

### CODICE COMPLETO

```cpp
/*
  Arduino Starter Kit example
  Project 11 - Crystal Ball

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

  Parts required:
  - 220 ohm resistor
  - 10 kilohm resistor
  - 10 kilohm potentiometer
  - 16x2 LCD screen
  - tilt switch

  created 13 Sep 2012
  by Scott Fitzgerald

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

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

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// set up a constant for the tilt switch pin
const int switchPin = 6;

// variable to hold the value of the switch pin
int switchState = 0;

// variable to hold previous value of the switch pin
int prevSwitchState = 0;

// a variable to choose which reply from the crystal ball
int reply;

void setup() {
  // set up the number of columns and rows on the LCD
  lcd.begin(16, 2);

  // set up the switch pin as an input
  pinMode(switchPin, INPUT);

  // Print a message to the LCD.
  lcd.print("Ask the");
  // set the cursor to column 0, line 1
  // line 1 is the second row, since counting begins with 0
  lcd.setCursor(0, 1);
  // print to the second line
  lcd.print("Crystal Ball!");
}

void loop() {
  // check the status of the switch
  switchState = digitalRead(switchPin);

  // compare the switchState to its previous state
  if (switchState != prevSwitchState) {
    // if the state has changed from HIGH to LOW you know that the ball has been
    // tilted from one direction to the other
    if (switchState == LOW) {
      // randomly chose a reply
      reply = random(8);
      // clean up the screen before printing a new reply
      lcd.clear();
      // set the cursor to column 0, line 0
      lcd.setCursor(0, 0);
      // print some text
      lcd.print("the ball says:");
      // move the cursor to the second line
      lcd.setCursor(0, 1);

      // choose a saying to print based on the value in reply
      switch (reply) {
        case 0:
          lcd.print("Yes");
          break;

        case 1:
          lcd.print("Most likely");
          break;

        case 2:
          lcd.print("Certainly");
          break;

        case 3:
          lcd.print("Outlook good");
          break;

        case 4:
          lcd.print("Unsure");
          break;

        case 5:
          lcd.print("Ask again");
          break;

        case 6:
          lcd.print("Doubtful");
          break;

        case 7:
          lcd.print("No");
          break;
      }
    }
  }
  // save the current switch state as the last state
  prevSwitchState = switchState;
}
```