Sei sulla pagina 1di 53

Andrea

Coppola – Pietro Marchetta

CORSO PRATICO DI
ARDUINO
M ODULO INTERMEDIO
© 2016 Area 51 s.r.l., San Lazzaro di Savena (Bologna)

Prima edizione e-book Area51 Publishing: gennaio 2016

Curatore della collana: Mirco Baragiani

Cover: Marienrica Caravita

Redazione e sviluppo ebook: Enrico De Benedictis

Se intendi condividere questo ebook con un’altra persona, ti chiediamo cortesemente di scaricare una copia a pagamento per ciascuna delle persone a cui lo vuoi destinare. Se stai leggendo questo ebook e non lo hai acquistato,
ti chiediamo, se ti piace, di acquistarne anche una copia a pagamento, al fine di poterci permettere di far crescere il nostro lavoro e di offrirti sempre più titoli e una qualità sempre maggiore. Grazie per il tuo aiuto e per aver
rispettato il lavoro dell’autore e dell’editore di questo libro.

Segui Area51 Publishing su:

Facebook

Twitter

YouTube

Spreaker

Instagram

www.area51editore.com

www.area51editore.com/blog
Ringrazio Andrea Coppola, mio mentore in Blender, per avermi
spinto a realizzare questo manuale.
Un ringraziamento anche alla mia ragazza Barbara Damiani per
la sua grande pazienza e per essere una grande fonte di
ispirazione. Un ringraziamento anche alla mia famiglia che mi ha
sempre aiutato in tutto.
Dedico questo ebook a mio padre, ringraziandolo per quello che
fa tutt’oggi per me.
INTRODUZIONE
Dopo i progetti sviluppati nel modulo base, continuando a sfruttare la notevole versatilità
di Arduino, in questo manuale modificheremo un vecchio modellino di automobile
radiocomandata, ottenendo un valido punto di inizio per creare un drone terrestre
riciclando quello che avete in casa.
Nella prossima uscita approfondiremo diverse tematiche quali la programmazione di
Arduino e l’interfacciamento a esso di una app creata per smartphone.

Questo ebook è rivolto a chi vuole approfondire l’elettronica e l’interfacciamento ad


Arduino di diversi componenti disponibili sul mercato, cercando di arricchire la propria
cultura in campo tecnologico. A oggi sono presenti svariati componenti destinati a
risolvere diverse problematiche senza ricorrere a lunghe programmazioni o particolari
configurazioni elettroniche che potrebbero scoraggiare chi si avvicina a questo
meraviglioso mondo.
Non preoccupatevi se alcuni passaggi non vi saranno immediatamente chiari. Con il tempo
e la pratica prenderete più confidenza e diventerete più smaliziati. L’importate è aver
voglia di sperimentare, non dovrete mai aver paura di commettere errori, con i fallimenti
si fanno grandi passi in avanti e ci si mette sempre in discussione acquisendo competenze
nuove senza rinunciare al divertimento.
I
1. L PROGETTO

A oggi esistono molte tipologie di droni. Secondo Wikipedia “un drone è un veicolo
controllato da remoto senza la presenza umana”. L’obiettivo di questo ebook è la
realizzazione di un drone casalingo con una spesa minima, riutilizzando vecchi giocattoli
o apparecchiature che si hanno in casa, così da diminuire i rifiuti elettronici in discarica. È
bello essere un po’ ecologici, inoltre il nostro drone sarà elettrico quindi a emissioni zero.
Sicuramente molti tra voi avranno un vecchio modellino di auto radiocomandata con il
telecomando che non funziona più o magari perso in qualche angolo di casa. Se invece che
lasciarla abbandonata cercassimo un modo per risolvere questo inconveniente, creando un
piccolo drone che la renda radiocomandata via bluetooth con il cellulare? Fantascienza?
Assolutamente no.
Negli ultimi anni abbiamo assistito a un’escalation tecnologica mai vista prima, possiamo
fare cose che prima potevano permettersi solo pochi eletti. Un nuovo movimento, una
nuova filosofia ha smosso questo mondo creando un sistema semplice, intelligente, ma
soprattutto divertente. Sto parlando di Arduino, una scheda che nella sua semplicità ha
cambiato la vita dell’hobbista consentendogli un salto di qualità inimmaginabile prima.
Sfruttiamo allora questa scheda per creare qualcosa di utile e divertente.
Spiegheremo nei prossimi capitoli come interfacciare Arduino UNO (che prenderemo a
riferimento) o qualsiasi altro Arduino abbiate in casa a un’automobile giocattolo
controllandone i movimenti da smartphone tramite bluetooth.
Ovviamente Arduino da solo non è in grado di controllare un motore elettrico direttamente
quindi ci avvarremo di altre schede collegabili ad Arduino per raggiungere il nostro
obiettivo. Nel progetto abbiamo usato delle schede già rodate con Arduino, dal costo
decisamente basso e su cui potrete trovare online un’ampia documentazione.
Per il controllo dei motori abbiamo usato un L298N, noto per controllare grossi carichi
come i motori elettrici, operazione che Arduino non riuscirebbe singolarmente a garantire
senza danneggiarsi. L298N è un ponte H che ha come interessante caratteristica quella di
poter invertire la polarità di tensione in modo da invertire la rotazione di un motore
elettrico e di modularne la potenza grazie al pwm di Arduino; ne parleremo in modo
approfondito nei prossimi capitoli, spiegando nel dettaglio la scheda che abbiamo usato.
Un altro componente è il modulo bluetooth HC-06. Perchè abbiamo scelto questo
modulo? Prima di tutto per il costo molto basso, poi perché facile da interfacciare: usa un
protocollo standard usato da molti device commerciali. È necessario specificare che in
Italia esiste un piano di frequenze radio ben preciso che indica chi può usare certe
frequenze e chi invece altre. Il bluetooth lavora su una frequenza libera di 2.45Ghz quindi
non abbiamo vincoli di alcun tipo, in particolare che riguardino tasse o contributi,
ricordando comunque che la potenza dovrà essere quella standard del modulo.
Effettuati i collegamenti e la programmazione, spiegheremo come radiocomandare il
drone dandovi anche ulteriori spunti per aumentargli le prestazioni in fatto di intelligenza.
Con questo drone potremo avere una base di partenza per altre nostre attività o potremo
migliorarlo per nuovi progetti.
2. HARDWARE
Iniziamo analizzando ogni singolo componente di questo progetto.
Utilizzeremo come board Arduino UNO, ne riportiamo il pinout nell’immagine
sottostante. È la piattaforma più famosa al mondo, con molteplici varianti per numerose
applicazioni. Ha semplificato la vita a noi elettronici per quanto riguarda
l’interfacciamento di componenti che un tempo sarebbero stati complessi da gestire
prevalentemente per ragioni di programmazione. La sua semplicità è disarmante, tuttavia
nessuno vieta di addentrarci anche nelle parti più nascoste come la gestione dei timer e
altre funzioni un po’ più tecniche ma, non essendo oggetto della trattazione di questo
ebook, rimandiamo alla dettagliata descrizione nel datasheet dei vari microcontrollori usati
dal team di Arduino. Vediamo adesso come è facile progettare un piccolo drone
telecomandato con poca spesa e tanta resa, ma soprattutto divertendosi e imparando
qualcosa di nuovo. Questa sarà la base di altri progetti che potrete realizzare liberamente
riciclando quello che avete in casa. Le possibilità sono infinite, il limite sarà solo la nostra
immaginazione.

L ND H B
298 UAL - M C
RIDGE OTOR ONTROLLER
È un componente molto interessante. Si tratta di un ponte H per il controllo di grossi
carichi come motori elettrici. Arduino non può controllare da solo un motore elettrico
perché rischierebbe di esser danneggiato dalle tensioni in gioco. Un motore elettrico
normalmente è costituito da un avvolgimento e da alcune calamite. Quando si alimenta
l’avvolgimento esso si comporta come una elettrocalamita: la carica elettromagnetica
viene influenzata dalle calamite quindi il motore entra in funzione. Il problema di
collegare Arduino direttamente al motore non è solo dovuto alle tensioni che spesso
possono non essere compatibili, ma anche al fatto che quando smettiamo di alimentare la
bobina interna di un motore si potrebbe verificare un dannoso ritorno di tensione verso
Arduino. Dobbiamo allora usare un qualcosa per interfacciarlo, la soluzione più semplice
sarebbe quella di utilizzare un transistore di potenza.
Nella figura soprastante possiamo vedere una semplice configurazione di un transistore in
modalità interruttore controllato dal pin 9 che genera un segnale pwm per il controllo di
tensione. O meglio genera una serie di impulsi di durata programmabile tramite
l’istruzione di Arduino “analogWrite(pin,valore);”. Il pin non è difficile da comprendere,
per il valore è necessaria una spiegazione. Abbiamo a disposizione un pwm con
risoluzione 8 bit, quindi 256 diversi valori che possiamo impostare. Da questo si deduce
che se dividiamo la tensione applicata ai valori che possiamo utilizzare, è possibile variare
la velocità del motore stesso. Sappiate che impostando 0 il motore si ferma, se impostate
255 il motore funzionerà a pieno regime. Basterà dividere il valore di tensione per i valori
usabili con Arduino per impostare la velocità.
Le immagini che seguono in sequenza vi fanno capire, grazie all’aiuto di un oscilloscopio,
come si comporta il segnale pwm in base ai valori:

Impostato a 25

Impostato a 125
Impostato a 240

Da queste immagini si evince il funzionamento del pwm: all’aumentare del valore


aumenta il periodo. Semplice vero?
Siamo riusciti a far funzionare il motore, ma con un semplice transistor non possiamo
regolare una cosa fondamentale, ovvero il verso di rotazione, quindi il motore avrà solo un
verso. A noi serve che possa girare anche al contrario per consentirci di effettuare la
retromarcia e permetterci, ad esempio, di evitare un ostacolo.

Attenzione: ci sono modellini radiocomandati di automobile che per il motore di


trazione hanno 3 cavi, una massa e 2 positivi. Il discorso che stiamo per fare non vale
per questa tipologia. Vi basterà alimentare uno o l’altro con un transistor oppure
modificare opportunamente i collegamenti del motore per usare il nostro sistema. Si
tratta comunque di una situazione rara.
Ci viene in aiuto l’elettronica. Esiste un componente denominato ponte H che riesce a
controllare un carico induttivo come un motore in continua. È costituito da 4 transistor in
una particolare configurazione che riesce ad alimentare il nostro motore in 2 modi diversi,
a tensione e corrente a carico negativo o positivo.
In pratica è come se invertisse i cavi positivo e negativo facendo cambiare il verso di
rotazione al nostro motore. L298N riesce a comandare fino a 2 motori
contemporaneamente con una tensione massima di 46V e a sopportare un carico di 4A,
oltre a dare una formidabile protezione logica al nostro Arduino, senza rischiare di
danneggiarlo. Se acquisterete la stessa scheda che ci apprestiamo a utilizzare, potrete
alimentare Arduino da essa prelevando i 5V grazie a uno stabilizzatore di tensione
(ricordando di abilitare il jump sulla scheda). Indipendentemente dalla tensione che
useremo per alimentare i motori, L298N alimenterà costantemente Arduino.
Questo componente può anche azionare un motore passo passo a 4 fili, ma solo collegando
le 4 uscite. Sappiate che la precisione di passo non sarà eclatante come quella di un
componente dedicato, ad esempio pololu a4988 che riesce a gestire i micropassi nei casi
dei cnc o delle stampanti 3D.
L298N comanda i motori con sei pin. 2 pin denominati ENA ENB abilitano il
funzionamento dei motori e i restanti 4 pin IN1 IN2 per ENA e IN3 IN4 per ENB ne
controllano il movimento. Se generiamo un pwm sul IN1 il motore girerà in un verso, al
contrario se generiamo un pwm sul IN2 girerà nel senso opposto. Avviene la situazione
analoga su i restati 2 pin che controllano ENB. Con questo abbiamo descritto il
funzionamento della scheda, di seguito faremo alcuni test esplicativi.

Questo piccolo esempio vi mostrerà come funziona il modulo. Ho commentato le varie


parti per maggior chiarezza:
//Menù di controllo:
//
// 1 - Motore 1 Avanti
// 2 - Motore 1 Stop
// 3 - Motore 1 Indietro
//
// 4 - Motore 2 Avanti
// 5 - Motore 2 Stop
// 6 - Motore 2 Indietro

// Definisco le variabile per il Motore 1
int dir1PinA = 2;
int dir2PinA = 3;
int speedPinA = 9; // Definisco il pin per il controllo di velocità con un
segnale PWM

// Definisco le variabile per il Motore 1
int dir1PinB = 4;
int dir2PinB = 5;
int speedPinB = 10; // Definisco il pin per il controllo di velocità con un
segnale PWM

void setup() {

// Inizializzo la porta seriale a 9600 boud:
Serial.begin(9600);

//Configuro i pin di Arduino in uscita per pilotare L298N

pinMode(dir1PinA,OUTPUT);
pinMode(dir2PinA,OUTPUT);
pinMode(speedPinA,OUTPUT);
pinMode(dir1PinB,OUTPUT);
pinMode(dir2PinB,OUTPUT);
pinMode(speedPinB,OUTPUT);

}

void loop() {

// Inizializzo l’interfaccia seriale in ascolto

if (Serial.available() > 0) {
int inByte = Serial.read();
int speed; // Variabile locale

switch (inByte) {

//______________Motore 1______________

case ‘1’: // Motore 1 Avanti
analogWrite(speedPinA, 255);//Configurazione velocità del motore tramite
PWM
digitalWrite(dir1PinA, LOW);
digitalWrite(dir2PinA, HIGH);
Serial.println(“Motore 1 Avanti”); // Scrive sulla seriale
Serial.println(” “); // Crea una line vuota
break;

case ‘2’: // Motore 1 Stop
analogWrite(speedPinA, 0);
digitalWrite(dir1PinA, LOW);
digitalWrite(dir2PinA, HIGH);
Serial.println(“Motore 1 Stop”);
Serial.println(” “);
break;

case ‘3’: // Motore 1 Indietro
analogWrite(speedPinA, 255);
digitalWrite(dir1PinA, HIGH);
digitalWrite(dir2PinA, LOW);
Serial.println(“Motore 1 Indietro”);
Serial.println(” “);
break;

//______________Motore 2______________

case ‘4’: // Motore 2 Avanti
analogWrite(speedPinB, 255);
digitalWrite(dir1PinB, LOW);
digitalWrite(dir2PinB, HIGH);
Serial.println(“Motore 2 Avanti”);
Serial.println(” “);
break;

case ‘5’: // Motore 2 Stop
analogWrite(speedPinB, 0);
digitalWrite(dir1PinB, LOW);
digitalWrite(dir2PinB, HIGH);
Serial.println(“Motore 2 Stop”);
Serial.println(” “);
break;

case ‘6’: // Motor 2 Indietro
analogWrite(speedPinB, 255);
digitalWrite(dir1PinB, HIGH);
digitalWrite(dir2PinB, LOW);
Serial.println(“Motore 2 Indietro”);
Serial.println(” “);
break;

default:

// Resetta tutti i pin dopo che è stato effettuato il ciclo
for (int thisPin = 2; thisPin < 11; thisPin++) {
digitalWrite(thisPin, LOW);
}
}
}
}

Analizziamo alcune porzioni di codice:


case ‘1’

Il “case” è una istruzione, un’etichetta dove di seguito possono esser elencate varie
funzioni. Il tutto viene controllato da “switch (inByte)” che legge la variabile di “int
inByte = Serial.read();”. Letto il dato, o il tasto premuto, come nel nostro caso, provvede a
salvarlo nella variabile che poi viene letta dall’istruzione switch che controllerà la
presenza del dato tra le etichette che abbiamo definito. Se il dato è presente viene eseguita
la porzione di codice al suo interno. Un case deve sempre finire con un break.

analogWrite(speedPinA, 255);

Questa istruzione definisce il valore di PWM da applicare al pin enable del L298N,
avremo 256 (compreso lo zero) valori, più sarà alto il valore e più velocemente girerà il
nostro motore. Quindi possiamo impostare vari valori di velocità: se viene definito 0 il
motore rimarrà fermo a 255, ovvero andrà a piena potenza. Possiamo quindi dedurre che
c’è una relazione tra quel valore e il valore di tensione applicata al motore. Per spiegarci
meglio ipotizziamo di configurare un valore di 125, L298N applicherà al motore solo la
metà della tensione nominale. Un ulteriore esempio: ipotizziamo di alimentare il tutto a 9
volt, con una comunissima batteria di quelle che trovate al supermercato. Se settiamo il
valore 125, L298 applicherà circa 4.5 volt. Come possiamo capire se un valore è ben
definito? Dividendo i valori che abbiamo a disposizione per i volt nominali, quindi nel
nostro esempio sarà 9/256 (256 perché contiamo anche il valore zero). In questo modo
sapremo quanti volt vale ogni valore. Non siamo obbligati a utilizzare una batteria dello
stesso voltaggio di quelle che alimentano i motori, ma possiamo settarlo da software in
modo tale che possa rispettare i valori di tensione di lavoro dei motori per non rischiare di
danneggiare. Con il PWM si ha il pieno controllo senza dover aggiungere altri componenti
al nostro progetto, ne consegue un risparmio monetario e anche un risparmio energetico.

digitalWrite(dir1PinA, LOW);

digitalWrite(dir2PinA, HIGH);

Anche queste due istruzioni sono molto importati. Settano i pin di direzione del nostro
motore. Il loro funzionamento è semplice, configurati in questo modo il motore gira in un
senso, ma se li configurassimo come segue:
digitalWrite(dir1PinA, HIGH);

digitalWrite(dir2PinA, LOW);

il nostro motore girerebbe nel verso contrario. I valori sono sempre l’opposto dell’altro
tranne per la fase di spegnimento dove saranno posti entrambi in LOW.

default:
for (int thisPin = 2; thisPin < 11; thisPin++) {
digitalWrite(thisPin, LOW);

In questo caso, una volta che un’etichetta viene eseguita o che comunque non viene
rilevata nessuna azione, lo switch passa il controllo all’etichetta default che con un ciclo
for mette a livello basso (LOW) fermando tutti i motori. A meno che non compaiano
anomalie, quindi, se non digitate nessun comando sul serial monitor di Arduino i motori si
fermeranno comunque senza arrecare danni.

HC B -06 LUETOOTH

È un modulo di comunicazione standard Bluetooth che può essere interfacciato ad


Arduino in modalità seriale o creando una seriale su dei pin diversi.
Esistono diverse versioni di questo modulo che differiscono tra loro per un differente
protocollo Bluetooth, è necessario quindi prestare attenzione prima dell’acquisto.

Fondamentalmente si suddividono in due grandi serie che sono:



Serie Industriale la cui sigle sono HC-03, HC-04 (HC-04-M, HC-04-S)
Serie Civile la cui sigle sono HC-05, HC-06(HC-06-M, HC-06-S)

Di entrambe le serie il numero finale indica la possibilità di cambiare in modo dinamico la


modalità Master o Slave relativa al protocollo Bluetooth. Quindi, nel caso il numero finale
sia 3 o 5, i moduli hanno la possibilità di poter cambiare la configurazione tramite i
comandi AT. Invece, per i moduli che finisco con i numeri pari bisognerà controllare che
siano Master o Slave perché non si potrà cambiare la modalità a piacimento. Nel nostro
caso abbiamo scelto HC-06 in modalità slave fissa solo perché ha un costo leggermente
inferiore.
Caratteristiche tecniche:

La versione del Bluetooth è la v 2.0+EDR


La frequenza di funziona è 2.4ghz ISM band
Il processore a bordo è un CSR Bluecore4
L’alimentazione consigliata è di 3,3V 50mA
La corrente richiesta in accoppiamento è 30/40 mA
La corrente richiesta in comunicazione è 8 mA
Velocità di comunicazione Seriale: 4800, 9600, 19200, 38400, 57600, 115200,
234000, 460800, 921600, 1382400 bps
Modulo HC Bluetooth e di classe 2 2,5mW di potenza dBm4 distanza massima circa
10 metri

Prima accensione
Come detto in precedenza, a secondo del modulo acquistato viene fornita una
configurazione di base. Il nostro modulo è configurato in modalità Slave con velocità di
9600 bps, passkey 1234, nominativo di identificazione BT UART. Il vostro modulo non
dovrebbe discostarsi molto da questo.
Iniziamo con un primo test per capire come utilizzare il nostro modulo Bluetooth. Di
seguito riportiamo lo Sketch da caricare su Arduino per la nostra prova:
#include <SoftwareSerial.h>
SoftwareSerial BT(7, 8);
// crea una porta seriale virtuale UART
// crea una porta seriale virtuale UART
// collega BT modulo TX al pin D7
// collega BT module RX al pin D8
// collega BT Vcc al pin 5V, GND al pin GND
void setup()
{
// Configura il PIN13 come uscita
pinMode(13, OUTPUT);
// Configura la velocità del SoftwareSerial port
BT.begin(9600);
// Inviamo un messaggio appena si connette
BT.println(“Hello from Arduino”);
BT.println(“Send ‘1’ to turn LED on”);
BT.println(“Send ‘2’ to turn LED on”);
BT.println(“Send ‘?’ to Help”);
}
char a; // dichiariamo una variabile di tipo carattere
void loop()
{
if (BT.available())
// Se arriva del testo dal Bluetooth…
{
a=(BT.read()); // …leggilo e memorizza in “a”
if (a==‘1’)
{
digitalWrite(13, HIGH);
BT.println(“LED on”);
// se il carattere è “1” accendi il led
}
if (a==‘2’)
{
digitalWrite(13, LOW);
BT.println(“LED off”);
// Se il carattere è “2” spegni il led
}
if (a==’?’)
{
BT.println(“Send ‘1’ to turn LED on”);
BT.println(“Send ‘2’ to turn LED on”);
//Se mi invii un ? Invia al device queste stringhe
}
// Da qui potete inserire tanti “if” per quanti comandi volete far eseguire
ad Arduino tramite Bluetooth
}
}

Una volta caricato lo Sketch su Arduino, basterà collegarsi con il proprio smartphone al
modulo utilizzando una qualsiasi app che faccia da terminale Bluetooth. Nel nostro caso
abbiamo scelto Bluetooth Terminal che trovate su Play Store.

Una volta individuato il modulo ed effettuato il collegamento, basterà digitare 1 per


accendere il led su Arduino o 2 per spegnerlo. Arduino vi invierà un messaggio per
indicare lo stato del led. In questo esercizio abbiamo inserito anche un altro comando che
darà la possibilità all’utente di ricordare i comandi che è possibile digitare. Digitando il
“?” sarà inviato il messaggio di help. Come potete notare, abbiamo inserito anche un
messaggio di benvenuto, quando vi collegherete al modulo potrete così capire se è tutto
funzionante. Non abbiamo impostato casualmente i pin 7,8 per il SoftwareSerial. Abbiamo
indicato quei pin per non avere conflitti quando andremo a unire lo Sketch del L298N a
questo per testarne il funzionamento da remoto. Questo metodo di lavoro vi aiuterà in
futuro. Quando creerete applicazioni più complesse dove interfacciare diversi dispositivi o
sensori potreste incorrere in errore, grazie a questo sistema invece avrete il pieno controllo
del vostro progetto e, unendo i vari pezzi di software testati, non incorrerete in errori di
nessun tipo. Sfortunatamente IDE di Arduino non ha un vero e proprio debug passo passo,
quindi a mio avviso è meglio agire per blocchi. Avrete in questo modo un controllo totale.
Tornando a parlare del nostro modulo Bluetooth, potete evincere le potenzialità e le sue
molteplici applicazioni. Essendo un sistema standard sarà compatibile con quasi tutti i tipi
di dispositivi che adottano tale tecnologia. Nel nostro progetto, sostituendo il telecomando
classico di un modellino radiocomandato, sono intuibili i vantaggi. Si potrà creare una app
dedicata, con funzioni avanzate che potranno spaziare dal controllo di direzione, velocità a
tante altre funzioni. Volendo si potrà interfacciare a vari sensori per la temperatura e
umidità, per un controllo a distanza di ambienti non accessibili o, rimanendo nel ludico,
potremo installare dei led aggiuntivi che simulino i fari di un auto o gli indicatori di
direzione. Nel prossimo capitolo metteremo in pratica quanto sin qui trattato a livello
teorico, procedendo con la costruzione del nostro drone terrestre.
CABLAGGIO MODELLINO DI AUTO
3.

Adesso dobbiamo mettere in pratica le nozioni apprese in precedenza, cercando di unire


tutti i tasselli del nostro progetto.
Prima di tutto dovrete trovare un modellino di auto che faccia al caso nostro. Abbiamo
recuperato un “cimelio” d’infanzia che giaceva abbandonato in uno scatolone. Abbiamo
ritrovato solo l’automobilina, il telecomando è andato perduto ma useremo il modulo
bluetooth per guidarla.

Prima di tutto dobbiamo smontarla per rimuovere la vecchia elettronica (immagine


sottostante) sostituendola con i nostri componenti. Dovremo poi isolare i cavetti che
alimentano il motore che controlla le ruote posteriori e il servo motore che in questi
modellini economici è realizzato da un semplice motore in continua.
Quando riuscirete a smontare l’automobilina, spesso l’impresa non è delle più facili,
testate i motori possibilmente con la stessa batteria (se funzionante) o con la stessa
tensione nominale per verificare l’integrità dei motori e capire il senso di marcia che poi
andremo a impostare durante la programmazione di Arduino. Non preoccupatevi per
eventuali errori commessi durante il cablaggio, potremo effettuare ogni correzione in fase
di programmazione. Il vantaggio di utilizzare il “ponte H” L298N è che potremo
comunque decidere il senso di marcia e la potenza applicata ai motori in modo da
controllarne il funzionamento.
Collegate alla corrispettiva morsettiera OUT2 e OUT3 del L298N i motori (se riuscite a
individuare i poli di alimentazione tanto meglio), cercate di collegarli entrambi nello
stesso modo così in fase di configurazione non troverete grandi difficoltà. Il pregio dei
motori in continua è che invertendo la tensione si invertirà solo la rotazione, quindi non
causerete danni di nessun tipo. Nel collegarli cercate di non far uscire la parte del filo al di
fuori del morsetto per non rischiare un corto circuito con il resto dell’elettronica. Le
tensioni in gioco non sono pericolose quindi non preoccupatevi se capiterà di toccare con
un dito i poli della batteria.
Vi avevamo accennato che il modulo L298N ha un jump o meglio 2 contatti che, con un
apposito connettore di contatto, abilitano l’alimentazione sulla morsettiera +5V che
utilizzeremo per alimentare Arduino. Questa caratteristica è utile se vorremo riutilizzare la
stessa batteria per alimentare sia i motori che l’elettronica di controllo.
Sempre sulla board esistono altri due jump che gestiscono l’attivazione dei motori;
abbiamo deciso di tenerli a un livello alto o meglio di alimentarli grazie allo stesso jump.
In alternativa possono essere collegati ai pin digitali di Arduino e programmati per
abilitare i motori a vostro piacimento. Lasciandoli già attivi si risparmiano 2 pin che
possono essere usati per ampliare il nostro progetto.
Rimangono i pin IN1 IN2 IN3 IN4 che servono per la regolazione della direzione di
rotazione dei motori e devono essere collegati ai rispettivi pin digitali.
Colleghiamo ora ad Arduino anche il modulo bluetooth: il pin 7 al TX del modulo e il pin
8 al RX del modulo. Ricordatevi di impostare l’alimentazione VCC a 3.3 volt e il gnd al
gnd, ricordatevi inoltre di collegare una batteria o un pacco di stilo al nostro L298N in
modo tale da aver un cavo non collegato. I primi test saranno infatti effettuati con la usb
collegata. Nel nostro caso abbiamo collegato una batteria quadrata da 9 volt, grazie al
PWM useremo metà della tensione.
Procediamo con il test.

T EST, CONTROLLI E MISURAZIONI

Dopo aver effettuato ogni collegamento testiamo per scrupolo i vari componenti
singolarmente, in modo tale da capire se non ci siano stati errori di cablaggio o di altra
natura.
Prima di tutto cercate di non impilare le schede una sopra l’altra, se possibile, e prestate
attenzione ai collegamenti per evitare cortocircuiti. Regolate il PWM in base
all’elettronica della vostro modellino in modo tale che non ci siano strani movimenti di
sterzata e accelerazioni. Trovate una superficie rialzata per lasciare le ruote libere di
muoversi, nel nostro caso abbiamo usato un contenitore di cd rom (molto rudimentale ma
efficace), in modo tale che l’automobilina non vi sfugga. Questo è un test a vuoto: non
mettiamo sotto sforzo i motori ma possiamo capire se abbiamo compiuto le giuste scelte.
Siate pazienti e preparatevi a dover rimetter mano al codice se necessario. Se avete un
tester controllate la tensione che eroga ogni uscita del ponte H così che possiate avere le
massime prestazioni senza danneggiare i motori con tensioni non adeguate. In ogni caso,
seguendo le indicazioni che vi abbiamo dato non si presenteranno problemi particolari, al
massimo l’automobilina potrebbe procedere a bassa velocità (nel caso stiate facendo un
test in casa eviterete così danni al mobilio!). Non temete errori e continuate a effettuare
prove per comprendere meglio il funzionamento.
Consigliamo di fare un test di “stress” del codice proposto per individuare eventuali bug.
Il codice indicato costituisce un riferimento generale. Potrebbero tuttavia esserci delle
differenze sulla vostra automobilina e facendo questi test riuscirete a individuare eventuali
anomalie. Nel nostro caso abbiamo notato che non azzerando il PWM prima di passare
alla retromarcia, di tanto in tanto si presentava un fenomeno strano: il motore smetteva di
funzionare. Effettuato lo stesso test con un altro motore elettrico da banco il problema non
si è presentato. Probabilmente si tratta quindi di un difetto del motore montato sul
modellino. Altri piccoli problemi potrebbero presentarsi perché è impossibile inserire tutte
le variabili, tenete conto che stiamo hackerando un prodotto nato per fare altro. Se tutto è
andato a buon fine, possiamo togliere il piedistallo e vedere se i motori riescono a far
muovere il modellino senza incertezze, ovviamente resteremo vincolati alla lunghezza del
cavo.
Un ulteriore test importante è quello di collocare l’auto su un piano inclinato in modo da
controllare la reazione dei motori in salita. Controllate che non si surriscaldi troppo il
motore, nel caso regolate a dovere la variabile del codice che controlla il PWM. Si
potrebbe già impostare una funzione nel codice per frenare l’auto in salita senza che torni
indietro. Basterà creare una funzione che attivi la frenata sia in salita che in discesa.
Aggiungeremo anche altre funzioni interessanti, ne parleremo nella prossima
pubblicazione dove affronteremo anche ciò che concerne l’aggiunta di sensori per
monitorare l’ambiente.

S KETCH CONCLUSIVO

Siamo arrivati alla parte conclusiva, uniremo il codice ai test fatti in precedenza per far
funzionare l’automobilina con il bluetooth.
Come potete vedere nell’immagine abbiamo creato un menu di aiuto richiamabile tramite
“?”, utile per ricordarvi i comandi che potete usare.

Spiegheremo il codice nelle sue parti per rendevi poi dopo autonomi nel modificarlo,
aggiungendo altre funzioni e rendendolo più ricco.
Arrivati a questo punto dobbiamo staccare il modellino dal cavo usb. Vi consigliamo
anche di creare un pacco di batterie stilo per alimentare il tutto.
Vi proponiamo adesso il codice realizzato per radiocomandare il modellino tramite
bluetooth:
#include <SoftwareSerial.h>
SoftwareSerial BT(7, 8);
// crea una porta seriale virtuale UART
// collega BT modulo TX al pin D7
// collega BT module RX al pin D8
// collega BT Vcc al pin 5V, GND al pin GND

//Menù di controllo:
//
// 1 - Motore 1 Avanti
// 2 - Motore 1 Stop
// 3 - Motore 1 Indietro
//
// 4 - Motore 2 Avanti
// 5 - Motore 2 Stop
// 6 - Motore 2 Indietro

// Definisco le variabile per il Motore 1
int dir1PinA = 2;
int dir2PinA = 3;
int speedPinA = 9; // Definisco il pin per il controllo di velocità con un
segnale PWM

// Definisco le variabile per il Motore 1
int dir1PinB = 4;
int dir2PinB = 5;
int speedPinB = 10; // Definisco il pin per il controllo di velocità con un
segnale PWM

void setup()
{
BT.begin(9600);
// Inviamo un messaggio appena si connette
BT.println(“Hello from Automobilina”);
BT.println(“’7’ Comandi di aiuto”);
//Configuro i pin di Arduino in uscita per pilotare L298N
pinMode(dir1PinA,OUTPUT);
pinMode(dir2PinA,OUTPUT);
pinMode(speedPinA,OUTPUT);
pinMode(dir1PinB,OUTPUT);
pinMode(dir2PinB,OUTPUT);
pinMode(speedPinB,OUTPUT);
}


void loop()
{
if (BT.available())
// Se arriva del testo dal Bluetooth…
{
int inByte=(BT.read()); // …leggilo e memorizza in “a”
switch (inByte) {

//______________Motore 1______________

case ‘1’: // Motore 1 Avanti
analogWrite(speedPinA, 255); //Configurazione velocità del motore tramite
PWM
digitalWrite(dir1PinA, LOW);
digitalWrite(dir2PinA, HIGH);
BT.println(“’Motore 1 Avanti’”); // Scrive su la seriale
break;

case ‘2’: // Motore 1 Stop
analogWrite(speedPinA, 0);
digitalWrite(dir1PinA, LOW);
digitalWrite(dir2PinA, HIGH);
BT.println(“’Motore 1 Stop’”);
break;

case ‘3’: // Motore 1 Indietro
analogWrite(speedPinA, 255);
digitalWrite(dir1PinA, HIGH);
digitalWrite(dir2PinA, LOW);
BT.println(“’Motore 1 Indietro’”);
break;

//______________Motore 2______________

case ‘4’: // Motore 2 Avanti
analogWrite(speedPinB, 255);
digitalWrite(dir1PinB, LOW);
digitalWrite(dir2PinB, HIGH);
BT.println(“’Motore 2 Avanti’”);
break;

case ‘5’: // Motore 1 Stop
analogWrite(speedPinB, 0);
digitalWrite(dir1PinB, LOW);
digitalWrite(dir2PinB, HIGH);
BT.println(“‘Motore 2 Stop’”);
break;

case ‘6’: // Motor 2 Indietro
analogWrite(speedPinB, 255);
digitalWrite(dir1PinB, HIGH);
digitalWrite(dir2PinB, LOW);
BT.println(“‘Motore 2 Indietro’”);
break;

case ‘7’: // Motor 2 Indietro
BT.println(” ‘1’ Motore 1 Avanti”);
BT.println(” ‘2’ Motore 1 Stop”);
BT.println(” ‘3’ Motore 1 Indietro”);
BT.println(” ‘4’ Motore 2 Avanti”);
BT.println(” ‘5’ Motore 2 Stop”);
BT.println(” ‘6’ Motore 2 Indietro”);
BT.println(” ‘7’ Menu di aiuto”);
break;

default:
// Resetta tutti i pin dopo che è stato effettuato il ciclo
for (int thisPin = 2; thisPin < 11; thisPin++) {
digitalWrite(thisPin, LOW);
}
}
}
}

Analizziamo nel dettaglio alcune istruzioni. Si tratta di un firmware davvero semplice che
comunque vi darà spunti per avanzare con altri progetti. Cercheremo di farvi una base
solida non solo per modificare l’attuale codice ma anche di riscrivere uno nuovo da soli. È
importate capire che Arduino o meglio atmega sono microcontrollori ed eseguono il
codice in sequenza anche se potete creare, come nel nostro casto, piccoli sotto programmi
richiamabili a una certa azione o quando di presenta una determinata condizione. Se tali
condizioni non si presentassero Arduino andrà avanti fino alla fine.
Non possiamo avvalerci della memoria di storage di Arduino: quando fate una stesura di
un firmware dovrete fare molta attenzione a non usare tutta la memoria e le sue risorse.
Prestate quindi attenzione a quali variabili usate e che tipo di istruzioni.
Iniziamo adesso ad approfondire le varie istruzioni.
#include <SoftwareSerial.h>
SoftwareSerial BT(7, 8);

Come abbiamo già detto, questa istruzione crea una porta seriale virtuale su i pin 7,8 di
Arduino. È giusto precisare che la board è predisposta per avere una seriale fisica sui pin
0,1 che comunicano direttamente con un convertitore seriale (nel nostro caso è un altro
atmega programmato per fare un convertitore seriale usb). Il vantaggio di usare quei due
pin dedicati è che non si dovrà caricare questa libreria e che potremo quindi risparmiare
pin nel caso volessimo usare altri componenti da collegare. Abbiamo deciso di usarla per
farvene comprendere il funzionamento, in modo da non precludere nessuna strada durante
la progettazione.
È possibile programmare altri micro proprio dai quei pin usando Arduino come
programmatore, si deve però precisare che si dovrà creare nel file board.txt una board
virtuale in modo che IDE di Arduino sappia come programmarlo. Il vantaggio è che si
potrà caricare in nostro software su una scheda creata ad hoc, evitando di caricare il
firmware bootloader di Arduino, risparmiando spazio per il nostro programma e lasciando
la possibilità di configurare il micro anche con frequenze di lavoro differenti.
Tornando alle istruzione sopracitata notate che viene caricata la libreria SoftwareSerial.h
che si occupa di gestire una vera e propria porta seriale. Vi rimandiamo sul sito di Arduino
dove sono riportate tutte le istruzioni che si possono utilizzare.
Di seguito ne riportiamo alcune:

SoftwareSerial()
available()
begin()
isListening()
overflow()
peek()
read()
print()
println()
listen()
write()

Spieghiamo adesso le istruzioni che abbiamo utilizzato.

SoftwareSerial BT(7, 8) configura la porta seriale sui pin 7,8 di Arduino. BT è una
etichetta che stabiliamo per ricordarci quando andremo a usare il resto dei comandi.

BT.begin(9600); configura la velocità della porta seriale che potrà essere impostata su
questi valori:
300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 234000, 460800,
921600, 1382400
Selezionerete quella che vi serve in base alle vostre esigenze o al dispositivo che dovrete
interfacciare.

BT.println(“Hello from Automobilina”); scrive sulla porta seriale quindi invia un


messaggio su essa. “ln” manda a capo il carrello di scrittura, in sua assenza i dati vengono
inviati in fila. L’istruzione contraria è:

int inByte=(BT.read()); che legge un valore in arrivo dalla porta seriale e lo memorizza
come valore intero nella variabile inByte che useremo più avanti per fare delle azioni ben
precise.

È giusto precisare che i comandi usati per la libreria SoftwareSerial.h sono identici al
protocollo seriale hardware con qualche istruzione in più, che nel nostro progetto non
impiegheremo, per la gestione di dati, eventi e flussi.

if (BT.available()) questa istruzione mette in attesa la porta seriale che aspetterà i dati in
arrivo per poi memorizzarli nella variabile inByte, consentendoci di gestire gli eventi che
vogliamo Arduino esegua.

switch (inByte) variabile che viene usata da “switch” che passa in rassegna i “case” che
abbiamo in elenco.
Si potrebbe fare la stessa cosa con l’istruzione “if”, di seguito riportiamo un esempio di
utilizzo:
if (variabile > 50)
{
// qui scrivete l’evento che si deve verificare
}
else
{
// in caso che il primo evento non vada a buon fine gli diamo
un’alternativa
}

Ricordatevi di inserire sempre questa istruzione:


default:
// Resetta tutti i pin dopo che è stato effettuato il ciclo
for (int thisPin = 2; thisPin < 11; thisPin++) {
digitalWrite(thisPin, LOW)

Nel nostro caso abbiamo creato un ciclo FOR che resetta tutti i pin in modo da non avere
nessuno stato attivo su di essi. È utile quando dobbiamo fare cicli ripetitivi che
normalmente richiederebbero un set di istruzioni infinito ma, come abbiamo detto in
precedenza, la memoria in un micro è limitata e quindi dobbiamo trovare ogni tipo di
stratagemma per non sprecarla. Il ciclo FOR ripete per un certo numero di volte una
determinata azione che abbiamo deciso. Riportiamo un esempio per capire meglio:
for(int x = 0; x < 100; x++) {
println(x); //scriverà i numeri da 0 a 99
}

Nel linguaggio C il “++” serve per incrementare una determinata variabile. Si può usare
anche “+=”. Per decrementare si usa “—” oppure “-=”, sono tutti operatori utili per la
manipolazioni delle variabili.

Torniamo su alcune istruzioni di cui abbiamo già parlato:


analogWrite(speedPinA, 255);

Crea un pwm di circa 490 Hz, è una tecnica per controllare nel nostro caso i motori e
genera un segnale variabile. Andiamo a controllare il Duty cycle cioè il tempo dallo stato
attivo in proporzione al tempo complessivo, sostanzialmente togliamo la tensione in una
certa frequenza di tempo. In questo modo riusciamo a creare una tensione diversa da
quella di base. Il motore reagirà con l’aumento e la diminuzione di velocità.
digitalWrite(dir1PinA, HIGH);
digitalWrite(dir2PinA, LOW)

A differenza dall’istruzione precedente, questa pone i pin a livello basso o livello alto
quindi 1 o 0. È molto semplice da usare, noterete che viene indicato “HIGH” come valore
alto, quindi 1, e al contrario “LOW” come valore basso cioè 0. Le applicazioni sono
infinite, in questo caso selezioniamo il senso di marcia del nostro motore. Potremmo
anche azionare altri dispositivi come un relè per l’accensione delle luci o altre cose dove
siano necessari solo due stati, acceso o spento.
Affrontiamo adesso la dichiarazione di un pin uscita o ingresso.
pinMode(dir1PinA,OUTPUT);
pinMode(dir2PinA,OUTPUT);
pinMode(speedPinA,OUTPUT);
pinMode(dir1PinB,OUTPUT);
pinMode(dir2PinB,OUTPUT);
pinMode(speedPinB,OUTPUT);

In questo caso il nostro codice segnala ad Arduino i pin indicati dalle variabili che
abbiamo dichiarato all’inizio:
int dir1PinA = 2;
int dir2PinA = 3;
int speedPinA = 9;
int dir1PinB = 4;
int dir2PinB = 5;
int speedPinB = 10;

Il codice indica ad Arduino che i pin saranno uscite che poi gestiranno diversi eventi. Lo
stesso comando può definire pin di entrata pinMode(pin, INPUT); in questo modo
Arduino potrà ricevere dei comandi dall’esterno per interagire.
Abbiamo dichiarato delle variabili intere ma possiamo anche dichiarare char, byte, int,
word, long e flot. Ricordatevi che ogni variabile ha un peso nella ram quindi non siate
generosi nell’uso, si potrebbero presentare problemi nell’esecuzione del programma.

Curiosità: nel caso abbiate collegato un pulsante o un qualsiasi componente che


abbia bisogno di una resistenza di pullup, ovvero una resistenza che viene messa in
serie a un pulsante (di solito collegata all’alimentazione per abbassare i rimbalzi
causati dal pulsante), ricordatevi che Arduino potrebbe leggere dei falsi input, ovvero
potrebbe pensare che abbiate premuto il pulsante anche se tale azione non è stata
eseguita. È possibile in alternativa optare per pinMode(pin, INPUT_PULLUP); che
usa la resistenza interna al micro. In certi casi abbiamo però riscontrato delle
anomalie, consigliamo di usare una resistenza da 10kohm.
CONCLUSIONE
Nel prossimo volume aggiungeremo altri elementi alla nostra automobilina, che useremo
come vera e propria piattaforma di apprendimento. Quindi parleremo dei sensori e del loro
impiego per il controllo del nostro prototipo di drone o semplicemente per un
monitoraggio ambientale. Ci occuperemo poi dell’ambiente di sviluppo App Inventor per
la realizzazione di una applicazione Android che si interfacci al nostro drone tramite il
bluetooth. Sarete in grado di gestire autonomamente progettazione e realizzazione,
partendo da qualsiasi idea vi venga in mente. Vi rimando quindi al prossimo volume di
Corso Pratico di Arduino per approfondire e continuare la realizzazione del nostro drone.
NOTE BIOGRAFICHE
Pietro Marchetta, nato il 6 febbraio 1982, è un Perito Elettronico. Sin da ragazzo ha avuto
il “vizio” di smontare ogni apparecchio elettronico per comprenderne il funzionamento.
Iscritto al corso di elettronica, ha condotto con entusiasmo gli studi fino al conseguimento
del diploma.
Ha lavorato come elettricista, manutentore macchinari industriali e riparatore elettronico.
La sua passione per l’elettronica è cresciuta sempre più: nel 2013 ha auto-costruito una
stampante 3D basata sulla Prusa 2 (ad oggi ne ha realizzate 3) e su Arduino. L’incontro
con Arduino ha stimolato la sua ispirazione sino all’esplorazione dell’internet delle cose
(IoT) e all’evoluzione dell’industria 4.0 dove l’elettronica condivide informazione in
modo intelligente. Ad oggi ha realizzato svariati progetti grazie ad Arduino. Nutre anche
una grande passione per il mondo dell’open source, ama Linux e i suoi derivati, negli
ultimi mesi si sta concentrando sulle virtualizzazioni di sistemi operativi. Spera di riuscire
a infondere in voi la stessa passione che ha per l’elettronica e tutto quello che ne orbita
attorno.
Profilo LinkedIn: https://it.linkedin.com/in/iz2rpn
Andrea Coppola, architetto, designer, 3D artist e costruttore (e parecchi anni fa anche
musicista arrangiatore e produttore).
Titolare e fondatore dello studio L.A.A.R. (www.laboratoriodiarchitettura.info), ha
lavorato e lavora tuttora come progettista di interni e designer (progettando i due modelli
di cucina “Nairobi” e “Skin” per Reval Cucine s.r.l. e la sedia “Cra Cra” per Art Leather).
Lavora inoltre come coordinatore per la sicurezza nei cantieri edili (C.S.E.) ed è stato
assistente universitario presso la facoltà di Architettura di Roma “La Sapienza”,
insegnando in alcuni master.
Appassionato di computer grafica e in particolare di Blender, tiene corsi e insegna
attraverso il sito www.blenderhighschool.it, riferimento italiano di Blender e partner
ufficiale di Blender Italia (www.blender.it). In questo sito, connesso con
www.blenderclick.it (gestito con Francesco Andresciani), contribuisce attivamente alla
causa di Blender, grazie alla sua versatilità, offrendo tutorial, trucchi, libri e prodotti
gratuiti e/o a pagamento, oltre a servizi di modellazione e rendering.
Come consulente ha realizzato dei cataloghi per aziende di cucine (insieme ad Alan
Zirpoli) e per la Mars Society di Bergamo, un progetto interattivo utilizzando le reali
mappe del pianeta rosso fornite dalla NASA (con Francesco Andresciani).
Ha pubblicato numerosi ebook, 10 videocorsi, una Academy a tema (Thematic Academy)
su Blender e “Blender – La guida definitiva”; 1 ebook sulla Stampa 3D; 3 ebook su
Autocad; 1 corso di fonia e 1 thriller (“L’Altra Specie”), tutti editi da Area51 Publishing.

Portfolio personale: http://www.blenderhighschool.it/chi-siamo.html
CV e Studio di Architettura: www.laboratoriodiarchitettura.info
Training (in italiano): www.blenderhighschool.it
Libri e videocorsi: http://www.area51editore.com?affiliates=25
Lavori in Kenya: www.lamiacasainkenya.com
CLICCA O FAI TOUCH QUI
Esperto in un click
Indice
Introduzione
1. Il progetto
2. Hardware
L298N Dual H-Bridge Motor Controller
HC-06 Bluetooth
3. Cablaggio modellino di auto
Test, controlli e misurazioni
Sketch conclusivo
Conclusione
Note biografiche