![13 Numerazione capitolo](13-num-capitolo.png)
## 13 - LAMPADA EMOTIVA

**CREERAI UNA LAMPADA CHE SI ACCENDE E SI SPEGNE QUANDO TOCCHI UN PEZZO DI MATERIALE CONDUTTIVO**

> **Scopri:** installare librerie fornite da altri, creare un sensore di tocco
>
> **Tempo:** 45 MINUTI
> **Livello:** ■ ■ ■ ■ □
> **Basato sui progetti:** 1, 2, 5

**Per questo progetto utilizzerai la libreria CapacitiveSensor di Paul Badger, che permette di misurare la capacità elettrica del tuo corpo.**

![Ingredienti](13-ingredienti.png)  
>**INGREDIENTI**
>*   LED
>*   Resistenza da 220 Ohm
>*   Resistenza da 1 Mega Ohm
>*   Lamina di metallo (es. foglio di alluminio)

La capacità misura la quantità di carica elettrica che un corpo è in grado di immagazzinare. La libreria controlla due piedini di Arduino (uno è un emettitore, l'altro un ricevitore) e misura il tempo a loro richiesto per raggiungere lo stesso stato. Questi piedini sono collegati a un oggetto metallico, come un foglio di alluminio. Quando ti avvicini all'oggetto, il tuo corpo è in grado di assorbire parte della carica, allungando i tempi necessari ai due piedini per raggiungere lo stesso stato.

### PREPARARE LA LIBRERIA
La versione più recente della libreria CapacitiveSensor è qui: [arduino.cc/capacitive](http://arduino.cc/capacitive). Scarica il file sul tuo computer e decomprimilo. Apri la cartella che contiene gli sketch di Arduino (solitamente è nella cartella "Documenti"). Nella cartella, crea una nuova cartella chiamata "libraries". Posiziona qui la cartella CapacitiveSensor e riavvia il software Arduino.
Clicca sul menu **File > Examples** nel software di Arduino, e vedrai una nuova voce "CapacitiveSensor". La libreria che hai aggiunto include un progetto di esempio. Apri **CapacitiveSensorSketch** e compilalo. Se non compare un avviso di errore, è stato installato correttamente.

> *Per maggiori informazioni sulle librerie:* [arduino.cc/en/Reference/Libraries](http://arduino.cc/en/Reference/Libraries)

### COSTRUISCI IL CIRCUITO

![Schema del circuito e montaggio](13-immagine_circuito_lampada_emotiva.png)

1.  Collega un LED al piedino 12 e collega il catodo a massa attraverso la resistenza da 220 ohm.
2.  Collega i piedini digitali 2 e 4 alla breadboard. Collega i due piedini con una resistenza da 1 mega ohm. Nella stessa riga del piedino 2, inserisci un filo lungo (almeno 8-10 cm) che fuoriesce dalla breadboard, non collegato a nulla all'altra estremità. Questo diventa il sensore di tocco.

**In questo progetto non c'è bisogno di fornire 5V alla breadboard. Il piedino digitale 4 fornisce la corrente al sensore.**

![Schema elettrico](13-schema_elettrico_lampada.png)

![Forbici e colla](forbici-colla.png)
> Proprio come con altri progetti con i LED, diffonderne la luce li rende molto più interessanti. Palline da ping pong, piccoli paralumi di carta o di plastica, tutto ciò che hai a portata di mano può andar bene per diffondere la luce.
>
> Puoi nascondere il sensore dietro qualcosa di solido e continua a funzionare. La capacità può essere misurata attraverso materiali non conduttivi come il legno e la plastica. L'aumento della superficie del sensore con una superficie conduttiva più grande lo rende più sensibile; prova a collegare un foglio di alluminio o una rete di rame al filo. Potresti fare una base per la lampada con cartone, legno sottile o con un panno e rivestire la superficie interna con un foglio collegato al filo del sensore. L'intera base della lampada si comporterebbe quindi come un sensore di tatto. Aggiorna la soglia variabile nel codice quando fai queste modifiche per garantire ancora un risultato affidabile.

### IL CODICE

#### Importa la libreria CapacitiveSensor
All'inizio del tuo programma, includi la libreria CapacitiveSensor. Si fa come con una libreria nativa Arduino, come la libreria `Servo` nei progetti precedenti. Crea un'istanza della libreria. Quando la utilizzi, dici all'istanza quali piedini sono utilizzati per inviare e ricevere informazioni. In questo caso il piedino 4 alimenta il sensore di materiale conduttivo attraverso la resistenza, e il piedino 2 è quello che misura.

```cpp
#include <CapacitiveSensor.h>
CapacitiveSensor capSensor = CapacitiveSensor(4,2);
```

#### Imposta la soglia
Crea una variabile per la soglia di rilevamento alla quale la lampada si accende. Puoi modificare questo valore dopo aver testato la funzionalità del sensore.
Poi definisci il piedino collegato al LED.

```cpp
int threshold = 1000;
const int ledPin = 12;
```

Nel `setup()`, apri una connessione seriale a 9600 bps per vedere i valori letti dal sensore. Inoltre, rendi il ledPin un **OUTPUT**.

```cpp
void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}
```

#### Rileva il tocco
Nella funzione `loop()`, crea una variabile di tipo long per memorizzare il valore del sensore. La libreria legge il valore del sensore usando il comando `capSensor.capacitiveSensor()`.
Che richiede un parametro che identifica il numero di campioni che vuoi leggere. Se leggi solo pochi campioni, puoi vedere molte variazioni nel sensore. Se prendi troppi campioni, potresti introdurre un ritardo leggendo molte volte il sensore. 30 campioni è un buon valore di partenza. Stampa il valore del sensore sul monitor seriale.

```cpp
void loop() {
  long sensorValue = capSensor.capacitiveSensor(30);
  Serial.println(sensorValue);
```

#### Controlla la lampada
Con un'istruzione `if()...else`, controlla se il valore del sensore è più alto della soglia. Se lo è, accendi il LED; altrimenti spegnilo.

```cpp
  if(sensorValue > threshold) {
    digitalWrite(ledPin, HIGH);
  }
  else {
    digitalWrite(ledPin, LOW);
  }
```

Poi aggiungi un piccolo `delay()` prima di finire il `loop()`.

```cpp
  delay(10);
}
```

### USALA

Dopo aver programmato Arduino, vorrai scoprire quali sono i valori del sensore quando viene toccato. Apri il monitor seriale e prendi nota del valore proveniente dal sensore quando non lo tocchi. Premi leggermente il filo che fuoriesce dalla breadboard. Il numero dovrebbe aumentare. Prova a premere con maggiore fermezza e vedi se cambia.

Una volta che hai un'idea della gamma di valori che stai ricevendo dal sensore, torna allo sketch e modifica la soglia variabile a un numero che è maggiore del valore del sensore quando non viene toccato, ma inferiore al suo valore quando viene premuto. Carica lo sketch con il nuovo valore. La luce dovrebbe accendersi quando tocchi il filo e spegnersi quando viene lasciato. Se non riesci ad accendere la luce, prova a ridurre ancora un po' la soglia.

![Cervello](cervello.png)
> *Probabilmente hai notato che i valori del sensore cambiano a seconda di quanta parte del tuo dito è stata in contatto con il conduttore. Si può sfruttare questo fenomeno per ottenere altre interazioni con il LED? Che ne pensi di più sensori usati per alzare e abbassare l'intensità della luce? Se inserisci una resistenza diversa tra i piedini 2 e 4 cambierà la sensibilità. È utile per l'interfaccia?*

**Librerie scritte da altri, come la CapacitiveSensor di Paul Badger sono strumenti utili per ampliare le funzionalità di Arduino. Una volta installate, si comportano in modo simile alle librerie che fanno parte del software di base.**

### CODICE COMPLETO

```cpp
/*
  Arduino Starter Kit example
  Project 13 - Touch Sensor Lamp

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

  Parts required:
  - 1 megohm resistor
  - metal foil or copper mesh
  - 220 ohm resistor
  - LED

  Software required :
  - CapacitiveSensor library by Paul Badger
    https://www.arduino.cc/reference/en/libraries/capacitivesensor/

  created 18 Sep 2012
  by Scott Fitzgerald

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

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

// import the library (must be located in the Arduino/libraries directory)
#include <CapacitiveSensor.h>

// create an instance of the library
// pin 4 sends electrical energy
// pin 2 senses senses a change
CapacitiveSensor capSensor = CapacitiveSensor(4, 2);

// threshold for turning the lamp on
int threshold = 1000;

// pin the LED is connected to
const int ledPin = 12;


void setup() {
  // open a serial connection
  Serial.begin(9600);
  // set the LED pin as an output
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // store the value reported by the sensor in a variable
  long sensorValue = capSensor.capacitiveSensor(30);

  // print out the sensor value
  Serial.println(sensorValue);

  // if the value is greater than the threshold
  if (sensorValue > threshold) {
    // turn the LED on
    digitalWrite(ledPin, HIGH);
  }
  // if it's lower than the threshold
  else {
    // turn the LED off
    digitalWrite(ledPin, LOW);
  }

  delay(10);
}
```