Corso Arduino Base - MUST

www.opsitalia.com
CORSO ARDUINO
PRIMO LIVELLO
Durata: 8 ore

•  I componenti elettronici di base
•  Introduzione alla scheda Arduino
•  Le basi della programmazione
•  Le comunicazioni seriali
•  Input digitali e analogici semplici
•  Ricavare input dai sensori
•  L’output visivo
•  L’output fisico
INDICE DEGLI ARGOMENTI

Introduzione alla scheda Arduino
1.  Introduzione: Le schede Arduino ufficiali
2.  Architettura: Hardware e Software
3.  Come Arduino interagisce con il mondo esterno: Input e Output
I componenti elettronici di base
1.  Resistenze, condensatori e diodi LED
Le basi della programmazione
1.  Introduzione: L’ambiente di sviluppo integrato di Arduino [IDE]
2.  Tipi di dati
3.  Controllo di flusso [if … then, while, do … while, for, switch … case]
4.  Stringhe
5.  Operatori aritmetici
Le comunicazioni seriali
1.  Introduzione: Le porte seriali in Arduino
2.  Ricevere dati da Arduino
3.  Inviare dati ad Arduino
DETTAGLIO ARGOMENTI [1/2]

Input digitali e analogici semplici
1.  Introduzione:
2.  Utilizzare un interruttore
3.  Leggere valori analogici
Ricavare input dai sensori
1.  Introduzione
2.  Il partitore resistivo
3.  Rilevare la luce
4.  Gestire un interrupt
L’output visivo
1.  Introduzione
2.  Collegare e utilizzare i LED
3.  Regolare il colore di un led
L’output fisico
1.  Introduzione
2.  Utilizzare un servomotore
3.  Controllare i servomotori via software
DETTAGLIO ARGOMENTI [2/2]

Prima di cominciare a muovere i primi passi con Arduino, dobbiamo dare uno sguardo ad
alcuni componenti elettronici.
I componenti elettronici si dividono in:
•  Attivi: sono componenti che necessitano di una sorgente di energia esterna per poter
funzionare e in tal caso possono fornire in uscita un segnale con energia maggiore del
segnale ricevuto in ingresso.
•  Passivi: sono componenti che non sono in grado di erogare più energia di quanta gliene
viene fornita.
I componenti che esamineremo sono tra i più comuni e saranno:
•  Resistore – Componente elettronico passivo
•  Condensatore – Componente elettronico passivo
•  Diodo LED – Componente elettronico attivo
I COMPONENTI DI BASE

I resistori (impropriamente detti resistenze) trattengono il flusso della corrente elettrica. Una
tensione che attraversa la resistenza limita la corrente proporzionalmente al valore della
resistenza, in base alla nota legge di ohm:
V = R * I R = V / I I = V / R
Le strisce colorate sulle resistenze ne indicano il valore.
I COMPONENTI DI BASE: I RESISTORI [1/2]

RESISTORI IN SERIE
La resistenza totale di n resistori in serie è
data dalla somma delle resistenze di ciascun
resistore:
Il collegamento in serie di resistori a volte si
adotta per necessità. Ad esempio per evitare
archi voltaici.
RESISTORI IN PARALLELO
La resistenza totale di n resistori in parallelo
è data dalla relazione:
ovvero è il reciproco della somma dei
reciproci delle resistenze dei singoli resistori
I COMPONENTI DI BASE: I RESISTORI [2/2]

I condensatori servono a immagazzinare una carica elettrica per un breve periodo di tempo e
si utilizzano nei circuiti digitali per filtrare (ridurre) le cadute e i picchi dei segnali elettrici.
I condensatori che si utilizzano più spesso sono quelli ceramici non polarizzati; per esempio,
per il disaccoppiamento (per ridurre i picchi di disturbo) si utilizzano i condensatori a disco
da 100 nF.
I condensatori elettrolitici di solito sono in grado di immagazzinare una carica maggiore
rispetto a quelli ceramici e si utilizzano nei circuiti dove circola una tensione superiore, come
alimentatori e circuiti dei motori. I condensatori elettrolitici di solito sono polarizzati e il
terminale negativo (contrassegnato da un segno meno) deve essere collegato alla messa a
terra (o a un punto con un voltaggio inferiore a quello del terminale positivo).
I COMPONENTI DI BASE: I CONDENSATORI [1/2]

CONDENSATORI IN SERIE
La capacità totale di n condensatori in serie è
data dalla seguente relazione:
La tensione di funzionamento di una serie di
condensatori è data dalla somma delle
singole tensioni di funzionamento.
CONDENSATORI IN PARALLELO
La capacità totale di n condensatori in
parallelo è in questo caso la somma delle
singole capacità:
Il collegamento in parallelo dei condensatori
a volte si adotta per necessità, per poter
dissipare maggiore calore.
I COMPONENTI DI BASE: I CONDENSATORI [2/2]

I LED (Light-Emitting Diode) sono componenti attivi e polarizzati basati su semiconduttore
e hanno come gli altri diodi un catodo e un anodo.
I due reofori non hanno la medesima lunghezza e l’anodo (+) è quello più lungo. Il catodo (-)
è invece contrassegnato da una tacca sul colletto dell’involucro.
I COMPONENTI DI BASE: I DIODI LED [1/2]
I LED non possono essere alimentati superando la
loro corrente massima di lavoro, ma vanno utilizzati
in serie a un resistore con un valore di resistenza
opportuno.
La tensione a cui il LED lavora dipende dal suo
colore, passando dai 2.0V dei rossi ai 3.3V dei
bianchi.
Inoltre è importante ricordare che la corrente
massima erogabile da una scheda Arduino è
massimo 150mA, pertanto se vogliamo utilizzare più
LED è utile fornire a ciascun LED solo 10mA.

Per semplificare le cose, in tabella sono
presenti i valori delle resistenze da
utilizzare in funzione del colore del
diodo LED
Il valore della resistenza dipende sia dalla tensione di alimentazione, sia dalla corrente che
vogliamo far fluire nel diodo, sia dalla sua caduta di tensione (tensione di lavoro).
I COMPONENTI DI BASE: I DIODI LED [2/2]
Il calcolo del corretto resistore da utilizzare in
serie con un diodo LED deve essere effettuato
nel seguente modo:
R = (Vpin – V)/I
R = Resistenza da inserire in serie
Vpin = Tensione di alimentazione del LED
V = Tensione di caduta del LED
I = Corrente che attraversa il LED
Esempio:
LED Rosso: Vpin = 5V , I = 10mA
R = (5 – 2.0)/10mA = 300 ohm (che non
esiste, il valore più prossimo è 330 ohm).
Colore
Volt
Caduta
20mA
@
5V
10mA
@
5V

Infrarosso
1.5
180
ohm
390
ohm

Rosso
2.0
150
ohm
330
ohm

Arancio
2.0
150
ohm
330
ohm

Giallo
2.1
150
ohm
330
ohm

Verde
giallo
2.2
150
ohm
330
ohm

Verge
smeraldo
3.3
100
ohm
180
ohm

Blu
3.3
100
ohm
180
ohm

Bianco
3.3
100
ohm
180
ohm

UV
3.3
100
ohm
180
ohm

Blu
viola
(430
nm)
4.6
22
ohm
47
ohm

Arduino è una scheda elettronica di piccole dimensioni con un microcontrollore e circuiteria
di contorno, utile per creare rapidamente prototipi per scopi hobbistici e didattici. [fonte
Wikipedia]
Arduino è una scheda hardware open-source, pre-assemblata e con un proprio linguaggio di
sviluppo. Il microcontrollore a bordo della scheda è già predisposto per essere programmato
ed essendo “open” ogni utente può riprogrammarlo e cambiarne le funzionalità di base
oppure può aggiungere librerie all’ambiente di sviluppo.
Tramite la scheda è possibile realizzare prototipi praticamente per “ogni” cosa, la scheda è
estremamente versatile e ben si adatta a progetti di automazione e robotica.
Sfruttando le caratteristiche del microcontrollore, una volta terminato il progetto, è possibile
passare dal prototipo al prodotto con pochi componenti aggiuntivi.
Inoltre, in rete esiste una vasta comunità di utenti (neofiti o esperti) che pubblica progetti
scaricabili gratuitamente.
LA SCHEDA ARDUINO

LE SCHEDE ARDUINO UFFICIALI
“LE SCHEDE BASE”
LA SCHEDA ARDUINO: SPECIFICHE TECNICHE [1/2]
Arduino
Microcontrollore
FLASH
EEPROM
SRAM
I/O
Digitali
PWM
Ingressi

Analogici

Chip
USB
Dimensioni

KB
KB
KB
n.
pin
n.
pin
n.
pin
Kpo
mm

Uno
ATmega328P
32
1
2
14
6
6
ATmega8U2
68,6
x
53,3

Diecimila
ATmega168
16
0,5
1
14
6
6
FTDI
68,6
x
53,3

Due
ATMEL
SAM3U
256
0
50
54
4
16
-‐

Duemilanove
ATmega168/328P
16/32
0,5/1
1/2
14
6
6
FTDI
68,6
x
53,3

Fio
ATmega328P
32
1
2
14
6
8
Nessuno
40,6
x
27,9

Leonardo
ATmega32u4
32
1
2,5
14
7
12
ATmega32u4
68,6
x
53,3

LilyPad
Atmega168V
o

ATmega328V

16
0,5
1
14
6
6
Nessuno
Ø
50

Mega
ATmega120
128
4
8
54
14
16
FTDI
101,6
x
53,3

Mega2560
ATmega2560
256
4
8
54
14
16
ATmega8U2
101,6
x
53,3

Nano
ATmega168
o

ATmega328

16/32
0,5/1
1/2
14
6
8
FTDI
43
x
18

Mini
ATmega328
32
1
2
14
6
8
Nessuno

Micro
ATmega32u4
32
1
2,5
20
7
12
ATmega32u4
48
x
18,7

LA SCHEDA ARDUINO: “LE SCHEDE BASE”
Arduino Uno Arduino Due Arduino Leonardo
Arduino LilyPad Arduino Mega 2560
Arduino Nano
Arduino Mini

LE SCHEDE ARDUINO UFFICIALI
“LE SCHEDE EVOLUTE”
LA SCHEDA ARDUINO: SPECIFICHE TECNICHE [2/2]
Arduino
Microcontrollore
Processore
FLASH
EEPROM
SRAM
I/O
Digitali
PWM
Ingressi

Analogici

Chip
USB
SD
Ethernet
PoE
Wi-‐Fi
Dimensioni

KB
KB
KB
n.
pin
n.
pin
n.
pin
Kpo
mm

Yùn

ATmega32u4

32
1
2,5
14/20
7
6/12
ATmega32u4
SI

IEEE

802.3

10/100M
bit/s

OPZ.

IEEE

802.11b/g/n

68,6
x
53,3

Atheros
AR9331

MIPS
@400MHz

16000

RAM

64
MB

DDR2

USB
HOST

Tre
(annunciata)

ATmega32u4

32
1
2,5
14
7
6
-‐
-‐
-‐
-‐
-‐
-‐

TI
AM3359AZCZ100

(ARM
Cortex-‐A8)

IEEE

802.3

10/100M
bit/s

Ethernet
ATmega328
Nessuno
32
1
2
14
4
6
FTDI
SI
IEEE

802.3

10/100M
bit/s

OPZ.
NO
68,6
x
53,3

Robot

(control
board)

ATmega32u4
Nessuno
32
1
(int)

512
(ext)

2,5
5
6
4/8
ATmega32u4
SI
NO
NO
NO
Ø
190

h.
100

Robot

(motor
board)

ATmega32u4
Nessuno
32
1
2,5
4
1
4

(I/O
dig.)

ATmega32u4
SI
NO
NO
NO
Ø
190

h.
100

Esplora
ATmega32u4
Nessuno
32
1
2,5
-‐
-‐
-‐
ATmega32u4
NO
NO
NO
NO
165,1
X
61

joys_ck
analogico
2
assi
-‐
4
boaoni
-‐
potenziometro
lineare
-‐
microfono
-‐
sensore
di
luce
-‐
sensore
di
temperatura
-‐
accelerometro
3
assi
-‐

buzzer
-‐
led
RGB
-‐
2
input
TinkerKit
-‐
2
output
TinkerKit
-‐
conneaore
per
display
TFT
o
LCD
o
leaore
SD
Card

LA SCHEDA ARDUINO: “LE SCHEDE EVOLUTE”
Arduino Yùn Arduino Ethernet Arduino Tre (in arrivo)
Arduino Robot Arduino Esplora

Gli shield sono schede di espansione che consentono di aggiungere funzionalità avanzate alla nostra
scheda Aduino.
Esistono svariati shield che svolgono funzioni diverse che sono realizzati da produttori differenti.
Di seguito l’elenco degli shield ufficiali prodotti da Arduino (fonte www.arduino.cc):
LA SCHEDA ARDUINO: GLI SHIELD
SHIELD “STANDARD”
•  Arduino GSM Shield
•  Arduino Ethernet Shield
•  Arduino WiFi Shield
•  Arduino Motor Shield
SHIELD “PROTOTIPAZIONE”
•  Arduino Wireless SD Shield
•  Arduino Wireless Proto Shield
•  Arduino Proto Shield
PARAMETRI PER LA SCELTA DI UNA SCHEDA “SHIELD” ADEGUATA
•  Verificare la presenza degli schemi dello shield. Un produttore che non rilascia gli schemi della
scheda shield non è un produttore affidabile.
•  Verificare la piedinatura dello shield. Molto spesso è possibile utilizzare shield in “cascata”, ma per
farlo è necessario che non siano presenti conflitti sui pin della scheda Arduino.

LA SCHEDA ARDUINO: ARCHITETTURA [ARDUINO UNO]
La scheda Arduino Uno rev3 dispone dei seguenti pin:
A0 … A5 pin analogici
0 … 13 pin digitali
i pin con il simbolo ~ possono essere
pilotati in PWM (Pulse With Modulation)
IOREF Tensione di riferimento per i pin digitali
RESET Un valore di tensione basso resetta il
microcontrollore
3V3 Fornisce una tensione di 3,3 volt generata
dal regolatore di tensione della scheda
5V Fornisce una tensione di 5 volt generata
dal regolatore di tensione della scheda
VIN Pin per alimentare la scheda, la tensione da
fornire deve essere 7-12 volt
AREF Tensione di riferimento per gli input
analogici

La scheda Arduino Uno mette a disposizione una serie di pin con più funzioni:
D0 … D1 utilizzati per trasmettere (D0) e ricevere (D1) dati seriali in TTL
D2 … D3 utilizzati per collegare degli interruput esterni INT0 (D2) INT1 (D3)
tramite la funzione attachInterrupt(interrupt, ISR, mode)
D10… D13 utilizzati per le comunicazioni SPI con la libreria SPI library
SS (D10) - MOSI (D11), MISO (D12), SCK (D13)
A4 … A5 utilizzati per le comunicazioni TWI con la libreria WIRE library
SDA (A4) - SCL (A5)
LA SCHEDA ARDUINO: ARCHITETTURA [ARDUINO UNO]
PIN CON PIÙ FUNZIONI
NOTA: AUMENTARE IL NUMERO DI PIN DIGITALI DI ARDUINO
La scheda Arduino dispone di 14 pin digitali, ma è possibile aumentare questo numero fino a 20
utilizzando i pin analogici. Ovviamente se i pin vengono utilizzati in modalità digitale non potranno
essere utilizzati in modalità analogica.
NUOVI PIN DIGITALI: A0 … A5 -> D14 … D19

La scheda Arduino dispone di svariati pin suddivisi in digitali e analogici.
Pin Digitali: operano con segnali digitali, ovvero con segnali che assumono un valore di
tensione discreto:
0 volt (valore logico 0) oppure 5 volt (valore logico 1)
I pin digitali sono etichettati con la lettera D e possono essere utilizzati in tre modalità
differenti: ingresso, uscita, uscita PWM.
Per variare la modalità di funzionamento di un pin digitale si utilizza la funzione:
pinMode (pin, mode)
Pin Analogici: operano con segnali analogici, ovvero con segnali che assumono un valore
di tensione continuo:
da 0 volt a 5 volt su una scala di 1024 valori possibili [step 0,005 volt]
I pin analogici operano unicamente con segnali in ingresso, il valore della tensione è
convertito da un DAC 10bit (causa dei 1024 valori possibili: 2^10 = 1024).
LA SCHEDA ARDUINO: INPUT E OUTPUT

Un segnale modulato in PWM (Pulse Width Modulation ovvero modulazione a variazione
della larghezza d'impulso), è un tipo di modulazione digitale che permette di ottenere una
tensione media variabile dipendente dal rapporto tra la durata dell' impulso positivo e di
quello negativo.
La durata di ciascun impulso può essere espressa in rapporto al periodo tra due impulsi
successivi, implicando il concetto di ciclo di lavoro (duty cycle).
LA SCHEDA ARDUINO: I SEGNALI PWM [1/2]
Il duty cycle è il rapporto tra il tempo in cui l'onda assume valore alto e il periodo T
(l'inverso della frequenza: T=1/f).

Per meglio chiarire il concetto di duty cycle, ecco alcuni esempi riferiti ad Arduino:
•  duty cycle 0% = tensione 0 volt
•  duty cycle 50% = 50% tensione 5 volt 50% tensione 0 volt
•  duty cycle 100% = tensione 5 volt
LA SCHEDA ARDUINO: I SEGNALI PWM [2/2]
ESEMPI DI UTILIZZO DI UN SEGNALE PWM
La modulazione a larghezza di impulso è largamente utilizzata anche per regolare la potenza elettrica
inviata ad un carico, per esempio negli inverter, per regolare la velocità dei motori in corrente continua
e per variare la luminosità delle lampadine.

Come detto nella scheda Arduino non esistono uscite analogiche. E’ possibile ovviare a
questo problema realizzando un piccolo circuito che sia in grado di convertire un onda
quadra (segnale PWM) in una tensione continua il cui valore dipende dalla durata del ciclo
positivo.
N.B.: La frequenza di un uscita PWM di Arduino è di 500 Hz.
LA SCHEDA ARDUINO: LE USCITE ANALOGICHE
DIMENSIONIAMO RESISTENZA E CONDENSATORE
Per dimensionare correttamente il filtro tutto ciò che dobbiamo fare è
dimensionare correttamente la costante di tempo del filtro.
f(taglio) = 1 / (2π* t) t = R*C
Per avere un filtro con un tempo di risposta lento dovremmo quindi
regolare la costante di tempo in modo che risponda con un fattore 100
rispetto al periodo dell’onda di Arduino.
T = 1/f -> T = 1/500 Hz = 0,2 ms -> quindi t = 200 ms
R*C = 200 ms -> R = 20kΩ e C = 10 μF

La scheda di Arduino dispone di due ambienti di programmazione:
•  Arduino IDE
Ambiente ufficiale di Arduino, realizzato dal team che ha creato la scheda, disponibile
all’indirizzo http://arduino.cc/en/Main/Software
L’ambiente di sviluppo consente di utilizzare la scheda, insieme ai sensori a essa collegati
come una periferica del PC. I programmi sviluppati nell’IDE sono caricati sulla scheda,
che può funzionare se correttamente alimentata, anche non connessa al PC.
•  Processing
Strumento gratuito e open-source simile all’IDE di Arduino, disponibile all’indirizzo:
https://www.processing.org/download/
I programmi anziché essere in esecuzione sulla scheda sono in esecuzione sul PC, in
questo modo è possibile estendere le potenzialità della scheda sfruttando la potenza di
calcolo e le periferiche del PC.
I programmi sviluppati in Processing si basano sul linguaggio di sviluppo Java™
GLI AMBIENTI DI PROGRAMMAZIONE

I programmi per l’IDE di Arduino hanno
estensione .ino (è possibile trovare file con
estensione .pde, è la vecchia estensione, ora
utilizzata per l’ambiente Processing).
L’IDE DI ARDUINO
BARRA DEI COMANDI:
•  Verifica File
•  Carica File: Verifica e carica sulla scheda
Arduino il programma
•  Nuovo File
•  Apri File
•  Salva File

I programmi scritti per Arduino vengono chiamati sketch. I termini sketch o programma
sono sinonimi.
Il codice contenuto all’interno di una sketch è suddiviso tra codice che deve essere eseguito
una sola volta – setup() – e codice che deve essere eseguito continuamente – loop() – dopo la
configurazione della scheda.
LE BASI DELLA PROGRAMMAZIONE
Per chi ha esperienza in C/C++
Il procedimento di costruzione crea un file
intermedio:
•  init(): inizializza l’hardware di Arduino
•  setup(): inizializza lo sketch
•  loop(): chiamata ripetutamente, il ciclo for non
termina mai
•  return: non viene mai invocata
int main(void)
{
init();
setup();
for(;;)
loop();
return(0);
}

Esempio: Blink.ino
// LED collegato al pin digitale 13
int led = 13;
// il metodo viene eseguito una volta sola, quando inizia lo sketch
void setup() {
pinMode(led, OUTPUT); // Inizializza il pin digitale com output
}
// il metodo loop() viene eseguito in continuazione
void loop() {
digitalWrite(led, HIGH); // accende il LED
delay(1000); // aspetta un secondo
digitalWrite(led, LOW); // spegne il LED
delay(1000); // aspetta un secondo
}
LE BASI: ESEMPIO

LE BASI DELLA PROGRAMMAZIONE: TIPI DI DATO

Il linguaggio di programmazione utilizzato per programmare la scheda Arduino è un
linguaggio funzionale, ovvero le istruzioni (comandi) che impartiamo alla scheda, sono
funzioni che a loro volta possono contenere funzioni o essere racchiuse in funzioni.
Le funzioni sono composte da:
•  Prototipo: <tipo dato restituito> nome funzione (<lista parametri ingresso>)
•  Corpo funzione: contiene le istruzioni eseguite racchiuse tra parentesi graffe {}
Esempio: boolean antiRimbalzo(int pin)
•  La funzione si chiama antiRimbalzo, questo sarà il comando da utilizzare per “chiamarla”;
•  La funzione restituisce al termine della sua esecuzione un valore di tipo boolean (Vero, Falso);
•  La funzione richiede un parametro in ingresso (obbligatorio) e tale parametro è di tipo int. Se
invocassi la funzione con un parametro di tipo diverso si genererebbe un errore.
LE BASI DELLA PROGRAMMAZIONE: LE FUNZIONI

Le strutture di controllo, in qualsiasi linguaggio di programmazione, sono il cuore del
processo logico e decisionale del programma e consentono, utilizzate correttamente, al
programmatore di decidere quale comportamento adottare in funzione di eventi diversi.
LE BASI DELLA PROGRAMMAZIONE:
CONTROLLO DI FLUSSO [1/2]
IF ... THEN ... ELSE
if (analogPin < 500)
// verifico la condizione
{
// eseguo codice se VERA
}
else
{
// eseguo codice se FALSA
}
SWITCH
switch (variabile) {
case 1:
// eseguo codice se variabile = 1
break;
case 2:
// eseguo codice se variabile = 2
break;
default:
// eseguo codice se non si verificano
// le condizioni previste sopra
}

CONTROLLO DI FLUSSO [2/2]
FOR
for (i=0; i<255; i++)
// inizializzo la variabile i a 0
// verifico se i è minore di 255
// incremento il valore di 1 di 1
{
// eseguo codice finché la
// condizione i<255 è vera
}
WHILE
i = 0;
while (i<255) {
i++;
}
// NB: while può non essere eseguito
DO … WHILE
i = 0;
do {
i++;
} while (i<255
// NB: do while è eseguito almeno 1
// volta
CONTINUE & BREAK
continue : permette in un ciclo for o
while di proseguire con le iterazioni del
ciclo, saltando tutte le istruzioni
presenti dopo la parola chiave continue
break : permette di interrompere un ciclo
for, while o un blocco switch, passando
all’esecuzione del codice all’esterno del
blocco

Nell’ambiente di programmazione di Arduino esistono due metodi per manipolare stringhe
di testo:
•  Array di caratteri
char vecchiaStringa = “Questa è una sequenza di caratteri”;
•  Tipo dati string
String nuovaStringa = vecchiaStringa;
FUNZIONI DI MANIPOLAZIONE STRINGHE
•  charAt(n)
Restituisce il carattere che si trova nella posizione n della stringa String
•  compareTo(s2)
Confronta la stringa String con la stringa s2
•  concat(s2)
Restituisce una nuova stringa String che è la combinazione della stringa String e di s2
LE BASI DELLA PROGRAMMAZIONE: STRINGHE [1/2]

•  indexOf(s)
Restituisce il numero di indice della stringa String o del carattere indicato o -1 se non trova nulla
•  length()
Restituisce il numero di caratteri contenuti nella stringa String
•  replace(A, B)
Sostituisce tutte le istanze della stringa String (o del carattere) A con B
•  substring(index, to)
Restituisce una stringa String con i caratteri che cominciano dall’indice index, fino ai caratteri identificati dalla
posizione to
•  toLowerCase()
Restituisce una stringa String con tutti i caratteri convertiti in lettere minuscole
•  toUpperCase()
Restituisce una stringa String con tutti i caratteri convertiti in lettere maiuscole
•  trim()
Restituisce una stringa String privata di tutti gli spazi bianchi all’inizio e alla fine
LE BASI DELLA PROGRAMMAZIONE: STRINGHE [2/2]

OPERATORI
ARITMETICI
int val;
val = 10; // assegnamento
val = 10 + 5; // somma
val = 10 - 5; // sottrazione
val = 10 * 5; // moltiplicazione
val = 10 / 5; // divisione
ARITMETICI (FORME CONTRATTE 1)
int val = 10;
val += 5; // val = val + 5;
val -= 5; // val = val - 5;
val *= 5; // val = val * 5;
val /= 5; // val = val / 5;
CONFRONTO
int val1, val2;
val1 == val2 // uguaglianza
val1 != val2 // diverso
val1 > val2 // maggiore
val1 >= val2 // maggiore uguale
val1 < val2 // minore
val1 <= val2 // minore uguale
ARITMETICI (SPECIALI)
int val = 10;
val++; // incremento
val--; // decremento
val = val % 3; // modulo (resto)

La memoria di Arduino è limitata, e dipende dal tipo di scheda a disposizione. Per evitare
inutili sprechi, le funzioni sono raggruppate in librerie, incluse nei progetti solo se necessarie.
•  EEPROM
Arduino dispone di una memoria EEPROM, che consente di mantenere i dati memorizzati anche
in assenza di alimentazione. La libreria EEPROM contiene metodi e le funzioni per accedere alla
memoria
•  Ethernet
Libreria sviluppata per sfruttare le caratteristiche dell’Arduino Ethernet Shield, contiene metodi e
funzioni per collegare Arduino a una rete Ethernet
•  Firmata
Libreria che consente di utilizzare un protocollo generico per la comunicazione tra un
microcontrollore e un computer host
•  LiquidCrystal
Libreria per gestire display a cristalli liquidi basati su controller HD44780 o compatibili
LE BASI DELLA PROGRAMMAZIONE: LE LIBRERIE [1/2]

•  SD
Libreria sviluppata per sfruttare le caratteristiche dell’Arduino SD Card Shield leggendo e scrivendo
memorie SD
•  Servo
Libreria sviluppata per gestire i servomotori
•  SPI
Libreria sviluppata per utilizzare il protocollo SPI (Serial Pheriperal Interface)
•  SoftwareSerial
Libreria sviluppata per creare e gestire la comunicazione di ulteriori porte seriali (software) in
aggiunta a quella hardware presente sulla scheda
•  Stepper
Libreria sviluppata per gestire i motori stepper
•  Wire
Libreria sviluppata per utilizzare la modalità di comunicazione a due fili (TWI/I2C)
LE BASI DELLA PROGRAMMAZIONE: LE LIBRERIE [1/2]

In questa sezione vedremo come utilizzare il canale seriale per inviare e ricevere informazioni
di ogni tipo tra Arduino e il proprio computer o altri dispositivi seriali.
Il computer può a interagire con i sensori o altri dispositivi collegati ad Arduino.
Uno sketch di Arduino può anche utilizzare la porta seriale per accedere indirettamente a
tutte le risorse del computer a cui è connesso (tipicamente utilizzando Processing).
L’IDE di Arduino mette a disposizione il Serial Monitor per visualizzare i dati inviati da
Arduino e per consentire l’invio dei dati ad Arduino.
Per avviare il Monitor Seriale dall’IDE: Strumenti -> Monitor Seriale
LE COMUNICAZIONI SERIALI

•  Serial.begin(baud rate)
Apre il canale di comunicazione seriale e ne imposta la velocità (min:300 – max:115.200).
La velocità tra i dispositivi collegati tra loro deve essere la stessa.
•  Serial.write()
Scrive un carattere sul canale seriale, la codifica utilizzata è lo standard ASCII 8 bit.
Il comando non blocca lo sketch poiché i dati sono inviati in background.
•  Serial.print() – Serial.println()
Scrive una stringa di testo, eventualmente formattata, sul canale seriale.
•  Serial.available()
Restituisce TRUE se è disponibile, per la lettura, un dato sul canale seriale, FALSE in caso contrario.
•  Serial.read()
Legge un carattere dal canale seriale, dopo la lettura il carattere è eliminato dal canale.
•  Serial.flush()
Attende che tutti i dati disponibili in uscita siano inviati.
COMUNICAZIONI SERIALI: LE FUNZIONI

/*
* OutputSeriale sketch
* Stampa una sequenza di numeri interi sul canale seriale
*/
int numero = 0;
void setup()
{
Serial.begin(9600); // imposta il canale seriale a 9600 baud
}
void loop()
{
Serial.print("Numero: "); // Stampa la stringa "Numero: "
Serial.println(numero); // Stampa numero
delay(500); // Attende 500 millisecondi
numero++; // incrementa di una unità la variabile numero
}
COMUNICAZIONI SERIALI: RICEVERE DATI DA ARDUINO

/*
* RicezioneSeriale sketch
* La frequenza di lampeggiamento del
* LED lampeggia è proporzionale
* al valore ricevuto dalla porta
* seriale
*/
const int ledPin = 13;
int blinkRate = 0;
void setup()
{
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
}
void loop()
{
if ( Serial.available()) {
char ch = Serial.read();
if( isDigit(ch) ) {
blinkRate = (ch - '0');
blinkRate = blinkRate * 1000;
}
}
blink();
}
void blink()
{
digitalWrite(ledPin, HIGH);
delay(blinkRate);
digitalWrite(ledPin, LOW);
delay(blinkRate);
}
COMUNICAZIONI SERIALI: INVIARE DATI AD ARDUINO

I pin di Arduino sono in grado di rispondere agli input digitali e analogici.
I pin che accettano input digitali rilevano la presenza o l’assenza di una tensione sul pin,
mentre i pin che accettano input analogici misurano un intervallo di tensione.
La funzione che consente di rilevare gli input digitali è: digitalRead(pin)
La funzione che consente di rilevare gli input analogici è: analogRead(pin)
L’IDE di Arduino dispone di una serie di nomi logici (costanti) per riferirsi ai pin:
•  TRUE
•  FALSE
•  HIGH
•  LOW
•  INPUT
•  OUTPUT
INPUT DIGITALI E ANALOGICI

PROBLEMA: Vogliamo che Arduino risponda alla chiusura di un contatto elettrico, sia
esso un interruttore o un pulsante.
COMPONENTI:
•  Arduino Uno Rev3
•  Breadboard + fili
•  Resistore 10kΩ [da utilizzare come resistenza pull-down]
•  Pulsante da circuito stampato
INPUT DIGITALI: UTILIZZARE UN INTERRUTTORE [1/2]

/*
* InterruttoreLED sketch
*/
const int ledPin = 13; // Configuriamo il pin a cui sarà collegato il LED
const int inputPin = 2; // Configuriamo il pin a cui sarà collegato il pushbutton
void setup(){
pinMode(ledPin, OUTPUT); // Definiamo il pin del LED come OUTPUT
pinMode(inputPin, INPUT); // Definiamo il pin del pushbutton come INPUT
}
void loop(){
int val = digitalRead(inputPin); // Leggiamo il valore del pin pushbutton
if (val == HIGH) // Verifichiamo se il valore letto è HIGH [5 volt]
{
digitalWrite(ledPin, HIGH); // Accendiamo il LED quando il pushbutton è premuto
}
else
{
digitalWrite(ledPin, LOW); // Spegniamo il LED quando il pushbutton non è premuto
}
}
INPUT DIGITALI: UTILIZZARE UN INTERRUTTORE [2/2]

PULL-DOWN
•  Uno dei due capi del resistore è collegato a GND;
•  Il potenziale al pin di ingresso non è più casuale,
ma è determinato dalla GND;
•  Generalmente consumano più tensione delle pull-
up;
•  In caso di chiusura del contatto lo stato logico sarà
alto (VCC = 5 volt);
PULL-UP
•  Uno dei due capi del resistore è collegato a VCC;
•  il potenziale al pin di ingresso non è più casuale, ma
è determinato dalla VCC;
•  Generalmente consumano meno tensione delle
pull-down;
•  In caso di chiusura del contatto lo stato logico sarà
basso (GND = 0 volt);
INPUT DIGITALI: RESISTENZE PULL-DOWN VS. PULL-UP
I resistori di pull-down o pull-up sono utilizzati in elettronica per assicurarsi che gli ingressi del sistema
logico abbiano uno stato consistente nel caso in cui altri dispositivi siano rimossi.
Nel caso di un interruttore se il contatto è aperto e il pin non è agganciato ad alcuna tensione il pin si
troverà in uno stato non consistente.
Lasciare i circuiti in queste condizioni è un errore molto grave poiché è possibile che campi elettrici
esterni inducano tensioni tali da far commutare i circuiti interni del microcontrollore.

/*
* InterruttoreAffidabile sketch
*/
const int inputPin = 2;
const int ledPin = 13;
const int delayAntiRimbalzo = 10;
void setup()
{
pinMode(inputPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop()
{
int stato= antiRimbalzo (inputPin);
digitalWrite(ledPin, stato);
}
// antiRimbalzo restituisce il valore
// della lettura quando è stabile
boolean antiRimbalzo(int pin)
{
boolean stato;
boolean statoPrecedente;
statoPrecedente = digitalRead(pin);
for(int i=0; i<delayAntiRimbalzo; i++)
{
delay(1);
stato = digitalRead(pin);
if (stato != statoPrecedente)
{
i= 0;
statoPrecedente = stato;
}
}
return stato;
}
INPUT DIGITALI: UTILIZZARE UN INTERRUTTORE
[IN MODO AFFIDABILE]

PROBLEMA: Si vuole leggere una tensione restituito da un potenziometro (resistore
variabile) su un pin analogico.
COMPONENTI:
•  Arduino UNO rev3
•  Potenziometro 10KΩ [sono i potenziometri ideali da collegare a un pin analogico]
INPUT ANALOGICI: LEGGERE VALORI ANALOGICI [1/2]

/*
* potenziometro sketch
* gestisce il lampeggiamento di un led in base al valore letto da un potenziometro
*/
const int potPin = 0; // configuriamo il pin a cui sarà collegato il potenziometro
const int ledPin = 13; // configuriamo il pin a cui sarà collegato il LED
int val = 0; // var dove memorizziamo il valore letto dal potenziometro
void setup()
{
pinMode(ledPin, OUTPUT); // definiamo il pin del LED come OUTPUT
}
void loop() {
val = analogRead(potPin); // leggiamo il valore di tensione sul potenziometro
digitalWrite(ledPin, HIGH); // accendiamo il LED
delay(val); // attendiamo un numero di millisecondi pari al valore letto
digitalWrite(ledPin, LOW); // spegniamo il LED
delay(val); // attendiamo un numero di millisecondi pari al valore letto
}
INPUT ANALOGICI: LEGGERE VALORI ANALOGICI [2/2]

Utilizzando i sensori e ricavando i valori da loro misurati, Arduino ottiene informazioni sul
mondo che lo circonda.
I dati provenienti dai sensori possono essere letti solo dai pin di input, il tipo e il numero dei
pin dipende dal tipo di sensore.
Arduino dispone di diversi metodi per comunicare con i sensori, nel dettaglio:
•  On/Off digitale
E’ il metodo più semplice, alcuni sensori si limitano a impostare un voltaggio su on o off
(es. gli interruttori)
Tutti questi sensori utilizzano il comando digitalRead();
•  Segnale Analogico
Diversi sensori si limitano a fornire un segnale analogico, un voltaggio che è
proporzionale alla grandezza da misurare (es. sensore di luce, sensore di temperatura,
sensore di pressione, etc…)
Tutti questi sensori utilizzano il comando analogRead();
RICAVARE INPUT DAI SENSORI [1/2]

•  Durata dell’impulso
I sensori di distanza, forniscono i dati utilizzando la durata di un impulso, proporzionale
al valore misurato.
Le applicazioni che utilizzano questi sensori utilizzano il comando pulseIn();
•  Protocollo Seriale
Alcuni sensori, come i lettori RFID, comunicano con la porta seriale. Le diverse schede
di Arduino dispongono di una o più porte seriali software in aggiunta alla porta seriale
hardware standard.
•  Protocolli sincroni I2C e SPI
Sono protocolli che consentono di utilizzare periferiche o componenti esterni
collegandoli in cascata tra loro e utilizzando pochi fili.
I2C (2 linee di segnale, normalmente unidirezionale, bassa velocità)
SPI (2 linee di segnale + 1 linea per abilitare il dispositivo, alta velocità)
Arduino dispone di librerie ad-hoc per gestire i due protocolli di comunicazione
RICAVARE INPUT DAI SENSORI [1/2]

DEF: Più resistori si dicono in serie quando sono attraversati dalla stessa corrente.
Il circuito che esamineremo prende il nome di partitore di tensione resistivo poiché
la tensione totale del circuito si ripartisce tra i resistori in serie in modo direttamente
proporzionale ai valori di ciascuno di essi.
IL PARTITORE RESISTIVO

PROBLEMA: Si vogliono rilevare i cambiamenti di intensità della luce.
COMPONENTI:
•  Resistore 10KΩ
•  LDR (Light Dependent Resistor) da 10KΩ
RICAVARE INPUT DAI SENSORI: RILEVARE LA LUCE [1/2]

/*
* luce sketch
* gestisce il lampeggiamento di un led in base alla quantità di luce rilevata
*/
const int sensorPin = 0; // configuriamo il pin a cui sarà collegato il sensore LDR
const int ledPin = 13; // configuriamo il pin a cui sarà collegato il LED
void setup()
{
pinMode(ledPin, OUTPUT); // definiamo il pin del LED come OUTPUT
}
void loop() {
int rate = analogRead(sensorPin); // leggiamo il valore di tensione sul potenziometro
digitalWrite(ledPin, HIGH); // accendiamo il LED
delay(rate); // l’attesa dipende dal livello della luce
digitalWrite(ledPin, LOW); // spegniamo il LED
delay(rate);
}
RICAVARE INPUT DAI SENSORI: RILEVARE LA LUCE [2/2]

Un interrupt è un segnale asincrono, generato da dei sensori o periferiche in generale, finalizzato a una
particolare richiesta/azione. Con Arduino è possibile utilizzare gli interrupt avvalendosi di una
particolare funzione denominata Interrupt Service Routine (ISR)
Le ISR sono funzioni molto speciali che a differenza delle altre funzioni hanno alcune limitazioni:
•  Collegare una funzione ISR a un determinato interrupt cancella l’eventuale collegamento precedente
di un’altra funzione ISR;
•  Non hanno parametri di chiamata [ma è possibile utilizzare delle variabili globali purché esse siano
dichiarate volatile] e non restituiscono nessun valore;
•  Durante l’esecuzione di una ISR gli altri interrupt sono ignorati [pertanto è bene che siano il più
brevi possibile];
•  Durante l’esecuzione di una ISR il normale flusso di esecuzione dello sketch è fermato;
•  La funzione delay() non può essere utilizzata all’interno di una funzione ISR;
•  la funzione millis() non può essere utilizzata all’interno di una funzione ISR poiché non viene
incrementata;
•  I dati seriali ricevuti, mentre una funzione ISR è in esecuzione, potrebbero essere persi;
RICAVARE INPUT DAI SENSORI: GESTIRE UN INTERRUPT [1/3]

SINTASSI:
attachInterrupt(interrupt, ISR, mode)
PARAMETRI:
interrupt:il numero dell’interrupt [Arduino Uno: INT 0 su D2 e INT 1 su D3]
ISR: Interrupt Service Ruotine è la funzione che viene invocata quando l’interrupt è generato;
Mode: definisce quando l’interrupt deve essere generato. Esistono quattro modalità definite da
altrettante costanti:
•  LOW: genera l’interrupt quanto il pin ha valore basso [0 volt];
•  CHANGE: genera l’interrupt quanto il pin cambia valore
•  RISING: genera l’interrupt quando il pin passa dallo stato basso [0 volt] allo stato alto [5 volt];
•  FALLING: genera l’interrupt quando il pin passa dallo stato alto [5 volt] allo stato basso [0 volt]

// InterruttoreLEDInterrupt sketch
const int ledPin = 13; // Configuriamo il pin a cui sarà collegato il LED
const int inputPin = 2; // Configuriamo il pin a cui sarà collegato il pushbutton
const int interruptPin = 0; // Configuriamo il pin a cui sarà collegato l’ISR
int val;
void setup(){
pinMode(ledPin, OUTPUT); // Definiamo il pin del LED come OUTPUT
pinMode(inputPin, INPUT); // Definiamo il pin del pushbutton come INPUT
attachInterrupt(interruptPin, deviatore, RISING); //colleghiamo l’ISR all’interrupt
val = 0;
}
void loop() {
}
void deviatore() {
if (val == HIGH) { // se il valore precedente era alto [5 volt]
val = LOW; // allora lo impostiamo basso [0 volt]
}
else { // se il valore precedente era basso [0 volt]
val = HIGH; // allora lo impostiamo alto [5 volt]
}
digitalWrite(ledPin, val); // scrivo il valore alto/basso sul pin del LED
}

PROBLEMA: Si vogliono controllare più LED.
COMPONENTI:
•  3 Resistori 330Ω
•  3 LED (Light-Emitting Diode) rossi
L’OUTPUT VISIVO: COLLEGARE E UTILIZZARE I LED [1/3]

/*
* treLED sketch
* facciamo lampeggiare 3 LED
*/
const int primoLED = 3;
const int secondoLED = 5;
const int terzoLED = 6;
void setup()
{
// dichiariamo i pin dei LED come output
pinMode(primoLED , OUTPUT);
pinMode(secondoLED, OUTPUT);
pinMode(terzoLED, OUTPUT);
}
void loop()
{
// i LED lampeggiano per 1 secondo
// (1000 millisecondi)
blinkLED(primoLED , 1000);
blinkLED(secondoLED, 1000);
blinkLED(terzoLED, 1000);
}
// fa lampeggiare il LED per un numero di
// millisecondi passati per argomento
void blinkLED(int pin, int durata)
{
// accende il LED
digitalWrite(pin, HIGH);
delay(durata);
// spegne il LED
digitalWrite(pin, LOW);
delay(durata);
}

/*
* treArrayLED sketch
* facciamo lampeggiare 3 LED
* utilizzando gli Array
*/
// Creiamo un array di pin collegati a LED
int ledPins[] = {3,5,6};
void setup() {
for(int i = 0; i < 3; i++) {
pinMode(ledPins[i], OUTPUT);
}
}
void loop() {
// i LED lampeggiano per 1 secondo
for(int i = 0; i < 3; i++) {
blinkLED(ledPins[i], 1000);
}
}
void blinkLED(int pin, int durata) {
// accende il LED
digitalWrite(pin, HIGH);
delay(durata);
// spegne il LED
digitalWrite(pin, LOW);
delay(durata);
}

/*
* Supercar sketch
* creiamo l'effetto supercar
*/
// Creiamo un array di pin collegati a LED
int ledPins[] = {3,5,6};
void setup() {
for(int i = 0; i < 3; i++) {
pinMode(ledPins[i], OUTPUT);
}
}
void loop() {
// i LED lampeggiano per 500 ms
for(int i = 0; i < 3; i++) {
blinkLED(ledPins[i], HIGH, 500);
}
for(int i = 2; i >= 0; i--) {
blinkLED(ledPins[i], LOW, 500);
}
}
void blinkLED(int pin, boolean stato, int
durata) {
// accende il LED
digitalWrite(pin, stato);
delay(durata);
}
L’OUTPUT VISIVO: GIOCHI DI LUCE CON I LED

PROBLEMA: Si vuole utilizzare un LED RGB controllandone il colore
L’OUTPUT VISIVO: REGOLARE IL COLORE DI UN LED [1/3]
DESCRIZIONE:
I Led RGB sono particolari tipi di
LED che possiedono 4 reofori.
Uno di essi è il catodo (RGB a
catodo comune) o l’anodo (RGB
ad anodo comune) mentre gli altri
tre pilotano direttamente i tre
elementi distinti presenti
all’interno della capsula del led
stesso, questi tre elementi
forniscono le componenti del
colore: Rosso, Verde e Blu.

COMPONENTI:
•  1 LED (Light-Emitting Diode) RGB a catodo comune
•  1 Resistore 330Ω
•  2 Resistori 180Ω

/*
* LEDRGBcasuale
*
*/
const int pinRosso = 3; // Seleziona il pin per i vari reofori del LED RGB
const int pinVerde = 5;
const int pinBlu = 6;
void setup()
{
// utilizzando la funzione analogWrite non è necessario dichiarare i pin come output
}
void loop()
{
analogWrite(pinRosso, random(255)); // imposta i colori utilizzando dei numeri casuali
analogWrite(pinVerde, random(255));
analogWrite(pinBlu, random(255));
delay(1000);
}

Collegando dei motori alla scheda Arduino è possibile far muovere degli oggetti del mondo
fisico.
•  Servomotori
I servomotori consentono di controllare con precisione il movimento fisico, la loro caratteristica peculiare è
quella di essere in gradi di saltare direttamente a una determinata posizione.
Sono ideali per ruotare un oggetto in un intervallo tra 0° e 180° e possono essere collegati direttamente alla
scheda Arduino poiché dispongono al loro interno il driver per il pilotaggio.
•  Motori a spazzole
Rappresentano la maggior parte dei motori economici controllabili in corrente continua (CC), sono dispositivi
semplici che dispongono di due terminali, collegati a loro volta alle spazzole interne del motore, che se
attraversate da corrente mettono in rotazione l’albero contenuto tra esse.
E’ possibile invertire la rotazione variando il senso di percorrenza della corrente.
•  Motori brushless
I motori brushless sono più potenti ed efficienti rispetto ai motori a spazzole di pari dimensioni ma richiedono
uno stadio di controllo più complesso.
E’ possibile utilizzarli con Arduino utilizzando dei controllori di velocità elettronici (ESC) utilizzati nel
modellismo, sono facilmente controllabili, similmente ai servomotori.
L’OUTPUT FISICO [1/2]

Collegando dei motori alla scheda Arduino è possibile far muovere degli oggetti del mondo
fisico.
•  Motori passo-passo
I motori passo passo sono motori che ruotano di un determinato numero di passi. Il numero dei passi e la
coppia del motore sono caratteristiche di fabbricazione. La rotazione può essere continua.
In commercio ne esistono di due tipi: unipolari e bipolari, identificabili dal numero di fili presenti: 4 (unipolari),
5 e 6 (bipolari).
Il metodo di controllo e gli stadi elettronici per pilotarli sono differenti, è però generalmente possibile pilotare
un motore unipolare come bipolare.
•  Solenoidi e Relè
La maggior parte dei motori produce un movimento rotatorio, i solenoidi producono invece un movimento
lineare.
Sono realizzati con un nucleo metallico che si grazie a un campo magnetico, che viene generato dal passaggio di
corrente all’interno delle spire che costituiscono la bobina.
I relè sono dei solenoidi, che sfruttando il movimento lineare del nucleo, aprono e chiudono dei contatti.
L’OUTPUT FISICO [2/2]

L’OUTPUT FISICO: I SERVOMOTORI
Il servomotore è un attuatore, ovvero un meccanismo che è in grado di trasformare un
segnale elettrico in movimento. Con Arduino è possibile, in maniera semplice, pilotare
servomotori da modellismo poiché è possibile alimentarli direttamente dall’uscita 5V.
Nel caso in cui si voglia pilotare servomotori che hanno un assorbimento di corrente
maggiore di quanto fornito da Arduino, sarà necessario prevedere un alimentazione esterna.
N.B.: Se si utilizza una sorgente di alimentazione esterna, la messa a terra deve essere collegata alla messa
a terra di Arduino

I servomotori devono essere pilotati con un segnale in PWM, le librerie di Arduino, in
particolare la libreria Servo ci viene in aiuto fornendo i comandi necessari al pilotaggio.
L’OUTPUT FISICO: UTILIZZARE UN SERVOMOTORE
La connessione di un servomotore alla scheda Arduino è molto semplice,
lo schema di collegamento è il seguente:
•  Cavo Rosso: V+, da collegare al positivo dell’alimentazione (5V)
•  Cavo Nero: GND, da collegare a massa (GND)
•  Cavo Bianco: Segnale, da collegare al pin di Arduino con cui si intende
pilotare il servomotore

La libreria Servo consente di pilotare agevolmente i servomotori collegati alla scheda
Arduino.
La libreria supporta fino a 12 servomotori nelle schede standard e fino a 48 sulla scheda
Arduino Mega.
Dovendo pilotare i servomotori in PWM, l’utilizzo della libreria disabilita la funzione
analogWrite() sui pin 9 e 10, indipendentemente che sia presente un servomotore o meno.
Per utilizzare i servomotori è necessario dichiarare una variabile di tipo Servo.
FUNZIONI LIBRERIA SERVO
•  servo.attach(pin) e servo.attach(pin, min, max)
Collega il servomotore al pin passato come argomento.
pin: numero del pin al quale è collegato il servomotore
min: durata dell’impulso, in microsecondi, che corrisponde a 0 gradi (default: 544)
max: durata dell’impulso, in microsecondi che corrisponde a 180 gradi (default: 2400)
L’OUTPUT FISICO: LA LIBRERIA SERVO [1/2]

•  servo.write(angolo)
Posiziona l’albero del servomotore di un angolo pari al numero di gradi passati come argomento.
•  servo.writeMicroseconds(uS)
Posiziona l’albero del servomotore direttamente con un impulso passato per argomento in
microsecondi.
•  servo.read()
Restituisce l’angolo corrente del servomotore in gradi (0° - 180°).
•  servo.attached()
Verifica se la variabile servo è collegata a un pin Arduino, restituisce un valore di tipo boolean.
•  servo.detach()
Scollega la variabile servo dal pin a cui è connessa.
Scollegati tutti i servomotori la funzione analogWrite() sui pin 9 e 10 è di nuovo attiva.
L’OUTPUT FISICO: LA LIBRERIA SERVO [1/2]

PROBLEMA: Si vuole controllare la posizione di un servomotore attraverso un
potenziometro.
COMPONENTI:
•  Potenziometro 10KΩ
•  Servomotore da 9 grammi
L’OUTPUT FISICO: CONTROLLARE I SERVO VIA SW [1/2]

L’OUTPUT FISICO: CONTROLLARE I SERVO VIA SW [2/2]
/* ControlloServo sketch */
#include <Servo.h>
Servo mioservo; // creo un oggetto servo per identificare il servomotore
int inputpin= 0; // pin analogico usato per connettere il potenziometro
int val; // variabile utilizzata per memorizzare il valore letto dal potenziometro
void setup()
{
mioservo.attach(9); // collego il servomotore al pin numero 9
}
void loop()
{
val = analogRead(inputpin); // leggo il valore del potenziometro
val = map(inputpin, 0, 1023, 0, 180); // trasformo il numero letto da 0 a 1023
// in un intervallo compreso tra 0 e 180
mioservo.write(val); // imposto l’angolo dell’albero del servomotore
delay(15); // attendo che il servomotore termini il
// posizionamento
}

APPROFONDIMENTI: L’OUTPUT ANALOGICO [1/3]
Arduino non dispone di uscite analogiche, ma pilotando un uscita digitale in PWM e
realizzando un filtro RC (Resistenza – Condensatore o Passa – Basso) possiamo trasformare
qualsiasi uscita digitale in un uscita analogica.
PROBLEMA: Si vuole controllare la posizione di un servomotore attraverso un
potenziometro.
COMPONENTI:
•  1 Resistore da 20KΩ
•  1 Condensatore da 10 uF (elettrolitico) (N.B.: Attenzione alla polarità)
•  1 Potenziometro da 10KΩ
•  Eventuale Tester per il controllo della tensione di uscita (non obbligatorio, possiamo sempre
utilizzare un ingresso analogico di Arduino per ricavare il valore di tensione presente in uscita dal
filtro RC

/*
* UscitaAnalogica sketch
* La misura della tensione è prevista tramite tester
*/
const int pinOut = 3; // definisco il pin da cui generare il segnale PWM per la
// conversione in analogico
const int pinLettura = 0; // pin a cui è connesso il potenziometro
void setup() {
pinMode(pinOut, OUTPUT); // definiamo il pin digitale PWM come OUTPUT
Serial.begin(9600);
}
void loop() {
int val = analogRead(pinLettura);
val = map(val, 0, 1023, 0, 255);
analogWrite(pinOut, val);
Serial.println(val);
delay(100);
}

GRAZIE PER L’ATTENZIONE
Contatti:
www.opsitalia.com
info@opsitalia.com

Corso Arduino Base - MUST

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Corso Arduino Base - MUST (20)

Corso Arduino Base - MUST