![05 Numerazione capitolo](05-num-capitolo.png)
## 05 - INDICATORE D'UMORE

**USA UN SERVOMOTORE PER CREARE UN INDICATORE MECCANICO PER RIVELARE DI QUALE UMORE SEI OGGI**

> **Scopri:** mappatura di valori, i servomotori, usare le librerie di Arduino
>
> **Tempo:** 1 ORA
> **Livello:** ■ ■ ■ □ □
> **Basato sui progetti:** 1, 2, 3, 4

![Ingredienti](05-ingredienti.png)  
>**INGREDIENTI**
>*   Potenziometro
>*   Servomotore & Motore Arm
>*   Connettore a pettine (3 piedini)
>*   Condensatore da 100 uF

![Servomotore](05-servomotore.png)  
> I **servomotori** sono un tipo speciale di motori che non ruotano in modo continuo, ma si muovono a una specifica posizione e ci stanno fino a che non dici loro di muoversi ancora. I servo normalmente ruotano solo di 180 gradi (metà di un cerchio). Combinando uno di questi motori con un piccolo oggetto di cartoncino, sarai in grado di far sapere alla gente se possono chiederti aiuto per il loro prossimo progetto oppure no.
> 
> Analogamente al modo in cui hai modulato a larghezza di impulso (PWM) i LED nel Progetto 04, i servomotori si aspettano degli impulsi che dicano loro in che modo muoversi. Gli impulsi arrivano sempre agli stessi intervalli di tempo, ma la larghezza varia tra 1000 e 2000 microsecondi. Anche se è possibile scrivere del codice per generare questi impulsi, il software di Arduino ha una libreria che ti permette di controllare facilmente il motore.

Dato che il servo ruota solo di 180 gradi e il tuo ingresso analogico oscilla tra 0 e 1023, hai bisogno di una funzione chiamata `map()` per cambiare la scala dei valori che arrivano dal potenziometro.

Uno degli aspetti più importanti della comunità di Arduino è rappresentato dalle persone di talento che estendono le sue funzionalità attraverso l'aggiunta di software. È possibile per tutti scrivere librerie che implementano le funzionalità di Arduino. Sono disponibili librerie per una gran varietà di sensori, attuatori e altri dispositivi che gli utenti hanno messo a disposizione della comunità. Una libreria software espande la funzionalità di un ambiente di programmazione. Il software di Arduino ha alcune librerie utili per lavorare con l'hardware o i dati. Una delle librerie incluse è progettata per i servomotori. Nel tuo codice, importando la libreria, tutte le sue funzionalità saranno disponibili per il tuo progetto.

### COSTRUISCI IL CIRCUITO

![Schema del circuito e montaggio](05-immagine_circuito_indicatore.png)

![Schema elettrico](05-schema_elettrico_ind_umore.png)

1.  Collega 5V e GND della scheda Arduino a un lato della tua breadboard.
2.  Metti un potenziometro sulla breadboard e collega un lato a 5V e l'altro a massa. Un potenziometro è un partitore di tensione. Quando giri la manopola, cambi il rapporto di tensione tra il piedino in mezzo e l'alimentazione. Puoi leggere questo cambiamento su un ingresso analogico. Collega il piedino di mezzo al piedino analogico 0. Questo controlla la posizione del servomotore.
3.  Il servo ha tre fili che fuoriescono da esso. Uno è l'alimentazione (rosso), uno è la massa (nero) e il terzo (bianco) è la linea di controllo che riceve le informazioni da Arduino. Collega tre piedini di un connettore a pettine al connettore del servo (vedi Fig. 3). Collega il connettore a pettine alla breadboard così ogni piedino è in una riga diversa. Collega 5V al filo rosso, massa al filo nero e il filo bianco al piedino 9.
4.  Quando un servomotore inizia a muoversi, utilizza più corrente di prima. Questo causa un calo di tensione della scheda. Collegando un condensatore da 100 uF tra l'alimentazione e la massa accanto al connettore a pettine come mostrato in Fig 1, puoi compensare i cambiamenti di tensione che avverranno. Puoi anche mettere un condensatore tra l'alimentazione e la massa del tuo potenziometro. Questi sono chiamati **condensatori di disaccoppiamento** perché riducono o separano i cambiamenti causati dai componenti nel resto del circuito. Fai attenzione a collegare il catodo alla massa (è il lato con una stringa nera sul lato) e l'anodo all'alimentazione. Se metti i condensatori al contrario, potrebbero esplodere.

![Dettaglio connettori servo](05-immagine_connettori_servo.png)  
*Fig.3: Il tuo servomotore ha connettori femmina, così hai bisogno di aggiungere dei connettori a pettine per collegarlo alla breadboard (Fig. 3).*

### IL CODICE

#### Importa la libreria
Per usare la libreria Servo, per prima cosa devi importarla: questo rende le funzioni dalla libreria disponibili per il tuo sketch.

```cpp
#include <Servo.h>
```
> *Nota che le istruzioni `#include` non hanno il punto e virgola alla fine della riga.*

#### Crea l'oggetto Servo
Per fare riferimento al Servo, hai bisogno di creare un'istanza della classe servo in una variabile: si chiama **oggetto**. Quando esegui questa operazione, gli stai dando un nome univoco che ha tutte le funzioni e le capacità che offre la libreria Servo. Da questo punto in poi, nel programma, ogni volta che fai riferimento a `myServo`, parlerai con l'oggetto Servo.

```cpp
Servo myServo;
```

#### Dichiara le variabili
Crea una costante per dare un nome al piedino a cui è collegato il potenziometro e le variabili per contenere il valore di ingresso analogico e l'angolo al quale vuoi che il servo si muova.

```cpp
int const potPin = A0;
int potVal;
int angle;
```

#### Associa l'oggetto Servo a un piedino di Arduino, avvia la porta seriale
Nel `setup()`, devi dire ad Arduino a quale piedino è collegato il tuo servo.
Includi una connessione seriale così puoi controllare i valori del potenziometro e vedere come vengono mappati alla posizione del servomotore.

```cpp
void setup() {
  myServo.attach(9);

  Serial.begin(9600);
}
```

#### Leggi i valori del potenziometro
Nel `loop()`, leggi l'ingresso analogico e invia il valore al monitor seriale.

```cpp
void loop() {
  potVal = analogRead(potPin);
  Serial.print("potVal: ");
  Serial.print(potVal);
```

#### Mappa i valori del potenziometro ai valori del servo
Per creare un valore utilizzabile per il servomotore dal tuo ingresso analogico, è più facile utilizzare la funzione `map()`. Questa funzione scala i numeri. In questo caso trasforma i valori tra 0 e 1023 in valori compresi tra 0 e 179. Richiede cinque parametri: il numero da scalare (qui è `potVal`), il valore minimo dell'ingresso (0), il valore massimo dell'ingresso (1023), il valore minimo dell'uscita (0) e il valore massimo dell'uscita (179). Memorizza il nuovo valore nella variabile angolo (`angle`).
Quindi, invia il valore mappato al monitor seriale.

```cpp
  angle = map(potVal, 0, 1023, 0, 179);
  Serial.print(", angle: ");
  Serial.println(angle);
```

#### Ruota il servo
Infine, è il momento di spostare il servo. Il comando `servo.write()` muove il motore alla posizione specificata. Alla fine del `loop()` metti un ritardo (`delay`) così il servo ha tempo di spostarsi nella nuova posizione.

```cpp
  myServo.write(angle);
  delay(15);
}
```

### USALO

Quando Arduino è stato programmato e acceso, apri il monitor seriale. Dovresti vedere una riga di valori simile a questa:  
**potVal : 1023, angle : 179**  
**potVal : 1023, angle : 179**

Quando muovi il potenziometro, dovresti vedere cambiare i numeri. Ancora più importante, dovresti vedere che il servomotore cambia posizione. Nota la relazione tra il valore di `potVal` e `angle` nel monitor seriale e la posizione del servo. Dovresti vedere risultati coerenti quando ruoti il potenziometro.

Una cosa bella di utilizzare i potenziometri come ingressi analogici è che ti forniscono l'intera gamma di valori compresi tra 0 e 1023. Questo li rende utili per testare progetti che utilizzano l'ingresso analogico.

![Lente](lente.png)
> I servomotori sono normali motori con all'interno ingranaggi e un circuito. La meccanica all'interno fornisce un feedback al circuito, così è sempre consapevole della sua posizione. Anche se sembra che abbia una gamma limitata di movimenti, è possibile ottenerne una grande varietà con alcune parti meccaniche aggiuntive. Ci sono parecchie risorse che ne descrivono in dettaglio i meccanismi come [robives.com/mechs](http://robives.com/mechs) e il libro ***Making Things Move*** di Dustyn Roberts.

![Cervello](cervello.png)
> Il potenziometro non è l'unico sensore che è possibile utilizzare per il controllo del servo. Con la stessa configurazione fisica (una freccia che punta a una serie di indicatori differenti) e un sensore diverso, che tipo di indicatore puoi costruire? Come si potrebbe fare con la temperatura (come nell'amorometro)? Potresti determinare l'ora del giorno con una fotoresistenza? Come entra in gioco la mappatura di valori quando si usano questi tipi di sensori?

**I servomotori possono facilmente essere controllati da Arduino usando una *libreria*, che è una raccolta di codice che estende un ambiente di programmazione. Qualche volta è necessario manipolare i valori mappandoli da una scala all'altra.**

![Forbici e colla](forbici-colla.png)  
> Ora che la parte di movimento è in funzione, è tempo di far sapere alle persone che sei disponibile ad aiutarli nei loro progetti o che vuoi essere lasciato in pace per pianificare la tua prossima creazione.**
>
> Con le forbici, taglia un pezzo di cartone a forma di freccia. Metti il servo a 90 gradi (controlla il valore angolare sul monitor seriale se non sei sicuro). Incolla la freccia in modo che sia orientata nella stessa direzione del corpo del motore. Ora dovresti essere in grado di ruotare la freccia di 180 gradi quando giri il potenziometro.
Prendi un pezzo di carta più grande del servo con la freccia attaccata e disegna su di esso un semicerchio. Da un lato del cerchio, scrivi "Stai fuori". Dall'altra parte, "Entra" e "Bussa" a metà dell'arco. Metti il servo con la freccia sopra il foglio. Congratulazioni, hai un modo per dire alle persone quanto sei impegnato con i tuoi progetti!

![Istruzioni per l'indicatore cartaceo](05-immagine_indicatore_carta.png)  
>1.  Fissa una freccia di carta al braccio del servo.
>2.  Disegna una base di carta e mettila sotto il servo.

### CODICE COMPLETO

```cpp
/*
  Arduino Starter Kit example
  Project 6 - Light Theremin

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

  Parts required:
  - photoresistor
  - 10 kilohm resistor
  - piezo

  created 13 Sep 2012
  by Scott Fitzgerald

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

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

// variable to hold sensor value
int sensorValue;
// variable to calibrate low value
int sensorLow = 1023;
// variable to calibrate high value
int sensorHigh = 0;
// LED pin
const int ledPin = 13;

void setup() {
  // Make the LED pin an output and turn it on
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);

  // calibrate for the first five seconds after program runs
  while (millis() < 5000) {
    // record the maximum sensor value
    sensorValue = analogRead(A0);
    if (sensorValue > sensorHigh) {
      sensorHigh = sensorValue;
    }
    // record the minimum sensor value
    if (sensorValue < sensorLow) {
      sensorLow = sensorValue;
    }
  }
  // turn the LED off, signaling the end of the calibration period
  digitalWrite(ledPin, LOW);
}

void loop() {
  //read the input from A0 and store it in a variable
  sensorValue = analogRead(A0);

  // map the sensor values to a wide range of pitches
  int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 4000);

  // play the tone for 20 ms on pin 8
  tone(8, pitch, 20);

  // wait for a moment
  delay(10);
}

```