UNIVERSITÀ DEGLI STUDI DI ROMA TOR VERGATA...

UNIVERSITÀ DEGLI STUDI DI ROMATOR VERGATA

FACOLTÀ DI INGEGNERIA

CORSO DI LAUREA IN INGEGNERIA INFORMATICA

A.A. 2014/2015

Tesi di Laurea

Realizzazione e Controllo di un pendolo inverso con carrello

RELATORE CANDIDATO

Ing. Daniele Carnevale Alessio Antenucci

CORRELATORI

Ing. Luca Boncagni

Indice

Ringraziamenti 1

Introduzione 2

1 Pendolo Inverso 4

1.1 Problema Generale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2 Modello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2.1 Carrello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2.2 Asta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.2.3 Equazioni del Moto . . . . . . . . . . . . . . . . . . . . . . . . 9

1.2.4 Equilibrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.2.5 Linearizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.2.6 Spazio di Stato . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.2.7 Funzione di Trasferimento . . . . . . . . . . . . . . . . . . . . 14

1.3 Identi�cazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3.1 Funzione di Attrito . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3.2 Modello del secondo ordine . . . . . . . . . . . . . . . . . . . . 16

1.3.3 Modello del terzo ordine . . . . . . . . . . . . . . . . . . . . . 18

2 Sistema di Controllo 20

INDICE I

INDICE

2.1 Analisi del Processo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.2 Primo controllore stabilizzante . . . . . . . . . . . . . . . . . . . . . . 21

2.2.1 Il problema del carrello . . . . . . . . . . . . . . . . . . . . . . 22

2.3 PID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4 Controllo Switching con Isteresi . . . . . . . . . . . . . . . . . . . . . 26

2.5 Risultati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3 Hardware Utilizzato 30

3.1 Raspberry pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.2 STM32f4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3 Sistema Fisico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.3.1 Ponte H . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.3.2 Motore DC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.3.3 Encoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.3.4 Stampante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.4 Collegamenti �sici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.4.1 Raspberry - Stm . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.4.2 Stm - Ponte H . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.4.3 Stm - Encoder . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

4 MARTe 46

4.1 Cos'è e come funziona? . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4.1.1 Comunicazione con Stm . . . . . . . . . . . . . . . . . . . . . 48

5 Come lanciare un esperimento 52

6 Conclusioni e sviluppi futuri 56

INDICE II

INDICE

Appendice A 58

Elenco delle �gure 79

Bibliogra�a 81

INDICE III

Ringraziamenti

Un ringraziamento sentito va al mio relatore, Daniele Carnevale, e al correlatore

Luca Boncagni, oltre che validi ingegneri ho conosciuto delle belle persone.

E poi: grazie alla famiglia sempre vicina, alla mamma che pensa sempre a tutto,

al papà che con poche parole ti dice tutto, al fratello che ti copre le spalle ed indica

la via. Un grazie alla ragazza che ti ricorda quali sono le cose importanti della vita,

agli amici che ti alzano dalla sedia dopo ore di studio e ai compagni di corso che

ti spingono a rimanerci. Grazie ai coinquilini che rendono la vita lontano da casa

semplice e divertente; grazie ai più stretti amici romani per le mangiate, giocate e

risate e a quelli storici di Isernia che ci sono sempre per le cose importanti. Grazie

alle persone su facebook che mettono 'mi piace' al primo video funzionante del pendolo

e a 'quelli del calcetto' e al 'gruppo magic' per ricordarti che ogni tanto puoi concederti

qualche vizio di gioventù. Grazie a tutti quelli che pensando alla mia laurea sono felici.

Introduzione 1

Introduzione

Il seguente lavoro di tesi parte con la scelta di un problema di controllo che viene stu-

diato applicando le conoscenze acquisite nei corsi legati all'ambito dell'Automatica ed

approfondite durante i mesi di lavoro. L'elaborato prevede una fase realizzativa, resa

possibile grazie a conoscenze del ramo informatico ed elettronico.

In particolare il punto di partenza di questo progetto è la modellizzazione di un

pendolo posto in equilibrio su un mezzo di locomozione, il così detto pendolo inverso,

al �ne di studiarne la problematica di controllo. Lo scopo del lavoro è la realizzazio-

ne del sistema in esame e la ricerca di un controllore lineare, che sappia mantenere

l'equilibrio del sistema dati ragionevoli condizioni iniziali e disturbi esterni. Tale ri-

cerca è stata convalidata da considerazioni teoriche, elaborazioni tramite Matlab e

simulazioni tramite Simulink; i risultati ottenuti sono stati applicati, in seguito ad

alcune misurazioni, al sistema �sico appositamente realizzato presso il Laboratorio di

Robotica Pesante dell'Università Tor Vergata.

L'e�ettiva novità del lavoro presentato è l'utilizzo di una tecnologia di espansio-

ne come la Raspberry Pi, munita dell'ambiente MARTe, in comunicazione con il

microcontrollore scelto per l'elaborazione del controllo.

Introduzione 2

Introduzione

La tesi è strutturata nel modo seguente:

1. Il capitolo uno illustra il processo di modellizzazione e linearizzazione del sistema

�sico, inclusa la rappresentazione di stato.

2. Nella seconda sezione si descrive il processo di sintesi del controllore, con simu-

lazione, e si mostrano i risultati ottenuti.

3. Nel terzo capitolo viene elencato l'hardware utilizzato per la realizzazione del

sistema �sico e del controllo.

4. Nel quarto si spiega in cosa consiste l'ambiente MARTe e l'implementazione dei

meccanismi di comunicazione tra Raspberry e Stm.

5. Nella sezione cinque si mostra la procedura per l'esecuzione di un esperimento.

6. Nell'ultima sezione si ricapitola il lavoro svolto e i risultati ottenuti.

7. Nell'appendice A si riporta il codice C e Matlab utilizzato.

Introduzione 3

Capitolo 1

Pendolo Inverso

Il sistema a pendolo inverso è un esempio che si trova comunementenei libri di testo sul controllo e nella letteratura di ricerca. La suapopolarità deriva in parte dal fatto che è instabile senza controllo epossiede una dinamica non lineare, ma soprattutto perchè ha diverseapplicazioni pratiche, come il controllo di un razzo al decollo o diun segway.

1.1 Problema Generale

Un pendolo semplice è costituito da un �lo inestendibile, a cui è �ssato inferiormente

un punto materiale di massa, il quale può oscillare attorno ad un punto �sso che

prende il nome di polo. In questo sistema, la componente della forza peso lungo il

�lo controbilancia la tensione del �lo stesso mentre la componente della forza peso

perpendicolare al �lo funge da forza di richiamo e produce il moto oscillatorio del

pendolo. Il pendolo inverso rappresenta un pendolo semplice rovesciato , rigido e

privo di polo: la parte inferiore può dunque muoversi per bilanciare le oscillazioni

di quella superiore in modo da garantire l'equilibrio. Nel nostro caso, il sistema da

analizzare è costituito da un pendolo inverso montato su un carrello motorizzato.

L'obiettivo del sistema di controllo è di bilanciare il pendolo inverso applicando una

coppia alle ruote del carrello cui il pendolo è collegato. L'ingresso di controllo è la

4

Cap. 1 Pendolo Inverso �1.2 Modello

Figura 1.1: Schematizzazione del robot.

forza che muove il carrello orizzontalmente mentre l'uscita è la posizione angolare del

pendolo. In particolare, si è considerato un problema bidimensionale in cui il pendolo

è impossibilitato a muoversi nel piano verticale (come mostrato nella schematizzazione

in �gura 1.1).

1.2 Modello

Al �ne di determinare il modello è necessario analizzare le forze che agiscono sul

pendolo inverso; per maggiore chiarezza espositiva, lo studio delle equazioni del moto

è stato suddiviso nelle due parti che compongono il sistema.

• (M) massa del carrello

• (m) massa del pendolo

• (b) coe�ciente di attrito del carrello

• (l) lunghezza �no al centro di massa del pendolo

• (I) momento di inerzia del pendolo

5


Figura 1.2: Schematizzazione del sista completo (da Matlab Tutorial).

• (F) forza motrice applicata al carrello

• (θ) angolo del pendolo dalla verticale

• (x) coordinata di posizione del carrello

Figura 1.3: Bilancio forze sistema completo (da Matlab Tutorial).

In prima analisi, è possibile notare dalla �gura 1.3 come la forza verticale che

interessa la parte inferiore, ovvero il peso del carrello stesso, venga controbilanciata

dalla reazione vincolare del terreno. Per questo motivo, nella prima sezione verrà

tralasciato lo studio delle forze verticali.

6


1.2.1 Carrello

La parte inferiore del pendolo inverso può essere rappresentato da ruote e piano di

appoggio per i componenti.

Figura 1.4: Bilancio forze carrello .

Analizzando la �gura 1.4, lo studio delle forze ortogonali del diagramma del corpo

libero del carrello, produce l'equazione 1.2.1:

F = Mx+ bx+N (1.2.1)

In cui:

• (N) forza di interazione con l'asta

• (P) forza di interazione con l'asta

• (bx) attrito

• (g) forza di gravità

7


1.2.2 Asta

Il bilancio delle forze orizzontali nel diagramma del corpo libero della parte superiore

del sistema meccanico, ci porta a scrivere l'equazione 1.2.2:

N = mx+mlθ cos θ −mlθ2 sin θ (1.2.2)

Figura 1.5: Bilancio forze pendolo.

Come rappresentato in �gura 1.5, dove:

• (mx) forza accelerazione robot

• (lθ cos θ) forza accelerazione angolare

• (lθ2 sin θ) attrito

Analizzando invece l'equilibrio verticale dell'asta, si ottiene:

8


P −mg = mδl cos θ

δt2=

= −mlθ2 cos θ −mlθ sin θ ⇒

P sin θ −mg sin θ = −mlθ2 cos θ sin θ −mlθ sin2 θ

(1.2.3)

1.2.3 Equazioni del Moto

Per trovare la prima equazione del moto si sfruttano le due equazioni sul bilancio delle

forze orizzontali, ottenute nelle sezioni 1.2.1 e 1.2.2, sostituendo la 1.2.2 nella 1.2.1,

si giunge a:

(M +m)x+ bx+mlθ cos θ −mlθ2 sin θ = F (1.2.4)

Per la seconda, è necessario partire dall'equazione sull'equilibrio dei momenti:

−Pl sin θ −Nl cos θ = Iθ (1.2.5)

Dove I è il momento di inerzia rispetto al baricentro del pendolo.

Mettendo dunque in evidenza P dall'equazione 1.2.3 e sostituendolo nella 1.2.5, si

ottiene:

Iθ = l sin θ(mg −mlθ2 cos θ −mlθ sin θ)− l cos θ(mx−mlθ2 sin θ −mlθ cos θ)⇒

θ =mgl sin θ −mlx cos θ

I +ml2

(1.2.6)

Il sistema composto dalle equazioni 1.2.4 e 1.2.6 trovate, porta all'identi�cazione

delle quattro variabili di stato del sistema. sostituendo infatti l'equazione 1.2.6 trovata

nella 1.2.4, si ottiene:

9


F = (M +m)(x) + bx+m2l2 cos θ

I +ml2(g sin θ − x cos θ)−mlθ2 sin θ (1.2.7)

Dalla quale mettendo in evidenza x:

x =F +mlθ2 sin θ − bx− m2l2g cos θ sin θ

I+ml2

(I+ml2)(M+m)−m2l2 cos2 θI+ml2

⇒

=x(−bI −ml2b) + θ2(ml sin θI +m2l3 sin θ)− F (I +ml2)−m2l2 cos θg sin θ

(I +ml2)(M +m)−m2l2 cos2 θ(1.2.8)

In ultimo, sostituendo tale valore nella 1.2.7:

θ =mgl sin θ −ml cos θ x(−bI−ml2b)+θ2(ml sin θI+m2l3 sin θ)−F (I+ml2)−m2l2 cos θg sin θ

(I+ml2)(M+m)−m2l2 cos2 θ

I +ml2=

=x(−bI −ml2b) + θ2(ml sin θI +m2l3 sin θ)

((I +ml2)(M +m)−m2l2 cos2 θ)(I +ml2)−

− F (I +ml2) + sin θ(mglMI +m2gl3M + Im2gl +m3gl2 −m3gl2 cos2 θ −m2l2 cos θg)

((I +ml2)(M +m)−m2l2 cos2 θ)(I +ml2)(1.2.9)

A questo punto possiamo scrivere il sistema:{x = x(−bI−ml2b)+θ2(ml sin θI+m2l3 sin θ)−F (I+ml2)−m2l2 cos θg sin θ

(I+ml2)(M+m)−m2l2 cos2 θ

θ = x(−bI−ml2b)+θ2(ml sin θI+m2l3 sin θ)−F (I+ml2)+sin θ(mglMI+m2gl3M+Im2gl+m3gl2−m3gl2 cos2 θ−m2l2 cos θg)((I+ml2)(M+m)−m2l2 cos2 θ)(I+ml2)

(1.2.10)

Il sistema dunque è del quarto ordine e presenta quattro variabili di stato: la

posizione x e la velocità x del carrello, la posizione e θ la velocità angolare θ del

pendolo.

Osservazione 1.2.1 Sempli�cazione: Le relazioni trovate posso essere sempli�cate

qualora il momento di inerzia risulti trascurabile. In tal caso, l'equazione 1.2.6 assume

la forma:

10


ml2θ = mgl sin θ −mlx cos θ ⇒

θ =1

l(g sin θ − x cos θ)

(1.2.11)

In questo modo, sostituendo sempre tale equazione nella 1.2.4 si ottiene una forma

sempli�cata dell' accelerazione:

(M +m)x+m cos θ(g sin θ − lx cos θ) = mlθ2 sin θ + F − bx⇒

x =mlθ2 sin θ −mg sin θ cos θ + F − bx

M +m sin2 θ(1.2.12)

E lo stesso vale per quella angolare:

θ =1

l(g sin θ − cos θ

mlθ2 sin θ cos θ + F − bxM +m sin2 θ

) =

=Mg sin θ −mg sin θ(sin2 θ + cos2 θ)−mlθ2 sin θ cos θ − F cos θ + bx cos θ

l(M +m sin2 θ=

=(M +m)g sin θ −mlθ2 sin θ cos θ − F cos θ + bx cos θ

l(M +m sin2 θ)(1.2.13)

�X

1.2.4 Equilibrio

In accordo con una prima analisi intuitiva, è possibile notare che il sistema pre-

senta due punti di equilibrio. Infatti esistono due valori xe1 e xe2 del vettore di

stato x =

xxθ

θ

e un valore u dell'ingresso F per cui x = 0 e xe1 =

x1 ∈ R

000

e

xe2 = ∆(x2, u) =

x1 ∈ R

0π0

.

11


In corrispondenza di una F = u = 0, il primo insieme è di equilibrio stabile e si

ha per xe1 =

x1 ∈ R

000

, mentre il secondo xe2 =

x1 ∈ R

0π0

risulta instabile. Proprio

quest'ultimo è l'insieme di equilibrio di nostro interesse.

Da uno studio più approfondito delle equazioni di�erenziali che descrivono il sistema,

non preso in considerazione in questa trattazione, si può dimostrare che questi due

sono anche gli unici stati do equilibrio del sistema.

1.2.5 Linearizzazione

Assumendo che il sistema rimanga vicino punto di equilibrio instabile xe2 trovato nella

sezione 1.2.4, ovvero che le oscillazioni del pendolo rimangono con�nate in un intorno

di θ = π, è possibile procedere alla linerazizzazione del sistema.

De�nizione 1.2.1 Sia φ deviazione della posizione angolare del pendolo dal punto

di equilibrio. ♣

Allora θ = π + φ, con:

• cos θ = cos(π + φ) ≈ −1

• sin θ = sin(π + φ) ≈ −φ

• θ2 = φ2 ≈ 0

Applicando tali approssimazioni, le equazioni linearizzate del moto diventano:

mlx = (I +ml)φ−mglφ

u = (M +m)x+ bx−mlφ(1.2.14)

12


Osservazione 1.2.2 Oscillazioni attorno al punto di equilibrio La linearizzazione

attorno a x2 è valida solo per |φ| < 20. Tale valore è presente in letteratura ed è

frutto di prove empiriche. �X

Il sistema 1.2.10 assume dunque la seguente forma sempli�cata:

{x = x(−bI−ml2b)+−F (I+ml2)−φm2l2g

(I(M+m)+Mml2

φ = x(−mlb)+F (ml)+φ(mgl(M+m))(I(M+m)+Mml2

(1.2.15)

1.2.6 Spazio di Stato

Riarrangiando opportunamente le due equazioni sistema 1.2.15 in una serie di equa-

zioni di�erenziali del primo ordine, e posto in cui x1 = x, x2 = x, x3 = φ e x4 = φ, si

può ottenere la relazione matriciale:

x = Ax+BF

x1

x2

x3

x4

=

0 1 0 0

0 − (I+ml2)bI(M+m)+Mml2

m2gl2

I(M+m)+Mml20

0 0 0 1

0 − mlbI(M+m)+Mml2

mgl(M+m)I(M+m)+Mml2

0

x1

x2

x3

x4

+

0

I+ml2

I(M+m)+Mml2

0ml

I(M+m)+Mml2

uy = Cx+Du

[y1

y2

]=

[1 0 0 00 0 1 0

]x1

x2

x3

x4

+

[00

]u

Dove y1 e l'uscita relativa alla posizione angolare del pendolo e y2 è la posizione del

carrello.

13


1.2.7 Funzione di Trasferimento

Passiamo ora al dominio di Laplace con l'accortezza di considerare nulle le condizioni

iniziali. Applicando le regole di trasformazione, il sistema 1.2.14 diventa:

mlX(s) = (I +ml)Φ(s)s2 −mglΦ(s)

U(s) = (M +m)X(s)s2 + bX(s)s−mlΦ(s)s2(1.2.16)

Al �ne di ottenere un'equazione che leghi la U(s) (ovvero l'ingresso del nostro

sistema) alla Φ(s) (uscita), bisogna eliminare X(s). Quindi dalla prima equazione:

X(s) = Φ(s)

[I +ml2

ml− g

s2

](1.2.17)

E sostituendo nella seconda:

U(s) = (M +m)

[I +ml2

ml− g

s2]Φ(s)s2 + b[

I +ml2

ml− g

s2

]Φ(s)−mlΦ(s)s2 (1.2.18)

Essendo, per de�nizione, funzione di trasferimento la relazione che lega ingresso e

uscita nel seguente modo:

Pp(s) =Φ(s)

U(s)=

=

mlqs2

s4 + b(I+ml2)q

s3 − (M+m)mglq

s2 − bmglqs

(1.2.19)

con q = [(M +m)(I +ml2)−m2l2].

Mediante calcoli analoghi, si ottiene la funzione di trasferimento del carrello:

14

Cap. 1 Pendolo Inverso �1.3 Identi�cazione

Pc(s) =X(s)

U(s)=

=

(I+ml2)s2−gmlq

s4 + b(I+ml2)q

s3 − (M+m)mglq

s2 − bmglqs

(1.2.20)

1.3 Identi�cazione

Un mera sostituzione dei parametri �sici reali nel modello può essere solo il punto di

partenza per una precisa realizzazione del modello reale. Il processo di identi�cazione

dei parametri è stato applicato per due volte in maniera tale da individuare, nel primo

caso, un iniziale processo sempli�cato del carrello e il valore di attrito dinamico del

carrello, mentre nel secondo, per identi�care l'intero sistema composto da carrello più

pendolo.

1.3.1 Funzione di Attrito

Figura 1.6: Funzione di Attrito.

L'andamento dinamico dell'attrito coulombiano è stato modellizzato come un fun-

zione Attr(x) dipendente dalla velocità di spostamento del carrello, in accordo con la

de�nizione di fattore di attrito tra corpi solidi data da Coulomb:

15


• dipende dalla natura dei materiali che si toccano e dallo stato delle super�ci a

contatto;

• non dipende dalle forze normali, né dall'estensione del contatto, né dalla forma

delle super�ci coniugate;

• non dipende dalla velocità relativa di strisciamento.

Attr(x) = (cd + c∆se−τcx2) sign(x) (1.3.1)

In cui cd rappresenta il coe�ciente di attrito dinamico, cs quello statico e c∆s la

loro di�erenza. τc è un parametro che incide sulla pendenza dell'esponenziale mentre

il sign(x) limita la funzione al semipiano positivo.

1.3.2 Modello del secondo ordine

Posto x1 = x e x2 = x, il modello del secondo ordine utilizzato è nella sua forma più

comune:

{x1 = x

x2 = −c(x) + τlineare(1.3.2)

Che, trasportato nello spazio di stato, da luogo alla seguente espressione matriciale:[x1

x2

]=

[0 10 cd

] [x1

x2

]+

[0b

]u

tenendo conto della coerente approssimazione:

c∆s ≈ bumin

in cui umin rappresenta il PWM necessario a superare l'attrito di primo distacco.

De�nita la funzione del modello ed e�ettuate le prove sperimentali sull'hardware,

16


è possibile lanciare il metodo pem, come mostrato nell'apposita sezione codici. Lo

scopo di questa identi�cazione è ricavare un modello dinamico del carrello il più fedele

possibile alla realtà in modo da riuscire a tenere in equilibrio l'asta, considerata per

il momento solo come un disturbo al sistema.

Impostando i seguenti parametri: dimensione delle grandezze in gioco, condizioni

iniziali, solutore e tolleranza del metodo pem si è riusciti ad arrivare ad un �tting

molto elevato, con valori oscillanti tra l'80 e il 93 % a seconda dei segnali di ingresso

e quindi degli esperimenti analizzati. Si sono infatti considerati input per quattro

valori di�erenti di gradini e rampe, quattro sinusoidi a velocità positiva di�erenti per

frequenza ed ampiezza e tre segnali misti, composizione dei precedenti elencati; in

totale un pool di 14 esperimenti. Di seguito viene riportato il caso di un riferimento

a rampa.

Figura 1.7: Fitting tra modello ed esperimento per ingresso a rampa.

La funzione di trasferimento, discretizzata, risultate è:

Ppend = 10−6 ∗ 1.55z + 1.514

z2 − 1.925z + 0.9252(1.3.3)

Dall'identi�cazione del modello del secondo ordine, inoltre, è stato possibile rica-

vare i parametri cd e b utili a calcolare i coe�cienti di attrito dell funzione . Questo

17


è l'andamento dell'attrito coulombiano presente sul sistema meccanico realizzato:

Figura 1.8: Funzione di attrito identi�cata.

1.3.3 Modello del terzo ordine

Al �ne di individuare i parametri del modello maggiormente attendibili, si è optato

per una procedura di identi�cazione in grado di agire direttamente sulla funzione di

trasferimento ricavata dalle equazioni di bilancio portate nel dominio di Laplace. Un

metodo alternativo sarebbe stato quello di continuare a lavorare nello spazio di sta-

to ed utilizzare come condizioni iniziali del processo i valori di attrito ricavati nella

precedente identi�cazione e i valori ottenuti sostituendo al modello teorico i valori

dell'hardware in esame. Tuttavia questo secondo metodo ha portato ad un �tting

minore, quindi è stato scartato. Per questo di�erente utilizzo del metodo pem biso-

gna impostare i seguenti parametri: grado nel numeratore, grado del denominatore,

tolleranza, ritardo in campioni e numero massimo di iterazioni. Si sono provati anche

ad utilizzare come algoritmi di identi�cazione arx e armax ma in entrambi i casi gli

esiti sono risultati peggiori.

18


Come ingresso alla procedura è stato dato il contributo di un primo controllore

associato al modello del secondo ordine, in maniera tale da ottenere un esperimento

su�cientemente esteso nel tempo e ricco di dati da permettere un' identi�cazione più

accurata. Le caratteristiche di questo primo sistema di controllo vengono spiegate in

dettaglio nella sezione 2.2.

Figura 1.9: Fitting tra modello ed esperimento completo.

Come si può notare dalla �gura 1.9, il �tting tra dati sperimentali e simulazione

è circa del 44 %, un risultato non di poco conto considerando la dinamica estre-

mamente rapida descritta dalle oscillazioni del pendolo attorno alla sua posizione di

equilibrio instabile. Discretizzata, la funzione di trasferimento ingresso uscita del

pendolo inverso completo risultante è dunque:

Ppend(z) =−0.002068z + 0.002084

z3 − 1.138z2 − 0.3517z + 0.5503(1.3.4)

19

Capitolo 2

Sistema di Controllo

In questa sezione si descriveranno le tecniche di controllo adottate per soddisfare i

requisiti di stabilità e robustezza.

2.1 Analisi del Processo

Analizzando l'equazione 1.3.3, si conclude che il sistema di partenza (coerentemente

con la natura del problema) risulta instabile, come si può notare dal luogo delle radici

e dalla risposta al gradino.

Da notare la vicinanza dei poli con la circonferenza di raggio unitario.

Figura 2.1: Luogo delle radici e Risposta al gradino per Ppend.

20

Cap. 2 Sistema di Controllo �2.2 Primo controllore stabilizzante

2.2 Primo controllore stabilizzante

Come detto precedentemente, il processo descritto dalla 1.3.3 è instabile. Tutta-

via, si può notare, osservando il luogo delle radici che è su�ciente scegliere un K

proporzionale tale da spostare tutti i poli all'interno della regione di stabilità.

L1 = KpPpend

e, per un Kp = 3, si ottiene un risultato soddisfacente in termini di stabilità e

robustezza:

Figura 2.2: Risposta al gradino e Diagramma di Bode per L1.

Margine di guadagno e di fase hanno rispettivamente valori di: 74.8 dB e 88.7

gradi.

In aggiunta, dallo studio dell'attrito e�ettuato, si è potuto implementare un blocco di

controllo tale da elidere l'azione non lineare dell'attrito.

Il sistema di controllo risultante è il seguente:

21


Figura 2.3: Sistema di controllo stabilizzante.

In cui, tenendo conto dell'equazione 1.3.2:

EstimatedAttr = bumine−τcx2

Provando questo controllore sul sistema �sico, esso risulta funzionale allo scopo. Si

vuole infatti ricordare che il �ne di questo primo sistema di controllo è quello di

permettere l'esecuzione di un esperimento valido per la seconda fase di identi�cazione.

In quest'ottica il pendolo viene visto come un disturbo al sistema, in quanto la sua

dinamica non è incorporata nel modello proposto.

2.2.1 Il problema del carrello

Per perseguire gli obbiettivi proposti per il lavoro di tesi, ovvero la stabilizzazione del

pendolo nell'intorno del suo punto di equilibrio instabile, si è dovuto rispondere ad

una domanda di intuitiva esistenza: lo spazio a disposizione del carrello è su�ciente

a permettere a quest'ultimo di portare in equilibrio il pendolo?

Le prove e�ettuate con il primo sistema di controllo mostrano come l'inseguimento

di un riferimento costante porti a rispondere in maniera negativa a questa domanda

(infatti il carrello, nel tentativo di mantenere l'asta dritta, urta contro i �ne corsa).

La soluzione adottata consiste del dare come riferimento al sistema una funzione

Rif(x) in cui x è posizione del carrello. In questo modo, la legge di controllo spingerà

22


il carrello ad accentrarsi lungo la guida agendo in maniera più repentina qualora

dovesse avvicinarsi ai �ne corsa (poichè l'errore ivi aumenta).

Figura 2.4: Andamento del riferimento.

Le curve agiscono nell'intervallo di x che de�nisce la capacità di movimento del

carrello (ovvero a 1500 passi encoder dal centro vi sono i �necorsa della struttura).

Le due funzioni gra�cate sono solo alcune delle tante vagliate; come si può notare

agiscono tutto nello stesso range di posizione di carrello e pendolo ma di�eriscono

per la loro dinamica. Prove sperimentali hanno portato a scegliere una cubica con i

seguenti parametri:

Rif(x) = (x

580)3 − 4097 (2.2.1)

Una soluzione di�erente, e probabilmente maggiormente interessante dal punto di

vista del controllo sarebbe stata quella di aggiungere una seconda uscita al sistema,

ovvero la posizione del carrello, e tentare di controllare anch'essa.

23

Cap. 2 Sistema di Controllo �2.3 PID

2.3 PID

Completata la fase di modellizzazione si arriva all'equazione 1.3.4 che descrive la

funzione di trasferimento del sistema in analisi. Nella �gura 2.3 è mostrato il suo

luogo delle radici e il diagramma di bode; come si può notare il sistema è stabile,

come indotto dalla precedente fase di controllo. La �gura accanto, invece, denota

la presenza di un errore a regime non nullo, ed in particolar modo costante per un

ingresso a gradino, mentre in basso l'andamento della sensitività del controllo.

Figura 2.5: Luogo delle radici, Diagramma di Bode e Risposta al gradino.

Per la realizzazione di un compensatore per sistema descritto si è optato per una

sintesi per tentativi. Al �ne di garantire robustezza a fronte di incertezze sul modello

(si ricorda che il modello trovato ha un �tting del 44% con i dati sperimentali) è stato

preso in considerazione un controllore tipo PID.

PID(e) = KP e+KI

∫e(t) dt+KD

de

dt(2.3.1)

Vista l'impossibilità teorica di realizzare un derivatore puro, si utilizza una derivata

ingegneristica, che approssima il derivatore �no ad una certa frequenza. Ciò risulta

24

Cap. 2 Sistema di Controllo �2.3 PID

nella formula complessiva (nel dominio della frequenza):

PID(s) = KP (τIs+ 1

TIs)(τDs+ 1

ατDs+ 1) (2.3.2)

in cui α è un valore adimensionale piccolo, tipicamente compreso tra 0.05 e 0.2,

mentre le costanti di tempo τI e τD sono tali per cui:

• KI = KP

τI

• KD = KP τD

La taratura di questi parametri è stata e�ettuata manualmente, eseguendo prove

sul modello �sico. Tuttavia è parso chiaro �n da subito come al variare dell'entità

dell'errore le esigenze del controllore fossero di�erenti, in particolar modo nel caso di

un carrello di lunghezza limitata come quello adoperato. Nel caso speci�co l'utilizzo

di un elevato guadagno integrale sin da subito mandava in oscillazione il sistema,

mentre risultava indispensabile qualora l'errore divenisse eccessivo in maniera tale da

riuscire a compensarlo portandolo a zero.

Invece che trovare un valor medio tra i due parametri, si è optato per l'utilizzo di una

tecnica di controllo più so�sticata.

In questa analisi si è deciso di non prendere in considerazione il termine derivativo,

sebbene una sua congrua aggiunta può migliorare le prestazioni del sistema di con-

trollo in termini di oscillazioni. Si vuole sottolineare che il termine derivativo è stato

implementato tramite pseudo-derivata: si ha inoltre la possibilità di de�nire la gran-

dezza della �nestra di interesse (quindi il numero di passi di campionamento) sulla

quale e�ettuare il calcolo.

25

Cap. 2 Sistema di Controllo �2.4 Controllo Switching con Isteresi

2.4 Controllo Switching con Isteresi

L'idea che è alla base di un controllo commutativo è l'utilizzo di due o più regolatori

inseriti in un sistema di controllo in grado di passare da uno all'altro a seconda del

veri�carsi o meno di alcune condizioni.

In un controllo di tipo switching con isteresi, le commutazioni non avvengono per

lo stesso valore di soglia ma per valori su�cientemente diversi per scongiurare il

fenomeno dello chattering. A causa di tale fenomeno, in presenza di rumore anche

lieve, si possono avere commutazioni indesiderate tra le due uscite e l'attivazione e

disattivazione dei diversi controllori può mandare in oscillazione il sistema.

Nel nostro caso le variabili decisionali utili nella scelta di uno dei due controllori

utilizzati, sono state: il valore dell'errore e la sua derivata e.

Figura 2.6: Limiti per il controllo switching con isteresi

26


Per valori di e ed e tali da rimanere nella zona rossa, ovvero in corrispondenza

di una posizione del pendolo prossima all'equilibrio, agisce il primo controllore; all'e-

sterno della zona arancione (zona bianca), invece, agisce il secondo; mentre in quella

centrale può attivarsi l'uno a l'altro a seconda se precedentemente fosse in azione C1

o C2. In particolar modo se al passo precedente fosse attivo C1 (quindi provengo dalla

zona interna), i valori di soglia per C2 sono eest e eest; mentre se è attivo C2, C1 si

attiverà per valori eint e eint.

Nella �gura 2.4 le aree di interesse per i due controllori sono state rappresentate come

quadrati, ma in realtà i valori di soglia saranno generalmente di�erenti l'uno dall'al-

tro. Non a caso, prove sperimentali hanno portato ad risultati più che soddisfacenti

utilizzando i valori:

• eest = 12

• eint = 10

• ˙eest = 600

• ˙eint = 400

Per quanto concerne i due regolatori utilizzati si è optato per un semplice guada-

gno statico per C1 e di un PI per C2. In entrambi i casi, oltre ad una saturazione è

stata aggiunta una deadzone sul contributo proporzionale in modo da ignorare errori

sui passi encoder di lieve entità e quindi diminuire le oscillazioni del sistema indotte

da piccoli errori di misura e piccoli discostamenti. In alternativa si sarebbe potuto

aggiungere un'azione derivativa tale da produrre lo stesso e�etto.

Il PI è stato implementato mediante un contributo integrale variabile nel tempo, otti-

mizzato per minimizzare l'errore: la logica è quella di optare per il minimo valore tra

la variazione massima che soddisfa i limiti derivativi e di ampiezza e il valore ottenuto

con il KI statico inserito. E' possibile trovare il codice corrispondente nell'appendice

A. Per i valori ricercati, C2 ha funzione di trasferimento:

27


C2(s) = PI(s) =2.276s+ 190

s(2.4.1)

Il sistema di controllo complessivo risultate ha la seguente forma:

Figura 2.7: Sistema di controllo completo

in cui, il blocchetto che descrive il PID è così fatto:

Figura 2.8: PID

Il contenuto dei vari blocchi è possibile visionarlo nel codice matlab dell'appendice

A.

28

Cap. 2 Sistema di Controllo �2.5 Risultati

2.5 Risultati

I risultati ottenuti tramite il sistema di controllo descritto in �gura 2.4 sono più che

soddisfacenti.

Si riportano i risultati di un singolo esperimento, non soggetto a disturbi esterni e di

una durata �ssata di 24.075 secondi.

Come si nota dalla �gura 2.9, il sistema prende ad oscillare attorno al suo punto di

equilibrio instabile non appena il controllo viene attivato (secondo 25.925).

Figura 2.9: Andamento dell'uscita del sistema e della variabile di controllo

Indagando la funzione di sensitività del controllo, si può vedere, dall'immagine ac-

canto, come l'uscita del controllore non vada a saturare la capacità dell'attuatore. Ciò

ha una importanza rilevante nell'analisi della stabilità assoluta del sistema, necessaria

qualora dovesse aggiungersi la non linearità portata dalla saturazione.

29

Capitolo 3

Hardware Utilizzato

In questo capitolo verranno presi in singola analisi tutti i compo-nenti hardware necessari alla riuscita dell'esperienza in analisi al�ne di una maggiore comprensione della loro interconnessione e delrisultato �nale.

3.1 Raspberry pi

Il Raspberry Pi è un single-board computer sviluppato dalla Raspberry Pi Foundation

in Ingliterra e presentato al pubblico ad inizio 2012. E' un dispositivo economico

dotato di elementi hardware tali da garantire il funzionamento di un sistema operativo

Linux (anche in modalità gra�ca) e un'interazione user friendly con l'utente.

Figura 3.1: Raspberry Pi 2.0.

30

Cap. 3 Hardware Utilizzato �3.2 STM32f4

Nella fase iniziale del lavoro di tesi si è dovuto rendere tale mini computer funzio-

nante e quindi munirlo di un sistema operativo. Accedendo al sito u�ciale è possibile

scaricare gratuitamente Raspbian, ovvero una versione di linux ottimizzata per il di-

spositivo, e trovare diverse guide su come formattare la micro SD sulla quale andrà

creata l'immagine del sistema operativo.

Il passo successivo è stato quello di annidare sul sistema operativo l'ambiente

MARTe, ampiamente illustrato nel capitolo 4.

3.2 STM32f4

STM32 è una famiglia di circuiti integrati microcontrollori a 32 bit da STMicroelec-

tronics. I chip STM32 sono raggruppati in serie correlati che si basa sul medesimo

core del processore ARM a 32-bit. Internamente, ciascun microcontrollore costituito

dal core del processore, memoria RAM statica, memoria �ash, interfaccia di debug, e

varie periferiche.

Figura 3.2: Stm32f4.

31

Cap. 3 Hardware Utilizzato �3.2 STM32f4

Il software che permette il funzionamento di tale miconcontrollore non è stato

caricato direttamente sulla Raspberry Pi ma viene lanciato da pc, questo secondo

un'ottica di marketing maggiormente di�usa. In ogni caso, per rendere operativo tale

microcontrollore è su�ciente caricarvi un singolo �le main in linguaggio C, il cui co-

dice è ampiamente descritto nell'appendice A.

Ci sono diverse guide su internet per con�gurare un ambiente di sviluppo per STM32F4;

si è dunque proceduto a scaricare e compilare sulla basetta 2 tools:

• Il summon-arm-toolchain per compilare ed eseguire debug dei programmi;

• La stlink utility per �ashare il binario su STM32F4.

Inoltre si è dovuto scaricare, con�gurare e compilare il codice del framework ARM1

per utilizzare le funzioni stm32f4/libs e costruire il programma di base STM32F4. Per

compilare il codice scritto è su�ciente eseguire il comando: makemain.bin; mentre

per caricare il �le sulla Stm: sudo./stlink−

utilwrite../STM32F4xxStdPeriphT emplates/main.bin0x08000000.

1Framework: http : //tech.munts.com/MCU/Frameworks/ARM/.Inoltre andando al seguente link è possibile trovare una lista di esempi:

http : //tech.munts.com/MCU/Frameworks/ARM/stm32f4/libs/STM32F4xxDSPStdPeriphLibV 1.1.0/Project/STM32F4xxStdPeriphExamples/ReleaseNotes.html.I �le: main.c,main.h, stm32f4xxconf.h, stm32f4xxit.cestm32f4xxit.h contenuti nella cartella

stm32f4/libs/STM32F4xxDSPStdPeriphLibV 1.1.0/Project/STM32F4xxStdPeriphT emplatessono stati ottenuti sfruttando proprio questi esempi.

32

danielecarnevale

Testo inserito

spazio

danielecarnevale

Testo inserito

deve essere fatto da ubuntu

Cap. 3 Hardware Utilizzato �3.3 Sistema Fisico

3.3 Sistema Fisico

Figura 3.3: Sistema �sico realizzato

Si analizzano ora le varie componenti elettromeccaniche necessarie alla realizza-

zione e funzionamento di un pendolo inverso con carrello. Si vuole sottolineare il

basso prezzo della strumentazione adoperata e come ciò non abbia compromesso il

raggiungimento degli obiettivi pre�ssati.

3.3.1 Ponte H

Figura 3.4: Piedinatura e schema dell' L298N

33


Il driver per i motori è un circuito che permette al segnale captato dai sensori

di comandare lo stato del motore (avanti - stop - indietro) e viene realizzato con un

circuito chiamato ponte H. Esistono due tipi di ponti H: quelli discreti, costituiti da

componenti sparsi come transistor e diodi e gli integrati, in questo caso tutto il circuito

è racchiuso in un package plastico di tipo DIP (dual in-line package) o simile. I ponti

H integrati sono molto versatili e, oltre a garantire una bassa occupazione di area nel

circuito, hanno buone prestazioni (l' L298 può fornire �no a 2 A per ponte), possono

essere essere montati in parallelo per ottenere alte correnti e riescono a lavorare in un

intervallo di tensioni di alimentazione molto ampio (da 6 V a 48 V circa a seconda

del modello). In �gura 3.3.1 si riporta la piedinatura del driver scelto per il progetto,

ossia L298N e il suo schema di funzionamento. Tale integrato è costituito da quattro

mezzi ponti H (numerati in �gura come 1-2-3-4) ognuno dei quali è costituito da due

transistor e da una logica che li comanda in modo da accenderne solo uno alla volta:

quando il transistor superiore di un mezzo ponte è in conduzione quello inferiore sarà

necessariamente spento e viceversa. E'inoltre presente un comando di ENABLE che

permette di inibire il funzionamento di una coppia di mezzi ponti.

Figura 3.5: L298 e circuito realizzato

34


3.3.2 Motore DC

Figura 3.6: Motore a magneti permanenti utilizzato

Un motore in corrente continua ha una parte mobile in grado di girare detta rotore

(o armatura) mentre l'altra, lo statore, è in grado di generare un campo magnetico

�sso. Il commutatore (detto anche collettore a spazzole), un interruttore rotante,

inverte due volte ad ogni giro la direzione della corrente elettrica che percorre i due

avvolgimenti in modo da generare un campo magnetico che entra ed esce dalle due

parti arrotondante dell'armatura. Questa tipologia di motore è perfettamente rever-

sibile e funziona anche come generatore dinamo.

Sotto precise restrizioni, ovvero che il circuito magnetico sia lineare e che l'attrito

meccanico sia funzione lineare della velocità del motore (nel motore è presente solo

attrito viscoso), i motori CC possono essere rappresentati come un sistema dinamico

non lineare modellizzato tramite il seguente circuito elettrico:

Figura 3.7: Schema elettrico dello statore e del rotore

35


Equazioni Elettriche

L'equazione che descrive il circuito in �gura 3.7 è dato da:

ve(t) = Ledie(t)

dt+Reie(t)⇒

ie(s)

ve(s)=

Ke

1 + τes(3.3.1)

dove Ke = 1Re

è il guadagno di statore e τe = Le

Reè la costante di tempo di statore.

Le stesse ipotesi vanno applicate al rotore, tenendo però conto dell'e�etto della forza

contro elettromotrice e(t). L'equazione associata al relativo circuito elettrico è:

va(t) = Ladia(t)

dt+Raia(t) + e(t)⇒ ia(s)

va(s)− e(s)=

Ka

1 + τa(s)(3.3.2)

dove Ka = 1Ra

è il guadagno di rotore e τa = La

Raè la costante di tempo di rotore.

Le due relazioni 3.3.1 e 3.3.2 forniscono un'espressione esplicita della forza contro elet-

tromotrice e della coppia meccanica cm erogata dal motore (equazioni del cappello):

{cm = Kieia = Kcia

e = Kieω = Keω(3.3.3)

in cui Ke e Kc sono due costanti, proprie del motore, dette costante elettrica e di

coppia, e ω è la velocità angolare.

Equazioni Meccaniche

Il comportamento del carico meccanico è praticamente sempre di tipo non lineare, ba-

sti pensare all' attrito di primo distacco; spesso, però, si e�ettua una implicita linea-

rizzazione attorno ad un punto di lavoro in modo da impiegare un modello del carico

di tipo lineare. Il più generale modello lineare del carico viene ricavato eguagliando

la coppia motrice cm alla somma di tre termini:

• la coppia di carico esercitata sull'asse del motore;

36


• uno proporzionale alla velocità ω di rotazione del motore secondo un coe�ciente

di attrito F, pari alla somma del coe�ciente di attrito del motore e di quello del

carico, riportato all' asse del motore;

• uno proporzionale alla derivata della velocità di rotazione del motore secondo

un momento di inerzia J, pari alla somma del momento di inerzia del motore e

di quello del carico, riportato all' asse del motore.

Si ottiene, quindi, la seguente equazione:

cm = cr + Fω + J (3.3.4)

Analogamente al caso elettrico, anche per le equazioni meccaniche si può associare

una funzione di trasferimento lineare alla relazione 3.3.4:

ω(s)

cm(s)− cr(s)=

Km

1 + τms(3.3.5)

dove Km = 1Fè il guadagno meccanico e τm = J

Fè la costante di tempo meccanica.

Si vuole ora ottenere la relazione diretta tra posizione e tensione di armatura. Inte-

grando entrambi i membri dell'equazione 3.3.5, sotto l'ipotesi di carico nullo che agisce

sul motore, e sfruttando l'equazione 3.3.4, si ottiene:

Θ(s) =Km

s(i+ τmsKT ia(s) (3.3.6)

In�ne, sostituendo le equazioni del cappello 3.3.3, e isolando Θ(s) si ha:

Θ(s) =KmKa

s(τmτas2 + (τm + τa)s+Ke + 1)va(s) (3.3.7)

37


Pilotaggio PWM

I motori DC, collegati ad un'opportuna scheda di controllo (driver ponte H), possono

essere controllati con un segnale PWM.

Figura 3.8: Duty Cycle

Un segnale PWM (Pulse Width Modulation) è un' onda quadra di duty cycle

variabile che permette di controllare la potenza assorbita da un carico elettrico (nel

caso speci�co un motore DC) modulando il duty cycle. Il duty cycle è il rapporto

tra il tempo in cui l'onda assume valore alto e il periodo. L'utilizzo di questa tecnica

permette di modi�care la velocità pur assicurando un rendimento energetico elevato; l'

idea è quella di pilotare la base del transistor con un' onda quadra: se la commutazione

è piuttosto frequente, a causa del comportamento da induttore, la corrente media è

sostanzialmente costante e proporzionale al duty cycle del segnale sulla base del MOS.

Tra i molti vantaggi che si ottengono con l' utilizzo di tecniche PWM, il più importante

è che le perdite di potenza rimangono estremamente basse se confrontate con l' entità

della potenza in uscita, inoltre il segnale PWM, proprio per la sua natura digitale, è

facilmente manipolabile.

38


3.3.3 Encoder

Figura 3.9: Encoder utiizzati

Gli encoder sono trasduttori di posizione digitali in grado di fornire un numero,

espresso in un particolare codice, in funzione dello spostamento. Gli encoder incremen-

tali, che si dividono in lineari ed angolari, si basano su un principio du funzionamento

geometrico: all'albero del motore, solidale con il rotore, viene collegato un disco opaco

con dei fori disposti in posizione radiale , tanto più numerosi quanto maggiore è la

risoluzione dell'encoder. Da un lato e dall'altro del disco sono inoltre disposte due

coppie di sensori, ognuna costituita da una trasmittente e un ricevente, i quali sono

in grado di individuare il passaggio dei fori applicati sul disco. Il trasmittente è co-

stituito da un led, mentre il ricevente è un foto transistore, entrambi operanti nella

banda ottica. Siccome le zone opache e quelle trasparenti hanno la stessa lunghezza,

posizionando opportunamente le due coppie di sensori, le forme d'onda in uscita dai

sensori stessi assumono una forma particolare (come mostrato in �gura 3.3.3).

A seconda del verso di rotazione del motore, lo stato logico dei due segnali prove-

nienti dai sensori è diverso: in corrispondenza del fronte di salita del segnale, infatti,

in un caso il segnale B è alto mentre nell'altro è basso. Questa proprietà permette

di decodi�care con successo non solo la rotazione ma anche il verso della stessa. Tale

decodi�ca è ad opera di un semplice contatore Up/Down (�gura 3.3.3) che misura gli

39


Figura 3.10: Forme d'onda e FlipFlop con Contatore

spostamenti incrementali del motore.

La risoluzione di un encoder corrisponde, da un punto di vista elettrico, al numero di

impulsi generati in uscita da ogni canale per angolo giro. Nel caso in cui l'encoder è

montato sull'albero posteriore di un motore con riduttore, la risoluzione viene moltipli-

cata per il fattore di riduzione N, La lettura incrementale del movimento dell'encoder

viene fatta tramite un circuito logico più complesso di un semplice contatore che è in

grado di rilevare tutti i fronti delle forme d'onda. Conseguenzialmente la risoluzione

dell'encoder viene quadruplicata.

Osservazione 3.3.1 Home: A causa dell'arbitrarietà della posizione iniziale dell'en-

coder e dello stato iniziale del contatore di decodi�ca, tutti i dispositivi dotati di

encoder incrementali prevedono la generazione di un segnale di home che assegna una

posizione di riferimento univoca e nota. Nel caso speci�co, per il primo encoder po-

sizionato sul motore è stato �ssato il valore 0 qualora il carrello si trovi all'estrema

sinistra della guida. Il secondo encoder posizionato alla base dell'asta, invece, viene

azzerato quando il pendolo si trova nel suo punto di equilibrio stabile. �X

40


Figura 3.11: Base del pendolo incernierato alla barra munita di encoder

3.3.4 Stampante

Il carrello utilizzato per la realizzazione del pendolo inverso è stato preso da una stam-

pante. Privata di tutto il super�uo è stato mantenuto solamente il motore, il carrello

(alleggerito del box per il toner) con le guide dentate e il supporto metallico e, in�ne,

la struttura essenziale della stampante. Frontalmente al carrello è stata realizzata

una semplice struttura in legno e metallo al �ne di permettere l'ancoraggio dell'asta

utilizzata per il pendolo e applicato un encoder per avere informazioni sull'output del

sistema.

Riguardo proprio al pendolo, tra i diversi materiali provati (barra di legno, antenna di

una televisione, tubo di plastica riempito d'acqua) si è optato in�ne per una barra in

metallo �lettata. I motivi legati a questa scelta sono legati principalmente all'elevato

attrito del sistema e quindi alla necessità di avere un oggetto pesante, il quale messo in

41


moto possedesse una considerevole inerzia. Inoltre sarebbe stato possibile aumentare

la massa, ed in particolar modo il momento di inerzia, dell'asta aggiungendo sempre

più bulloni sull'estremità superiore.

Figura 3.12: Carrello con pendolo

Osservazione 3.3.2 Imperfezioni del sistema meccanico: Il sistema presenta un gio-

co meccanico verticale dovuto alla non perfetta aderenza del carrello con la base in

metallo, dell'encoder con la propria basetta in plastica e dell'asta di supporto con

il foro realizzato nel legno. Tale non linearità non è stata considerata in fase di

modellizzazione. �X

42

Cap. 3 Hardware Utilizzato �3.4 Collegamenti �sici

3.4 Collegamenti �sici

Figura 3.13: Collegamenti sul sistema �sico

Una parte cruciale e dispendiosa di tempo è sicuramente la realizzazione dei colle-

gamenti necessari a mettere in comunicazione i vari componenti del sistema �sico. In

questa fase è necessario poter usufruire di strumenti come il saldatore e multimetro.

3.4.1 Raspberry - Stm

Per illustrare la logica che è dietro la comunicazione tra questi due dispositivi si

necessita dapprima di alcune nozioni riguardo MARTe e il suo funzionamento su

Raspberry. Per questo motivo verrà ampiamente descritta in seguito, nella sezione

4.1.1.

Osservazione 3.4.1 Veri�care il corretto funzionamento: Un feedback di un esito

positivo della comunicazione tra i due dispositivi è sicuramente il led verde che, una

volta lanciato MARTe, dovrà accendersi sulla Stm. �X

43


Figura 3.14: Collegamenti Raspberry - Stm

3.4.2 Stm - Ponte H

Un ponte 4-H come l'L298 può essere utilizzato per l'erogazione di potenza �no di

due motori in entrambe le direzioni.

Dal lato Stm, per ottenere il counter clock TIM3 a 2Mhz, il prescaler viene calcolato

nel seguente modo: Prescaler = (TIM3CLK/TIM3c.c)−1 = ((SystemCoreClock/2)/2000000)−

1 Per ottenere l'output clock TIM3a2KHz, invece, il periodo TIM3ARR viene

calcolato così: ARR = (TIM3c.c./TIM3o.c.)− 1 = 999

Figura 3.15: Collegamenti Stm - Ponte H

44


Osservazione 3.4.2 Collegamento tra ponte H e motore: Il motore dispone di due

�li i quali vanno collegati al ponte h, in collegamento a sua volta con la scheda Stm.

I pin interessati sono il 3 per il verso positivo della corrente e il 6 per il negativo.

Scambiando i due collegamenti si otterrebbe l'unico e�etto di invertire il senso di

rotazione del motore. �X

3.4.3 Stm - Encoder

Il primo passo è stato identi�care (dalla scheda tecnica della Stm) un timer funzionante

che può essere utilizzato per la quadratura dell' encoder e quali pin devono essere

collegati all'encoder stesso. L'assegnazione del pin su STM32F4 è molto �essibile:

c'è bisogno dei canali 1 e 2 destinati al timer scelto per consentire la decodi�ca degli

impulsi (le opzioni di codi�ca possono essere in 2x o 4x).

Per i collegamenti, l'unica accortezza risiede nel porre il GNR e l'alimentazione a 5V

negli stessi pin utilizzati per il ponte H.

Figura 3.16: Collegamenti Stm - Encoder

La parte di con�gurazione dei vari moduli per interfacciare l'hardware con la

raspberry e la stm sono descritti nell'appendice A.

45

Capitolo 4

MARTe

Alla �ne degli anni '90 al JET erano usate solo soluzioni hardware/-software dedicate per il controllo magnetico. Il sistema di controllooperava su un power-pc, ed in particolare sull'ambiente VxWorks, eper il sistema virtuale si utilizzavano 4 DSP. Ovviamente vi eranoevidenti limitazioni: il sistema non era �essibile a cambiamenti,le operazioni di debugging e testing erano complicate e i tempi dicommissione erano lunghi. Il primo passo in avanti è stato il fra-mework JETRT, che si bacava su un'unica libreria BaseLib e per-metteva, sebbene mantenendo una netta distinzione tra software ehardware, di eseguire validazioni e avviare il sistema in real time.Successivamente di è migliorato l'aspetto della Modularità, tramitedei moduli programmabili e riutilizzabili e la Separazione con l'ag-giunta di un bu�er dinamico per lo scambio dati tra le GAMs).MARTe consiste nel passo successivo. Utilizzando le funzionalitàimplementate in BaseLib2, Marte gestisce non solo lo schedulingdei thread real-time ma anche tutte le attività di I/O.

4.1 Cos'è e come funziona?

Il Multi-threaded Application Real-Time executor (MARTe) è un ambiente framework

dati guidato per lo sviluppo e l'implementazione di algoritmi di controllo in tempo

reale. Sostanzialmente MARTe è una raccolta di thread real-time programmati da una

state machine interna ognuno dei quali è completamente con�gurabile (applicazioni

e tempi). Implementa inoltre servizi e protocolli di comunicazione attraverso moduli

46

Cap. 4 MARTe �4.1 Cos'è e come funziona?

Figura 4.1: Schema generale di MARTe.

aggiuntivi, anch'essi con�gurabili, tali da coprire tutte le esigenze di I/O: CODAS,

interfacciamento WEB, sicurezza e servizio di logger.

Alla base di ogni applicazione basata su MARTe vi è quindi un insieme di bloc-

chi software indipendenti inter-comunicanti, denominati Generic Application Module

(GAM) orchestrato da uno scheduler real-time (IMG). Un'applicazione MARTe viene

creata collegando una raccolta di GAM, ognuna specializzata in un determinato com-

pito, utilizzando un bus dati di memoria denominata Bu�er Dynamic Data (DDB).

Ogni GAM può scambiare e acquisire dati su canali DDB nominativi e il framework

garantirà che tutte le risorse richieste sono presenti nel sistema. Solitamente ogni

GAM è associata ad una speci�ca funzione, in modo da consentire il riuso dello stesso

componente o la sostituzione di parte del sistema di controllo. Come già accennato

l'interfaccia hardware e la sincronizzazione viene eseguita utilizzando un modulo spe-

ciale chiamato IOGam il quale fornisce a MARTe un'interfaccia hardware standard che

prevede l'interazione con l'hardware reale da attuare a livello di drive (con�gurazione,

trasferimenti ecc). MARTe supporta due tipi di meccanismi di sincronizzazione, uno

basato su polling continuo di una risorsa e l'altra mediante interrupt. Il framework

può anche avere elementi di innesco asincroni sulla catena di controllo che raccolgono

gli ultimi dati disponibili e veri�cano se la latenza è accettabile.

47


Osservazione 4.1.1 Istallazione di MARTe è su�ciente caricare sulla SD il codice

dell'ambiente e farlo partire come eseguibile da raspbian. �X

Figura 4.2: Schermata di MARTe.

4.1.1 Comunicazione con Stm

Per iniziare una comunicazione, il bus master con�gura il clock, utilizzando una fre-

quenza inferiore o uguale alla frequenza massima del dispositivo slave supporta (in

genere �no a qualche MHz). Il master trasmette quindi la logica 0 per il chip desidera-

to sulla linea selezionata (SS). 0 viene trasmesso quando la linea del chip selezionata è

settata su basso, ovvero il suo stato o� è un 1 logico mentre on si a�erma con una lo-

gica 0. E' importante sottolineare questo perché la maggior parte dei dispositivi slave

hanno uscite tri-state; in questo modo il loro segnale MISO diventa ad alta impedenza

(logicamente disconnessa) quando il dispositivo non è selezionato. Apparecchi senza

uscite tri-state non possono condividere segmenti di bus SPI con altri dispositivi, cioè

solo uno degli slave può comunicare con il padrone e solo il suo chip selezionato essere

attivato.

Durante ogni ciclo di clock SPI, viene attivata una trasmissione dati full duplex:

48


Figura 4.3: Schema Master - Slave

• il master invia un bit sulla linea MOSI e lo schiavo lo legge dalla stessa linea.

• lo slave trasmette un bit sulla linea MISO ; il master legge da quella stessa linea.

Osservazione 4.1.2 Riguardo le trasmissioni:

Non tutte le trasmissioni richiedono tutte e quattro queste operazioni, tuttavia

anche se non signi�cative le e�ettuano comunque.

�X

Le trasmissioni dati normalmente coinvolgono due shift register con dimensione

�ssata della parola (otto bit), uno per il master e uno per lo slave, collegati in anello.

Figura 4.4: Scambio dati tra Master e Slave

I dati vengono generalmente consegnati dal bit più signi�cativo, facendo shiftare

un nuovo bit meno signi�cativo nel stesso registro. Dopo che il registro è stato spedito,

master e slave hanno scambiato i valori del registro. A questo punto ogni dispositivo

può prendere questo valore ed adoperarlo per operazioni come la scrittura in memoria.

49


Se ci sono più dati da scambiare, gli shift registers vengono caricati con nuovi dati e

il processo si ripete. Le trasmissioni possono coinvolgere qualsiasi numero di cicli di

clock . Quando non ci sono più dati da trasmettere, il master smette di commutare il

suo clock e deseleziona lo slave. Spesso le trasmissioni sono costituite da parole di 8

bit e un master, se ne esige, può attivare più di queste trasmissioni. Nonostante ciò,

sono comuni anche altri formati di parola.

Si procede ora ad analizzare nel dettaglio come questa comunicazione viene instaurata.

Figura 4.5: Comunicazione tra Master e Slave

Il rasberry Pi fa girare MARTe il quale carica il GPIOSysFsDrv e il SpiStmSup-

port. Il SpiStmSupport lancia i suoi moduli foglia: Quadratura Encoder, PWM, ADC,

DAC e tutto ciò che può implementare. Per ciascun modulo foglia il SpiStmSupport

invia un messaggio di con�gurazione SPI, che contiene l'id della funzione e i parametri

(dal cfg) di una speci�ca funzione che verrà eseguita sul dispositivo STM32F4. Alla

�ne, il SpiStmSupport invia il proprio messaggio di con�gurazione con il parametro

periodo e attiva il SysTick Interrupt sulla STM32F4.

Il dispositivo STM32F4 viene programmato con un set di funzioni di con�gurazio-

ne del dispositivo il quale può essere chiamato mediate un messaggio SPI. Quando

STM32F4 parte, con�gura il SPI1 come periferica slave; nel momento in cui arriva

un messaggio SPI, l'interrupt SPI controlla il suo byte riservato e se viene trovato un

50


id di con�gurazione valido per la funzione, lo memorizza insieme ai parametri della

funzione stessa. Il programma principale si sveglia quando la transazione SPI è �nita

e chiama la funzione richiesta. Ogni funzione di con�gurazione popola la struttura

della periferica e la aggiunge alla matrice dispositivi in ordine di chiamata.

Dopo che tutte le GAMs sono state caricate, il GPIOSysFsDrv interroga (mediante

un meccanismo di polling) il pin del clock. Quando esso si risveglia, il GPIOSysFsDrv

chiama la SpiStmSupport getData che avvia la comunicazione SPI con la Stm. Il

tempo di trasferimento deve essere inferiore a (0, 5 ∗ periodostmTime2ReadDevices)

altrimenti possono avvenire corruzioni di dati sui bu�er in scrittura e lettura della

Stm. Durante il ciclo di RT l'id della funzione non è valido; in questo modo il main

della Stm non esegue nulla alla �ne della transazione SPI. Il body del messaggio con-

tiene i dati per le attuazioni nel giusto ordine (copiati dalla precedente chiamata di

funzione WriteData) e dopo l'operazione contiene i nuovi dati campionati. La funzio-

ne di con�gurazione SysTick programma l'interrupt SysTick a risvegliarsi ogni mezzo

periodo speci�cato, mentre l'handler dell'interrupt SysTick cambia la fase della Stm

da �read� a �write�. Quando la fase è �read�, viene chiamata la funzione di lettura

di ogni dispositivo facendo spostare l'o�eset del txbu�er a destra, innescando pin del

clock RPI e facendo illuminare il PD12 (led verde). Fatto ciò la funzione ritorna. Que-

sto dà il tempo all'handler della SPIInterrupt per aggiornare i bu�er rx e tx. Quando

la fase è �write�, al contrario, si chiama la funzione di scrittura di ogni dispositivo;

quindi si fa scalare l'o�set dell' rxBu�er e si spegne il PD12.

51

Capitolo 5

Come lanciare un esperimento

Viene qui esposta la procedura corretta per lanciare un esperimento:

• Cavetteria:

collegare tramite cavo ethernet raspberry e pc;

collegare tramite miscro usb raspberry e pc;

collegare il cavo di alimentazione per il motore.

• Entrare nel sistema operativo del raspberry:

digitare da linea di comando ssh [email protected];

password: raspberry.

• Se necessario modi�care il �le di cfg (vedere appendice A)

entrare in code/EFDA−MARTe/trunk/Examples/MARTeRpiStm32f4_dma

e aprire il �le MARTe−RpiStm32f4Spi_completed_1.cfg per cambiare:

� SamplingTime

� tipo di riferimento (costante, sinh, x3)

� parametri del controllore e dell'isteresi

� il tau della funzione di attrito

52

Cap. 5 Come lanciare un esperimento

� impostazioni dei derivatori (Window)

� attivare o disattivare procedura di home (Home) e controllo switching

(ActivatePid)

• Attivare il Logger per il controllo di errori (�gura 5.1):

entrare nella cartella Logger, JTLogger e digitare ./JTLogger.sh;

cliccare sull'icona dei due computer, e cliccare ok.

• Avviare MARTe:

dalla cartella sopraindicata digitare

sudo ./MARTe−RpiStm32f4Spi.sh./MARTe−RpiStm32f4Spi_completed_1.cfg.

• E�ettuare l'esperimento (�gura 5.2):

da browser andare su http://192.168.200.238:8080;

cliccare su BROWSE in modo da far apparire l'interfaccia html di MARTe;

cliccare su MARTeContainer, StateMachine e quindi PULSE SETUP COM-

PLETED, PRE;

terminata la prova cliccare su EJP e quindi COLLECTION COMPLETED.

• Visione dei dati:

cliccare su FlotPlot e selezionare i segnali che si intende visualizzare;

cliccare su MATLABSupport e scaricare un �le .mat contenente tutti i dati.

Osservazione 5.0.3 Segnalazione di Errore se la procedura di avvio è andata a buon

�ne si accenderà dapprima una luce verde, poi una blu e in�ne entrambe. In caso

contrario è occorso un errore che il Logger avrà rilevato. �X

53


Figura 5.1: Logger

Figura 5.2: Interfaccia Browser

54


Figura 5.3: Interfaccia Browser, FlotPlot

Figura 5.4: Interfaccia Browser, Download .mat

55

Capitolo 6

Conclusioni e sviluppi futuri

Questo lavoro di tesi ha mostrato come sia possibile realizzare un pendolo inverso

funzionante a basso costo. A seguito di un iniziale lavoro di costruzione del siste-

ma �sico, che ha richiesto la conoscenza di nozioni nell'ambito dell'elettronica e della

meccanica, si è analizzato il problema teorico ed individuato il modello matematico.

Una fase cruciale è stata l'identi�cazione dei parametri del modello che ha permesso

di calzare il problema generale nel caso speci�co e venire a contatto con problematiche

quali la non linearità dell'attrito, i giochi meccanici della struttura e i �ne corsa strut-

turali inizialmente ignorate. Una oculata scelta delle tecniche di controllo adoperate,

in�ne, ha reso possibile il raggiungimento dell'obbiettivo proposto.

Parallelamente a tutto questo si è studiato, modi�cato ed adoperato l'ambienta MAR-

Te. Si è compreso il potenziale di un sistema pensato per l'ambito controllistico e le

potenzialità di un linguaggio a basso livello come il C. Questo, insieme all'utilizzo di

tecnologie in espansione come la Raspberry Pi rappresenta la vera novità introdotta

dal lavoro svolto.

Come per gli altri aspetti del progetto, il background conoscitivo (in questo caso

dell'informatica) è risultato sicuramente fondamentale per la riuscita �nale.

56

Cap. 6 Conclusioni e sviluppi futuri

Gli sviluppi futuri di questo lavoro di tesi sono molteplici. Una volta messo in

piedi un sistema funzionante (di cui ogni aspetto è ben noto), è possibile spingersi

oltre in tutti i campi, dalla meccanica a quello dei controlli. Si pensa dunque che una

naturale continuazione di questo progetto sia:

• La realizzazione di un sistema di controllo maggiormente performante e/o ro-

busto, in grado quindi di garantire migliori performance nel transitorio oppure

stabilità a fronte di disturbi esterni di maggiore entità.

• L'implementazione di una fase iniziale di swing up nella quale il pendolo è

in grado di portarsi autonomamente nell'intorno del suo punto di equilibrio

instabile per poi far partire il sistema di controllo.

• La diminuzione del tempo di campionamento del sistema e quindi l'ottimizza-

zione del codice per la comunicazione tra Stm e Raspberry Pi

• L'evoluzione del processo, considerando anche la posizione del carrello come una

uscita del sistema e quindi la realizzazione di un sistema di controllo SIMO.

• Il miglioramento dell'hardaware, ad esempio l'utilizzo di una guida circolare per

il carrello in modo da eliminare il problema dei �necorsa.

57

Appendice A

Codici

Per quanto concerne il codice prodotto si è deciso di riportare solo le sezioni più

importanti inerenti le soluzioni adottate e discusse nei capitoli precedenti.

Come è stato implementato un Derivatore

1 float PseudoDerivator::Evaluate(int64 usecTime, float sig) {

2

3 float deSig=0.0;

4 float meanSx=0.0,meanDx=0.0;

5 // float tSxMean=0.0,tDxMean=0.0;

6

7

8 pushData(usecTime,sig);

9

10 for(int i=0;i<c;i++){

11 meanSx+=yDataWindow[i];

12 meanDx+=yDataWindow[d-i-1];

13 }

14 meanSx/=c;

15 meanDx/=c;

16

17 deSig=(meanSx-meanDx)/(samplingTime*(d-c));

18

19

20 return deSig;

21 }

Come è stato implementato un PID

58


1 float PIDn1::Evaluate(int32 usecTime, float error, int nc, float *pwm_kp,

float *pwm_kd, float *pwm_ki)

2 {

3 if(nc == 1)

4 {

5 Kp = kp_int;

6 Kd = kd_int;

7 Ki = ki_int;

8 }

9 else

10 {

11 Kp = kp_est;

12 Kd = kd_est;

13 Ki = ki_est;

14 }

15

16 filteredInput = tauFilterPID*filteredInput + (1-tauFilterPID)*error;

17

18 float d_error = errorDerivator->Evaluate(usecTime, filteredInput); //to

evaluate the pseudo-derivative of the error signal

19

20 //derivative term with deadzone

21 float xd = Kd * d_error;

22 if(fabs(d_error) < derDeadzonePID)

23 xd = 0.0;

24 *pwm_kd = xd;

25 //proportional term with deadzone

26 float xp = Kp* filteredInput;

27 if(fabs(filteredInput) < propDeadzonePID)

28 xp = 0.0;

29 *pwm_kp = xd;

30 //partial pid, without the new value of the integrator

31 float xpid_new = xp + xd + integralState;

32 *pwm_ki = integralState;

33

34 //maximum desired variation that satisfies the amplitude and derivative

constraints

35 float temp1 = _min( _max(satAmplPID - abs(xpid_new),0.0),_max(satDerPID -

abs(xpid_new - xpidState),0.0));

36 //the integral state is updated according to the feasible values (by

temp1)

37 integralState += _min(temp1,_max(-temp1, Ki*(filteredInput +

previousError)*samplingTime*0.5));

38

39 //final PID with amplitude and derivative saturation

59


40 xpidState = _min(satAmplPID,_max(-satAmplPID, xpidState +

_min(satDerPID,_max(-satDerPID, -xpidState + xp + xd +

integralState)))) ;

41

42 previousError = filteredInput;

43

44 return (xpidState);

45

46 }

Come è fatta la funzione Execute della DCMotorControlGAM

1 bool DCMotorControlGAM::Execute(GAM_FunctionNumbers functionNumber) {

2 // Get input and output data pointers

3

4

5 int i=0;

6 input->Read();

7 int64 usecTime=((int64*)input->Buffer())[0];

8 float encoder_pend =(float)((int32*) input->Buffer())[2];

9 float ref=((float*) input->Buffer())[3]; //con pwm non va bene

10 float encoder_cart = (float)((int32*) input->Buffer())[4];

11

12 StmOutputData *out=(StmOutputData *)(output->Buffer());

13 float * otherOuts =((float *)out +1);

14 int32 * resetEnc2=(output->Buffer()+6);

15 int32 * resetEnc1 = (output->Buffer()+10);

16 float *pwm_kp = (float *)(output->Buffer()+11);

17 float *pwm_kd = (float *)(output->Buffer()+12);

18 float *pwm_ki = (float *)(output->Buffer()+13);

19

20 float rif_nuovo = rif;

21

22 if(activate_rif == 1.0)

23 rif_nuovo =

(encoder_cart/c_rif)*(encoder_cart/c_rif)*(encoder_cart/c_rif)+rif;


25 rif_nuovo = c_rif*encoder_cart+rif;


27 rif_nuovo = c_rif2*sinh(encoder_cart*c_rif)+rif;

28

29 float err = rif_nuovo - encoder_pend/encoderPPR;

30 float floatOut=0.0;

31 float vel_c=motorSpeed1->Evaluate(usecTime, encoder_cart);

60


32 float vel_p=motorSpeed2->Evaluate(usecTime,encoder_pend);

33 float derr = der_err->Evaluate(usecTime,err);

34

35 float c_prop = 5000/(samplingTime*1000000.0);

36

37 switch (functionNumber) {

38

39 case GAMPrepulse:

40 {

41 //nuovo

42 pid->Reset();

43 f->Reset();

44

45 counter = 0;

46 if(home == 0.0)

47 fasi = 1;

48 else

49 fasi = 1;

50 lastEncoder_p=0;

51 lastEncoder_c=0;

52 memset(output->Buffer(),0,4*sizeof(int32));

53 if(activate_pid == 1.0)

54 floatOut = pid->Evaluate(usecTime,err, zona, pwm_kp, pwm_kd,

pwm_ki);

55 else

56 floatOut = pid->Evaluate(usecTime,err, 2, pwm_kp, pwm_kd,

pwm_ki);

57 }

58 break;

59

60

61 case GAMOffline: //porta il carrello a sinistra

62 {

63 out->pwml = -(int)deadZone-50;

64 out->pwmr=out->pwml;

65 counter ++;

66 //printf("vel = %f\n",vel);

67 if(fabs(vel_c) <= 0.01 && counter >int(200*c_prop))

68 {

69 //printf("Sbatto");

70 out->pwml = 0;


72 *resetEnc1 = 1;

73 *resetEnc2 = 1;

74 memset(output->Buffer(),0,5*sizeof(int32));

61


75 }

76 }

77 break;

78

79 case GAMOnline:

80 {

81 switch (fasi) {

82

83 case 1: //porta il carrello quasi al centro

84 {

85 if(counter > 0 && counter != 1)

86 {

87 *resetEnc1 = 1;

88 *resetEnc2 = 1;

89 counter = 0;

90 }

91 if(counter == 0)

92 {

93 *resetEnc1 = 0;

94 *resetEnc2 = 0;

95 counter = 1;

96 }

97 out->pwml = (int)deadZone+50;


99 if(encoder_cart >= 1095 && encoder_cart<=1105)

100 {

101 printf("Fermo quasi al centro\n");

102 out->pwml = 0;


104 fasi ++;

105 lastEncoder_c = encoder_cart;

106 }

107 break;

108 }

109

110 case 2: //trova la deadzone

111 {

112 counter++;

113 if(counter % 70 == 0)

114 {

115 lastEncoder_c = encoder_cart;

116 motor_stop ++;

117 }

118 else

119 break;

62


120

121 deadZone = 600+motor_stop*5;

122 printf("deadZone = %f\n",deadZone);

123 out->pwml = deadZone;


125

126 if(deadZone > 850)

127 {

128 printf("Errore\n");

129 out->pwml = 0;


131 }

132 if(fabs(vel_c) >= 0.0002)

133 {

134 counter = 0;

135 fasi ++;

136 }

137

138 lastEncoder_c=encoder_cart;

139

140 break;

141 }

142

143 case 3: //porta il carrello al centro

144 {

145 out->pwml = deadZone;


147 if(fabs(encoder_cart)>=1495 &&

fabs(encoder_cart)<=1505)

148 {

149 printf("Fermo al centro\n");

150 out->pwml = 0;


152 *resetEnc1 = 1;

153 *resetEnc2 = 1;

154 fasi ++;

155 counter = 0;

156 }

157 break;

158 }

159

160 case 4: //da tempo per fermare il pendolo in basso

161 {

162 counter++;

163 out->pwml = 0;

63



165 if(counter<int(1200*c_prop))

166 {

167 *resetEnc2=1;//pendolo

168 *resetEnc1 = 1;

169 }

170 else

171 {

172 printf("Puoi alzare il pendolo\n");

173 *resetEnc2=0;

174 *resetEnc1 = 0;

175 counter = 0;

176 fasi ++;

177 }

178 lastEncoder_c = 0;

179 break;

180 }

181

182 case 5: //attende che porto il carrello su e parte

183 {

184 if(encoder_pend >=rif-1 && encoder_pend <= rif+1 &&

counter == 0)

185 {

186 printf("partito\n");

187 counter = 1;

188 }

189

190 if(counter == 1)

191 {

192 if(activate_pid == 1.0) // zona se 1 interna

pid , 2 esterna filtro

193 {

194 if(fabs(err)>switched_err_e ||

(fabs(err)<=switched_err_e &&

fabs(derr)>switched_derr_e))

195 zona = 2;

196 else if(fabs(err)<switched_err_i &&

fabs(derr)<switched_derr_i)

197 zona = 1;

198

199 floatOut = pid->Evaluate(usecTime,err,

zona, pwm_kp, pwm_kd, pwm_ki);

200 printf("zona = %d, err %f, derr

%f\n",zona,err,derr);

201 }

64


202 else

203 floatOut = pid->Evaluate(usecTime,err,

2, pwm_kp, pwm_kd, pwm_ki);

204

205 if(floatOut < 0)

206 floatOut=floatOut -

deadZone*exp(-tau*fabs(vel_c)*fabs(vel_c));

207 else

208 floatOut=floatOut +

deadZone*exp(-tau*fabs(vel_c)*fabs(vel_c));

//(fabs(vel)*0.3+1)/(fabs(vel)+1);//

*exp(-100*fabs(vel)*fabs(vel)); //

*(fabs(vel)*0.3+1)/(fabs(vel)+1);

209

210 //Saturation

211 if(floatOut>=0.0){

212 if(floatOut>pwmPeriod)

213 floatOut=pwmPeriod;

214 }

215 else {

216 if(floatOut<-pwmPeriod)

217 floatOut=-pwmPeriod;

218 }

219

220

221 //Dead Zone

222 out->pwml=(int16_t)(floatOut);


224

225

226 otherOuts[0]=encoder_pend/encoderPPR;

227 otherOuts[1]=err;

228

229 otherOuts[3]=(float) out->pwml;

230 otherOuts[4]=encoder_pend-lastEncoder_p;

231 otherOuts[5]=0;

232 otherOuts[6]=(float)vel_c;

233 otherOuts[7]=(float)vel_p;

234 otherOuts[8]=deadZone;

235 otherOuts[9]=0;

236 otherOuts[10] = *pwm_kp;

237 otherOuts[11] = *pwm_kd;

238 otherOuts[12] = *pwm_ki;

239

240 lastEncoder_p=encoder_pend;

65


241 lastEncoder_c=encoder_cart;

242 }

243 else

244 {

245 out->pwml = 0;


247 }

248 break;

249 }

250 }

251 break;

252 }

253 }

254 output->Write();

255 return True;

256 }

Come con�gurare MARTe e i segnali di input/output degli Encoder e delPonte H

1 +MARTe = {

2 Class = MARTeContainer

3 StateMachineName = StateMachine

4 Level1Name = LEVEL1

5 MenuContainerName = MARTe

6 +MARTe = {

7 Class = MenuContainer

8 }

9 +DriverPool = {

10 Class = GCReferenceContainer

11

12 +GPIOSysfs={

13 Class=GPIOSysfsDrv

14 NumberOfInputs = 11

15 NumberOfOutputs = 5

16 TimeTriggeringServiceName= ExternalTimeTriggeringService

17 ClockPin = 23

18 ResetAtPulseStart = True

19

20 +SpiStm32f4Support={

21 Class=SpiStm32f4

22 CS=0

23 SpiSpeed=15000000

24 DMABufferSize=64

66


25

26 +PWM1={

27 Class=Stm32f4PWMModule

28 Timer=3

29 Pins={0 1}

30 TimerChannels={3 4}

31 Ports="BB"

32 PWMPeriod=999

33 PWMCounterClock=10000000

34 }

35 +ENC1={

36 Class=Stm32f4EncoderModule

37 Timer=2

38 Pins={15 3}

39 Ports="AB"

40 }

41 +ENC2={

42 Class = Stm32f4EncoderModule

43 Timer = 4

44 Pins = {6 7}

45 Ports = "BB"

46 }

47 }

48 }

49

50 ...

51 }

DCMotorControlGAM nel .cfg

1 +DCMotorControl =

2 {

3 Class = DCMotorControlGAM

4

5 PWMPeriod = 999.0

6 DeadZone = 800.0 //valore iniziale che varia con lo sparo

7 SamplingTime = 0.0025

8 EncoderPPR=1.0

9 ActivateRif = 1.0 //per selezionare la funzione di rif

10 Rif = -4095 //encoder sul punto di eq instabile (soggetto ad

errore)

11 ConstRif2 = 0.0 // per 0.0, 1.0 e 2.0

12 //ConstRif = 0.02 // retta 2.0

13 ConstRif = 580.0 // x^3 1.0

67


14 //ConstRif = 0.0065 // sinh 3.0

15 //ConstRif2 = 0.014 // sinh 3.0

16

17 EsternalSwitch_derr = 600.0 // isteresi

18 InternalSwitch_derr = 400.0

19 EsternalSwitch_err = 12.0

20 InternalSwitch_err = 10.0

21

22 RifBotta = 600.0 // se volessi forzare io il controllo

23 Botta = 100.0

24 TempoBotta = 15.0

25

26 Tau = 95000 // log (statico/dinamico)/vel^2 per l'attrito

27

28 Home = 0.0 //0.0 la fa all'inizio, 1.0 no

29 ActivatePid = 1.0 //attiva (1.0) o disattiva(0.0) lo switching

30

31 //BarrierPwm = 1.0 //1.0 stop sul fine corsa, 0.0 no stop

32

33 Numerator = {50 -56.92 -17.6 27.52} //se volessi usare un filtro

invece che il pid

34 Denominator = {1 0 0 0}

35

36 +Derivator1 = {

37 Class = PseudoDerivator

38 WindowSize=5

39 SubWindowsSize=2


41 }

42 +DDerivator1 = {


44 WindowSize = 5

45 SubWindowsSize=2


47 }

48 +DerivatorErr = {


50 WindowSize = 5

51 SubWindowsSize=2


53 }

54

55 +PID =

56 {

57 Class = PIDn1

68


58

59 +ErrorDerivator =

60 {


62 WindowSize = 5

63 SubWindowsSize = 2


65 }

66 T_activate = 0.0


68 T_deactivate = 0.0

69

70 SatAmplPID = 999.0 //amplitude saturation

71 SatDerPID = 6000.0 //rate saturation per Ts

72 DerDeadzonePID = 100000.0 //deadzone of the derivative term

73 PropDeadzonePID = 0.0

74 TauFilterPID = 0.4 //input filter (of the error)

75

76 KpInt = 6.8289 //C1

77 KdInt = 0.0

78 KiInt = 170.0

79

80 KpEst = 6.8289 //C2

81 KdEst = 0.0

82 KiEst = 190.0

83 }

84

85 InputSignals = {

86 usecTime = {

87 SignalName=usecTime

88 SignalType=int64

89 }

90 ch2 = {

91 SignalName = count2

92 SignalType = int32

93 }

94 ch3={

95 SignalName = rif

96 SignalType = float

97 }

98 ch4={

99 SignalName = count1


101 }

102 }

69


103

104 OutputSignals = {

105 pwmlr = {

106 SignalName = pwm


108 }

109 ch1={

110 SignalName = encoderPPR


112 }

113 ch2={

114 SignalName = err


116 }

117 ch3={

118 SignalName = nonsatpwm


120 }

121 ch4={

122 SignalName = satpwm


124 }

125 ch5={

126 SignalName = stopDetect


128 }

129 ch6 = {

130 SignalName = resetEncoder1


132 }

133 ch7 = {

134 SignalName = cart_vel


136 }

137 ch8 = {

138 SignalName = pend_vel


140 }

141 ch9 = {

142 SignalName = NewDeadZone


144 }

145 ch10 = {

146 SignalName = resetEncoder2


70


148 }

149 ch11 = {

150 SignalName = Kp


152 }

153 ch12 = {

154 SignalName = Kd


156 }

157 ch13 = {

158 SignalName = Ki


160 }

161 }

162 }

Sezione del codice Matlab per l'identi�cazione del modello del secondoordine

1 clc

2 clear all

3 close all

4

5 l_guida = 0.316; %metri

6 %enc_giro = 50;

7 enc_max = 2996;

8 %raggio = 0.03; % 3 cm

9 inizio_dati = 20;

10 inizio_dati2 = 40;

11 n_exp = 11;

12 pwm_min = 650; %in media

13 cs = 0.8; %approssimazione

14

15 % CARICAMENTO DATI

16 %

17

18 % seleziona i dati delle prove sperimentali

19 count=1;

20 count2 = 1;

21 minTime=300;

22 Ts=0;

23 maxPwm=0;

24

25

71


26 mydata(count)=importdata([ 'download (' num2str(1) ').mat' ]); %rampe

27 mydata(count+1)=importdata([ 'download (' num2str(2) ').mat' ]);



30 mydata(count+4)=importdata([ 'allsignals(' num2str(1) ').mat' ]); %gradini

31 mydata(count+5)=importdata([ 'allsignals(' num2str(2) ').mat' ]);



34 mydata(count+8)=importdata([ 'allsignals(' num2str(5) ').mat' ]); %misti



37 mydata2(count2)=importdata([ 'allsignals(' num2str(8) ').mat' ]);

%sinusoidi rialzate, cambio struttura diversa (count1,count2 ecc)

38 mydata2(count2+1)=importdata([ 'allsignals(' num2str(9) ').mat' ]);



41

42 for i=1:n_exp

43 if(minTime >= max(mydata(count).SECONDS))

44 minTime=max(mydata(count).SECONDS);

45 Ts=mydata(count).SECONDS(31)-mydata(count).SECONDS(30);

46 end

47 tmpminPwm=min(mydata(count).SATPWM);

48 tmpmaxPwm=max(mydata(count).SATPWM);

49 if(maxPwm<abs(tmpminPwm))

50 maxPwm=abs(tmpminPwm);

51 end

52 if(maxPwm<tmpmaxPwm)

53 maxPwm=tmpmaxPwm;

54 end

55

56

57 count=count+1;

58 end

59 count=count-1;

60

61

62 for i=1:4

63 if(minTime >= max(mydata2(count2).SECONDS))

64 minTime=max(mydata2(count2).SECONDS);

65 Ts=mydata2(count2).SECONDS(31)-mydata2(count2).SECONDS(30);

66 end

67 tmpminPwm=min(mydata2(count2).SATPWM);

68 tmpmaxPwm=max(mydata2(count2).SATPWM);

69 if(maxPwm<abs(tmpminPwm))

72


70 maxPwm=abs(tmpminPwm);

71 end

72 if(maxPwm<tmpmaxPwm)

73 maxPwm=tmpmaxPwm;

74 end

75

76

77 count2=count2+1;

78 end

79 count2=count2-1;

80

81 %minTime=5;

82 %minTime=minTime/Ts;

83 %minTime = 2/Ts;

84 minTime = 120; %rampe 140

85

86 %I files delle misure (misure.txt) contegono un primo numero intero, il

87 %tempo di campionamento in millisecondi, e poi due colonne di numeri float

88 %separati da tabulazione semplice (valore dell'ingresso al motore (%PWM) e

89 %passo encoder)

90

91

92 Nfig = 1;

93 %time=zeros(minTime,count-1);

94 %dati_input=zeros(minTime,count-1);

95 %dati_output=zeros(minTime,count-1);

96

97

98 for i=1:count

99

100 %caricamento dati

101 %filep =fopen(strcat(char(stringa(i)),'measures.txt'),'r');

102 %Ts = fscanf(filep, '%d %',1)/10^6;

103 %measures = fscanf(filep, '%f %f',[2 inf]); %reading two columns of

floats

104 %measures = measures';

105 %fclose(filep);

106

107 %

108

109 time(:,i) = mydata(1,i).SECONDS(inizio_dati:minTime);

110 dati_input(:,i)

=(mydata(1,i).SATPWM(inizio_dati:minTime));%/maxPwm)*999; %input

111 dati_output(:,i) =

(mydata(1,i).COUNT(inizio_dati:minTime))*l_guida/enc_max*100;%/(2048*4);

73


trasformo enc in posizione del carrello

112

113

114 %

115 % %trasformo la misura di posizione nella misura di velocita'

116 % dati_output(1,i) = 0;

117 % for j=2:length(dati_output(:,i))

118 % dati_output(j,i) = (dati_output(j,i)-dati_output(j-1,i));

119 % end

120 %

121

122 figure(Nfig);

123 subplot(2,1,2);

124 plot(time(1:minTime-inizio_dati,i),dati_input(1:minTime-inizio_dati,i),'-r');

125 ylabel('Pwm Duty','Interpreter','Latex')

126

127 subplot(2,1,1);

128 plot(time(1:minTime-inizio_dati,i),dati_output(1:minTime-inizio_dati,i),'-b',

129 'linewidth',1.5)

130

131 ylabel('Cart position (cm)','Interpreter','Latex')

132 title('Experimental data')

133 xlabel('time (s)')

134 Nfig= Nfig +1 ;

135 end

136

137 j = i;

138

139 for i=1:count2

140

141 %caricamento dati

142 %filep =fopen(strcat(char(stringa(i)),'measures.txt'),'r');

143 %Ts = fscanf(filep, '%d %',1)/10^6;

144 %measures = fscanf(filep, '%f %f',[2 inf]); %reading two columns of

floats

145 %measures = measures';

146 %fclose(filep);

147

148 %

149

150 time(:,i+j) = mydata2(1,i).SECONDS(inizio_dati2:minTime+inizio_dati);

151 dati_input(:,i+j)

=(mydata2(1,i).SATPWM(inizio_dati2:minTime+inizio_dati));%/maxPwm)*999;

%input

74


152 dati_output(:,i+j) =

(mydata2(1,i).COUNT2(inizio_dati2:minTime+inizio_dati))*l_guida/enc_max*100;

153 %/(2048*4); trasformo enc in posizione del carrello

154

155

156 %

157 % %trasformo la misura di posizione nella misura di velocita'

158 % dati_output(1,i) = 0;

159 % for j=2:length(dati_output(:,i))

160 % dati_output(j,i) = (dati_output(j,i)-dati_output(j-1,i));

161 % end

162 %

163

164 figure(Nfig);

165 subplot(2,1,2);

166 plot(time(1:minTime-inizio_dati,i+j),dati_input(1:minTime-inizio_dati,i+j),'-r');

167 ylabel('Pwm Duty','Interpreter','Latex')

168

169 subplot(2,1,1);

170 plot(time(1:minTime-inizio_dati,i+j),dati_output(1:minTime-inizio_dati,i+j),'-b',

171 'linewidth',1.5)

172

173 ylabel('Cart position (cm)','Interpreter','Latex')

174 title('Experimental data')

175 xlabel('time (s)')

176 Nfig= Nfig +1 ;

177 end

178

179 %clear mydata;

180

181 % %% FILTRAGGIO DEI SEGNALI

182 %

183 % %%%PARAMETRI FILTRO

184 %

185 %guadagno statico del filtro

186 K = 1; %ricorda che 1 => 20 log_{10}(1) = 0 db

187 %prima pulsazione di rottura, zero

188 omega1 = 2*pi * 0.0001;

189 %seconda pulsazione di rottura, polo

190 omega2 = 2*pi * 0.00001;

191

192 tau1 = 1/omega1;

193 tau2 = 1/omega2;

194

195 Fs = tf([1],[tau1 1])*tf([1],[tau2 1]);

75


196

197 ysim=dati_output;

198 usim=dati_input;

199 yfiltrata=ysim;

200 ufiltrata=usim;

201 tsim = time;

202

203 %%

204 %calcolo vel

205 for j = 1:n_exp+4

206 for i= 1:minTime-inizio_dati

207 if i == minTime-inizio_dati

208 vel(i,j) = 0;

209 else

210 vel(i,j) = (yfiltrata(i+1,j)-yfiltrata(i,j))/Ts;

211 end

212 vel(minTime-inizio_dati+1,j) = 0;

213 end

214 end

215

216 data = merge(iddata([yfiltrata(:,1) vel(:,1)],ufiltrata(:,1),Ts),...

217 iddata([yfiltrata(:,2) vel(:,2)],ufiltrata(:,2),Ts),...













230 iddata([yfiltrata(:,15) vel(:,15)],ufiltrata(:,15),Ts));

231

232

233

234

235 %% IDENTIFICAZIONE

236

237 order=[2 1 2]; %[Ny Nu Nx]

238 t=0;

239

240 par = [0 0];

76


241 initialStates = [0 0]';

242

243

244 model = idnlgrey('LinearModelAttrito2',order,par,initialStates,t,'Name',

'Attrito');

245

246 model.Algorithm.SimulationOptions.Solver= 'ode45';

247 model.Algorithm.Display='On';

248 model.Algorithm.Tolerance=1e-7;

249 %model.Algorithm.MaxIter=300;

250 %parameter

251 %setpar(model, 'Fixed', {1 0}); %1 per vincolo , 0 per no vincolo

252 %setpar(model, 'Minimum', {0 0});

253 %setpar(model, 'Maximum', {1 1});

254

255 %zIddDataFC = iddata(dati_output(:,3),dati_input(:,3),Ts);

256

257 modelId = pem(data, model);

258

259 compare(data,modelId)

260

261 a = get(modelId,'Parameters');

262 [cd b] = a.Value;

263 %param = getparam(medelId,'Value'); % non va sul 2013

264

265 %% Funzione di attrito

266

267 u_min = 700/999*5; % in media, dipende dalla posizione della barra

268 cd = -31.0881;

269 b = 1.5309;

270 c_delta = u_min*b;

271 cd = -cd;

272 cs = cd+c_delta;

273 tc = 100; % lo fisso io, >>1

274 x = 0:0.1:10;

275 f = cd+c_delta*exp((-tc*x .^ (2)));

276 f_nn = c_delta*exp((-tc*x .^ (2)));

277 figure(1)%figure(Nfig+1)

278 plot(x,f);

279 ylabel('Cart vel','Interpreter','Latex')

280 xlabel('Friction coefficient','Interpreter','Latex')

281 title('Friction Function')

282 EstimatedAttr = b*u_min;

283

284 %% black box

77


285

286 %model1 = n4sid(data,3)

287 %compare(data,model1)

288

289 % simulink

290

291 %% Funzione di trasferimento

292

293 A = [0 1;0 -cd];

294 B = [0; b];

295 C = [1 0];

296 D = [0];

297

298 sys = ss(A,B,C,D)

299 %tf_s = ss2tf(sys);

300 %s = tf('s');

301 %tf_s = C((s*I-A)^(-1))*B+D

302

303 P_s = tf(sys);

304 P_pend = c2d(P_s,0.0025,'zoh')

78

Elenco delle �gure

1.1 Schematizzazione del robot. . . . . . . . . . . . . . . . . . . . . . . . 5

1.2 Schematizzazione del sista completo (da Matlab Tutorial). . . . . . . 5

1.3 Bilancio forze sistema completo (da Matlab Tutorial). . . . . . . . . . 6

1.4 Bilancio forze carrello . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.5 Bilancio forze pendolo. . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.6 Funzione di Attrito. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.7 Fitting tra modello ed esperimento per ingresso a rampa. . . . . . . . 17

1.8 Funzione di attrito identi�cata. . . . . . . . . . . . . . . . . . . . . . 18

1.9 Fitting tra modello ed esperimento completo. . . . . . . . . . . . . . . 19

2.1 Luogo delle radici e Risposta al gradino per Ppend. . . . . . . . . . . . 20

2.2 Risposta al gradino e Diagramma di Bode per L1. . . . . . . . . . . . 21

2.3 Sistema di controllo stabilizzante. . . . . . . . . . . . . . . . . . . . . 22

2.4 Andamento del riferimento. . . . . . . . . . . . . . . . . . . . . . . . 23

2.5 Luogo delle radici, Diagramma di Bode e Risposta al gradino. . . . . 24

2.6 Limiti per il controllo switching con isteresi . . . . . . . . . . . . . . . 26

2.7 Sistema di controllo completo . . . . . . . . . . . . . . . . . . . . . . 28

2.8 PID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2.9 Andamento dell'uscita del sistema e della variabile di controllo . . . . 29

79

ELENCO DELLE FIGURE ELENCO DELLE FIGURE

3.1 Raspberry Pi 2.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.2 Stm32f4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3 Sistema �sico realizzato . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.4 Piedinatura e schema dell' L298N . . . . . . . . . . . . . . . . . . . . 33

3.5 L298 e circuito realizzato . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.6 Motore a magneti permanenti utilizzato . . . . . . . . . . . . . . . . . 35

3.7 Schema elettrico dello statore e del rotore . . . . . . . . . . . . . . . . 35

3.8 Duty Cycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3.9 Encoder utiizzati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.10 Forme d'onda e FlipFlop con Contatore . . . . . . . . . . . . . . . . . 40

3.11 Base del pendolo incernierato alla barra munita di encoder . . . . . . 41

3.12 Carrello con pendolo . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.13 Collegamenti sul sistema �sico . . . . . . . . . . . . . . . . . . . . . . 43

3.14 Collegamenti Raspberry - Stm . . . . . . . . . . . . . . . . . . . . . . 44

3.15 Collegamenti Stm - Ponte H . . . . . . . . . . . . . . . . . . . . . . . 44

3.16 Collegamenti Stm - Encoder . . . . . . . . . . . . . . . . . . . . . . . 45

4.1 Schema generale di MARTe. . . . . . . . . . . . . . . . . . . . . . . . 47

4.2 Schermata di MARTe. . . . . . . . . . . . . . . . . . . . . . . . . . . 48

4.3 Schema Master - Slave . . . . . . . . . . . . . . . . . . . . . . . . . . 49

4.4 Scambio dati tra Master e Slave . . . . . . . . . . . . . . . . . . . . . 49

4.5 Comunicazione tra Master e Slave . . . . . . . . . . . . . . . . . . . . 50

5.1 Logger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

5.2 Interfaccia Browser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

5.3 Interfaccia Browser, FlotPlot . . . . . . . . . . . . . . . . . . . . . . . 55

80

ELENCO DELLE FIGURE ELENCO DELLE FIGURE

5.4 Interfaccia Browser, Download .mat . . . . . . . . . . . . . . . . . . . 55

81

Bibliogra�a

[1] , `Fondamenti di controlli automatici', McGraw-Hill, 2008.

[2] , `Sistemi dinamici', HOEPLI, 2008.

[3] , `Matlab Tutorials', Inverted Pendulum: System Modeling

[4] , `Controllo in corrente di un motore DC', Tesi di Pierluigi Di Franco, 2010

[5] , `Analisi e prima realizzazione di un prototipo segway', Tesi di Gianluca

Capparelli, 2009

82

Date post:	15-Feb-2019
Category:	Documents
Upload:	vokhanh
View:	214 times
Download:	0 times

UNIVERSITÀ DEGLI STUDI DI ROMA TOR VERGATA...

Documents