# Arduino

{% embed url="https://www.youtube.com/playlist?list=PLzJHlGXNwBAMrkjpivYxuBjNnLLwBFpda" %}

### Arduino semplice - Lez 2 - Il primo programma

<pre class="language-arduino"><code class="lang-arduino"><strong>// inizializzazione - funzione eseguita una sola volta all'inizio
</strong><strong>void setup() {
</strong>
}

// funzione chiamata di continuo
void loop() {

}
</code></pre>

Nella funzione di `setup` metteremo ad esempio le inizializzazioni (se un PIN è in ingresso o in uscita, tramite l'istruzione `pinMode`), mentre nella funzione `loop` il programma vero e proprio.

Lo sketch è sostanzialmente costituito da due sezioni:

* la funzione `setup()`: viene eseguita una sola volta, all'accensione o dopo il caricamento della sketch, oppure dopo la pressione del pulsante **Reset** di Arduino; contiene tra parentesi graffe le istruzioni `pinMode()` per impostare lo stato (input o output) dei pin, le inizializzazioni delle librerie utilizzate, l'apertura della porta seriale per il Serial Monitor ...;
* la funzione `loop()`: contiene tra parentesi graffe il corpo del programma che deve essere eseguito ciclicamente, specificando quali azioni deve compiere Arduino;

Facciamo un semplice programma per l'accensione del led interno collegato al pin I/O 13.

<pre class="language-arduino"><code class="lang-arduino"><strong>int LED = 13;  // PIN 13 è per azionare il LED interno
</strong>
void setup() {
    pinMode(LED, OUTPUT);   // imposta il pin 13 come uscita
}

void loop() {
    digitalWrite(LED, HIGH);  // accendi LED
    delay(1000);   // attendi per 1000 ms = 1 sec
    digitalWrite(LED, LOW); // spegni LED
    delay(1000); // attendi per 1000 ms = 1 sec   
}
</code></pre>

### Lez 3 - Accensione di un LED esterno

Il generatore interno di Arduino è di 5 V ma il diodo led ha bisogno di una tensione di 1,5 V e funziona con una corrente di 20 mA, bisogna quindi mettere una resistenza che va dimensionata correttamente: chiamiamo $$V_R$$ la caduta di tensione del resistore, quindi in base alla **legge di Ohm:**

$$
R = \frac {V_R} I
$$

per calcolare la resistenza del resistore. In questo caso:$$\frac {V_R} d$$

$$
R = \frac {5V - 1.5V} {20\ mA} = \frac {3.5V} {20\ mA} \approx 170\   Ohm
$$

**Limiti di Arduino per non sovraccaricare i PIN e bruciare la scheda - riferimenti:**

> Singolo PIN -> max 40 mA (buona norma farlo lavorare sotto 20 mA)
>
> Massimo complessivo -> 200 mA&#x20;

Il codice per far lampeggiare il diodo led esterno è uguale a quello utilizzato per il diodo led interno (quello del pin 13): ora invece colleghiamo il nostro diodo tramite breadboard e resistore al diodo led 10.

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FgiykXR4HWavhWJzqrTH3%2Fard1.PNG?alt=media&#x26;token=b6e2393e-1dc8-4ac0-ae42-cbacdb25991e" alt=""><figcaption><p>Circuito LED esterno</p></figcaption></figure>

```arduino
int LED = 10;

void setup() {
    pinMode(LED, OUTPUT);   // imposta il pin 10 come uscita
}

void loop() {
    digitalWrite(LED, HIGH);  // accendi LED
    delay(1000);   // attendi per 1000 ms = 1 sec
    digitalWrite(LED, LOW); // spegni LED
    delay(1000); // attendi per 1000 ms = 1 sec   
}
```

Soluzione:

{% embed url="https://www.tinkercad.com/things/fqkDLQyXzIT-circuito-led-esterno" %}

In questo esempio il **Periodo** T, tempo per fare un ciclo, è di 2 secondi in quanto 1 sec ON e 1 sec OFF:

<img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2F9nmwEHNdCHFhMoVOvcKM%2Ffile.excalidraw.svg?alt=media&#x26;token=dba51003-e2e8-405f-8671-f229d2c4f26a" alt="" class="gitbook-drawing">

La **Frequenza**, quanti cicli fa in un secondo è l'inverso del **Periodo**. Quindi:

$$
F = \frac 1 T = \frac 1 {2 sec} = 0.5 Hz
$$

che vuol dire mezzo ciclo al secondo.

> **Periodo**, si misura in **secondi** ed è il tempo per fare un ciclo di un segnale periodico
>
> La **Frequenza**, si misura in **Herz**, ed è quanti cicli vengono compiuti in un secondo.
>
> 1 Herz corrisponde a un ciclo al secondo.

Se invece il delay nel codice fosse di 500 ms cioè mezzo secondo, il Periodo sarebbe di 1 sec (non più due secondi) e la frequenza aumenterebbe a 1 Hz cioè un ciclo al secondo (e non più mezzo ciclo al secondo corrispondente a 0,5 Hz)

### Lez 4 - Input e output digitali - Accensione led con interruttore (deviatore), collegamenti hardware

Utilizzo di un **deviatore** per controllare un LED.

<img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FrnQXJuI8jJaGrWlNbM9g%2Ffile.excalidraw.svg?alt=media&#x26;token=0746ce5d-f522-42e4-bb8a-7588df1b1e62" alt="Utilizziamo un DEVIATORE al posto di un INTERRUTTORE" class="gitbook-drawing">

Deviatore che comanda un LED:

* quando il deviatore è su 5V (stato logico 1) voglio che il LED si accenda;
* quando il deviatore è su GND (stato logico 0) voglio che il led si spenga;

Vediamo le funzioni che utilizziamo:

* `digitalWrite(pin, stato)`  -> si usa per fornire lo stato logico in uscita (OUTPUT)  \
  se lo stato è `HIGH` il Pin si porta a 5V (1 logico) se è `LOW` (0 logico) il pin  \
  si porta a 0V;
* `digitalRead(pin)` -> si usa per acquisire uno stato in ingresso (INPUT), se applichiamo 5V il Pin si porta allo stato logico 1, se applichiamo 0V il pin si porta allo stato logico 0;

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FAU2UXvDxZr8hQQo4dU6Y%2FIngenious%20Migelo-Bombul.png?alt=media&#x26;token=8aec7e8b-fd93-4174-809c-2803321dc3e6" alt=""><figcaption></figcaption></figure>

```arduino
// C++ code
//

int LED=10;
int DEVIATORE=2;

void setup()
{
  pinMode(DEVIATORE, INPUT);
  pinMode(LED, OUTPUT);
}

void loop()
{
  int StatoDeviatore = digitalRead(DEVIATORE);
  
  if (StatoDeviatore == HIGH)
     digitalWrite(LED, HIGH);
  else
     digitalWrite(LED, LOW);  
}
```

Soluzione:

{% embed url="https://www.tinkercad.com/things/ffqaYpTA26V-accensione-led-con-interruttore-collegamenti-hardware" %}

### Lez 5a - Accensione led con pulsante, resistenza pull down, struttura if-else

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2F52sVIeTVsxU19fBEhmRA%2FPulsante.PNG?alt=media&#x26;token=1bb249d6-7679-451d-a04a-a559ce8729cc" alt=""><figcaption></figcaption></figure>

Facciamo il controllo del LED con un **pulsante**: Vogliamo che quando il **pulsante** è premuto il LED cambi stato e rimanga in tale stato anche dopo il rilascio del pulsante. Quando poi ripremiamo il pulsante cambi a questo punto lo stato.

In figura il flow chart del codice:

{% @mermaid/diagram content="
flowchart TD
        A(["Start"])
        A --> A1["StatusPrevious := LOW 
                StatusLED := LOW"]
        A1 --> Z[/Lettura StatusNow/]
        Z --> B{"StatusPrevious != StatusNow"}
        B --> |No|FIN@{ shape: cross-circ, label: "Summary" } 
        B --> |Yes|D{"StatusNow == HIGH"}
        D --> |Yes|E{"StatoLED == LOW"}
        E --> |Yes|F["StatoLED := HIGH
                Accendi LED"] --> FIN
        E --> |No|G["StatoLED := LOW
                Spegni LED"] --> FIN
        D --> |No|FIN --> Z
" %}

La variabile `StatusNow` a ogni loop contiene il valore letto dal pin collegato all'interruttore se in stato `LOW` o `HIGH`, mentre  `StatusPrevious` contiene il valore dello stato precedente del loop (alla fine del loop, `StatusPrevious` viene aggiornato a `StatusNow`).&#x20;

Il pulsante non può essere collegato direttamente al pin che legge lo stato del pulsante, altrimenti ci sarebbe cortocircuito. Per evitare questo dobbiamo mettere una resistenza. (In **PULL-DOWN** o in **PULL-UP**).

Vediamo il caso del collegamento del **pulsante** sulla breadboard con una **resistenza di PULL-DOWN**.

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FsrB9H3SkAMG4gbfq0aJy%2FPulsante.PNG?alt=media&#x26;token=e1a281c1-9152-48f0-ba14-8b0922258829" alt=""><figcaption></figcaption></figure>

Ora disegnamo la soluzione:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FwWS3z3Z0RKS5G6hRhjRJ%2FAccensione%20LED%20con%20Bottone.png?alt=media&#x26;token=e630a204-ffd2-4e7f-9845-72069105d82f" alt=""><figcaption><p>Soluzione con pulsante e resistenza PULL-DOWN</p></figcaption></figure>

```arduino
// C++ code
//
#define PULSANTE 3
#define LED 8

int StatoPulsantePrevious = 0;
int StatoLED = 0;

void setup()
{
  Serial.begin(9600);
  pinMode(PULSANTE, INPUT);
  pinMode(LED, OUTPUT);
}

void loop()
{
  int StatoPulsante = digitalRead(PULSANTE);
  if (StatoPulsante != StatoPulsantePrevious) {
    Serial.print("StatoPulsante CHANGED = ");
  	Serial.println(StatoPulsante);
    if(StatoPulsante == 1 && StatoLED == 0) {
      StatoLED = 1;
      digitalWrite(LED, HIGH);
    } else if (StatoPulsante == 1 && StatoLED == 1) {
      StatoLED = 0;
      digitalWrite(LED, LOW);
    }
    
    Serial.print("StatoLED: ");
    Serial.println(StatoLED);
    StatoPulsantePrevious = StatoPulsante;
  } 
  
}
```

Soluzione:&#x20;

{% embed url="https://www.tinkercad.com/things/1gwzpytlUs8-accensione-led-con-bottone" %}

### Lez 5b - Input digitali, collegamento pulsante, resistenze di pull-down e pull-up.

Con la **resistenza di PULL-DOWN**:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FAfS4QEn4R9TydiZnh852%2Fpull_down.PNG?alt=media&#x26;token=aaf2827e-9301-471d-a745-54f8eba81126" alt=""><figcaption><p>Utilizzo della RESISTENZA DI PULL-DOWN</p></figcaption></figure>

Con la **resistenza di PULL-UP**:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2Fti8VPZNrJ9cYsYaWwXvv%2Fpull_up.PNG?alt=media&#x26;token=c774e17b-dbd9-42d2-8589-4d331126b2d8" alt=""><figcaption><p>Utilizzo della RESISTENZA DI PULL-UP</p></figcaption></figure>

Con la resistenza di **PULL-UP** abbiamo la logica invertita rispetto alla **PULL-DOWN**.

Si può evitare di mettere una **resistenza esterna**, perché all'interno di Arduino ci sono anche delle **resistenze interne** che si possono richiamare tramite il codice.

> Esiste come resistenza interna, in Arduino, solo la resistenza di PULL-UP non quella di PULL-DOWN

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FB1kiJgbtxFtqqw53Ln5A%2FStunning%20Snicket.png?alt=media&#x26;token=46d6fc40-d06e-435f-8798-69a82b421c38" alt=""><figcaption></figcaption></figure>

```arduino
// Some code// C++ code
//

const int pulsante = 2;
const int led = 12;

bool statoPulsante = HIGH;

void setup()
{
  pinMode(led, OUTPUT);
  pinMode(pulsante, INPUT_PULLUP);
}

void loop()
{
  statoPulsante = digitalRead(pulsante);
  
  if(statoPulsante == HIGH)
    digitalWrite(led, LOW);
  else 
  	digitalWrite(led, HIGH);
}
```

Soluzione:

{% embed url="https://www.tinkercad.com/things/3BiQcRHhBZZ-accensione-led-utilizzo-resistenza-interna-pullup" %}

### Lez 6 - Monitor seriale

**SERIAL MONITOR**: Si tratta di una comunicazione seriale che consente di inviare dati al PC o di ricevere dati dalla scheda verso il PC attraverso i pin 0 e 1 (RX e TX).&#x20;

Per questo motivo i pin 0 e 1 è meglio non utilizzarli se non è strettamente necessario.

SERIAL MONITOR

* Per utilizzare la porta seriale è necessario inizializzarla nel setup con la funzione `Serial.begin(9600)`
* 9600 è la velocità di trasmissione tra Pc e Arduino:
* Questa velocità si misura in baud. Quindi 9600 vuol dire che trasmetteremo 9600 simboli al secondo;
* Attenzione a non confondere baud con bps o bit/s perché un simbolo è composto di più bit;&#x20;



### Lez 7 - Ingressi analogici (utilizzo del potenziometro)

#### ANALOGICO

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FmyjvzKWxuf3qFHgmO75i%2Fsegnale1.png?alt=media&#x26;token=53aff415-56ec-42a4-bdea-99d9a63c0395" alt=""><figcaption></figcaption></figure>

Il termine analogico si riferisce ad una grandezza (generalmente di tipo elettronico sotto forma di tensione) che è analoga ad una grandezza di riferimento che si vuole acquistare o controllare.

Un tipico esempio di grandezza analogica è ad esempio la temperatura.

#### DIGITALE

* Il termine digitale deriva dall'inglese digit (vuol dire cifra);
* In elettronica le grandezze digitali utilizzano il sistema binario;
* Abbiamo due soli numeri 0, 1;
* ALTO, BASSO - HIGH, LOW;
* ACCESO, SPENTO - ON, OFF;

#### Convertitore A/Digitale e D/Analogico

<img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FVrDDg807Qua09BrzXnCH%2Ffile.excalidraw.svg?alt=media&#x26;token=deab88a3-fc67-4740-9d40-5dc653d1d1cc" alt="" class="gitbook-drawing">

#### ADC - Convertitore Analogico Digitale (interno ad Arduino)

* Convertitore analogico-digitale (ADC)
* Caratteristiche del convertitore
  * 6 ingressi analogici
  * Risoluzione: 10 bit
  * Tempo di conversione: 13 - 260 us
  * Tensione in ingresso tra 0 e 5V

Conversione analogico - digitale:

$$
V_{IN} : n = V_{MAX} : (2^N - 1)
$$

risolvendola rispetto a _n_ troviamo:

$$
n = \frac {V_{IN}} {V_{MAX} } * (2^N - 1)
$$

Su Arduino la tensione massimo, $$V_{MAX}$$, è 5 V e N = 10. Si ottiene quindi:

$$
n = \frac {V_{IN}} 5 * 1023
$$

Vediamo i potenziometri per generare valori analogici.

**POTENZIOMETRO:** è semplicemente un resistore variabile. Utilizzato per produrre valori analogici.&#x20;

Il potenziometro con ha solo due terminali A e B come il resistore ma anche un terzo terminale C (terminale mobile) che mi permette di variare la resistenza: se io la resistenza la prendo tra C e A: quando porto C su A sto prendendo la resistenza 0 mentre quando porto C su B sto prendendo la resistenza massimo.

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FLV3HmpCyThJdrxtjzssE%2FPotenziometro.PNG?alt=media&#x26;token=f3877fe1-a0ca-42ad-a6aa-b80e8cf142ae" alt=""><figcaption></figcaption></figure>

Lo inizieremo ad utilizzare come **regolatore di tensione** - **partitore di tensione**.

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2F16Dah9xkYOlCDYSKsssj%2FPotenziometro2.PNG?alt=media&#x26;token=ae02ed89-f23c-435e-9ea6-c93cbb273e73" alt=""><figcaption></figcaption></figure>

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FWQ7QubAu8Cz67PeZCozV%2FPotenziometro3.PNG?alt=media&#x26;token=e38cf36f-aa05-4aa3-ac1a-1a17e63508d6" alt=""><figcaption></figcaption></figure>

Sul terminale C, se C = A, allora la tensione $$V_x$$ sarà 5 V (che è la tensione della batteria è 5V)

Sul terminale C, se C = B, allora la tensione $$V_x$$ sarà 0 V.

Nei punti intermedi, il valore di $$V_x$$ sarà un valore tra 0 e 5V, al esempio 2,7V, in base a come spostate il terminale C tra A e B: quanto più vi avvicinate ad A più tende a 5V viceversa avvicinandosi a B tende a 0V.

A questo punto collego C a un pin di imput analogico, come `A0`.

Funzione **`analogRead(pinAnalogico)`** per la lettura di valori discreti nel range tra 0 e 1023 (= $$2^{10} - 1$$).

`int valore = analogRead(A0);`

Utilizzo dell'esempio di lettura da potenziometro:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FdzSUexRW1EnKFIb1oNWb%2FFantabulous%20Blorr-Crift.png?alt=media&#x26;token=a299e4db-6776-45ea-b029-85bd1d45f880" alt=""><figcaption></figcaption></figure>

```arduino
/*
acquisizione dal canale A0  
*/
void setup() {
    // inizializzazione della comunicazione seriale
    Serial.begin(9600);
}

// funzione chiamata di continuo
void loop() {
    int n = analogRead(A0);
    Serial.print("Valore numerico acquisito su A0 --> n = ");
    Serial.println(n);
    float Vin = (float) n * 5 /1023;
    Serial.print("Vin = ");
    Serial.print(Vin);
    Serial.println(" Volt");
    Serial.println("");
    
    delay(2000);
}
```

Soluzione:

{% embed url="https://www.tinkercad.com/things/jXTuvFqAwbe-ingressi-analogici-potenziometro-" %}

### Lez 8 - Uscite analogiche PWM

#### Regolazione della luminosità di un diodo LED

**Uscite PWM**

Arduino non possiede delle vere e proprie uscite analogiche. Riusciremo però ad ottenere una variazione di una tensione utilizzando le uscite digitali con la tecnica PWM

Cos'è il **PWM** (**Pulse Width Modulation**)?

Modulazione a lunghezza d'impulso.

L'idea è quella di regolare il valore medio di un segnale digitale modificando i tempi relativi di ON e OFF

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2F4zg4g3VvDShmrDS8ksMc%2FPWM.PNG?alt=media&#x26;token=d60af975-23d5-4001-98fd-de6856f7e403" alt=""><figcaption><p>SEGNALE DIGITALE con UNA DETERMINATA FREQUENZA</p></figcaption></figure>

Le uscite PWM:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FTBCewegs9fBwB0D7osLS%2FDutyCicle.PNG?alt=media&#x26;token=a4902ac8-30f1-41d7-8cd8-9a8f20aefe20" alt=""><figcaption></figcaption></figure>

Il concetto di **Duty Cycle**, abbreviato in **DC,** come rapporto tra tempo a segnale alto $$T_{ON}$$ e periodo del segnale $$T$$ poi moltiplicato per 100 per avere la percentuale.

Per cambiare di DC non cambia il periodo ma il tempo, la percentuale,  in cui il segnale è altro, il $$T_{ON}$$.

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FaZojvEEP4ecw0dDGFbAR%2FPWM2.PNG?alt=media&#x26;token=c907d949-b3af-4923-8ab0-a97f81116cc0" alt=""><figcaption></figcaption></figure>

Le uscite **analogiche PWM** sono, su Arduino, quelle DIGITALE con il simbolo `~`. Si possono vedere nella figura sotto.

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FN8yTUS3xarzyj5qB2lOC%2FARDUINO_PWM.PNG?alt=media&#x26;token=dcacca60-27f2-4e95-931d-58cbfda1f634" alt=""><figcaption></figcaption></figure>

Per scrivere sulle uscite PWM di Arduino abbiamo:

```arduino
analogWrite(pin, val);
```

Pin -> 3, 5, 6, 9, 10, 11

`Val` è gestito da una variabile a 8 bit e quindi può assumere valori che vanno da 0 a 255.

Ad esempio se:

val = 0 -> abbiamo un DC del 0%;

val = 255 -> abbiamo un DC del 100%;

val = 127 -> abbiamo un DC del 50%;

Quindi, con la funzione `analogWrite`, possiamo regolare il **Duty Cycle**:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FdGbdBu9462sI75KhFxAl%2FPWM3.PNG?alt=media&#x26;token=e334e556-816d-4374-a0a0-c5fe7b25e4c0" alt=""><figcaption></figcaption></figure>

#### Controllo dei carichi in PWM

* La tecnica PWM è molto utilizzata per controllare diversi tipi di carichi: LED, lampade, motori, resistenze termiche.....
* Sembra strano far accendere qualcosa accendendo e spegnendo in continuazione
* La frequenze è però talmente alta (490 Hz sui pin 3, 9, 10 e 11 e 980 Hz sui pin 5 e 6) che sarà il nostro stesso occhio a fare la media di quel segnale e non percepire il lampeggio della lampada

Possiamo vedere il **potenziometro** come **regolatore di corrente** (nel caso precedente l'avevamo utilizzato come **regolatore di tensione**).

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FBvZB72XuNm2WAArLDT2Y%2FPotenziometro2.PNG?alt=media&#x26;token=8bb48f8a-0266-4763-94e7-ff8ab679d01d" alt=""><figcaption></figcaption></figure>

Per la legge di Ohm $$I = V/R$$ muovendo il cursore C verso i terminali A o B, aumentando o diminuendo la resistenza e quindi diminuendo o aumentando la corrente (la Resistenza e Intensità della corrente sono inversamente proporzionali per la legge di Ohm)

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FFdAuzqpfaU9AyHto14HB%2FPWM4.PNG?alt=media&#x26;token=d945ce37-afa8-42d1-b9bb-1c3106de5c28" alt=""><figcaption></figcaption></figure>



Ora vediamo, invece, come fare un regolatore di un diodo LED con Arduino:

#### CONTROLLO di un diodo LED in PWM

* Legge da un input analogico la tensione fornita da un potenziometro (10 bit -> 0 - 1023)
* Traduce nel relativo segnale PWM (8 bit -> 0-255)
* Invia al diodo Led una tensione PWM con duty cycle variabile proporzionale alla posizione del potenziometro
* Invia i risultati al serial monitor

#### La funzione `map`

Per fare la conversione tra i valori che arrivano dal potenziometro (0-1023) e quelli che devono andare al LED dal pin PWM (0-255) usiamo la funzione `map`.

```arduino
// val il val del duty cycle, es 127 per il 50%
map(val, min1, max1, min2, max2);

map(val, 0, 1023, 0, 255);

```

Ora che abbiamo visto le funzioni `analogWrite` e `map` possiamo utilizzarle insieme ad `analogRead` per regolare la luminosità di un LED  tramite un potenziometro:

<figure><img src="https://674701192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FdgsK7iAS8aXenaw6Clqe%2Fuploads%2FjEvkGQcUHLXzql9MvyxU%2FCopy%20of%20Ingressi%20analogici%20(POTENZIOMETRO)%20.png?alt=media&#x26;token=1f55bc9b-555c-4848-8135-15926b1833e4" alt=""><figcaption></figcaption></figure>

```arduino
int potenziometro = A0;
int LED = 10;
int ValPot = 0;
int ValOut = 0;

void setup() {
    Serial.begin(9600);
    // le lineee analogiche IN o OUT non vanno impostate
}

void loop() {
    // legge il valore analogico dal potenziometro
    ValPot = analogRead(potenziometro);
    
    // scala il valore letto (da 0 a 1023) in uno proporzionale (da 0 a 255)
    ValOut = map( ValPot, 0, 1023, 0, 255);
    
    // aggiorna il segnale pwm sull'out analagica led
    analogWrite(LED, ValOut);
    
    Serial.print("potenziometro = ");
    Serial.print(ValPot);
    Serial.print("\t Pwm Led = ");
    Serial.println(ValOut);
    Serial.print("dudy cycle = ");
    Serial.print(ValOut * 100/255);
}

```

Soluzione:

{% embed url="https://www.tinkercad.com/things/8QmZpKSg4zk-controllo-diodo-led-in-pwm" %}

### Learn Arduino and Circuits with Tinkercard!

{% embed url="https://youtu.be/Xgj5L7UOJDw?si=E1Z5wRMr0yOmfrQ8" %}

## MISC <a href="#misc" id="misc"></a>

{% embed url="https://www.brescianet.com/appunti/Elettronica/Arduino/corso/note.htm" %}

{% embed url="https://www.antoniovasco.it/2021/10/24/tipi-di-segnali-analogici-e-digitali/" %}

{% embed url="https://www.emanuelegenovese.it/resistenza-pull-up-pull-down/" %}
