Sei sulla pagina 1di 63

Dipartimento di Ingegneria Elettrica Elettronica e Informatica

Corso di Laurea in Ingegneria Elettronica

Anno 2021

Orazio Garofalo

Elaborato finale
Controllo di un sistema mobile attraverso sensori di
traccia

Relatore: Chiar.ma Prof.ssa Ing. Maide Angela Rita Bucolo


Correlatore: Chiar.ma Prof.ssa Ing. Salvina Gagliano
A mamma e papà
Ringraziamenti

Un ringraziamento speciale va ai miei genitori. Non potevo ricevere


genitori migliori. Grazie per avermi sostenuto in tutti i miei studi e per
avermi spinto sempre a cercare il “meglio e il massimo”.

Un pensiero va anche ai miei colleghi, Salvo, Donato, Emanuele e


Fabio, con i quali abbiamo condiviso gioie e dolori in questi anni
universitari. In particolare, a mio fratello Giacomo: miglior collega e
amico.

Ringrazio sentitamente la mia relatrice, la prof.ssa Bucolo, e la mia


correlatrice, la prof.ssa Gagliano, che in questi mesi di lavoro hanno
saputo guidarmi in modo efficace nella stesura di questo elaborato.
Indice

Elenco delle tabelle ................................................................. III

Elenco delle figure .................................................................. IV

Introduzione .............................................................................. 1

Capitolo 1 – Introduzione ai controlli automatici .................. 2


1.1 Definizione di sistema ............................................................. 3
1.2 Rappresentazione interna ........................................................ 4
1.3 Rappresentazione esterna ........................................................ 6
1.4 Raggiungibilità e controllabilità .............................................. 7
1.5 Controlli a catena aperta e a catena chiusa .............................. 9
1.5.1 Catena aperta .............................................................. 9
1.5.2 Catena chiusa .............................................................. 9
1.5.3 Vantaggi della retroazione ........................................ 11
1.6 Precisione a regime dei sistemi in retroazione ..................... 15

2 Capitolo 2 – Set up ................................................................... 18


2.1 Descrizione generale del sistema ........................................... 18
2.2 Shield .................................................................................... 20
2.3 Arduino ................................................................................. 23
2.4 Sensori ................................................................................... 26
2.4.1 Sensore di traccia ...................................................... 26
2.4.2 Sensore a ultrasuoni ................................................. 28
2.5 Attuatore ............................................................................... 30

I
3 Capitolo 3 – Studio: Caso studio ............................................ 32
3.1 Costruzione della vettura ....................................................... 32
3.2 Controllo a catena aperta ....................................................... 34
3.3 Controllo a catena chiusa ....................................................... 35
3.3.1 Singolo sensore ........................................................ 35
3.3.2 Doppio sensore ......................................................... 37

Conclusioni .............................................................................. 38

Appendice ................................................................................ 39

Bibliografia ............................................................................. 51

II
Elenco delle Tabelle
2.1 Pin e funzioni delle shield ............................................................. 22
2.2 Condizioni ingressi ....................................................................... 23
2.3 Uscite sensore di traccia ............................................................... 28

III
Elenco delle Figure
1
1.1 Sistema dinamico .................................................................... 3
1.2 Circuito RC serie ..................................................................... 5
1.3 Stato raggiungibile e sottospazio di raggiungibilità ................ 8
1.4 Stato controllabile e sottospazio di controllabilità .................. 8
1.5 Controllo a catena aperta ......................................................... 9
1.6 Controllo a catena chiusa ....................................................... 10
1.7 Retroazione negativa (a), Retroazione positiva (b) ................ 10
1.8 Disturbi in un sistema a catena aperta .................................... 13
1.9 Disturbi in un sistema a catena chiusa ................................... 14
1.10 Minimo schema di un sistema in retroazione ......................... 15
2
2.1 Sistema master-slave ............................................................. 18
2.2 Vettura con servomotori, Arduino e shield ................................
19
2.3 Dual DC Motor Shield V2 ..................................................... 20
2.4 Selezione della sorgente tramite jumper ................................ 21
2.5 Scheda Arduino UNO ........................................................... 24
2.6 Sensore KY-033 .................................................................... 26
2.7 Superficie chiara .................................................................... 27
2.8 Superficie scura ..................................................................... 27
2.9 Sensore HC-SR04 ................................................................. 28
2.10 Comportamento di HC-SR04 in presenza di ostacolo ........... 29
2.11 Servomotore .......................................................................... 31
3
3.1 Evoluzione del montaggio (a), (b), (c) ................................... 32
3.2 Risultato finale ...................................................................... 34

IV
V
Introduzione

Introduzione

In questo elaborato verrà preso in esame un sistema dinamico in cui


sono presenti due oggetti mobili, i quali, interagendo tra loro, formano
un sistema master-slave.

La prima parte dell’elaborato si concentrerà sull’affrontare temi di


natura teorica presentando la definizione formale di sistema e di
controllo. Saranno analizzati due tipi di controlli e le differenze che
sussistono tra i due.

Nella seconda parte, dopo aver descritto il quadro generale del


sistema, si analizzerà ogni componente del sistema descrivendone le
caratteristiche tecniche.

Infine, nella terza parte si prenderà in esame il caso studio, ossia, lo


schema di controllo di un sistema mobile attraverso sensore di traccia.

1
Capitolo 1 Introduzione ai controlli automatici

Capitolo 1 – Introduzione ai controlli


automatici
Ogni giorno, ciascuno di noi esegue centinaia se non migliaia di
controlli. In effetti, il controllo, inteso in senso ingegneristico,
caratterizza la vita di tutti i giorni e trova applicazione in molti campi
dell’ingegneria. Immaginiamo infatti di voler raggiungere l’università
partendo dalla nostra abitazione. In questo tragitto, sono necessari
numerosi controlli, infatti ci troveremo a dover frenare, accelerare,
sterzare, cambiare le marce, correggere l’andamento della macchina,
ecc. I controlli effettuati in quel tragitto non sono eseguiti solo da chi è
alla guida. Se l’automobile è abbastanza moderna è possibile che sia
presente un cruise control che permetterà in modo automatico alla
vettura di regolare la sua velocità, oppure un dispositivo detto BAS che
assiste il pilota in caso di una frenata di emergenza. Gli esempi esposti
sono tutti esempi di controlli eseguiti su un sistema. Nel primo caso si
parla di controllo manuale, eseguito direttamente dall’uomo, nel
secondo caso ci ritroviamo di fronte a un controllo automatico. La
seconda categoria di controlli è più interessante e su questa ci
focalizzeremo.

Dopo aver posto le basi teoriche sul significato di sistema,


analizziamo cosa si intende per controllo, quali tipi di controlli esistono
e perché certi controlli sono migliori di altri.

2
Capitolo 1 Introduzione ai controlli automatici

1.1 Definizione di sistema

Definizione 1.1. Un sistema dinamico è un ente matematico


caratterizzato da sei insiemi:
- Insieme delle variabili di ingresso 𝑈;
- Insieme delle variabili di uscita 𝑌;
- Insieme delle variabili di stato o spazio di stato 𝑋;
- Insieme del tempo, coincide con ℝ se il sistema è analogico,
coincide con ℕ se il sistema è digitale;
- Insieme delle funzioni ammissibili in ingresso;
- Insieme delle funzioni ammissibili in uscita;
e da due funzioni:
- Funzione transizione di stato 𝑥(𝑡);
- Funzione trasformazione di uscita 𝑦(𝑡).

Un sistema dinamico a tempo continuo

Var iabili di Var iabili di


ingr esso Sistem a uscita
dinam ico

Fig.1.1 sistema dinamico

costituisce un modello matematico di un oggetto fisico, il quale


interagisce con il mondo circostante tramite due vettori di variabili
dipendenti dal tempo. Tali vettori sono individuati dalle variabili di
ingresso e dalle variabili di uscita. Le variabili di ingresso
rappresentano le azioni che vengono compiute sull’oggetto in esame da
agenti esterni che ne influenzano il comportamento. Le variabili di
uscita rappresentano quanto del comportamento dell’oggetto stesso è di

3
Capitolo 1 Introduzione ai controlli automatici

interesse. In altri termini, tra le variabili di ingresso e quelle di uscita vi


è un rapporto di causa ed effetto: l’evoluzione delle seconde descrive il
modo in cui l’oggetto che si sta modellando risponde alle sollecitazioni
impresse con le prime [1].

Particolari tipi di sistemi sono i sistemi lineari tempo invarianti o


LTI. Se un sistema è lineare significa che la funzione transizione di stato
è una funzione lineare. In un sistema tempo invariante invece i
parametri di tale sistema non dipendono dal tempo. Ne segue che un
sistema LTI possiede congiuntamente queste due caratteristiche.

1.2 Rappresentazione interna

Un sistema LTI analogico è descritto secondo le seguenti equazioni


dette equazioni di stato o rappresentazione interna

𝑥̇ (𝑡) = 𝐴 ⋅ 𝑥 (𝑡) + 𝐵 ⋅ 𝑢 (𝑡)


+
𝑦(𝑡) = 𝐶 ⋅ 𝑥(𝑡) + 𝐷 ⋅ 𝑢(𝑡)

dove 𝑡 ∈ ℝ, 𝑥(𝑡), 𝑢(𝑡) e 𝑦(𝑡) sono vettori

𝑥(𝑡) ∈ ℝ!×# , 𝑢(𝑡) ∈ ℝ$×# , 𝑦(𝑡) ∈ ℝ%×#

in particolare, 𝑛 indica il numero degli stati, 𝑚 indica il numero degli


ingressi e 𝑝 il numero di uscite del sistema.
Si può dimostrare che la soluzione dell’equazione di stato è

"
𝑥(𝑡) = 𝑒 !" 𝑥(0) + ) 𝑒 !("$%) ⋅ 𝐵 ⋅ 𝑢(𝜏) 𝑑𝜏 = Φ(𝑡) ⋅ 𝑥(0) + Ψ(𝑡) ⋅ 𝑢(𝑡)
'

4
Capitolo 1 Introduzione ai controlli automatici

R(s) + E(s) Y(s)


C(s) P(s)
+
Esempio 1.1. Una volta
Y(s)
individuati gli stati, qualsiasi sistema può
essere rappresentato secondo le equazioni di stato. Facciamo un
esempio considerando un circuito RC serie.

VR(t)
I(t)

V0(t) C
Vc(t)

Fig. 1.2 circuito RC serie

L’ingresso in questione è la tensione di alimentazione 𝑉& (𝑡) pertanto


poniamo

𝑢(𝑡) = 𝑉& (𝑡)

Supponiamo ora di voler avere come uscita la tensione che cade sulla
resistenza, poniamo pertanto

𝑦(𝑡) = 𝑉' (𝑡)

Applicando la legge di Kirchhoff delle tensioni alla maglia otteniamo

𝑉& (𝑡) = 𝑉' (𝑡) + 𝑉( (𝑡)

𝑑𝑉( (𝑡)
𝑉& (𝑡) = 𝑅𝐶 ⋅ + 𝑉( (𝑡)
𝑑𝑡

ossia

1 1
𝑥̇ (𝑡) = − ⋅ 𝑥(𝑡) + ⋅ 𝑢(𝑡)
= 𝑅𝐶 𝑅𝐶
( ) ( )
𝑦 𝑡 = −𝑥 𝑡 + 𝑢 𝑡 ( )

5
Capitolo 1 Introduzione ai controlli automatici

1.3 Rappresentazione esterna

Lo studio di modelli matematici nel dominio del tempo può


diventare piuttosto complicato con il crescere della complessità del
sistema in quanto ci si trova davanti alla necessità di risolvere equazioni
differenziali. Un sistema dinamico può essere studiato facendo
esclusivamente riferimento a ingresso e uscita, che sono le grandezze
attraverso cui il sistema si rivela a chi lo osservi dall’esterno [2]. Questo
punto di vista porta alla definizione “esterna” di sistema dinamico
lineare. Attraverso delle trasformazioni (Laplace e Fourier) è possibile
studiare lo stesso sistema, in termini di equazioni algebriche, nel
dominio della frequenza. Terminato lo studio si antitrasforma ottenendo
il risultato finale nel dominio del tempo.
Consideriamo l’equazione di stato

𝑥̇ (𝑡) = 𝐴 ⋅ 𝑥(𝑡) + 𝐵 ⋅ 𝑢(𝑡)

ponendo ℒ{𝑥(𝑡)} = 𝑋(𝑠) e ℒ{𝑢(𝑡)} = 𝑈(𝑠), applicando la trasformata


di Laplace ambo i membri, con i dovuti passaggi si ha

𝑋(𝑠) = (𝑠𝐼 − 𝐴))# ⋅ 𝑥(0) + (𝑠𝐼 − 𝐴))# ⋅ 𝐵 ⋅ 𝑈(𝑠)

Applicando Laplace alla relazione di uscita si ha

𝑌(𝑠) = 𝐶 ⋅ 𝑋(𝑠) + 𝐷 ⋅ 𝑈(𝑠)

sostituendo l’espressione di 𝑋(𝑠) in 𝑌(𝑠) si ha

𝑌(𝑠) = 𝐶 ⋅ (𝑠𝐼 − 𝐴))# ⋅ 𝑥(0) + [𝐶 ⋅ (𝑠𝐼 − 𝐴))# ⋅ 𝐵 + 𝐷] ⋅ 𝑈(𝑠)

se 𝑥(0) = 0 abbiamo

𝑌(𝑠) = [𝐶 ⋅ (𝑠𝐼 − 𝐴))# ⋅ 𝐵 + 𝐷] ⋅ 𝑈(𝑠)

detta rappresentazione esterna, dalla quale si ricava

6
Capitolo 1 Introduzione ai controlli automatici

𝑌(𝑠)
𝐹(𝑠) = = 𝐶 ⋅ (𝑠𝐼 − 𝐴))# ⋅ 𝐵 + 𝐷
𝑈(𝑠)

la funzione di trasferimento 𝐹(𝑠).

1.4 Raggiungibilità e controllabilità

Il controllo di un sistema ha l’obiettivo di modificare le variabili di


uscita del sistema da controllare mediante opportune variabili di
ingresso. In particolare, prestiamo attenzione alle proprietà di
raggiungibilità e controllabilità, le quali descrivono le possibilità di
azione della funzione di ingresso 𝑢(𝑡) al fine di influenzare il
movimento dello stato. La proprietà di raggiungibilità descrive la
possibilità di modificare lo stato di un sistema a partire da un particolare
stato iniziale agendo in modo opportuno sull’ingresso 𝑢(𝑡). La
proprietà di controllabilità descrive la possibilità di trasferire lo stato di
un sistema a un particolare stato finale agendo in modo opportuno
sull’ingresso 𝑢(𝑡) [3].

Definizione 1.2. Uno stato 𝑥̅ si dice raggiungibile dallo stato zero


𝑥& = 𝑥(𝑡& ) al tempo 𝑡̅ ∈ [𝑡& ; +∞[ se ∃ 𝑢(𝑡) con 𝑡 ∈ [ 𝑡& ; 𝑡̅ ] tali che,
detto 𝑥(𝑡), 𝑡 ∈ [ 𝑡& ; 𝑡̅ ], il movimento dello stato generato da 𝑢(𝑡) a
partire dallo stato zero, risulti

𝑥(𝑡̅) = 𝑥̅

L’insieme degli stati raggiungibili rappresenta l’insieme di


raggiungibilità 𝑋' (𝑡̅) all’istante 𝑡̅ e costituisce un sottospazio lineare
dello spazio di stato 𝑋 [3].

7
Capitolo 1 Introduzione ai controlli automatici

Fig.1.3 stato raggiungibile e sottospazio di raggiungibilità

Definizione 1.3. Uno stato 𝑥̅ si dice controllabile allo stato zero 𝑥& =
𝑥(𝑡& ) al tempo 𝑡̅ ∈ [𝑡& ; +∞[ se ∃ 𝑢(𝑡) con 𝑡 ∈ [ 𝑡& ; 𝑡̅ ] tali che, detto
𝑥(𝑡), 𝑡 ∈ [ 𝑡& ; 𝑡̅ ], il movimento dello stato generato da 𝑢(𝑡) a partire
dallo stato zero, risulti

𝑥(𝑡̅) = 𝑥&

L’insieme degli stati controllabili rappresenta l’insieme di


controllabilità 𝑋( (𝑡̅) all’istante 𝑡̅ e costituisce un sottospazio lineare
dello spazio di stato 𝑋 [3].

Fig.1.4 Stato controllabile e sottospazio di controllabilità

8
Capitolo 1 Introduzione ai controlli automatici

Osservazione 1.1. Lo stato zero è uno stato prefissato considerato


come obiettivo. Tipicamente si tratta di uno stato di equilibrio non
coincidente, in generale, con l’origine dello spazio di stato [3].

1.5 Controlli a catena aperta e a catena chiusa

Per controllare un sistema esistono sostanzialmente due modalità:


- Controllo a catena aperta
- Controllo a catena chiusa

1.5.1 Catena aperta

Il controllo a catena aperta si basa su una elaborazione degli ingressi


eseguita senza conoscere il valore dell'uscita del sistema controllato,
essendo note alcune proprietà del sistema da controllare [4].
Se indichiamo con 𝐶(𝑠) la funzione di trasferimento dell’organo di
controllo, con 𝑃(𝑠) la funzione del sistema da controllare, 𝑅(𝑠) il
segnale di riferimento in ingresso e 𝑌(𝑠) il segnale di uscita, lo schema
di controllo risulta essere

R(s) Y(s)
C(s) P(s)

Fig.1.5 controllo a catena aperta

1.5.2 Catena chiusa

Il collegamento a catena chiusa o in retroazione consiste in un anello


di controllo che riporta all'ingresso del processo 𝑃(𝑠) che si vuole

9
Capitolo 1 Introduzione ai controlli automatici

controllare una funzione dell'uscita, la quale va sommata


algebricamente al segnale già presente in ingresso.

R(s) E(s) Y(s)


C(s) P(s)

Y(s)

Fig.1.6 controllo a catena chiusa

Si hanno due possibilità di sommare la funzione di uscita al segnale già


presente in ingresso, da queste due possibilità scaturiscono due diverse
configurazioni.
Si parla di retroazione negativa quando il segnale 𝑌(𝑠) va sottratto al
segnale di riferimento 𝑅(𝑠) in ingresso,

R(s) + E(s) Y(s)


C(s) P(s)
_

Y(s)

Fig.1.7 (a) retroazione negativa

si parla di retroazione positiva quando il segnale 𝑌(𝑠) va sommato al


segnale di riferimento 𝑅(𝑠) in ingresso

R(s) + E(s) Y(s)


C(s) P(s)
+
Y(s)

Fig.1.7 (b) retroazione positiva

10
Capitolo 1 Introduzione ai controlli automatici

In entrambi i casi, il segnale risultante sarà 𝐸(𝑠) il quale è proprio la


somma algebrica tra 𝑌(𝑠) e 𝑅(𝑠). In generale la retroazione positiva
porta a sistemi instabili, mentre la retroazione negativa apre la strada a
strategie di controllo molto efficaci per il raggiungimento della stabilità
del sistema e il miglioramento delle prestazioni del sistema [4].
Per essere più precisi, negli schemi a blocchi rappresentati in Fig.1.5,
Fig.1.6 (a) e Fig.1.5 (b), avremmo dovuto inserire un attuatore con
funzione di trasferimento 𝐴(𝑠), il quale è un dispositivo che trasforma
l’energia da una forma a un’altra. Ai fini della trattazione successiva
possiamo considerare che l’attuatore e quindi la sua funzione di
trasferimento sia inglobata nel processo 𝑃(𝑠).

1.5.3 Vantaggi della retroazione

Confrontiamo i due schemi di controllo e vediamo perché lo schema


in retroazione è più vantaggioso. In particolare, confrontiamo i due
sistemi nel caso in cui si ha una variazione di un parametro che influisce
sul processo e nel caso in cui si hanno disturbi sia in catena diretta che
in catena di retroazione.
Rispettivamente, le funzioni globali per lo schema a catena aperta e
quello a catena chiusa (retroazione negativa) sono:

𝑊* (𝑠) = 𝐶(𝑠) ⋅ 𝑃(𝑠) catena aperta

𝐶(𝑠) ⋅ 𝑃(𝑠)
𝑊( (𝑠) = catena chiusa
1 + 𝐶 (𝑠) ⋅ 𝑃(𝑠)

11
Capitolo 1 Introduzione ai controlli automatici

Supponiamo che la funzione di trasferimento del processo non dipenda


più dalla frequenza ma anche da una altro parametro 𝛼 tale che si abbia
𝑃(𝑠, 𝛼).

Definiamo la funzione sensitività ed effettuiamo alcune


considerazioni.

Definizione 1.4. Indichiamo la funzione sensitività alle variazioni


parametriche di una certa funzione di trasferimento 𝑊(𝑠) alle
variazioni di un parametro 𝛼 la seguente quantità

𝜕𝑊(𝑠, 𝛼)
, 𝑊(𝑠, 𝛼) 𝜕𝑊(𝑠, 𝛼) 𝛼
𝑆+ = = ⋅
𝜕𝛼 𝜕𝛼 𝑊 (𝑠, 𝛼)
𝛼

,
Calcoliamo ora la funzione 𝑆+ nei casi di catena aperta e catena
chiusa.

Catena aperta

,
𝜕𝑊* (𝑠, 𝛼) 𝛼 𝜕W𝐶(𝑠) ⋅ 𝑃(𝑠, 𝛼)X 𝛼
𝑆+ = ⋅ = ⋅ =
!
𝜕𝛼 𝑊* (𝑠, 𝛼) 𝜕𝛼 𝐶 (𝑠) ⋅ 𝑃(𝑠, 𝛼)

𝜕W𝑃(𝑠, 𝛼)X
𝐶(𝑠) ⋅ 𝜕W𝑃(𝑠, 𝛼)X 𝛼 𝑃(𝑠, 𝛼)
= ⋅ = = 𝑆-,
𝜕𝛼 𝐶 (𝑠) ⋅ 𝑃(𝑠, 𝛼) 𝜕𝛼
𝛼

In un controllo a catena aperta la sensibilità del sistema controllato è


uguale alla sensibilità del sistema non controllato. Dato che abbiamo
,
ottenuto 𝑆+ !
= 𝑆-, , capiamo che in un controllo a catena aperta, la
variazione di un parametro viene riportata totalmente sull’uscita.

Catena chiusa

12
Capitolo 1 Introduzione ai controlli automatici

,
𝜕𝑊( (𝑠, 𝛼) 𝛼 𝜕𝑊( (𝑠, 𝛼) 𝜕𝑃(𝑠, 𝛼) 𝛼
𝑆+ = ⋅ = ⋅ ⋅ =
"
𝜕𝛼 (
𝑊( 𝑠, 𝛼 ) (
𝜕𝑃 𝑠, 𝛼 ) 𝜕𝛼 𝑊( 𝑠, 𝛼)
(

𝐶(𝑠) ⋅ 𝑃(𝑠, 𝛼)
𝜕Y Z
1 + 𝐶(𝑠) ⋅ 𝑃(𝑠, 𝛼) 𝜕𝑃(𝑠, 𝛼) 1 + 𝐶(𝑠) ⋅ 𝑃(𝑠, 𝛼)
= ⋅ ⋅𝛼⋅ =
𝜕𝑃(𝑠, 𝛼) 𝜕𝛼 𝐶 (𝑠) ⋅ 𝑃(𝑠, 𝛼 )

1 𝜕𝑃(𝑠, 𝛼) 𝛼 1
= ⋅ ⋅ = ⋅ 𝑆,
( ) (
1 + 𝐶 𝑠 ⋅ 𝑃 𝑠, 𝛼 ) 𝜕𝛼 (
𝑃 𝑠, 𝛼 ) 1 + 𝐶 𝑠 ⋅ 𝑃 (𝑠, 𝛼 ) -
( )

Notiamo che in corrispondenza di

|𝐶(𝑠) ⋅ 𝑃(𝑠, 𝛼)| ≫ 1

si avrà

,
𝑆+ "
≈0

questo significa che se |𝐶(𝑠) ⋅ 𝑃(𝑠, 𝛼)| ≫ 1 allora riusciamo a rendere


il nostro sistema insensibile alle variazioni parametriche, il che
rappresenta un grande vantaggio dei sistemi a retroazione rispetto a
quelli a catena aperta.

Valutiamo i comportamenti dei due sistemi nel caso della presenza


di disturbi.

Catena aperta

D(s)

R(s) + Y(s)
C(s) P(s)

Fig.1.8 disturbi in un sistema a catena aperta

L’uscita è pari a

𝑌(𝑠) = 𝐷(𝑠) + 𝐶(𝑠) ⋅ 𝑃(𝑠) ⋅ 𝑅(𝑠)

13
Capitolo 1 Introduzione ai controlli automatici

se 𝑅(𝑠) = 0 allora 𝑌(𝑠) = 𝐷(𝑠). Ciò significa che il disturbo viene


completamente riportato sull’uscita.

Catena chiusa

D(s)

R(s) + E(s) + Y(s)


C(s) P(s)
_
+
Dm (s)

Fig.1.9 disturbi in un sistema a catena chiusa

L’uscita è pari a

𝐶(𝑠) ⋅ 𝑃(𝑠) 1 𝐶(𝑠) ⋅ 𝑃(𝑠)


𝑌(𝑠) = ⋅ 𝑅(𝑠) + ⋅ 𝐷(𝑠) − ⋅ 𝐷 (𝑠)
1 + 𝐶(𝑠) ⋅ 𝑃(𝑠) 1 + 𝐶(𝑠) ⋅ 𝑃(𝑠) 1 + 𝐶(𝑠) ⋅ 𝑃(𝑠) #

studiamo l’uscita sfruttando la sovrapposizione degli effetti. Ponendo


𝑅(𝑠) = 0 e 𝐷$ (𝑠) = 0 abbiamo

1
𝑌(𝑠) = ⋅ 𝐷(𝑠)
1 + 𝐶 (𝑠) ⋅ 𝑃(𝑠)

quindi se |𝐶(𝑠) ⋅ 𝑃(𝑠)| ≫ 1 allora 𝑌(𝑠) ≈ 0, l’effetto del disturbo


viene annullato.
Poniamo 𝑅(𝑠) = 0 e 𝐷(𝑠) = 0, in questo caso si ha

𝐶(𝑠) ⋅ 𝑃(𝑠)
𝑌(𝑠) = − ⋅ 𝐷 (𝑠)
1 + 𝐶 (𝑠) ⋅ 𝑃(𝑠) $

se |𝐶(𝑠) ⋅ 𝑃(𝑠)| ≫ 1 allora 𝑌(𝑠) ≈ 𝐷$ (𝑠), il disturbo è totalmente


riportato sull’uscita. Se |𝐶(𝑠) ⋅ 𝑃(𝑠)| ≪ 1 allora 𝑌(𝑠) ≈ 0.
Ricapitolando si ha

14
Capitolo 1 Introduzione ai controlli automatici

𝑠𝑒 |𝐶(𝑠) ⋅ 𝑃(𝑠)| ≪ 1 ⇒ 𝑌(𝑠) ≈ 𝐷(𝑠)


𝑠𝑒 |𝐶(𝑠) ⋅ 𝑃(𝑠)| ≫ 1 ⇒ 𝑌(𝑠) ≈ 𝑅(𝑠) − 𝐷$ (𝑠)

Possiamo annullare l’effetto dei disturbi scegliendo in modo opportuno


la banda del sistema, infatti, nel primo caso annulliamo il disturbo
presente nel ramo di retroazione, nel secondo quello in catena diretta.
In generale possiamo concludere che il controllo a catena chiusa ha una
maggiore robustezza ai disturbi.

1.6 Precisione a regime dei sistemi in retroazione

Vediamo di seguito le caratteristiche che un sistema deve possedere


affinché si abbia una certa precisione a regime. In altre parole, studiamo
le condizioni che si devono riscontrare affinché il segnale di uscita 𝑌(𝑠)
segua il segnale di riferimento in ingresso 𝑅(𝑠).

Consideriamo un semplice schema di un sistema in retroazione,


dove per semplicità abbiamo posto

𝐹(𝑠) = 𝐶(𝑠) ⋅ 𝑃(𝑠)

R(s) + E(s) Y(s)


F(s)
_

Fig.1.10 minimo schema di un sistema in retroazione

Dato che l’obiettivo è che il segnale di uscita segua il riferimento, siamo


interessati al segnale

𝐸(𝑠) = 𝑅(𝑠) − 𝑌(𝑠)

15
Capitolo 1 Introduzione ai controlli automatici

e in particolare vogliamo che sia nullo.


Calcoliamo la funzione di trasferimento tra l’errore e il riferimento, si
ha

𝐸(𝑠) = 𝑅(𝑠) − 𝑌(𝑠) = 𝑅(𝑠) − 𝐸(𝑠) ⋅ 𝑅(𝑠)

ne segue che

1
𝐸(𝑠) = ⋅ 𝑅(𝑠)
1 + 𝐹 (𝑠)

esplicitando i poli in zero, i quali individuano il tipo del sistema, della


funzione 𝐹(𝑠) possiamo riscrivere

𝑠%
𝐸(𝑠) = ⋅ 𝑅(𝑠)
𝑠 % + 𝐹b (𝑠)

Sappiamo che qualsiasi segnale si può scomporre nel dominio del


tempo e nel dominio della frequenza usando rispettivamente le serie di
Taylor e di Fourier. Un segnale in scomposto in serie di Taylor non è
altro che un polinomio il cui termine generico è

𝑡.
𝑟(𝑡) =
𝑘!

il quale in frequenza risulta

1
𝑅(𝑠) =
𝑠 ./#

Dopo queste premesse, analizziamo l’andamento dell’errore a


regime. Siamo interessati alla quantità

𝑒0 = lim 𝑒(𝑡)
1→ /0

16
Capitolo 1 Introduzione ai controlli automatici

se questo limite esiste ed è finito, per calcolarlo possiamo applicare il


teorema del valore finale, cioè

lim 𝑒(𝑡) = lim 𝑠 ⋅ 𝐸(𝑠)


1→ /0 4→ &

sostituendo i risultati ottenuti prima abbiamo

𝑠% 1 𝑠 %).
𝑒0 = lim 𝑠 ⋅ % ⋅ = lim
4→ & 𝑠 + 𝐹b (𝑠) 𝑠 ./# 4→ & 𝑠 % + 𝐹b (𝑠)

il risultato deve essere analizzato per casi

+∞ 𝑠𝑒 𝑝 < 𝑘
1
𝑠𝑒 𝑝 = 𝑘 ≠ 0
b
𝐹 (0)
𝑒0 =
1
𝑠𝑒 𝑝 = 𝑘 = 0
1 + 𝐹b (0)
0 𝑠𝑒 𝑝 > 𝑘

Possiamo concludere che per avere un errore a regime nullo o


comunque finito, il numero dei poli 𝑝 della funzione di trasferimento
del sistema da controllare ovvero il tipo del sistema deve essere sempre
maggiore o uguale al grado del segnale in ingresso.

Osservazione 1.2. Queste considerazioni riguardanti l’errore si sono


potute svolgere solo grazie al fatto che il sistema da controllare è posto
in retroazione. Anche in questo caso il controllo in retroazione si è
dimostrato superiore rispetto al controllo a catena aperta.

17
Capitolo 2 Set up

Capitolo 2 – Set up
In questo capitolo ci occuperemo di descrivere il set up, ovvero la
configurazione, del sistema fisico che ci siamo preposti di studiare e
controllare. In particolare, vedremo quali sono i componenti che
costituiscono il sistema e come interagiscono tra di loro.

2.1 Descrizione generale del sistema

Il sistema studiato è composto principalmente da due oggetti mobili


che chiameremo vetture. L’obiettivo finale del sistema è che entrambe
le vetture seguano un percorso individuato da una linea nera tracciata a
terra. Le vetture proseguono una dietro l’altra. La prima vettura,
secondo il senso di marcia (da destra verso sinistra vedendo la Fig.2.1),
sarà chiamata “master”. La seconda vettura invece, che insegue la
prima, sarà chiamata “slave”.

Fig.2.1 sistema master-slave

Su entrambe le vetture sono montati dei sensori. Sulla vettura master


sono montati due sensori di traccia, mentre, sulla slave è montato un
sensore a ultrasuoni. La master grazie ai due sensori di traccia, i quali

18
Capitolo 2 Set up

lavorano in senso di differenziale, è in grado di seguire la linea nera a


terra. La vettura slave, tramite il sensore a ultrasuoni, è capace di
individuare la distanza dalla master e quindi modificare la sua velocità
(2 modalità) in riferimento a tale distanza ed eventualmente, se troppo
vicina, fermarsi.
Ciascuna delle vetture si serve di due servomotori per spostarsi. Essi
sono della Lego e di tecnologia mindstorm NXT.
Sia i sensori che i servomotori sono controllati da un microcontrollore,
Arduino nella fatti specie.
È inoltre montata una shield, compatibile con Arduino che controlla sia
la velocità sia la direzione di ciascun servomotore in modo
indipendente.

Fig. 2.2 vettura con servomotori (a), Arduino (b) e shield (c)

Osservazione 2.1. In generale, un architettura di tipo master-slave è


composta da due elementi, dove l’elemento “master” impartisce
istruzioni all’elemento “slave”. Possiamo dire che il sistema in
questione è un sistema di tipo master-slave in quanto la posizione della
prima vettura influisce direttamente sulla seconda.

19
Capitolo 2 Set up

2.2 Shield

Come si evince dalla Fig.2.3 la shield è montata direttamente su


Arduino e funge da interfaccia per i servomotori. In particolare,
abbiamo usato la Dual DC Motor Shield V2.

Fig.2.3 Dual DC Motor Shield V2

Si tratta di una shield progettata per permettere a una scheda Arduino


di pilotare due motori DC o un motore passo-passo bipolare,
controllando sia la velocità sia la direzione di ciascun canale in modo
indipendente.
Alcune applicazioni possono richiedere di controllare la velocità del
motore o la posizione angolare di un servo tramite potenziometro; per
questi motivi in questa shield sono state aggiunte due porte digitali di
I/O e due porte di ingresso analogiche.
Le porte analogiche possono essere usate per leggere potenziometri o
altri sensori analogici, mentre le porte di I/O digitali sono utilizzabili
per pilotare servomotori o interfacciarsi ad altri dispositivi digitali.
In questa versione viene adoperato il driver A4953 della Allegro
Microsystems; la tecnologia DMOS garantisce una minore produzione
di calore e di conseguenza una efficienza migliore.

20
Capitolo 2 Set up

Per garantire condizioni operative di sicurezza è possibile misurare la


corrente assorbita da ciascun motore; questo permette di evitare
condizioni di stallo. È inoltre presente un sensore digitale di
temperatura integrato con interfaccia I2C utile per monitorare la
temperatura della shield con lo scopo di prevenire il pericolo di
surriscaldamenti.
Infatti, quando il chip A4953 lavora ad alti valori di corrente può
diventare molto caldo e questo calore può attraversare tutta la scheda.
Per evitare pericolose condizioni di surriscaldamento si può utilizzare
il sensore digitale di temperatura montato sulla scheda vicino al chip
A4953. Questo permette di monitorare la temperatura tramite il bus I2C
utilizzando i pin SCL e SDA della scheda Arduino.
La logica della Dual DC Motor Shield è alimentata direttamente dalla
scheda Arduino, mentre le uscite motore possono essere alimentate dal
pin 𝑉5! della scheda Arduino o da una alimentazione esterna, anche se
si raccomanda vivamente di utilizzare un alimentatore esterno. Nel
nostro progetto abbiamo utilizzato un alimentatore esterno.
La selezione della sorgente di alimentazione è fatta tramite un jumper.
Inserendo il jumper nei due pin i motori saranno alimentati da 𝑉5! di
Arduino (vedi Fig.2.4), se invece viene rimosso i motori andranno
alimentati con sorgente esterna collegata alla morsettiera.

Fig.2.4 selezione della sorgente tramite jumper

21
Capitolo 2 Set up

Questa scheda comprende anche LED indicatori di direzione per


entrambi i canali che risultano utili durante le fasi di debug per
verificare il comportamento del firmware; i led sono attivi anche
quando non è presente alcun motore sulle uscite.

Questa shield ha due canali separati, chiamati A e B. Ciascun canale


usa due pin Arduino per pilotare il motore, più̀ un terzo eventuale per
monitorare la corrente assorbita dal motore. Potete usare in modo
indipendente ciascun canale per pilotare due motori DC o unirli per
pilotare un motore passo-passo.
I pin utilizzati, divisi per canale, sono mostrati nella seguente tabella

Canale A Canale B
Pin Arduino Funzione Pin Arduino Funzione
3 In1_1 6 In2_1
5 In1_2 9 In2_2
A0 Current sense A1 Current sense
Tab.2.1 pin e funzioni della shield

Per capire il significato di questi segnali ed il loro utilizzo facciamo


riferimento alla tabella successiva (Tab.2.2), dove sono riportate tutte
le condizioni. Si noti che sono riportate solo le condizioni per il canale
A in quanto quelle per il canale B sono le stesse, si deve solamente
sostituire In1_1 con In2_1 e In1_2 con In2_2.

22
Capitolo 2 Set up

In1_1 In1_2 Uscite M1+ e M1-


0 0 Alta impedenza (il motore è in rotazione libera)
0 1 La corrente scorre da M1+ a M1- (direzione 1)
1 0 La corrente scorre da M1- a M1+ (direzione 2)
1 1 Livello LOW per le uscite (freno motore)
Tab2.2 condizioni ingressi

La Dual DC Motor Shield V2 è in grado di misurare la corrente


assorbita da ciascun motore. La corrente del canale A può essere
misurata sul pin analogico A0 di Arduino mentre la corrente del canale
B è monitorata sul pin A1. Se non si desidera monitorare la corrente
oppure se si necessita di più̀ pin liberi su Arduino si può disabilitare la
funzione Current Sensing rimuovendo i due jumper sui connettori strip
SenA e SenB [5].

2.3 Arduino

Arduino è una scheda a microcontrollore. Un microcontrollore è un


piccolo computer: al suo interno trovano posto un microprocessore e
una serie di dispositivi «integrati» che funzionano da memoria e da
periferiche per permettergli di comunicare con il modo esterno.

Tra i vari modelli di Arduino, ci accingiamo a descrivere Arduino


UNO il quale è modello nel sistema in esame. Una scheda Arduino
UNO si presenta secondo la Fig.2.5

23
Capitolo 2 Set up

Fig.2.5 scheda Arduino UNO

Descriviamone i componenti principali

Connettore USB
Ha un duplice scopo, infatti, si usa per alimentare la scheda utilizzando
i cinque volt presenti nelle porte USB, ma si può utilizzare anche per
scambiare dati con Arduino.

Alimentazione
Su un angolo del circuito stampato si trova un piccolo barilotto di colore
nero. Si può inserire un jack per alimentare la scheda. La tensione
fornita sarà poi livellata a 5 volt da un regolatore di voltaggio.

GND
GND significa Ground, cioè «terra» o «massa». È il polo negativo di
alimentazione, anche chiamato il «comune» o «zero volt».

5V
Questo pin fornisce la tensione a cinque volt regolata e stabilizzata da
Arduino. Lo stabilizzatore interno può fornire fino a circa un ampere di
corrente.

Vin

24
Capitolo 2 Set up

Questo pin è collegato direttamente all’ingresso di alimentazione e si


può utilizzare per prelevare una tensione di alimentazione più elevata
necessaria per far funzionare componenti collegati ad Arduino. Si
potrebbero avere dei motori che funzionano a dodici volt: per utilizzarli,
si alimenterà Arduino a dodici volt attraverso la presa di alimentazione
e si porterà la tensione di dodici volt ai motori, prelevandola dal pin
Vin.

PIN 0-13
Arduino ha quattordici pin che possono essere configurati per
funzionare da ingressi o uscite. La configurazione si fa nel software.
Arduino è un dispositivo digitale, quindi i pin possono generare o
leggere un valore alto o basso, e quindi pari a zero o cinque volt. Un pin
digitale configurato come uscita non potrà mai fornire, per esempio, un
valore di 2,5 volt, ma unicamente zero o cinque volt. Alcuni pin
riportano accanto al numero identificativo una piccola «serpentina»
chiamata «tilde» (~): questi pin possono generare un segnale particolare
molto utile per pilotare motori elettrici o per regolare a piacere
l’intensità luminosa di un LED.

A0-A5
Arduino ha sei pin in grado di leggere livelli analogici e di convertirli
in un numero che si potrà utilizzare all’interno degli sketch. Questi
particolari ingressi sono posti a parte e contrassegnati dalle sigle: A0,
A1, A2, A3, A4, A5.

Software
Arduino non è solo hardware ma anche software. Per programmare la
scheda è sufficiente collegarla al proprio computer con un cavo USB,
quindi scrivere il programma, compilarlo e farlo eseguire. Il codice è

25
Capitolo 2 Set up

scritto in una sorta di C++ semplificato ed è chiamato sketch. È presente


anche un ambiente di sviluppo dedicato, cioè Arduino IDE [6].

2.4 Sensori

Abbiamo detto che i sensori utilizzati nel sistema studiato, sono i


sensori di traccia e a ultrasuoni. Analizziamo in modo specifico le loro
caratteristiche.

2.4.1 Sensore di traccia

Il sensore di traccia usato nel progetto è il modulo KY-033.

Fig.2.6 sensore KY-033

Analizziamone il funzionamento.
È composto da un comparatore di segnali, un potenziometro per
regolarne la sensibilità, e due fotodiodi: il primo fotodiodo è un
trasmettitore di raggi infrarossi, mentre il secondo è un ricevitore. Il
principio di funzionamento è basato sulla tendenza degli infrarossi ad
essere assorbiti dalle superfici scure: tale funzionamento consiste
nell’inviare un segnale dal trasmettitore e attenderne l’eventuale
ricezione sul ricevitore, in questo modo possiamo distinguere (a grandi

26
Capitolo 2 Set up

linee) il colore bianco della superficie, da quello nero. Se la ricezione


da parte del fotodiodo ricevitore è andata a buon fine, allora vuol dire
che l’infrarosso è stato riflesso su una superficie chiara,

Fig.2.7 superficie chiara

diversamente, dopo un brevissimo intervallo di tempo, si verifica un


time-out e ciò indica che il segnale non è stato ricevuto: in tal caso
siamo di fronte ad una superficie scura

Fig.2.8 superficie scura

I fotodiodi non sono gestiti direttamente da Arduino, ma da un


comparatore integrato nel modulo, il quale confronta la tensione
generata dal fotodiodo ricevitore con quella di riferimento. Il risultato
viene inviato sui pin del microcontrollore sotto forma di segnali TTL.
In base a tale confronto, l’uscita DO del sensore (Data Output, è l’uscita
che andrà collegata ad Arduino) sarà LOW oppure HIGH, ma può
anche essere letta come pin analogico, ottenendo un intervallo di

27
Capitolo 2 Set up

possibili valori compresi tra 0 e 1023. I valori di uscita (analogici e


digitali) sono riassunti nella seguente tabella [7]

Superficie Tipo di lettura Uscita


Nero Digitale High
Nero Analogico Maggiore di 500
Bianco Digitale Low
Bianco Analogico Minore di 500
Tab.2.3 uscite sensore di traccia

2.4.2 Sensore a ultrasuoni

Il sensore a ultrasuoni utilizzato nel sistema studiato è HC-SR04.

Fig.2.9 sensore HC-SR04

Analizziamone il funzionamento.
È composto da una scheda con tre integrati ed altri componenti. Il
modulo presenta quattro pin di connessione, e precisamente:
- Vcc: viene collegato alla tensione di alimentazione da 3 a 5.5V
- TRIG: è il pin Trigger che deve essere portato alto per inviare il
segnale a ultrasuoni
- ECHO: è il pin che produce un impulso quando viene ricevuto
il segnale riflesso dall’ostacolo
- GND: è il pin da collegare al ground.

28
Capitolo 2 Set up

Il sensore HC-SR04 non ci da direttamente la misura della distanza


dell’oggetto, ma lo si utilizza per emettere un treno di impulsi ad
ultrasuoni (ne saranno emessi 8 quando verrà portato per 10
microsecondi a stato alto il suo pin Trigger). Gli impulsi sonori saranno
propagati nell’ambiente circostante e, se incontrano uno ostacolo,
torneranno indietro verso il sensore che li ha emessi. Quando il sensore
“sentirà” il ritorno dell’impulso sonoro porterà a stato basso il suo pin
Echo (che nel frattempo era stato portato automaticamente alto).

Fig.2.10 comportamento di HC-SR04 in presenza di ostacolo

Misurando il tempo che intercorre tra l’emissione del segnale sonoro ed


il suo ritorno potremo calcolare la distanza dell’ostacolo sul quale è
rimbalzato. La velocità del suono è la velocità con cui un suono si
propaga in un certo ambiente, detto mezzo la quale varia a seconda del
mezzo. Il nostro mezzo è l’aria, nella quale la velocità del suono è di
0,03431 𝑚/𝜇𝑠 a 20 °C, temperatura nella quale normalmente
utilizziamo i sensori agli ultrasuoni.
Dato che lo spazio percorso è

𝑆𝑝𝑎𝑧𝑖𝑜 = 𝑉𝑒𝑙𝑜𝑐𝑖𝑡à ⋅ 𝑇𝑒𝑚𝑝𝑜

La nuova formula sarà

𝑆𝑝𝑎𝑧𝑖𝑜 [𝑐𝑚] = 0,03431 ⋅ 𝑇𝑒𝑚𝑝𝑜 [𝜇𝑠]

29
Capitolo 2 Set up

Dobbiamo però ricordarci che la distanza percorsa dal suono è doppia


rispetto alla distanza dell’ostacolo, in quanto l’impulso sonoro deve
andare verso l’ostacolo e tornare indietro, quindi anche il tempo
impiegato in totale è doppio. Quindi si ha

𝑆𝑝𝑎𝑧𝑖𝑜 [𝑐𝑚] = 0,017155 ⋅ 𝑇𝑒𝑚𝑝𝑜 [𝜇𝑠]

Un calcolo più immediato si può fare usando l’espressione

𝑇𝑒𝑚𝑝𝑜 [𝜇𝑠]
𝑆𝑝𝑎𝑧𝑖𝑜 [𝑐𝑚] =
58

Il sensore ha un campo di misura che si estende da 2 cm a 4 m, la


precisione arriva a 1 cm, l’ostacolo all’interno di un cono di 30° [8].

2.5 Attuatore

Si tratta, per definizione, di un sistema che crea e “attua” un moto,


attraverso un insieme di meccanismi in grado di trasformare un certo
tipo d’energia in una nuova forma. Nello specifico, l’energia elettrica
diventa movimento lineare. Gli attuatori lineari elettrici, infatti,
convertono il moto rotatorio di un motore in un movimento di tiro o
spinta, esercitando una forza su un singolo asse. Trovano largo impiego
nella movimentazione di carichi più o meno pesanti, e possono rivelarsi
idonei per numerose applicazioni industriali. Questi prodotti vengono
utilizzati praticamente in qualunque ambito sia possibile automatizzare
delle movimentazioni lineari. Ad esempio, senza questi dispositivi non
vi sarebbe la regolazione automatica di nastri trasportatori, deviatori,
robot mobili utilizzati nelle linee di produzione dell’industria pesante
piuttosto che del packaging, dell’automotive, della logistica fino alla
zootecnica [9].

30
Capitolo 2 Set up

Nel progetto, è stato utilizzato il servomotore della Lego, tecnologia


Mindstorm NXT 2

Fig.2.11 servomotore

Questo servomotore è ideale per applicazioni di carico inferiore, a


velocità maggiore e quando nel design del robot sono necessari tempi
di risposta più rapidi ed uno spazio occupato minore.
Caratteristiche:
- Contagiri con la precisione di un grado
- 240-250 giri/min
- Coppia motrice di 8 N/cm
- Coppia massima di 12 N/cm
- ID automatico incorporato nel software
Il motore è dotato di un contagiri con il quale si effettuano controlli con
la precisione di un grado ed ha un sensore di rotazione incorporato [10].

31
Capitolo 3 Studio: Caso studio

Capitolo 3 – Studio: Caso studio


Dopo aver presentato le componenti principali del sistema,
analizziamo nello specifico tutti i passi compiuti finalizzati al
funzionamento del sistema. Nello specifico ci concentreremo sul caso
studio di questo elaborato ovvero la vettura master. Analizzeremo lo
schema di controllo e i risultati ottenuti.

3.1 Costruzione della vettura

In primo luogo, ci siamo occupati di costruire passo passo l’oggetto


del nostro studio. Per farlo, abbiamo cercato di seguire più fedelmente
possibile le istruzioni di montaggio fornite dalla Lego. Di seguito
alcune immagini che descrivono l’evoluzione del montaggio

Fig.3.1(a) evoluzione del montaggio

32
Capitolo 3 Studio: Caso studio

Fig.3.1(b) evoluzione del montaggio

Fig.3.1(c) evoluzione del montaggio

La vettura finale, nella pratica, si presentava come in Fig.3.2

33
Capitolo 3 Studio: Caso studio

Fig.3.2 risultato finale

Notiamo sostanziali differenze. Le modifiche apportate sono dovute al


fatto che abbiamo utilizzato Arduino come microcontrollore e non il
blocco NXT come si vede in Fig.3.1(c). Al posto del blocco NXT è stata
montato una piastra su cui è fissato Arduino, la shield e una batteria da
5V come alimentazione aggiuntiva.

3.2 Controllo a catena aperta

Abbiamo detto che il controllo a catena aperta si basa su una


elaborazione degli ingressi eseguita senza conoscere il valore dell'uscita
del sistema controllato, essendo note alcune proprietà del sistema da
controllare [4]. In pratica, un sistema a catena aperta risponde solo agli
input forniti [1].
Nel nostro caso, implementare un controllo a catena aperta implica
programmare il microcontrollore in modo che comandi a entrambi i

34
Capitolo 3 Studio: Caso studio

servomotori di azionarsi. Cosa che è stata fatta caricando sulla scheda


lo sketch indicato nell’appendice come sketch 2.
In condizioni ideali, se i servomotori ruotano con la stessa velocità, la
vettura dovrebbe andare diritto e pertanto seguire perfettamente la linea
nera tracciata a terra. Le condizioni ideali implicano un perfetto
bilanciamento della vettura, una perfetta condizione del manto stradale
e totale assenza di disturbi esterni.
È chiaro che queste condizioni sono impossibili da ottenere, appunto
perché ideali. Infatti, la vettura aveva la tendenza a girare verso destra.
Era quindi necessario un controllo a catena chiusa che ci permette di
quantificare quanto la vettura andava fuori strada, ovvero quantificare
l’errore, per correggere la traiettoria con opportuni ingressi.

3.3 Controllo a catena chiusa

Abbiamo implementato due tipi controllo a catena chiusa. Il primo


implica l’utilizzo di un solo sensore di traccia, il secondo implica l’uso
di due sensori di traccia. Analizziamo entrambi i tipi di controlli e
vediamo perché il secondo si rivela più efficiente.

3.3.1 Singolo sensore

Lo sketch riguardante il controllo a catena chiusa con singolo


sensore è quello indicato nell’appendice con sketch 3.

La vettura master, abbiamo detto, ha il compito di seguire una traccia


nera a terra. Grazie al sensore, la vettura riconosce quando si trova sulla
linea nera o quando va fuori strada.
Dato che il sistema non si trova in condizioni ideali, notavamo che la
vettura tendeva ancora una volta a sterzare verso destra. In un primo

35
Capitolo 3 Studio: Caso studio

momento, quindi, la vettura riusciva a seguire la linea nera, ma dopo un


certo Δ𝑡 si trovava a destra della linea, qui interveniva il controllo
tramite sensore.
Non appena il sensore non riceve più una superficie scura ma chiara, il
microcontrollore comanda alla vettura di fermarsi e di ruotare su sé
stessa di 45° a sinistra per verificare la presenza della traccia. Si
possono verificare due scenari:
- Se il sensore ha rilevato una superficie scura allora il
microcontrollore comanda a entrambi i servomotori di
riprendere la marcia.
- Se il sensore ha rilevato una superficie chiara allora il
microcontrollore comanda ai servomotori di far ruotare la
vettura di 90° rispetto all’ultima posizione assunta dalla vettura.
Il microcontrollore permette la rotazione in quanto, dopo aver fermato
la vettura, tiene in quiete un servomotore e aziona l’altro. Se deve
ruotare a destra tiene in quiete il servomotore sinistro e aziona quello
destro, viceversa, se deve ruotare a sinistra tiene in quiete il
servomotore destro e aziona quello sinistro.

Quando la vettura andava troppo a destra rispetto alla traccia nera


allora il microcontrollore comandava alla vettura di ruotare di 45° a
sinistra. In questo caso, il sensore rilevava la traccia nera e quindi la
vettura riprendeva il moto.
Quando la vettura andava troppo a sinistra rispetto alla traccia nera, il
microcontrollore, così come nel 1° caso, comandava alla vettura di
ruotare di 45° a sinistra. Il sensore non rilevava una superficie scura e
quindi il microcontrollore faceva ruotare la vettura di 90°. A questo
punto il sensore era in grado di rilevare la traccia nera, pertanto, il
microcontrollore faceva sì che la vettura riprendesse il moto rettilineo.

36
Capitolo 3 Studio: Caso studio

Ci rendiamo conto, anche in senso sperimentale, che questo metodo è


poco prestante, infatti, ogni qualvolta la vettura andava fuori strada il
microcontrollore non sa prontamente secondo quale verso correggere
l’andamento. Il controllo diventa ancora peggiore quando la vettura va
troppo a sinistra della linea nera. Infatti, il microcontrollore fa ruotare
la vettura, alla ricerca della traccia nera, prima a sinistra e dopo a destra
mentre noi desideriamo che questa ruoti direttamente verso destra,
senza controllare a sinistra. Dato che è andata fuori strada verso sinistra
è chiaro che la vettura dovrebbe correggere il tiro sterzando
leggermente a destra. Questo è un limite che possiamo superare con
l’introduzione di un secondo sensore di traccia.

3.3.2 Doppio sensore

Lo sketch riguardante il controllo a catena chiusa con due sensori di


traccia lo si trova in appendice con il nome di sketch 4.

L’algoritmo consiste nella continua lettura dei sensori e nel far


variare lo stato dei rispettivi motori non appena non viene più rilevata
la traccia su almeno uno dei due sensori.
I sensori saranno posizionati all’interno della traccia, ai lati del robot,
ai limiti della pista. La regola è: finché entrambi i sensori rilevano una
superfice scura la vettura prosegue avanti, se uno dei sensori va fuori
pista allora la vettura ruota a destra o a sinistra fino a riottenere lo stato
precedente.
Quando uno dei due sensori rileva la superficie chiara si distinguono
due diversi tipi di gestione:
- se la superficie chiara è stata rilevata dal sensore sinistro: il
microcontrollore mantiene a velocità costante il servomotore

37
Capitolo 3 Studio: Caso studio

sinistro e diminuisce la velocità del servomotore destro. In


questo modo la vettura ruoterà verso destra rimettendosi in pista.
- se la superficie chiara è stata rilevata dal sensore destro: il
microcontrollore mantiene a velocità costante il servomotore
destro e diminuisce la velocità del servomotore sinistro. In
questo modo la vettura ruoterà verso sinistra rimettendosi in
pista.
Infine, si è imposta la condizione di stop nel momento in cui entrambi
i sensori rilevano una superficie chiara. Quando questo si verifica
significa che la pista è terminata e quindi la vettura si deve fermare.

38
Conclusioni

Conclusioni
Il contributo principale in questo lavoro è costituito dallo sviluppo
del codice per il controllo delle vetture e dei sensori. Le molteplici
prove eseguite sono state in grado di far emergere le potenzialità di un
kit di robotica di base come il Kit Mindstorm NXT e l’enorme potere
della piattaforma Arduino per il controllo dei sistemi robotici; ma hanno
anche fatto sì che ne emergessero i limiti.

Esistono già macchine capaci di fare in grande ciò che il nostro


sistema fa e che sono utilizzate in ambiti professionali, ovviamente con
un aumento dei costi di progettazione e complessità strutturale.

Questo elaborato ha posto solo le basi per un’analisi più


approfondita di sistemi di tal natura. Miglioramenti futuri potrebbero
essere: l’inclusione di più sensori, una migliore calibrazione e
posizionamento dei sensori, migliorie della risposta del sensore a livello
software, un più adeguato bilanciamento della vettura e infine la
realizzazione di una struttura per la vettura più resistente e adatta a
muoversi in ambienti più grandi.

39
Appendice

Appendice

Sketch 1 – Slave con sensore a ultrasuoni

#define trigPin 4
#define echoPin 2
#define pinAlimenta 8

long durata, cm;

#include <Servo.h>
Servo myServo;
int const potPin= A0;
int const p1=9;
int const p5=5;
int const p3=3;
int const p6=6;
int const p9=9;
int potVal;
int angle;

void setup(){
Serial.begin(9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(pinAlimenta, OUTPUT);
digitalWrite(pinAlimenta, HIGH);
pinMode(p1,OUTPUT);
pinMode(p5,OUTPUT);

40
Appendice

pinMode(p3,OUTPUT);
pinMode(p6,OUTPUT);
Serial.begin(9600);
}

void loop(){
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
durata = pulseIn(echoPin, HIGH);
cm = durata / 58;
Serial.print("Cm = ");
Serial.println(cm);
Serial.println();

//VELOCITÀ 1 se il master dista più di 20 cm


if(cm>=10){
//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,190); //più basso è più veloce
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,190);
}

//VELOCITÀ 2 se il master dista meno di 10 cm


if(cm<10 && cm>4){

41
Appendice

//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,210);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
}

//STOP se il master dista meno di 4cm


if(cm<4){
//MOTORE 1
digitalWrite(p5,LOW);
analogWrite(p3,0);
//MOTORE2
digitalWrite(p6,LOW);
analogWrite(p9,0);
}

Serial.println (cm, DEC);


}

42
Appendice

Sketch 2 – Master senza sensori

#include <Servo.h>

Servo myServo;

int const potPin= A0;


int const p1=9;
int const p5=5;
int const p3=3;
int const p6=6;
int const p9=9;
int potVal;
int angle;

void setup(){
Serial.begin(9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(pinAlimenta, OUTPUT);
digitalWrite(pinAlimenta, HIGH);
pinMode(p1,OUTPUT);
pinMode(p5,OUTPUT);
pinMode(p3,OUTPUT);
pinMode(p6,OUTPUT);
Serial.begin(9600);
}

43
Appendice

void loop(){
//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,200);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,200);
}

44
Appendice

Sketch 3 – Master con un solo sensore di traccia

#include <Servo.h>
Servo myServo;

int const potPin= A0;


int const p1=9;
int const p5=5;
int const p3=3;
int const p6=6;
int const p9=9;
int flag=1;
int iterazione=0;
int potVal;
int angle;
int Sensor = A5;
int sensorValue = 0;

void setup(){
pinMode(p1,OUTPUT);
pinMode(p5,OUTPUT);
pinMode(p3,OUTPUT);
pinMode(p6,OUTPUT);
Serial.begin(9600);
}

void loop() {
delay(1000);
sensorValue = analogRead (Sensor);

45
Appendice

//1° CONTROLLO

// vede linea nera


if(sensorValue > 500){
//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,210);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
iterazione=0;
}

//vede linea bianca


if(sensorValue < 50 && flag==1){
//MOVIMENTO A SINISTRA
//MOTORE 1 SINISTRA M1
digitalWrite(p5,HIGH); // ANTIORARIO
analogWrite(p3,240); // più lento
//MOTORE2 DESTRA M2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
delay(1000);
flag=0;
//stop
//MOTORE 1
digitalWrite(p5,LOW);
analogWrite(p3,0);

46
Appendice

//MOTORE2
digitalWrite(p6,LOW);
analogWrite(p9,0);
delay(2000);

iterazione++;
}

// 2° CONTROLLO

// vede linea nera


if(sensorValue > 500){
//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,210);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
iterazione=0;
}

//vede linea bianca


if(sensorValue < 50 && flag==0){
//MOVIMENTO A DESTRA
//MOTORE 1 SINISTRA M1
digitalWrite(p5,HIGH); // ANTIORARIO
analogWrite(p3,210);
//MOTORE2 DESTRA M2
digitalWrite(p6,HIGH);

47
Appendice

analogWrite(p9,255); //più lento


delay(1000);
flag=1;
//stop
//MOTORE 1
digitalWrite(p5,LOW);
analogWrite(p3,0);
//MOTORE2
digitalWrite(p6,LOW);
analogWrite(p9,0);
delay(2000);

iterazione++;
}

//se è andato troppo fuori strada

if(iterazione==6){
iterazione=0;

//1° CONTROLLO
// vede linea nera
if(sensorValue > 500){
//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,210);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,210);

48
Appendice

//vede linea bianca


if(sensorValue < 50 && flag==1){
//MOVIMENTO A SINISTRA
//MOTORE 1 SINISTRA M1
digitalWrite(p5,HIGH); // ANTIORARIO
analogWrite(p3,210); // più lento
//MOTORE2 DESTRA M2
digitalWrite(p6,HIGH);
analogWrite(p9,240);
delay(1000);
flag=0;

//stop
//MOTORE 1
digitalWrite(p5,LOW);
analogWrite(p3,0);
//MOTORE2
digitalWrite(p6,LOW);
analogWrite(p9,0);
delay(2000);
}

// 2° CONTROLLO
// vede linea nera
if(sensorValue > 500) {
//MOTORE 1
digitalWrite(p5,HIGH);

49
Appendice

analogWrite(p3,210);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
}

//vede linea bianca


if(sensorValue < 50 && flag==0){
//MOVIMENTO A DESTRA
//MOTORE 1 SINISTRA M1
digitalWrite(p5,HIGH); // ANTIORARIO
analogWrite(p3,255);
//MOTORE2 DESTRA M2
digitalWrite(p6,HIGH);
analogWrite(p9,210); //più lento
delay(1000);
flag=1;
//stop
//MOTORE 1
digitalWrite(p5,LOW);
analogWrite(p3,0);
//MOTORE2
digitalWrite(p6,LOW);
analogWrite(p9,0);
delay(2000);
}
}
}

50
Appendice

Sketch 4 – Master con doppio sensore di traccia

#include <Servo.h>
Servo myServo;
int const potPin= A0;
int const p1=9;
int const p5=5;
int const p3=3;
int const p6=6;
int const p9=9;
int potVal;
int angle;

int Sensor_dx = A5;


int sensorValue_dx ;
int Sensor_sx = A4;
int sensorValue_sx ;

void setup() {
pinMode(p1,OUTPUT);
pinMode(p5,OUTPUT);
pinMode(p3,OUTPUT);
pinMode(p6,OUTPUT);
Serial.begin(9600);
}

void loop() {

51
Appendice

sensorValue_dx = analogRead (Sensor_dx);


sensorValue_sx = analogRead (Sensor_sx);

//1° CONTROLLO
// entrambi i sensori vedono linea nera
if(sensorValue_dx > 500 && sensorValue_sx>500){
//MOTORE 1
digitalWrite(p5,HIGH);
analogWrite(p3,210);
//MOTORE2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
} //dritto

//sensore sinistra vede linea nera e il destro vede bianco


if(sensorValue_sx>500 && sensorValue_dx< 50){
//MOVIMENTO A SINISTRA
//MOTORE 1 SINISTRA M1
digitalWrite(p5,HIGH); // ANTIORARIO
analogWrite(p3,210);
//MOTORE2 DESTRA M2
digitalWrite(p6,HIGH);
analogWrite(p9,240); // più lento
}

//sensore destro vede linea nera e il sinistro vede bianco


if(sensorValue_dx>500 && sensorValue_sx< 50){
//MOVIMENTO A DESTRA
//MOTORE 1 SINISTRA M1

52
Appendice

digitalWrite(p5,HIGH); // ANTIORARIO
analogWrite(p3,240); // più lento
//MOTORE2 DESTRA M2
digitalWrite(p6,HIGH);
analogWrite(p9,210);
}

// vedono bianco entrambi


if(sensorValue_dx<50 && sensorValue_sx<50){
//STOP
//MOTORE 1 SINISTRA M1
digitalWrite(p5,LOW); // ORARIO
analogWrite(p3,0);
//MOTORE2 DESTRA M2
digitalWrite(p6,LOW);
analogWrite(p9,0);
}

Serial.println (sensorValue_sx, DEC);

53
Bibliografia

Bibliografia
[1] N. S. Nise, “Controlli automatici”, CittàStudi Edizioni

[2] S. Rinaldi, C. Piccardi, “I sistemi lineari – teoria, modelli,


applicazioni”, CittàStudi Edizioni

[3] Laboratorio Didattico Sperimentale, “Proprietà strutturali e leggi di


controllo”,
http://www.ladispe.polito.it/corsi/contrautoinf270/material/Raggiungi
b_controllab.pdf

[4] Wikipedia, “Controllo automatico”,


https://it.wikipedia.org/wiki/Controllo_automatico

[5] Microbot, “Dual DC Motor Shield V2”

[6] P. Aliverti, "Il manuale di Arduino", Edizioni LSWR, Milano, 2016

[7] Elettronica e Maker, “Inseguitori di linea e Arduino”,


https://elettronicaemaker.it/2019/06/21/inseguitori-di-linea-e-arduino/

[8] Makerslab.it, “Sensore di distanza ad ultrasuoni HC SR04 con


Arduino”, https://www.makerslab.it/sensore-di-distanza-ad-ultrasuoni-
hc-sr04-con-arduino/

[9] MecVel, “Cosa sono gli attuatori lineari elettrici?”,


https://www.mecvel.it/cose-un-attuatore-lineare-elettrico/

[10] Lego, “Servomotore medio EV3”, https://www.lego.com/it-


it/product/ev3-medium-servo-motor-45503

[11] Andrea Basile, “Controllo a catena aperta di un manipolatore


tramite rilevatore di colori” [tesi di laurea], Università degli Studi di
Catania, Dipartimento di Ingegneria Elettrica Elettronica e Informatica,
Corso di laurea in Ingegneria Elettronica

54

Potrebbero piacerti anche