tesi - leet.it · Title: Microsoft Word - tesi.doc Author: Claudio Created Date: 12/23/2005 2:15:41 PM

POLITECNICO DI MILANO

Facoltà di Ingegneria

Corso di Laurea in Ingegneria Informatica

STUDIO E REALIZZAZIONE DI UN BRACCIO ROBOTICO

ANTROPOMORFO E SOLUZIONE DELLA CINEMATICA

INVERSA MEDIANTE RETE NEURALE

Relatore: Prof.ssa Giuseppina GINI

Correlatore: Dott. Ing. Michele FOLGHERAITER

Tesi di Laurea di :

Fortunato MARZAGALLI Matr. 647152

Claudio Sergio MATTIONI Matr. 645620

Anno Accademico 2002-2003

Indice

PARTE A................................................................................................................8 IL MODELLO.......................................................................................................8

Capitolo 1.......................................................................................................................9 Progettazione di un arto robotico antropomorfo..........................................................9

1.1 ALCUNE CONVENZIONI...........................................................................................................9 1.2 LA STRUTTURA DELL’ARTO ANTROPOMORFO...........................................................10

1.2.1 LO SCHELETRO ............................................................................................................................... 10 1.2.2 LE ARTICOLAZIONI....................................................................................................................... 11 1.2.3 L’APPARATO MUSCOLARE.......................................................................................................... 12

Adduzione - abduzione dell’omero ................................................................................................................. 12 Rotazione dell’omero......................................................................................................................................... 14 Adduzione - abduzione del radio..................................................................................................................... 15

1.3 IL MODELLO GEOMETRICO .................................................................................................16 1.3.1 LA CINEMATICA DIRETTA ......................................................................................................... 17

Adduzione – abduzione dell’omero ................................................................................................................ 17 Rotazione dell’omero......................................................................................................................................... 18 Adduzione-abduzione del radio ....................................................................................................................... 19

1.3.2 LA CINEMATICA INVERSA.......................................................................................................... 20 1.4 RISULTATI ......................................................................................................................................21

1.4.1 SPAZIO DI LAVORO....................................................................................................................... 22 1.4.2 STUDIO DI FATTIBILITA’ ............................................................................................................ 23

Capitolo 2 ....................................................................................................................25 Il sistema articolare .....................................................................................................25

2.1 LA SPALLA ......................................................................................................................................25 2.2 IL GOMITO.....................................................................................................................................29

Capitolo 3 .................................................................................................................... 31 Il sistema muscolare ................................................................................................... 31

3.1 L’ATTUATORE DI MCKIBBEN...............................................................................................31 3.1.1 COSTRUZIONE DI UN ATTUATORE DI MCKIBBEN........................................................ 32 3.1.2 CARATTERISTICHE DI UN ATTUATORE DI MCKIBBEN............................................... 33

3.3 L’INSTALLAZIONE DEI MUSCOLI DI MCKIBBEN........................................................35 3.3 IL CIRCUITO PNEUMATICO...................................................................................................36

Capitolo 4 ....................................................................................................................38 Il sistema sensoriale ....................................................................................................38

4.1 SENSORI DI FORZA....................................................................................................................38 4.2 SENSORI DI ACCORCIAMENTO ...........................................................................................39 4.3 SENSORE ANGOLARE ..............................................................................................................42

Capitolo 5 ....................................................................................................................43 Conclusioni..................................................................................................................43

5.1 LE PRESTAZIONI.........................................................................................................................43

5.1.1 RIGIDITA’ DEI GIUNTI................................................................................................................. 44 5.1.2 LO SPAZIO DI LAVORO................................................................................................................ 44

5.2 LA ROBUSTEZZA.........................................................................................................................46 5.3 PROSSIMI SVILUPPI ....................................................................................................................46

PARTE B..............................................................................................................47 LA RETE NEURALE .........................................................................................47

Capitolo 6 ...................................................................................................................48 Le reti neurali ..............................................................................................................48

6.1 INTRODUZIONE .........................................................................................................................48 6.2 FUNZIONAMENTO DEL CERVELLO BIOLOGICO ......................................................49 6.3 IL NEURONE ARTIFICIALE STANDARD ..........................................................................52 6.4 DEFINIZIONE DELLE RETI NEURALI ..............................................................................53 6.5 APPRENDIMENTO NELLE RETI NEURALI .....................................................................55

6.5.1 ALGORITMO DI BACK-PROPAGATION ................................................................................ 56 6.6 TIPOLOGIE DI RETI NEURALI .............................................................................................59

6.6.1 RETI LINEARI STANDARD.......................................................................................................... 59 6.6.2 RETI FEED-FORWARD.................................................................................................................. 60 6.6.3 RETI A BASE RADIALE ................................................................................................................. 60

6.7 VANTAGGI E SVANTAGGI DELLE RETI NEURALI.....................................................62 Capitolo 7 ....................................................................................................................64 Cinematica inversa risolta mediante reti neurali ........................................................64

7.1 INTRODUZIONE .........................................................................................................................64 7.2 MODELLAZIONE DI RETI NEURALI IN MATLAB........................................................65

7.2.1 CREAZIONE DELLA RETE NEURALE ............................................................................................ 66 7.2.2 GENERAZIONE DEI DATI DI TRAINING ............................................................................ 67 7.2.3 NORMALIZZAZIONE DEI DATI DI TRAINING ................................................................. 68 7.2.4 ADDESTRAMENTO DELLA RETE NEURALE...................................................................... 69

7.3 SOLUZIONE DELLA CINEMATICA INVERSA.................................................................71 7.4 ANALISI DELLE PRESTAZIONI ........................... Errore. Il segnalibro non è definito. 7.5 IMPLEMENTAZIONE DELLA RETE NEURALE IN SIMULINK................................78 7.6 PROBLEMATICHE DI INTERFACCIAMENTO AL ROBOT .........................................82 7.7 CONCLUSIONI............................................................. Errore. Il segnalibro non è definito.

PARTE C..............................................................................................................85 ALLEGATI ..........................................................................................................85

Bibliografia..................................................................................................................86 Allegato A ....................................................................................................................87 Il braccio antropomorfo: il modello reale ...................................................................87

A.1 CARATTERI GENERALI COSTRUTTIVI .............................................................................87 A.1.1 SCHELETRO DEL BRACCIO........................................................................................................ 88 A.1.2 SCHELETRO DELL’AVAMBRACCIO ........................................................................................ 88

A.2 LE ARTICOLAZIONI DELL’ARTO SUPERIORE ..............................................................89 A.2.1 ARTICOLAZIONE SCAPOLO-OMERALE ............................................................................... 89 A.2.2 ARTICOLAZIONE DEL GOMITO.............................................................................................. 91

A.3 MUSCOLI DELL’ARTO SUPERIORE.....................................................................................91 A.3.1 MUSCOLI AXO-APPENDICOLARI.........................................................................................................92

MUSCOLI TORACO-APPENDICOLARI ................................................................................................. 92

Muscolo grande pettorale.................................................................................................................................. 92 MUSCOLI SPINO-APPENDICOLARI....................................................................................................... 93 Muscolo grande dorsale .................................................................................................................................... 93

A.3.2 MUSCOLATURA INTRINSECA DELL’ARTO....................................................................................93 MUSCOLI DELLA SPALLA.......................................................................................................................... 93 Muscolo deltoide................................................................................................................................................ 93 Muscolo sottoscapolare..................................................................................................................................... 94 Muscolo sovraspinato........................................................................................................................................ 94 MUSCOLI DEL BRACCIO............................................................................................................................ 95 Muscolo bicipite ................................................................................................................................................. 95 Muscolo tricipite................................................................................................................................................. 95

Allegato B ....................................................................................................................97 Funzioni implementate...............................................................................................97

Bestdemo.............................................................................................. Errore. Il segnalibro non è definito. Demoarm .......................................................................................................................................................... 101 Dist..................................................................................................................................................................... 103 Generatetd ........................................................................................................................................................ 104 Ikine ................................................................................................................................................................... 106 Init ...................................................................................................................................................................... 107 Inverse ............................................................................................................................................................... 109 Mostraerrore ..................................................................................................................................................... 112 Movearm ........................................................................................................................................................... 114 Moveforearm .................................................................................................................................................... 116 Muovibraccio .................................................................................................................................................... 117 Newnet .............................................................................................................................................................. 118 Newtrain............................................................................................................................................................ 119 Normalizetd ...................................................................................................................................................... 120 Plotarm .............................................................................................................................................................. 121 Plotlink............................................................................................................................................................... 123 Resetarm............................................................................................................................................................ 124 Rotarm............................................................................................................................................................... 125 Test..................................................................................................................................................................... 126 Worstdemo ....................................................................................................................................................... 128

Allegato C .................................................................................................................. 130 Funzioni utilizzate .................................................................................................... 130

Sim ..................................................................................................................................................................... 130 Train................................................................................................................................................................... 132 Newff ............................................................................................................................................. 134

Introduzione

“-La domanda che voglio farle, dottore, è questa: perché i robot hanno forma umana? Che bisogno c’è che un

automa abbia una testa e quattro arti?

-Vuol dire perché non li costruiamo funzionalmente, come le altre macchine?

-Esatto. Perché?

-Perché in natura, la forma umana è quella di maggior successo.”

(Isaac Asimov – Abissi d’acciaio)

L’idea del robot risale ai tempi antichi, quando alcuni miti raccontavano di creature

meccaniche portate alla vita.

Oggi il termine automa è applicato, nel linguaggio comune, ai dispositivi artigianali, di solito

più meccanici che elettromeccanici, realizzati per imitare i movimenti degli esseri viventi.

Il termine robot, dalla radice ceca che vuol dire “lavoro forzato”, rappresenta un omaggio alla

fantasia di Karel Capek, che lo usò per la prima volta nel senso comunemente inteso nel

famoso racconto R.U.R.

I robot, come sono oggi intesi in campo tecnico, non sono invece imitazioni di esseri umani o

di altre forme viventi, se non per l’aspetto limitato di riprodurne la mobilità. Le radici del loro

sviluppo sono da ricercare nello sforzo di automatizzare le operazioni richieste dalla

produzione industriale.

L’automatizzazione del lavoro manuale iniziò nel diciottesimo secolo, ma veri robot non

furono realizzabili però fino all’invenzione, negli anni quaranta, dei computer, e fino alla

miniaturizzazione dei loro componenti.

Tuttavia, per vedere l’applicazione dei robot su vasta scala, è necessario attendere fino agli anni

Ottanta, quando il loro costo comincia ad essere competitivo rispetto alle soluzioni

tradizionali, e da allora risulta inverosimile pensare ad una fabbrica senza applicazioni

robotiche.

Non è possibile predire se e quando gli androidi della fantascienza diverranno una realtà;

infatti anche l’imitazione di un’azione apparentemente semplice come il camminare si è

dimostrata estremamente difficoltosa per i robot umanoidi , fra cui citiamo il recente Honda

robot.

Da questa breve introduzione storica si intuisce come mai parlare di robotica oggi significhi

spaziare in ambiti estremamente diversi.

Anche restringendo secondo il nostro interesse la trattazione ai soli robot manipolatori,

bisogna per lo meno identificare tre macroaree radicalmente distinte: il campo dei

manipolatori robotici industriali, il settore delle protesi mediche e la ricerca sulla robotica

antropomorfa.

Lo spirito che anima la prima è la volontà di rendere i processi industriali efficienti e

caratterizzati da alti standard di qualità, con la predilezione quindi di arti robotici funzionali.

Per il secondo settore, la volontà è costruire arti che assomiglino come forma e mobilità agli

arti umani, e che permettano l’innalzamento della qualità della vita delle vittime di amputazioni

o malformità. E’ quindi evidente come il fulcro del lavoro sia la ricerca della miniaturizzazione

dei componenti e di soluzioni riguardanti l’interfacciamento con il corpo umano.

E’ il terzo settore quello che ci interessa maggiormente descrivere.

Nel settore della ricerca il motore primo è proprio quanto descritto nella citazione iniziale,

ossia capire come mai la forma umana, assolutamente non specializzata, abbia avuto un tale

successo, e ripeterne le fattezze in una macchina.

Fioriscono per questo schiere di robot assolutamente “inutili”, se visti in ottica industriale.

Il robot che cammina (ma che se cade è spacciato) o quello che riesce a rialzarsi (ma non a

camminare), quello che fa anche le scale, quello che segue le persone.

E’in questo ambito di ricerca che si colloca il nostro lavoro.

Alla base del nostro lavoro sta un progetto, ideato e curato dall’ ing. Michele Folgheraiter che

si propone di fondere realtà virtuale, intelligenza artificiale e robotica antropomorfa in un

indagine delle caratteristiche del movimento dell’arto superiore e della la mano.

All’inizio del nostro lavoro esisteva già un prototipo di braccio in montaggio in laboratorio.

Questo prototipo comprendeva un giunto della spalla realizzato con una sfera (vedi par. 2.1) e

aveva alcuni attuatori e le schede di comunicazione già montate. Non esisteva ancora nulla per

quanto concerne lo studio delle reti neurali per i nostri scopi.

Il nostro lavoro aveva quindi l’obiettivo di realizzare una struttura scheletrico – muscolare

antropomorfa, e un meccanismo realtime basato sulle reti neurali per la generazione del

movimento.

Da una parte quindi, partendo dallo studio del prototipo di braccio realizzato dall’ing.

Folgheraiter, se ne è studiata la struttura, e in base ad un analisi sia del modello teorico che del

prototipo si sono evidenziati i pregi e sono state trovate strutture alternative per correggerne i

difetti. Si è giunti quindi alla realizzazione un secondo prototipo, con prestazioni sodisfacenti.

Dall’altra, partendo dalla conoscenza attuale delle reti neurali, si è compiuta un analisi delle

tipologie principali, per trovare l’architettura più adatta per risolvere l’algoritmo di cinematica

inversa, e in base a questa scelta, si è realizzata una applicazione realtime di comando per il

robot.

La relazione che segue serve a presentare i progressi fatti, i risultati ottenuti e i punti di

miglioramento, ed è organizzata secondo lo schema seguente.

Nel capitolo 1 sono riportati i passi principali della progettazione compiuta sul robot, a partire

dall’analisi del prototipo. Del progetto vengono sottolineate le specifiche principali e gli indici

di qualità.

Nel capitolo 2 vengono presentate le soluzioni ad hoc utilizzate per realizzare le articolazioni e

la struttura in genere del prototipo.

Nel capitolo 3 viene presentato l’attuatore di McKibben, e viene analizzato il suo montaggio

sul braccio robotico, con riferimento alle problematiche evidenziate durante la progettazione.

Nel capitolo 4 si descrivono i sensori utilizzati, con particolare attenzione alla loro

costruzione e al montaggio.

Nel capitolo 5 vengono tratte le conclusioni, relativamente alla struttura del braccio robotico, e

alle sue caratteristiche funzionali e morfologiche.

Nel capitolo 6 si presentano le reti neurali e ne viene spiegato il funzionamento, analizzando le

affinità con il cervello biologico e i vantaggi e gli svantaggi derivanti dal loro utilizzo in

problemi simili al nostro.

Nel capitolo 7 verrà invece proposto un metodo di soluzione della cinematica inversa tramite

rete neurale che presenta una buona approssimazione all'interno dello spazio di lavoro e un

elevata velocità di calcolo che ha permesso lo sviluppo di un'applicazione real-time per il

controllo.

PARTE A

IL MODELLO

Progettazione di un arto robotico antropomorfo _________________________________________________________________________

-9-

Capitolo 1

Progettazione di un arto robotico antropomorfo

Obiettivo della progettazione del braccio robotico è la ricerca del modello che più possibile rispecchi il braccio reale, come geometria dei link, come posizionamento e azione degli attuatori, nel tentativo di riprodurre più fedelmente possibile la mobilità e la struttura dell’arto superiore umano.

1.1 ALCUNE CONVENZIONI

Lo strumento scelto per la progettazione è stato Matlab, per la sua indubbia flessibilità, la

facilità con cui è possibile rappresentare graficamente i movimenti, e la possibilità di

interfacciamento con altri tools di realtà virtuale, rendendo possibile in un futuro animare il

nostro modello tramite realtà virtuale.

Per poter rappresentare il braccio nello spazio tridimensionale messo a disposizione da Matlab,

abbiamo dovuto fissare alcune convenzioni. Si è scelto quindi un braccio destro, e si è posto

l’origine degli assi nel centro della spalla. La terna cartesiana è stata posta avente l’asse X

uscente a destra della spalla (ossia adagiato sul piano frontale), l’asse Y uscente in avanti (sul

piano sagittale) e l’asse Z determinato da una convenzione destrorsa.

Uno degli aspetti che più ci premeva di controllare, nella fase di progettazione, era l’azione dei

muscoli. Volendo utilizzare un sistema muscolare simile a quello umano, l’obiettivo era trovare

una configurazione degli attuatori che potesse lavorare solo in trazione. Per studiare questo


-10-

aspetto abbiamo posto, per convenzione, che i muscoli che stessero lavorando in trazione

fossero di colore rosso, mentre quelli in elongazione fossero rappresentati in verde.

1.2 LA STRUTTURA DELL’ARTO ANTROPOMORFO

In Matlab il braccio è stato rappresentato come un insieme di segmenti, essi stessi

rappresentabili semplicemente con le coordinate dei loro estremi. Modellare il movimento del

braccio è equivalso quindi a generare trasformazioni (per lo più rotazioni) di punti che fossero

coerenti con il loro significato fisico. Era necessario quindi verificare che per nessuna ragione

le ossa modificassero durante il movimento la loro lunghezza e che le estremità dei muscoli

giacessero sul segmento congiungente i due capi dell’osso (ossia non se ne distaccassero) e che

permettessero solo movimenti che trovassero un corrispettivo nel caso reale. E’ stata a tal fine

creata una funzione di test per verificare tutte queste condizioni. (Vd allegato B, funzione

TEST)

Il seguito della descrizione ricalca la struttura seguita nell’analisi del braccio umano, e la

divisione in paragrafi trova corrispondenza con la divisione in paragrafi dell’allegato A.

1.2.1 LO SCHELETRO

L’apparato scheletrico del modello è estremamente semplice. Poiché si è deciso di eliminare

l’articolazione sterno-claveare, non si è sentito il bisogno di rappresentare la clavicola e i suoi

complessi movimenti sulla cassa toracica. Uniche ossa rappresentate quindi, le tre ossa lunghe

dell’arto superiore umano ovvero omero, ulna e radio.

Tramite un processo di analisi, si è deciso poi di effettuare due ulteriori modifiche.

Non dovendo rappresentare il movimento rotatorio dell’ulna sul radio (o più comunemente, la

rotazione del polso), abbiamo optato per rappresentare ulna e radio come un unico osso.

Inoltre abbiamo deciso di rappresentare l’omero come un osso rettilineo (e non a forma di L,

come sarebbe più sensato rappresentare il femore), in quanto la testa dell’osso risulta

praticamente centrata sull’asse dell’osso (vedi allegato B).

In fase avanzata di progettazione, per risolvere il problema della gestione del grado di libertà

della spalla, che nel braccio reale è dovuto all’azione della cosiddetta “cuffia rotatoria”,


-11-

abbiamo aggiunto una tuberosità sulla testa dell’omero uscente secondo l’asse X. Il perché di

tale scelta è spiegato in seguito.

1.2.2 LE ARTICOLAZIONI

L’articolazione scapolo-omerale pur essendo dotata di tre gradi di libertà ha una mobilità

abbastanza ridotta. Infatti come visto nello studio del braccio umano, l’ampia mobilità

dell’arto è dovuta alla somma della mobilità dell’articolazione scapolo - omerale con la mobilità

dell’articolazione sterno - claveare.

Figura 1.1 : Traduzione grafica dell'escursione massima di circumduzione della parte libera dell'arto sul tronco per

effetto della sommazione delle libertà di movimento dell'articolazione scapolo-omerale e della articolazione sterno-

claveare: l’ellissoide piccolo rappresenta il cono di circumduzione dell'articolazione scapolo-omerale, l’ellissoide

maggiore indica l'escursione per sommazione del movimento dell'articolazione sterno-claveare


-12-

Per creare un modello che assomigli il più possibile a questa configurazione, abbiamo imposto

che il gomito (e quindi tutta la struttura del braccio) giaccia nell’ottante di spazio caratterizzato

dall’avere coordinate X e Y positive, e Z negative, secondo la convenzione adottata.

L’articolazione del gomito risulta essere invece caratterizzata da un solo grado di libertà.

Per semplicità non si sono messi vincoli sull’ adduzione dell’avambraccio, in maniera diversa

dal caso reale, in cui l’adduzione massima riduce l’angolo tra braccio e avambraccio a circa 30

gradi.

1.2.3 L’APPARATO MUSCOLARE

Sulla base degli stessi criteri topografico - funzionali utilizzati in medicina, il movimento

dell’arto è stato suddiviso in tre movimenti fondamentali, ciascuno dei quali associato ad un

gruppo di muscoli.

Adduzione - abduzione dell’omero

Questo movimento serve a fissare la posizione del gomito all’interno della sua regione di

mobilità, che abbiamo definito essere un cono corrispondente ad un ottante dello spazio che

circonda il giunto.

Nel caso reale sono circa una decina i muscoli che collaborano a formare questo movimento.

In fase di analisi si è rilevato che lo stesso movimento (dal punto di vista dello spazio

raggiungibile) può essere compiuto utilizzando solo tre di questi dieci muscoli. Tale

semplificazione rende radicalmente più facile la gestione del modello, ma non è esente da

problemi. Il più notevole, evidente nella successiva fase di creazione del braccio in laboratorio,

risulta essere la difficoltà nel raggiungere alcune posizioni alle estremità dello spazio di lavoro.

Infatti per posizioni particolari del braccio, alcuni muscoli, pur avendo una forza

considerevole (Vd. Cap. 3 ) risultano avere un braccio estremamente ridotto, in alcuni casi

addirittura insufficiente per compiere la rotazione. Si capisce quindi il motivo della

sovrabbondanza di muscoli nel braccio umano: per compiere un solo movimento, vi è il

bisogno di più muscoli, che agiscano in successione su diversi archi del movimento.


-13-

Figura 1.2 :I muscoli della spalla. Si possono osservare, in visione frontale, il pettorale (in alto, a destra), il dorsale (in

basso, a destra) e il deltoide (a sinistra), ancorati all’omero.

Dalla figura 1.2 si può apprezzare il posizionamento degli attacchi dei muscoli, progettato

appositamente per permettere il movimento dell’arto in tutte le posizioni permesse

dall’articolazione, con solo azioni di trazione da parte dei muscoli.

Il deltoide, che è caratterizzato dall’avere l’origine (estremità del muscolo a monte

dell’articolazione interessata) posizionata esattamente sopra il centro della spalla e l’inserzione

(estremità del muscolo a valle dell’articolazione) posizionata verso la metà dell’omero, presenta

due caratteristiche peculiari. Per prima cosa si nota come la sua contrazione risulti avere

effetto solo sul grado di elevazione del braccio e non sullo spostamento del braccio sul piano

sagittale, inoltre il posizionamento dell’inserzione molto in basso gli permette di avere

un’azione notevole in condizione di massima elevazione del braccio (utile per esempio, per

reggere degli oggetti).

In maniera analoga, il pettorale ha l’origine esattamente a lato rispetto al centro della spalla, di

modo da poter agire esclusivamente sul movimento sul piano orizzontale del braccio, e

risultare ininfluente ai fini del movimento sagittale.

Risulta poi avere un inserzione estremamente vicina ala spalla, non avendo bisogno di

applicare forze considerevoli, il che fa si che l’escursione tra lunghezza massima e minima sia

contenuta.

L’ultimo muscolo è il dorsale, che risulta essere antagonista di entrambi i muscoli citati prima.

In generale esso adduce il braccio quando pettorale o deltoide lo abducono, e serve per


-14-

abbassare il braccio se utilizzato insieme al pettorale (azione antagonista rispetto al deltoide), o

per farlo arretrare, se utilizzato insieme al deltoide (azione antagonista rispetto al deltoide).

Rotazione dell’omero

In fase di modellazione, trovare una strategia efficace che permettesse in una maniera semplice

di gestire e utilizzare il terzo grado di libertà della spalla è stato il punto più critico e rimane

uno dei punti da migliorare.

Segue quindi una descrizione dettagliata del problema e della soluzione adottata.

Fissata la posizione dell’omero tramite l’azione di pettorale, deltoide e dorsale, il braccio

umano presenta ancora un grado di libertà residuo, più precisamente quello che gli permette di

ruotare il gomito attorno all’asse dell’omero. I muscoli che comandano questo movimento

sono tutti molto corti e raccolti attorno all’articolazione scapolo-omerale, e vengono

denominati complessivamente “cuffia rotatoria”.

Di questi è possibile analizzarne solo due, il sopraspinato e il sottoscapolare, che per la loro

posizione in configurazione antagonista riescono da soli a generare il movimento in questione.

Entrambi i muscoli hanno origine sulla scapola (per la precisione uno su ciascuna faccia) e si

inseriscono sulla piccola tuberosità della testa dell’omero (nel modello rappresentato come un

escrescenza della testa dell’omero perpendicolare al piano che ospita il movimento

dell’avambraccio).

Nel braccio umano, per ogni posizione assunta dal braccio, l’azione combinata dei muscoli

della cuffia contribuisce solo con una rotazione del braccio attorno al proprio asse e non ne

determina in nessun caso una rotazione attorno alla spalla.

La soluzione adottata, pur patendo a causa delle eccessive ipotesi semplificative, garantisce

tutte queste proprietà.


-15-

Figura 1.3: Visione posteriore del braccio: in basso il muscolo sopraspinato e in alto il sottoscapolare

I due muscoli sono rappresentati ciascuno da due segmenti e i due segmenti più piccoli di

ciascun muscolo, che si innestano sulla cima della piccola tuberosità della testa dell’omero

hanno origine in due punti opposti rispetto al centro di rotazione della spalla.

Questa particolare configurazione fa sì che le azioni della terna di muscoli adduttori-abduttori

e della coppia rotatoria siano scorrelate.

Inoltre la posizione dei due punti opposti rispetto al centro (quello anteriore spostato verso

sinistra e in alto, quello posteriore verso destra e in basso), è stata ideata al fine di permettere

ai due muscoli di avere un azione rotatoria antagonista efficace per qualunque posizione del

braccio nello spazio ammissibile.

Come si vedrà più ampiamente in seguito, in fase di realizzazione sono scaturite alcune

problematiche a causa delle ipotesi semplificative su cui è basata la progettazione della spalla.

In particolare non è stato possibile realizzare i tratti sopraccitati dei muscoli sottoscapolare e

sopraspinato con dei tendini rettilinei, per la necessità di rendere il giunto della spalla tramite

l’utilizzo di una sfera.

Adduzione - abduzione del radio

Il terzo movimento, fissata la posizione e la rotazione dell’omero tramite l’azione dei muscoli

esposti prima, comanda lo spostamento dell’avambraccio. I muscoli modellati sono due,

bicipite e tricipite.


-16-

Figura 1.4: Braccio (con i suoi muscoli) e avambraccio. Si possono osservare il bicipite ( in alto ) che contraendosi

determina l’avvicinamento del radio all’omero e il tricipite (in basso, seminascosto dal braccio stesso), che

contraendosi allinea l’avambraccio al braccio.

Mentre la collocazione del bicipite risulta estremamente chiara, una nota esplicativa merita

forse la posizione del tricipite. Come nel caso reale, esso ha origine nella parte alta dell’omero

e ne costituisce lungo tutta la lunghezza il rivestimento posteriore, per poi piegare attorno al

gomito e attaccarsi nella parte iniziale dell’ulna.

Nel modello, per far sì che per ogni posizione dell’avambraccio il tricipite avesse un’azione

non nulla, è stata aggiunta una tuberosità lungo l’omero, che sposta l’azione del tricipite un

poco più verso il basso e ne impone il braccio massimo d’azione.

1.3 IL MODELLO GEOMETRICO

Per visualizzare il braccio, sono state create appositamente alcune funzioni di Matlab.

La funzione INIT (che si può trovare nell’allegato B), inizializza le costanti fondamentali del

braccio, mentre la funzione RESETARM (Vd. allegato B) posiziona il braccio nella posizione

di riposo. Da questo momento in poi ogni chiamata alla funzione PLOTARM visualizza la

posizione attuale del braccio.


-17-

Figura 1.5 : visualizzazione della struttura completa del braccio

Particolare importanza, per analizzare la geometria del braccio, l’analisi delle funzioni che

costituiscono lo studio della cinematica diretta e inversa.

1.3.1 LA CINEMATICA DIRETTA

Scrivere un algoritmo di cinematica diretta significa, nel nostro caso, determinare la posizione

del braccio, e in particolare del polso, partendo dalle lunghezze dei muscoli.

Seguendo la classificazione esposta precedentemente, il codice che genera il movimento del

braccio è stato suddiviso in tre funzioni corrispondenti alle tre azioni distinte, ciascuna delle

quali indipendente dalle altre e originata dall’azione di differenti gruppi muscolari.

Adduzione – abduzione dell’omero

Il movimento è governato dall’azione di tre muscoli ma, come accennato, questo problema ha

2 gradi di libertà. Da ciò si deduce che il valore della lunghezza di uno dei muscoli deve

dipendere dalle lunghezze degli altri due.

E’ possibile allora in maniera facile utilizzare di volta in volta le lunghezze dei due muscoli

attivi, cioè in contrazione, per trovare la posizione del braccio e quindi risalire alla lunghezza

del muscolo passivo.


-18-

La funzione che gestisce questo movimento si chiama MOVEARM (vedi allegato B), e si basa

sulla risoluzione di un sistema di 3 equazioni in 3 incognite (le coordinate di un punto del

braccio) in forma simbolica.

Nel caso in cui si stiano contraendo il pettorale e il dorsale, ossia il braccio si stia abbassando,

il sistema di equazioni si presenta nella forma seguente:

=−+−+−=−+−+−=−+−+−

2222

2222

2222

).,())1,3(())1,2(())1,1((.))1,3(.())1,2(.())1,1(.(.))1,3(.())1,2(.())1,1(.(

INSERTPECTSHOULDERdistshoulderzshoulderyshoulderxlengthdorsorigindorszorigindorsyorigindorsxlengthpectoriginpectzoriginpectyoriginpectx

Nel sistema le incognite x, y, z rappresentano il punto del braccio in cui si inseriscono sia il

pettorale che il dorsale. Le prime due equazioni impongono che la distanza tra i due estremi

del muscolo, in un caso pettorale e nell’altro dorsale, sia uguale alla lunghezza comandata,

mentre la terza impone la condizione per cui alla fine del movimento la posizione dell’attacco

dei muscoli rispetto all’osso non risulti modificata. In particolare shoulder e pect.insert (come

tutte le variabili scritte in corsivo) sono i valori attuali del braccio, mentre SHOULDER e

PECT.INSERT (come tutte le variabili scritte in stampato) sono i valori iniziali.

Si omette di riportare il sistema relativo agli altri due casi, in cui cambia la coppia di muscoli

attivi, poiché l’unica modifica rilevante, dovuta alla necessità di scalare i valori essendo

l’inserzione del deltoide non coincidente con l’inserzione di pettorale e dorsale, rende

difficilmente leggibile il sistema.

Qualunque sia la scelta della coppia di muscoli attivi, trovare un punto dell’omero equivale a

trovarne l’orientamento, e da questo dato è possibile ricavare con semplici proporzioni le

posizioni di tutti gli altri punti notevoli solidali all’omero.

Rotazione dell’omero

La funzione ROTARM contiene la seconda parte dell’algoritmo di cinematica diretta. Una

volta che MOVEARM ha fissato la posizione dell’asse dell’omero, la ROTARM, che simula il

funzionamento dei muscoli della cuffia rotatoria, impone la rotazione dell’omero intorno al

suo asse.

A livello geometrico, il problema si riduce a fissare la posizione della piccola tuberosità della

testa dell’omero, che dovendo giacere sul piano perpendicolare all’asse dell’omero, presenta

solo un grado di libertà.


-19-

Anche in questo caso quindi abbiamo che dei due muscoli che controllano il movimento, ne

esisterà sempre uno attivo e uno passivo, ossia uno in contrazione e uno in estensione.

=−+−+−=++

=−+−+−

2222

2222

).,())1,3(())1,2(())1,1((0))1,3(*())1,2(*())1,1(*(

.))1,3(.())1,2(.())1,1(.(

INSERTSUPRSHOULDERdistshoulderzshoulderyshoulderxelbowzelbowyelbowx

lengthsubsoriginsubszoriginsubsyoriginsubsx

Nel sistema presentato si è utilizzata una simbologia lievemente diversa da quella utilizzata in

Matlab per scrivere la ROTARM, che ne aumenta la leggibilità, senza togliere validità al

sistema.

In questo caso x, y, z rappresentano le coordinate dell’estremità della piccola tuberosità e le

condizioni imposte rappresentano in ordine:

⋅ L’azione del sottoscapolare, ossia l’accorciamento deve corrispondere

all’avvicinamento dei due estremi del muscolo;

⋅ La rigidità dell’osso, ossia la piccola tuberosità deve rimanere perpendicolare all’omero;

⋅ La conservazione delle distanze, ossia la lunghezza della piccola tuberosità deve

rimanere invariata.

Come si può notare, il caso simmetrico non presenta nessuna differenza.

=−+−+−=++

=−+−+−

2222

2222

).,())1,3(())1,2(())1,1((0))1,3(*())1,2(*())1,1(*(

.supr))1,3(.supr())1,2(.supr())1,1(.supr(

INSERTSUPRSHOULDERdistshoulderzshoulderyshoulderxelbowzelbowyelbowx

lengthoriginzoriginyoriginx

Adduzione-abduzione del radio

Le prime due parti dell’algoritmo fissano la posizione del gomito (MOVEARM) e il suo

orientamento (ROTARM). A questo punto il polso, insieme a tutto l’avambraccio può solo

trovarsi nel piano passante per il gomito e perpendicolare all’asse della piccola tuberosità. Il

problema presenta quindi un grado di libertà residuo.

Anche in questo caso i muscoli sono due, ma solo quello attivo verrà preso in considerazione.

=−+−+−=++

=−+−+−

2222

2222

).,())1,3(())1,2(())1,1((0))1,3(.*())1,2(.*())1,1(.*(

.))1,3(.())1,2(.())1,1(.(

INSERTBICELBOWdistelbowzelbowyelbowxinsertsubszinsertsubsyinsertsubsx

lengthbicoriginbiczoriginbicyoriginbicx

=−+−+−=++

=−+−+−

2222

2222

).,())1,3(())1,2(())1,1((0))1,3(.*())1,2(.*())1,1(.*(.))1,3(.())1,2(.())1,1(.(

INSERTTRICELBOWdistelbowzelbowyelbowxinsertsubszinsertsubsyinsertsubsx

lengthtricorigintriczorigintricyorigintricx


-20-

La prima equazione, come nei casi precedenti, impone l’azione del muscolo, sia esso tricipite o

bicipite, la seconda impone la condizione di perpendicolarità con la piccola tuberosità (ossia fa

in modo che venga garantito un solo grado di libertà al gomito), mentre la terza impone che i

punti dell’avambraccio non modifichino la loro distanza reciproca.

Come nella MOVEARM, anche qui l’algoritmo si conclude aggiornando tutti i punti

dell’avambraccio in base all’informazione di direzione contenuta nella terna x, y, z.

1.3.2 LA CINEMATICA INVERSA

Come l’esperienza comune conferma, il braccio umano ha 4 gradi di libertà. La soluzione di un

algoritmo di cinematica inversa, fissata la posizione del polso, troverà necessariamente infinite

soluzioni (tranne per posizioni particolari del polso ai margini dello spazio di lavoro. Questo è

un problema che, come si è riscontrato in lavori analoghi [ 2 ], può compromettere il training

della rete neurale.

Un suggerimento per risolvere il problema è stato trovato su un articolo di Ogihara &

Yamazaki [ 1 ]:

“although human upper extremities have redundant degrees of freedom which enables various ways of motion to

accomplish a certain task, human motion is mostly achieved as a fixed pattern; there are no much differences in

motion for all people.”

Abbiamo ripetuto questa osservazione e abbiamo verificato che soggetti diversi, dovendo

porre la mano nella medesima posizione, assumono posizioni del gomito estremamente

analoghe, in accordo con l’ipotesi sopra citata.

Si è creato quindi un algoritmo che approssimasse tale comportamento.

Secondo l’osservazione compiuta, in prima approssimazione il piano passante per spalla,

gomito e polso è inclinato di 20° rispetto al piano verticale, con il gomito ruotato verso

l’esterno.


-21-

Figura 1.6 : struttura del braccio in vista frontale, con evidenziato l’angolo di 20°, sottolineato trattando della

cinematica inversa

In sede di stesura del codice, l’algoritmo si è presentato estremamente arduo da realizzare

utilizzando i formalismi di Matlab. Ne è stata quindi creata una versione modificata, che però

ha il difetto di porre a zero l’angolo di inclinazione del braccio rispetto al piano verticale.

La funzione che contiene il calcolo della cinematica inversa si chiama INVERSE (Vd. allegato

B) e contiene ancora qualche errore nel codice. Per la generazione dei dati di training, al fine di

verificare che le soluzioni generate dalla INVERSE fossero corrette, è stata calcolata la

corrispondenza della posizione richiesta del polso e quella risultante dall’applicazione degli

algoritmi di cinematica diretta. Le soluzioni venivano scartate nel caso lo scarto fosse maggiore

di pochi decimi di millimetro.

1.4 RISULTATI


-22-

1.4.1 SPAZIO DI LAVORO

Nella pianificazione delle posizioni raggiungibili dal polso del braccio meccanico ci si è basati

sul modello reale, e le limitazioni che ne sono scaturite, riflettono quelle di un braccio umano a

cui sia stata tolta la mobilità della cinta scapolare.

Figura 1.7 : Si può notare il raffronto fra lo spazio raggiungibile dal gomito umano, e lo spazio raggiungibile dal gomito

del robot (area evidenziata). La terza curva evidenzia lo spazio raggiungibile dal gomito umano grazie alla somma della

mobilità della spalla sommata a quella della cinta scapolare.

Dall’immagine si apprezza come i limiti geometrici imposti all’inizio generino uno spazio di

raggiungibilità per il gomito simile a quello reale (sempre se si esclude il movimento della cinta

scapolare).

Per quanto riguarda lo spazio di lavoro del polso, le immagini di seguito mostrano quanto esso

sia ampio, ed è anche possibile notare la sua forma simmetrica rispetto ad un piano diagonale.


-23-

a b

c d

Figure 1.8 a-b-c-d : Spazio di lavoro del braccio robotico, visto da dietro (a), dall’alto (b), di lato (c) e di fronte (d). In

blu il braccio, inclinato in fuori e con l’avambraccio lievemente flesso. Si può notare come, a causa della disposizione

geometrica dei muscoli, Il piano Z=-X divida lo spazio di lavoro in due zone simmetriche.

1.4.2 STUDIO DI FATTIBILITA’


-24-

Scopo principale della progettazione era stabilire se si potesse costruire un braccio e rendere il

movimento mediante muscoli di McKibben, attuatori pneumatici dalle caratteristiche

estremamente particolari.

In primo luogo si è osservato che una struttura muscolare composta da sette muscoli disposti

come nel modello può muovere efficacemente il braccio in tutte le posizioni dello spazio di

lavoro del braccio umano.

In secondo luogo si sono misurati gli accorciamenti percentuali massimi dei muscoli per

verificare che la dinamica degli attuatori di McKibben fosse sufficientemente ampia.

E’ risultato che le contrazioni percentuali derivanti dalla scelta dei valori geometrici delle

estremità dei muscoli sono tutte pari o al di sotto del 20%, soglia critica per un attuatore di

McKibben :

Lunghezza minima Lunghezza massima Contrazione percentuale

Bicipite 23 29 20.7%

Tricipite 29 35 17,4%

Sottoscapolare 16,9 20,8 18,7%

Sopraspinato 16,22 20,1 19,3%

Pettorale 20,6 25 17,5%

Deltoide 15,3 18 15%

Dorsale 32 40,36 20,7%

Inoltre si sottolinea come sia facile prevedere che nel braccio robotico i due muscoli più

problematici, il bicipite e il dorsale, non arrivino mai all’accorciamento completo (permesso in

fase di modellazione), in quanto esso corrisponde ad una posizione non naturale e quindi non

ammessa.

Ad esempio, la massima contrazione del bicipite nel modello è quella che corrisponde a far

coincidere l’asse dell’avambraccio con quello del braccio, mentre per il braccio robotico reale,

l’accorciamento massimo del bicipite corrisponde alla posizione per cui braccio e avambraccio

formano un angolo di 30 gradi.

Il sistema articolare _________________________________________________________________________

-25-

Capitolo 2

Il sistema articolare

Obiettivo della attività di laboratorio, costruire un braccio robotico che avesse le stesse proprietà studiate nel modello. In questo compito siamo stati enormemente facilitati dall’esistenza di un prototipo in avanzata fase di sviluppo. Abbiamo quindi potuto analizzare i punti di forza e di debolezza del prototipo, e proporre alcune modifiche, al fine di rendere la struttura robusta e in grado di compiere i movimenti descritti dal modello.

2.1 LA SPALLA

Il prototipo di braccio era stato realizzato sulle specifiche di un progetto estremamente diverso

dal nostro, il quale prevedeva un attacco a L della testa dell’omero nella spalla.


-26-

a b

Figure 2.1 a-b : spalla del prototipo, in visione frontale (a) e dal basso (b)

Tale modello aveva l’indubbio merito di possedere tre gradi di libertà, ma soffriva di qualche

problema di ostruzione, in quanto dalla posizione di riposo la rotazione dell’omero sul proprio

asse (o meglio, sull’asse verticale passante per la spalla) risultava ostruita dallo stesso attacco

della spalla. Inoltre, l’azione combinata di deltoide, pettorale e dorsale tendevano a far uscire la

testa dell’omero dalla sua sede.

La nostra prima proposta di modifica consisteva in una struttura realizzata tramite una sfera di

plastica molto più grande della precedente (circa 7 cm di diametro), bloccata in mezzo a due

lastre di metallo forate con un diametro leggermente inferiore al diametro della sfera. Le due

lastre di metallo si sarebbero dovute ancorare al busto del robot, lasciando il cono dato

dall’apertura circolare nella lastra inferiore centrato sull’ottante in cui si sarebbe dovuto

muovere il braccio.


-27-

a b

Figura 2.2 a-b : Struttura della prima proposta di spalla, vista di fronte (a) e dal basso (b)

Questo progetto soffriva di due difetti: risultava estremamente difficile gestire il terzo grado di

libertà e il cono raggiungibile dal braccio risultava limitato rispetto al modello. Punti di forza di

questo incastro, l’estrema stabilità della testa dell’omero all’interno della spalla.

Abbiamo trovato poi una terza soluzione, come modifica della precedente.

a b

Figura 2.3 a-b : Struttura della seconda proposta di spalla, vista di fronte (a) e dal basso (b)


-28-

In questo caso le due lastre di metallo sono congiunte a 90 gradi circa, e ospitano la sfera, che

risulta saldamente bloccata al loro interno. In questa configurazione l’azione combinata di

deltoide, pettorale e dorsale non destabilizza più la struttura, ma fa in modo che la testa

dell’omero risulti ancora di più incassata nella spalla.

Il braccio risulta quindi bloccato dalla struttura della spalla nel movimento indietro e verso

sinistra (entrambi non concessi dal modello), e risulta addirittura meno limitato del modello

nei movimenti verso l’alto (fatto tutt’altro che negativo).

Inoltre è stato possibile, apportando una piccola modifica a questa struttura, controllare il

terzo grado di liberta. Come suggerito dal modello abbiamo aggiunto la piccola tuberosità sulla

testa dell’omero (uscente secondo l’asse delle X), e abbiamo posto il passaggio dei tendini del

sottoscapolare e del sopraspinato nella stessa struttura di supporto della spalla.

Per fare in modo che il tendine non fosse troppo sollecitato, l’attacco alla piccola tuberosità è

stato realizzato in modo che potesse ruotare sul proprio asse orientandosi secondo la direzione

di trazione dei due muscoli.

a b

Figura 2.4 a-b : Soluzione adottata (a) e elementi utilizzati (b)

Per realizzare questo abbiamo forato la sfera e abbiamo inserito un bullone di piccolo

diametro e l’abbiamo bloccata inserendo nel foro un bullone di grosso diametro forato lungo


-29-

l’asse. Il tendine dei due muscoli rotatori passa per un piccolo foro praticato nel bullone più

piccolo ed è bloccato grazie a due dadi posti uno a monte e uno a valle del foro.

Purtroppo la struttura così ottenuta non rispecchia a pieno i requisiti posti dal modello.

Figura 2.5 : particolari dei tendini della cuffia rotatoria

Infatti, pur essendo le origini dei tendini opposte rispetto al centro di rotazione, essendo i

tendini adagiati sulla sfera viene persa la scorrelazione tra attività della cuffia e attività della

terna deltoide – pettorale – bicipite, e la cuffia può dare dei contributi alla rotazione del

braccio.

2.2 IL GOMITO

Per quanto riguarda il gomito, il prototipo presentava già caratteristiche ottimali. La cerniera

come previsto permetteva il movimento solo di adduzione e abduzione, con un angolo tra


-30-

omero e ulna compreso tra 180 gradi in massima abduzione e 30 gradi in massima adduzione.

Il nostro lavoro è consistito quindi solamente nell’aggiungere il sensore (un potenziometro) al

fine di rilevare l’angolo del gomito. Il corpo del potenziometro è stato forato al fine di

effettuare l’ancoraggio con l’avambraccio tramite vite, avendo così la certezza di ridurre al

minimo il gioco della cerniera.

a b

Figura 2.6 a-b : Fotografie del giunto del gomito

Il sistema muscolare _______________________________________________________________________________________

-31-

Capitolo 3

Il sistema muscolare

The McKibben Artificial Muscle is a pneumatic actuator which exhibits many of the properties found in real muscle. Its spring-like characteristics, physical flexibility, and light weight make it ideal for applications such as the Anthroform Biorobotic Arm and Powered Prosthetics Project. The device was first developed for use in artificial limbs in the 1950’s and, recently, was commercialized for robotic applications. Among the more attractive attributes of the actuator is a very high force to weight ratio, making it ideal mobile robots.

3.1 L’ATTUATORE DI MCKIBBEN

Il muscolo artificiale di McKibben è un attuatore pneumatico che presenta molte delle

proprietà trovate in un muscolo reale. Il suo comportamento simile ad una molla, la flessibilità

ed il peso leggero lo rendono ideale per essere applicato in molti progetti di robotica

antropomorfa.

Il dispositivo è stato originariamente sviluppato per l’uso in membra artificiali negli anni 50 e,

più recentemente, è stato commercializzato negli anni 80 dalla Bridgestone Rubber Company

del Giappone e negli anni 90 dallo Shadow Robot Group (Inghilterra) per applicazioni

robotiche. Alcune versioni dell’attuatore sono inoltre disponibili da Images Company.

Sicuramente la proprietà più attraente dell’attuatore è il rapporto elevato forza-peso, che lo

rende ideale per la robotica mobile.


-32-

3.1.1 COSTRUZIONE DI UN ATTUATORE DI MCKIBBEN

I muscoli artificiali di McKibben sono disponibili in commercio, ma a causa degli alti costi è

preferibile acquistare singolarmente le parti e assemblare l’attuatore in laboratorio.

Figura 3.1 : attuatore McKibben disponibile in commercio

Primo elemento è il tubo interno di gomma. La scelta può ricadere su tubi in silicone o lattice,

con un diametro consigliato (per quanto riguarda i tubi in silicone) di 15 mm a fronte di uno

spessore di parete di 1 mm.

Nella scelta del materiale di composizione del tubo il parametro chiave da osservare è

indubbiamente possibilità di sostenere allungamenti ripetuti (fino a più del 300% della

lunghezza a riposo), senza subire lacerazioni.

La copertura esterna a rete, con maglia elementare a pantografo, è realizzata in nylon ed è un

prodotto normalmente usato come condotto flessibile per cavi elettrici. Il diametro di questo

elemento in situazione di completa estensione deve essere pari o al limite poco maggiore del

diametro esterno del tubo di gomma.


-33-

Al tubo di gomma va applicata una valvola pneumatica da un lato e un tappo (in alluminio)

dall’altro. Entrambi questi componenti dovrebbero essere opportunamente scanalati per poter

essere bloccati con del fil di ferro.

Una volta montato il muscolo, ad esso verranno applicati due tendini. Dalla parte del tappo di

alluminio basterà inserire il tendine all’interno di un buco fatto nel tappo. Dall’altra parte il

tendine andrà fissato con una fascetta di metallo di quelle utilizzate per i tubi di gomma.

Il tipo “di tendini artificiali” usati per fissare il muscolo dipende esclusivamente

dall’applicazione. Nel nostro caso a causa delle forze elevate abbiamo utilizzato fili da pesca di

nylon da 1.1 mm dove lo stress era meno elevato, e fili da 1.6 mm in condizione di forte stress.

Non è stato possibile l’utilizzo di fil di ferro poiché risultava essere troppo fragile in caso di

torsioni.

3.1.2 CARATTERISTICHE DI UN ATTUATORE DI MCKIBBEN

Il meccanismo di funzionamento di un muscolo di Mckibben è estremamente semplice.

L’aumentare della pressione all’interno del tubo di gomma tende a farlo gonfiare fino al

raggiungimento del volume massimo, e la maglia incrociata ne impone un simultaneo

accorciamento, con un effetto a pantografo.

Un meccanismo talmente semplice è in grado di generare una forza notevole. Un piccolo

muscolo, di solo 6 millimetri di diametro, ha la potenza e la velocità di un muscolo di un dito

umano. Un muscolo di 30 millimetri di diametro è in grado di sollevare più di 70 kg a una

pressione di solo 4 bar, mentre un grande muscolo (50 millimetri) ha abbastanza potenza per

abbattere un muro di mattoni [ 5 ].

Le caratteristiche funzionali principali da sottolineare per spiegare la particolarità di tali

attuatori, sono le seguenti :

⋅ Rapporto forza-peso di 400 a 1

⋅ Peso da 10 a 100 grammi

⋅ Pressioni di utilizzo tra 0 e 4 bar

⋅ Bassa rigidità

⋅ Meccanismo di lavoro solo in trazione

⋅ Basso costo


-34-

L’utilizzo di attuatori di Mckibben non è esente da criticità. Per il nostro lavoro abbiamo

dovuto metterne in luce in particolare due:

In primo luogo la dinamica dei muscoli di McKibben non è perfettamente lineare. Mentre il

muscolo si contrae a pressione costante, la forza di trazione prodotta tra le due estremità

decresce. La forza massima possibile ad una determinata pressione si ottiene quando il

muscolo è allungato il più possibile. La relazione tra pressione e forza è lineare a lunghezza

costante.

Figura 3.2 : Grafico lunghezza-forza di un muscolo di McKibben a pressione costante

La seconda criticità consiste nell’accorciamento massimo percentuale. I migliori muscoli che

siamo riusciti a produrre hanno un accorciamento solo del 25%, senza contare la lunghezza di

tendini, tappi, sensori che per muscoli lunghi 25 cm a riposo, riducono l’accorciamento

possibile del sistema attuatore – sensore – tendine fino al 17% circa.

Si riporta indicativamente la contrazione percentuale di tre muscoli prodotti dalla Shadow

Robot Company [ 5 ], uno di 6, uno di 20 e uno di 30 millimetri di diametro.

Muscolo Shadow Robot Company, 6 mm diametro:


-35-

0,5 Kg 1 Kg 2 Kg 3,2 Kg 4,6 Kg

0 Bar N/A 3% 2% 2% 1%

2 Bar 12% 10% 7% 5% 3%

4 Bar 20% 20% 17% 11%


0 Kg 5 Kg 10 Kg 15 Kg 20 Kg 25 Kg

0 Bar N/A 8% 6% 2% 1% 0%

2 Bar 35% 29% 23% 17% 12% 10%

4 Bar 33% 29% 25% 23% 20%


0 Kg 10 Kg 20 Kg 35 Kg 50 Kg 70 Kg

0 Bar N/A 2% 1% 0% 0% 0%

2 Bar 35% 33% 30% 27% 24% 21%

4 Bar 35% 33% 31% 29% 27%

I muscoli che noi utilizzeremo hanno un diametro compreso tra 15 e 20 mm, con una capacità

contrattile media del 20% alla pressione massima che potremo utilizzare ( circa 8 bar ).

3.3 L’INSTALLAZIONE DEI MUSCOLI DI MCKIBBEN

Nonostante il modello desse informazioni affidabili sull’accorciamento percentuale necessario

per ciascun muscolo, e desse per lo meno un idea della forza che avrebbe dovuto applicare

ciascun muscolo, la scelta dei parametri chiave del muscolo, e della sua installazione, è risultata

essere possibile in definitiva solo per via sperimentale.

Si è verificato quindi che il deltoide è il muscolo che deve sopportare il carico maggiore in caso

di manipolazione di un oggetto, ed è stato quindi necessario aumentare lo spessore del suo

tendine per evitare rotture.


-36-

Si è scoperto poi che la coppia bicipite – tricipite se gonfiata alla massima pressione, genera

degli sforzi sui tendini difficili da sostenere. In questo caso si è optato per la riduzione della

forza della coppia di muscoli, e si è sostituito il tricipite con un modello di diametro minore.

Si è dovuto costruire un muscolo speciale per contenere la lunghezza del dorsale. Questo

muscolo, avendo bisogno di 8 cm di accorciamento, con un muscolo normale avrebbe dovuto

essere lungo almeno 40 cm, senza contare sensore di forza e tendini. Si è riusciti a costruire un

muscolo con un accorciamento di quasi il 30%, riuscendo così a contenere la sua lunghezza a

27 cm più sensori e tendini.

Si è infine dovuto spostare l’attacco di pettorale e dorsale molto vicino alla spalla, per

contenerne l’accorciamento percentuale, sfruttando il fatto che questi due muscoli potevano

avere un braccio meno considerevole rispetto al deltoide, non dovendo sollevare oggetti.

3.3 IL CIRCUITO PNEUMATICO

Al momento attuale il circuito pneumatico per alimentare e controllare singolarmente i

muscoli di Mckibben non è stato ancora costruito. Ne esiste però un progetto, interessante per

il costo contenuto dei componenti utilizzati.

La soluzione standard imporrebbe l’utilizzo di 14 elettrovalvole, ossia due per ciascun

muscolo, una per il carico e una per lo scarico. Un elettrovalvole commerciale ha l’indubbio

pregio di permettere il controllo diretto della pressione e della velocità di immissione dell’aria,

ma ha dei notevoli costi, sull’ordine dei 70-80 euro per ogni elettrovalvola. Bisogna aggiungere

anche che l’ingombro di questi dispositivi è abbastanza elevato.

L’idea che abbiamo avuto è di utilizzare alcuni servomeccanismi di dimensioni ridotte tratti dal

mondo della modellistica per aprire e chiudere dei rubinetti.

Il servomeccanismo, costando fino a 4 volte meno dell’elettrovalvola, è composto da un

motore elettrico, comandabile anche tramite pc, che muove un albero a cui si possono

applicare diversi dispositivi. Ha alcuni grandi punti di forza, come per esempio la coppia

superiore al Kg per centimetro, il controllo retroattivo che svincola l’utilizzatore da dover

applicare sensori sul servomeccanismo, e l’estrema precisione di posizionamento.


-37-

Il rubinetto scelto è un semplice modello da calorifero. Ha il vantaggio di funzionare con un

meccanismo a vite che permette una grande precisione nell’apertura e nella chiusura del flusso

d’aria, ma quello che più colpisce è la possibilità di aprire e chiudere il passaggio dell’aria con

una forza estremamente ridotta.

Con questa soluzione si perde la possibilità di controllare direttamente tramite le valvole la

pressione del singolo muscolo, ma si riduce notevolmente l’ingombro dell’apparato e si riduce

la spesa a un quarto, rispetto al metodo classico con elettrovalvole.

Il sistema sensoriale _______________________________________________________________________________________

-38-

Capitolo 4

Il sistema sensoriale

Il sistema sensoriale del braccio presenta diverse tipologie di sensori, a causa dell’eterogeneità delle scelte effettuate

nei singoli componenti strutturali. In particolare ogni muscolo è dotato di un sensore di forza e uno di

accorciamento, la flessione del gomito è rilevata da un potenziometro e gli stessi servomeccanismi delle valvole

contengono sensori che permettono loro di funzionare in anello chiuso.

4.1 SENSORI DI FORZA

Il sensore di forza è posto in serie ad ogni attuatore di McKibben, affinché possa rilevare la

forza impressa dal muscolo, e d’altra parte, lo sforzo a cui esso è sottoposto. Questo dato può

essere utilizzato per impostare il robot a bassa o alta cedevolezza, semplicemente imponendo

minimi e massimi alla forza di ogni singolo attuatore, o per evitare rotture dovute a sforzi

eccessivi.

L’elemento di base con cui sono costruiti i sensori di forza da noi utilizzati è uno strain gage.

Di per se, uno strain gage misura la deformazione a cui è soggetto, modificando la resistenza

misurabile ai suoi capi. Questo grazie alla variazione della resistività del materiale di cui è

composto in seguito alla deformazione.


-39-

a

b

Figure 4.1 a-b : sensore di forza (strain gege) in vista laterale (a) e frontale (b)

Il sensore di forza da noi utilizzato è composto da un ponticello di metallo, forato alle due

estremità, sul quale è incollato lo strain gage. Quando il ponticello è sottoposto a trazione,

tende a raddrizzarsi e accorcia quindi lo strain gage, che misura questa deformazione con una

variazione della resistenza ai suoi capi.

4.2 SENSORI DI ACCORCIAMENTO


-40-

Come si è potuto osservare precedentemente, a pressione costante la lunghezza dei muscoli

dipende dal carico cui sono sottoposti. In teoria basterebbe quindi l’informazione dei sensori

di forza, insieme alla conoscenza della pressione all’interno dei muscoli, per determinarne la

lunghezza.

Siccome la scelta delle valvole, per criteri di minor prezzo, ha favorito la scelta di valvole

attuate da servomeccanismi, al posto delle elettrovalvole commerciali, non ci è possibile

conoscere la pressione all’interno di ogni singolo muscolo. Vi è quindi il bisogno di una misura

diretta della lunghezza.

Figura 4.2 : Flex sensor

Il flex sensor è un dispositivo che cambia la propria resistenza quando piegato.

Approssimativamente, un flex sensor nella posizione di riposo misura 15 cm di lunghezza e ha

una resistenza nominale di circa 10 KOhm; se piegato la resistenza aumenta gradualmente.

Quando il sensore è piegato a 90 gradi la resistenza è circa 30 – 40 KOhm.

L’utilizzo di tali sensori nella forma originale poneva però forti problemi. Infatti a causa della

loro lunghezza, quando il muscolo su cui fossero stati fissati fosse stato completamente

contratto, il flex sensor se ne sarebbe trovato ad una distanza considerevole, rischiando di

urtare con altre parti del robot e dare misure quindi falsate, inoltre, poiché una forza di appena

5 grammi è sufficiente a fletterlo, sarebbe stato eccessivamente sensibile a spostamenti d’aria.


-41-

a b

c

Figura 4.3 a-b-c: Progetto di Flex sensor installato su un muscolo a riposo (a) e in seguito alla contrazione del muscolo

(b), fotografia di un muscolo con installato un flex sensor (c)

La soluzione adottata consiste quindi nel tagliare il flex sensor in 4 parti (risultanti quindi

lunghe circa 3-4 cm) e utilizzare solo una di queste parti per ogni muscolo.

Sfruttando il fatto che l’attuatore di McKibben ha un accorciamento costante per tutta la sua

lunghezza (ad eccezione delle estremità), si fissa come in figura una parte del flex sensor al

muscolo grazie a degli agganci inseriti sotto la guaina in rete di nylon.

L’accorciamento misurato sarà proporzionale all’accorciamento totale dell’attuatore.


-42-

4.3 SENSORE ANGOLARE

Nel costruire un braccio meccanico sarebbe opportuno poter inserire dei sensori su tutti i

giunti, al fine di rilevarne l’esatta posizione. In questo modo si evita di dover ricostruire la

posizione del robot a partire dalle informazioni dei motori, o come nel nostro caso, dalle

informazioni di forza e soprattutto di accorciamento dei sensori posti sui muscoli.

Per come è stata costruita la spalla, è estremamente difficile adattarvi un sensore; al contrario,

per quanto riguarda il gomito, il posizionamento di un sensore è estremamente agevole.

Figura 4.4 : potenziometro ancorato al giunto del gomito

Infatti ci è bastato sostituire il perno della cerniera con il corpo del sensore, vincolandolo con

delle viti all’avambraccio e bloccare la testa rendendola solidale col braccio.

Conclusioni _______________________________________________________________________________________

-43-

Capitolo 5

Conclusioni

A causa della mancanza delle valvole, è stato possibile fare solo pochi esperimenti, e sempre su valori limite del movimento del braccio. Ne è emersa comunque la robustezza, sia della struttura che dei componenti, l’ampiezza dello spazio di lavoro, l’aderenza al modello e una discreta somiglianza al braccio umano.

5.1 LE PRESTAZIONI

Pur non potendo controllare la pressione dei singoli muscoli indipendentemente, abbiamo

però potuto effettuare due tipi di sperimentazioni:

⋅ rilevare la rigidità dei giunti per l’azione combinata di coppie (o terne) di muscoli

antagonisti,

⋅ studiare i confini dello spazio di lavoro

Inoltre abbiamo effettuato alcune prove per sperimentare la velocità di movimento del

braccio, in relazione alla velocità di apertura del circuito d’aria. Abbiamo così verificato che i

tubi rigidi (del diametro interno di 3 mm) usati per immettere ed estrarre l’aria sotto pressione

dagli attuatori permettono lo svuotamento praticamente istantaneo del muscolo e quindi una

sua reazione praticamente immediata a qualunque variazione di pressione. L’unico ritardo può

essere quindi dovuto al comportamento ad elastico, o a molla, del muscolo, che a fronte di un

gradino di pressione si intuisce facilmente che dovrebbe avere una risposta tipica di un taglio

alle alte frequenze.

Conclusioni _______________________________________________________________________________________

-44-

5.1.1 RIGIDITA’ DEI GIUNTI

Il dato che sicuramente ha colpito in questo tipo di esperimenti è la forza spaventosa esercitata

da questi muscoli anche già a pressioni basse (4 atm).

La coppia bicipite – tricipite come concepita in partenza, ossia con entrambi i muscoli di

diametro 15 mm generava una forza troppo elevata perché i tendini potessero resistere. Per

evitare problemi futuri è stato quindi necessario diminuire il diametro del tricipite, in modo

che non potessero verificarsi rotture.

La rigidità rilevata è comunque apprezzabile. Anche ben sotto la soglia di rottura bisognava

applicare una forza considerevole all’avambraccio per riuscire ad ottenere dei movimenti del

polso, che si mantenevano però contenuti in qualche centimetro al massimo.

I cinque muscoli che coordinano il movimento della spalla invece non sono stati mai

sperimentati alla massima pressione poiché, già a 4 atm deformano la struttura portante in

alluminio. Questo soprattutto per l’azione combinata della coppia di muscoli rotatori, che si

consiglia quindi di non far mai lavorare contemporaneamente in trazione.

5.1.2 LO SPAZIO DI LAVORO

Scegliendo un piccolo set di muscoli, e gonfiandoli gradatamente, si è potuto apprezzare prima

di tutto la fluidità e l’estrema somiglianza del movimento con quello di un braccio vero, in

secondo luogo si è potuto ammirare come il braccio riuscisse con buona facilità a portarsi alle

estremità dello spazio di lavoro previsto e permesso dai vincoli sui giunti.

In figura 5.1 a si può notare come, anche con bassa pressione (4 atm) sia possibile sollevare la

mano molto più in alto del capo, mentre in figura 5.1 b sempre alla stessa pressione si è riusciti

a raggiungere un punto laterale molto lontano dal busto.

In figura 5.1 c si nota come, con la stessa configurazione di a, una pressione maggiore faccia

salire ulteriormente il braccio, mentre in figura 5.1 d si nota il braccio completamente esteso in

avanti.

Conclusioni _______________________________________________________________________________________

-45-

a b

c d

Figura 5.1 a-b-c-d : Posizioni del braccio viste lateralmente utilizzando sopraspinato, deltoide, pettorale e bicipite (a),

sopraspinato, deltoide dorsale e tricipite (b), posizione del braccio vista frontalmente utilizzando sopraspinato,

deltoide, pettorale e bicipite (c), sopraspinato, deltoide, pettorale e tricipite (d)

Conclusioni _______________________________________________________________________________________

-46-

5.2 LA ROBUSTEZZA

Punto di vanto del nostro lavoro di laboratorio è che nessun attuatore da noi prodotto sia

esploso. In compenso il componente (per altro scelto da noi) che si è rivelato senz’altro

sottodimensionato e troppo poco resistente , è il filo di nylon da 1,1 mm usato per i tendini. In

varie riprese l’abbiamo dovuto sostituire con del filo di spessore maggiore (ma più rigido),

poiché non reggeva i carichi che gli si sono sottoposti.

La struttura, pur essendo stata costruita in alluminio, sembra essere abbastanza deformabile,

constatate le forze di parecchie decine di kg in gioco.

5.3 PROSSIMI SVILUPPI

L’evoluzione del lavoro da noi fatto dovrebbe portare a rifinire alcuni particolari lasciati in

sospeso:

⋅ sistemare l’algoritmo di cinematica inversa

⋅ rinforzare la struttura portante del busto

⋅ rinforzare i tendini dei muscoli più a rischio

⋅ costruire il sistema di valvole per controllare ogni muscolo singolarmente

Il lavoro dovrebbe poi continuare raccogliendo dallo stesso braccio i dati di training necessari

ad allenare la rete neurale che ne gestisca il movimento, e in seguito sperimentando sistemi di

controllo fine mediante l’utilizzo ad esempio di sensori di visione per posizionare in maniera

accurata la mano.

-47-

PARTE B

LA RETE NEURALE

Le reti neurali _________________________________________________________________________

- 48 -

Capitolo 6

Le reti neurali

In questo capitolo vengono presentate le reti neurali; spiegheremo in che cosa consistono, come funzionano, in riferimento anche al funzionamento del cervello biologico di cui esse cercano di essere una modellazione matematica, e analizzeremo le diverse tipologie di reti più celebri, nonché i vantaggi e gli svantaggi derivanti dal loro uso in termini di velocità e precisione di elaborazione dell'informazione.

6.1 INTRODUZIONE

Nell’ambito dello studio di sistemi robotici intelligenti e complessi, si è sempre visto alla

natura biologica degli esseri viventi come il miglior modello possibile da imitare, sia per quanto

riguarda il cervello che per quanto riguarda la struttura vera e propria e di conseguenza il

movimento. Ai nostri giorni comunque siamo in grado di costruire dei calcolatori con una

capacità di elaborazione numerica infinitamente superiore a quella umana; si pensi soltanto alla

potenza di calcolo che hanno raggiunto ormai i nostri computer, in grado ad esempio di

effettuare istantaneamente moltiplicazioni multiple fra matrici di dimensione elevatissima, o

alla precisione nanometrica di alcune elaborazioni. Ciò nonostante, allo stato attuale delle cose,

i robot antropomorfi dotati di intelligenza artificiale sono ancora palesemente inferiori

all’essere umano e questo proprio perché il “cervello artificiale” non riesce tuttora a risolvere

alcuni problemi che sono invece alla portata non solo degli uomini ma anche della maggior

parte degli animali che popolano il nostro pianeta: il saper riconoscere e memorizzare un

Le reti neurali _________________________________________________________________________

- 49 -

determinato percorso, l’apprendimento sensoriale e percettivo dall’ambiente e il controllo degli

arti in funzione del movimento e della locomozione sono ancora, ad esempio, alcuni dei

problemi più importanti che non hanno al momento avuto una risoluzione soddisfacente.

Tuttavia, negli ultimi anni, un nuovo modo di considerare questi problemi e di analizzare la

struttura del cervello animale per cercare di carpirne i segreti ed arrivare quindi a un’imitazione

soddisfacente ha portato a degli sviluppi sostanziali nella ricerca delle soluzioni, grazie

soprattutto alla nascita e allo sviluppo delle cosiddette reti neurali artificiali, o semplicemente

reti neurali. Per capire meglio di che cosa si tratta inizieremo dapprima a parlare del

funzionamento del cervello animale e del suo componente principale, il neurone, per poi

passare alla modellazione matematica di quest’ultimo ed infine alle strutture complesse di

interconnessione neuronica artificiale, ovvero le reti neurali.

6.2 FUNZIONAMENTO DEL CERVELLO BIOLOGICO

Al giorno d’oggi risulta ancora difficile cercare di spiegare quale sia il segreto del cervello

animale e come mai esso sia in grado di compiere elaborazioni complesse, come quelle

necessarie per risolvere i problemi citati in precedenza, specialmente in termini di precisione e

velocità; infatti uno dei pochi dati scientifici certi a riguardo è che l’unità funzionale del tessuto

nervoso, cioè il neurone, che può essere a ragione considerato il singolo componente funzionale

del cervello biologico, è assai più lento, in termini di velocità di trasferimento

dell’informazione, del componente elementare dei calcolatori, il transistor, in quanto propaga

l’informazione a una velocità che varia da 0,5 a 120 m/s (a seconda del tipo di neurone) [ 1 ],

mentre nel transistor la propagazione dell’informazione, rappresentata da un valore logico

binario, avviene alla velocità della luce c = 300000 km/s. Non si può dunque ricercare nella

velocità di elaborazione del proprio componente elementare la superiorità del cervello

biologico rispetto a quello animale. La spiegazione attualmente ritenuta la più valida perciò è

che questa superiorità sia da attribuire alla struttura vera e propria del cervello biologico, per

quanto riguarda sia la natura del componente elementare sia soprattutto quella del tessuto

nervoso che vede un elevatissimo e complicatissimo livello di interconnessioni neuroniche. In

un cervello umano, ad esempio, vi sono 1012 [ 2 ] neuroni, ognuno dei quali può connettersi

Le reti neurali _________________________________________________________________________

- 50 -

con 105 neuroni attigui. Bisogna dunque analizzare la struttura del tessuto nervoso e del

singolo neurone per cercare di proporre una modellazione matematica soddisfacente al

funzionamento del cervello animale. Come si osserva dalla figura (6.1) il neurone, altresì detto

cellula nervosa, è costituito da un corpo cellulare contenente il nucleo e da un numero variabile

di prolungamenti, distinti sia per funzione che per struttura in neuriti e dendriti. [ 3 ]. Il corpo

cellulare, dotato di carica elettrica negativa rispetto al fluido extracellulare che lo circonda, riceve

in ingresso segnali elettrici dai suoi dendriti per mezzo di ioni sodio Na+ che diminuiscono la

differenza di potenziale tra l’interno del corpo cellulare e il fluido extracellulare provocando il

cosiddetto fenomeno di “scarica neuronica”, cioè la generazione di un impulso elettrico che si

propaga tramite l’assone, un sottile e lungo filamento cilindrico, fino alle giunzioni sinaptiche che

fungono da legami fra un neurone e l’altro.

Figura 6.1 : Struttura di un neurone

Le reti neurali _________________________________________________________________________

- 51 -

Come abbiamo detto in precedenza, un neurone può connettersi con 100000 neuroni

circostanti in un cervello umano; risulta perciò di fondamentale importanza la funzione delle

giunzioni sinaptiche, veri e propri reticoli in grado di trasportare l’informazione, sotto forma

di impulso elettrico, a un numero elevatissimo di cellule circostanti a seconda del tipo di

segnale attivato dal neurone di partenza; difatti il segnale prodotto dal neurone come scarica è

il risultato combinato di una quantità di stimoli che giungono da altri neuroni che, a loro volta,

ricevono questi segnali dagli organi di senso dopo opportune operazioni di vaglio e

selezione operate da quest’ultimi.

Sarà dunque questo modo di procedere sul quale verterà il fulcro della modellazione

matematica del funzionamento del cervello biologico, che partirà perciò da un modello del

componente elementare, il neurone artificiale, per poi arrivare alle più complesse e difficili

modellazioni delle scariche neuroniche come funzioni di attivazione e delle giunzioni sinaptiche

come strati di interconnessione, i quali andranno a formare, a seconda della loro struttura, le

diverse tipologie di reti neurali.

Figura 6.2 : Modello schematizzato di un neurone

Le reti neurali _________________________________________________________________________

- 52 -

6.3 IL NEURONE ARTIFICIALE STANDARD

Figura 6.3 : Struttura matematica del neurone artificiale standard

Come abbiamo visto in precedenza il neurone biologico è formato dai dendriti, attraverso i

quali giungono i segnali provenienti da altri neuroni, e dall’assone, che invece permette la

propagazione del segnale elaborato dal corpo centrale del neurone. La modellazione

matematica di questa struttura, a cui si darà il nome di neurone artificiale standard e che possiamo

vedere in figura 6.3, sarà perciò un sistema con un numero n di variabili reali d’ingresso, u1,

u2, …, un, ed una variabile reale di uscita y; la combinazione lineare degli ingressi,

opportunamente pesata, sarà uguale a un segnale s che rappresenterà il segnale di attivazione, il

quale, a sua volta, verrà elaborato dalla cosiddetta funzione di attivazione ( )sσ che produrrà

infine il segnale di uscita y. [ 4 ].

Ricapitolando dunque il neurone artificiale è costituito da:

Le reti neurali _________________________________________________________________________

- 53 -

- segnale di attivazione : nnuuuS θθθθ ++++= ...22110

- funzione di attivazione : )(sy σ=

I parametri 1θ , 2θ , …, nθ prendono il nome di pesi mentre 0θ prende il nome di bias o

parametro di polarizzazione che può essere anche visto come peso idealmente associato

all’ingresso 0u = 1. La funzione di attivazione è una funzione non lineare che deve essere

reale, monotona crescente e dotata di due asintoti (superiore e inferiore) in quanto deve

rappresentare il fenomeno bioelettrico della scarica neuronica descritto in precedenza. Essa

prende quindi il nome di funzione sigmoidale e può essere rappresentata sostanzialmente da tre

tipi di funzioni matematiche celebri, ovvero:

- Sigmoide standard ses −+=

11)(σ

- Tangente iperbolica )tanh()( ss =σ

- Segno o Scalino

<→≥→

=00

)(inf

sup

ss

sσσ

σ

L’intervallo [ infσ supσ ] che specifica i valori degli asintoti superiore e inferiore della funzione

sigmoidale può essere nell’ultimo caso rappresentato da [-1 1] (e in tal caso si parla di Segno)

o da [0 1] (così la funzione prende il nome di Scalino).

6.4 DEFINIZIONE DELLE RETI NEURALI

Una volta definito il funzionamento del neurone artificiale, non ci resta ora che vedere come

più neuroni possono cooperare ed essere interconnessi fra loro per formare l’oggetto della

nostra ricerca, ovvero quel complesso modello matematico delle reti sinaptiche cerebrali a cui

si da il nome di reti neurali. Innanzitutto diciamo che la struttura di una rete neurale può essere

la più svariata possibile a seconda di come si realizzano le interconnessioni fra un neurone e

l’altro; in questo modo si formano le diverse tipologie di reti che andremo ad analizzare in

seguito. Comunque, in generale, una rete neurale è formata da diversi strati; uno strato è un

Le reti neurali _________________________________________________________________________

- 54 -

insieme di neuroni standard connessi in questo modo : gli ingressi di un neurone u1, u2, …, un,

appartenente allo strato i-esimo saranno i medesimi per tutti gli m neuroni appartenenti a

quello strato (dove con m si indica il numero dei neuroni dello strato i-esimo) che andranno a

formare, combinando gli n ingressi con i k pesi 1θ , 2θ , …, kθ diversi per ogni neurone,

una sequenza di m segnali di attivazione differenti, i quali saranno elaborati da funzioni

sigmoidali che potranno essere le medesime (almeno in uno stesso strato) oppure no. Una

volta elaborati i diversi segnali, esse produrranno una sequenza di m uscite 1y , 2y , …, my

che diventeranno gli ingressi dello strato i+1-esimo, ovvero lo strato successivo.

Figura 6.4 : Esempio di semplice rete neurale

Come si percepisce dalla descrizione appena fatta, è evidente che la complessità della rete

neurale non può che dipendere da due parametri fondamentali, cioè dal numero m di neuroni

di uno strato e soprattutto dal numero i di strati da cui è formata.

E’importante sottolineare, come possiamo anche osservare dalla figura 6.5, che il primo strato

di una rete viene detto strato d’ingresso, l’ultimo strato di uscita e gli strati intermedi invece

vengono chiamati strati nascosti proprio perché, da un punto di vista esterno alla rete, ciò che si

vede sono gli ingressi dello strato d’ingresso che entrano nella rete, la quale produrrà le proprie

uscite che non saranno altro che le uscite dello strato di uscita, rendendo così trasparente il

funzionamento interno degli strati nascosti.

Le reti neurali _________________________________________________________________________

- 55 -

Figura 6.5 : Definizione degli strati di una rete neurale

6.5 APPRENDIMENTO NELLE RETI NEURALI

La peculiarità che distingue le reti neurali da altri tipi di modelli del cervello biologico che sono

stati proposti è la capacità di apprendere; innanzitutto diciamo che, trattandosi di un modello

matematico, ciò equivale a dire che la rete neurale sarà in grado di approssimare sempre

meglio una determinata funzione matematica d’interesse mano a mano che aumenta il numero

di iterazioni successive di elaborazione, avendo essa la possibilità di conoscere l’errore

commesso nell’approssimazione all’iterazione n-esima e quindi di poterlo usare per aggiornare

i propri parametri (cioè i pesi di ogni neurone che la compone) prima di compiere l’iterazione

n+1-esima, per diminuire così sempre di più l’errore di approssimazione, ovvero la differenza

fra l’uscita desiderata corrispondente a un determinato ingresso, che chiameremo target, e

l’uscita effettivamente realizzata dalla rete per quell’ingresso. Ovviamente lo stesso dato

ingresso-uscita dovrà essere soggetto a diverse e numerose elaborazioni successive prima che

la rete riesca a raggiungere uno scostamento minimo accettabile dal target di riferimento, ma

tutte queste elaborazioni non diranno invece niente per quanto riguarda un altro dato

ingresso-uscita di nostro interesse. Per cui, se vogliamo che la nostra rete approssimi bene il

numero N di dati ingresso-uscita che ci servono dovremo far sì che ogni iterazione elabori

contemporaneamente gli N dati al fine di produrre un errore via via minore per tutto il

Le reti neurali _________________________________________________________________________

- 56 -

“dominio” che ci interessa; questo tipo di iterazione, che è poi quella che viene usata in

pratica, prende il nome di epoca : per capire un po’ meglio la complessità di quello che stiamo

trattando diciamo solamente che per una rete neurale composta da 2 soli strati con 25 neuroni

nello strato d’ingresso e 1 neurone nello strato d’uscita, la quale riceve 2 ingressi 1u , 2u per

produrre un uscita y (una complessità dunque nemmeno paragonabile a quella di un cervello

biologico), e per la quale il numero N di coppie ingressi-uscita di nostro interesse sia ad

esempio N=300, non è affatto sbagliato ipotizzare che le epoche necessarie per un buon

apprendimento siano qualche decina di migliaia! In realtà è doveroso dire che, il

procedimento appena descritto prende il nome di addestramento mentre per apprendimento si

intende il voler imporre un determinato comportamento alla rete senza fornirgli la conoscenza

dei target ricavati matematicamente o sperimentalmente (a seconda che la funzione

matematica da voler approssimare sia nota o meno). Il metodo di addestramento più utilizzato

è il cosiddetto procedimento back-propagation o retro-propagazione; esso consiste

nell’aggiornare i parametri di una rete per sottogruppi, ovvero aggiornare strato per strato i

pesi di ogni singolo neurone partendo dallo strato d’uscita e procedendo a ritroso verso lo

strato iniziale, e verrà presentato di seguito.

6.5.1 ALGORITMO DI BACK-PROPAGATION

Spiegheremo ora nel dettaglio l’algoritmo di retro-propagazione che permette a tutti i pesi jkθ

di essere aggiornati ed in sostanza alla rete neurale di apprendere; questo metodo è

fondamentalmente strutturato in due passi [ 5 ].

Il primo passo consiste nell’elaborazione da parte della rete neurale del pattern dei valori di

uscita che verranno calcolati in base agli ingressi dati e al corrente valore assunto dai pesi jkθ ;

essi verranno indi confrontati, secondo una funzione errore E(θ ), con il target di riferimento

dei valori desiderati, producendo così un vettore di errore rappresentante gli scostamenti dei

singoli output rispetto ai valori desiderati.

Nel secondo passo le componenti dell’errore verranno propagate all’indietro (da qui il nome

back-propagation come già visto in precedenza) in modo che, secondo una regola di

Le reti neurali _________________________________________________________________________

- 57 -

apprendimento che vedremo in seguito, i pesi della rete verranno modificati in maniera

proporzionale alla loro influenza relativa sull’output finale ottenuto.

Il problema sta proprio nel definire la politica della regola di apprendimento che permetta

un’efficiente aggiornamento dei pesi; nell’algoritmo back-propagation si procede in questo

modo; innanzitutto si sceglie come funzione di errore E(θ ) la seguente funzione:

E(θ ) = ∑ −iq

qi

qi yt 2)(

21

Essa prende il nome di errore quadratico medio o anche di “MSE” (dall’inglese Medium Square

Error). Il vettore qit rappresenta il target (cioè il valore di output desiderato) per il pattern

d’ingresso qix , mentre q

iy rappresenta il vettore delle effettive uscite prodotte dalla rete

neurale. E’ possibile dimostrare che questa funzione è continua, convessa e differenziabile

ovunque per qualunque peso jkθ e può quindi essere utilizzata la regola del gradiente come

politica per determinare i pesi che la minimizzano. [ 2 ] Più formalmente, data la funzione

errore, possiamo specificare l’algoritmo in questo modo:

)(θηθ E∇−=∆

dove η è un parametro reale positivo che determina la velocità di convergenza dell’algoritmo,

cioè il cosiddetto “tasso di apprendimento”, mentre il gradiente della funzione errore )(θE∇ è

il vettore delle derivate parziali prime.

∂∂

∂∂

=∇N

EEEθθ

θθθ )(,...,)()(1

Più precisamente il passo di aggiornamento dei pesi per uno strato è così definito:

jkjk

Eθθηθ

∂∂

−=∆)(

Tale variazione corrisponde a produrre uno spostamento, dal punto rappresentativo

dell’insieme corrente dei pesi, in direzione opposta al gradiente della funzione errore. Quindi

l’errore della rete neurale diminuisce con il numero delle iterazioni, e la procedura di

apprendimento converge ad un insieme di pesi stabili. Dunque in tale configurazione, alla

presentazione di nuovi esempi in input anche non coperti dai valori N di addestramento

forniti alla rete (i cosiddetti “valori esterni”), la rete dovrebbe restituire in uscita un valore che

approssima bene l’output desiderato. In questo caso si dice che la rete è ben allenata e potrà

Le reti neurali _________________________________________________________________________

- 58 -

quindi essere utilizzata come strumento di calcolo della funzione da approssimare, di cui erano

noti i punti campione utilizzati per l’addestramento, per qualunque altro punto nel dominio di

definizione della funzione stessa.

L’algoritmo appena presentato soffre di alcuni problemi legati al procedimento matematico del

gradiente (come il fatto che impone variazioni più grandi in valore assoluto ai pesi con derivate

parziali prime maggiori) ma bisogna comunque ricordare che esso è uno dei migliori algoritmi

di addestramento tuttora esistenti in termini di affidabilità, velocità di apprendimento e

versatilità.

Figura 6.6 : I due passi di funzionamento dell’algoritmo back-propagation

Le reti neurali _________________________________________________________________________

- 59 -

6.6 TIPOLOGIE DI RETI NEURALI

Analizzeremo ora tre diverse tipologie di reti neurali, mettendo in mostra le principali

caratteristiche che le distinguono; ricordiamo che la struttura di una rete neurale può essere

molto diversa da rete a rete ma dovrà sempre presentare le caratteristiche fondamentali

descritte in precedenza e dovrà sempre essere composta da neuroni artificiali standard. Non

tratteremo di reti neurali composte da neuroni artificiali costruiti in maniera diversa da quella

che abbiamo presentato e nemmeno delle cosiddette reti neurali dinamiche, ovvero reti dotate

di elementi di memoria. Ci limiteremo a parlare delle seguenti tre famiglie di reti neurali : le reti

lineari standard, le reti feed-forward (o perceptroni multistrato), le reti cascade-forward e le

reti a base radiale (o radial basis).

6.6.1 RETI LINEARI STANDARD

Le reti lineari standard sono la più semplice tipologia di reti neurali esistente; esse sono

composte da due soli strati: nello strato d’ingresso gli n ingressi 1u , 2u , …, nu sono elaborati

da m neuroni non-lineari, con una funzione sigmoidale )(sσ che deve essere gioco forza della

medesima tipologia per tutti i neuroni del primo strato (solitamente viene usato il sigmoide

standard). Le uscite del primo strato fungono ovviamente da ingressi dello strato d’uscita che

in questo tipo di rete è il più semplice possibile, ovvero consiste in un solo neurone lineare che

produce l’unica variabile di uscita y, che dunque non è altro che una semplice combinazione

lineare degli ingressi dello strato d’uscita (come è anche possibile osservare dalla Figura 6.7).

Le reti neurali _________________________________________________________________________

- 60 -

Figura 6.7 : Rete lineare standard

6.6.2 RETI FEED-FORWARD

Le reti neurali feed-forward, altresì dette “perceptroni multistrato”, sono certamente la

tipologia di reti neurali più celebre e utilizzata attualmente nelle applicazioni; esse consistono

nella connessione in serie di più strati di neuroni. Ciò contraddistingue questa tipologia di reti

perché, nella maggior parte dei casi, si tende a limitare il numero degli strati allo strato d’uscita

e a quello d’ingresso aumentando, a seconda delle problematiche da affrontare e della

precisione di approssimazione da ottenere, il numero di neuroni del primo strato. Invece nelle

reti feed-forward si procede in senso opposto, aumentando il numero degli strati e decidendo

a priori il massimo numero di neuroni per strato. Le reti feed-forward inoltre sono formate da

neuroni non-lineari in tutti gli strati, i quali solitamente sono formati dalla medesima funzione

sigmoidale.

Figura 6.8 : Reti feed-forward

6.6.3 RETI A BASE RADIALE

Le reti neurali _________________________________________________________________________

- 61 -

Le reti a base radiale, o RBF (dall’inglese Radial Basis Function), differiscono dalle altre

tipologie non tanto per la struttura o per il numero di strati ma piuttosto per la funzione di

attivazione σ (s) dei neuroni artificiali che la compongono; infatti la suddetta funzione non è

in questo caso una funzione sigmoidale, ma bensì una funzione a simmetria radiale nello

spazio degli ingressi (da qui il nome della rete), dove non esiste un asintoto superiore, quanto

piuttosto un punto di massimo, e il valore della funzione per +∞→s e −∞→s è il

medesimo ed è rappresentato dal valore dell’asintoto inferiore infσ . La funzione più usata è la

celebre funzione probabilistica che prende il nome di funzione gaussiana :

- Funzione gaussiana 2

2

2)(

21)( σ

πσσ

ms

es−

−=

dove ‘ 2σ ’ e ‘ m ’ sono i 2 parametri probabilistici “media” e “varianza”.

Da sottolineare anche il fatto che i pesi non vengono in questa particolare tipologia di rete

moltiplicati per gli ingressi ma invece sottratti ad essi andando a formare la cosiddetta “legge

del neurone RBF” : y = )( θσ −u .

Figura 6.9 : Rete a base radiale

Le reti neurali _________________________________________________________________________

- 62 -

6.7 VANTAGGI E SVANTAGGI DELLE RETI NEURALI

In chiusura di capitolo analizzeremo infine i vantaggi e gli svantaggi derivanti dall’uso di reti

neurali in problemi come il nostro che prevedono come metri di valutazione la velocità di

elaborazione (fattore questo determinante per un’applicazione real-time) e la bontà di

approssimazione.

Il principale vantaggio derivante dall’utilizzo delle reti neurali è senza dubbio il fatto che esse

sono dotate di una estrema velocità computazionale, dato che i calcoli che essa esegue per

generare gli output sono semplici somme, prodotti e combinazioni lineari di vettori e matrici;

ciò fa sì che l’utilizzo di reti neurali sia la soluzione ideale per problemi di controllo real-time,

specie quando l’algoritmo che si vuole approssimare tramite le reti è molto pesante

computazionalmente o addirittura di difficile o impossibile implementazione, in quanto non

esattamente rappresentabile in forma matematica. Un altro grande vantaggio è senza dubbio la

capacità di adattamento a nuove situazioni, nel senso che, a fronte di cambiamenti del

problema da risolvere, è possibile effettuare un nuovo training della rete neurale già creata,

tramite nuovi valori di target, per renderla così adatta al nuovo problema; ciò è

particolarmente vero in situazioni nelle quali il problema non muta radicalmente bensì

intervengono lievi cambiamenti in alcuni parametri che concorrono a formarlo: in questo caso

i pesi della rete non saranno da cambiare del tutto, ma solo da variare di poco, cosa che è

fattibile con poche epoche di addestramento e permette il risparmio di tempo e risorse.

Ovviamente le reti neurali presentano anche degli svantaggi che principalmente possono

essere ricercati nella precisione da voler raggiungere; in molti casi purtroppo l’approssimazione

ottenuta, anche con reti di complessa struttura ed allenate con migliaia di epoche, non è

sufficiente per il problema che si vuole risolvere. Inoltre, se si vuole ottenere dei buoni risultati

in termini di errore percentuale ottenuto, è senza dubbio necessario implementare reti di

media/alta complessità, fornire migliaia di dati di training e addestrare la rete con migliaia di

epoche: anche con i più potenti calcolatori oggi in commercio, i processi sopra descritti

richiedono decine di ore di lavoro e poco si adattano a problemi in cui c’è una continua

necessità di aggiornare la rete e di riaddestrarla a fronte di cambiamenti di output da ottenere.

Un altro svantaggio è il fatto che nel caso di funzioni da approssimare in cui gli output,

derivanti da input molto simili, siano molto diversi fra loro (è il caso ad esempio di una

Le reti neurali _________________________________________________________________________

- 63 -

funzione con parametri di casualità), può succedere che nemmeno una fitta campionatura del

dominio di funzione porti a un’approssimazione accettabile.

In conclusione dunque le reti neurali sono la soluzione ideale quando non è richiesta una

precisione estrema nei risultati e quando è predominante il bisogno di adattarsi in maniera

flessibile a situazioni del mondo reale difficilmente modellizzabili e rappresentabili con

algoritmi matematici precisi.

Cinematica inversa risolta mediante reti neurali _________________________________________________________________________

- 64 -

Capitolo 7

Cinematica inversa risolta mediante reti neurali

In questo capitolo descriveremo il nostro lavoro di soluzione della cinematica inversa di un modello virtuale di braccio robotico antropomorfo controllato da lunghezze dei muscoli, anziché da classiche variabili di giunto, sviluppato mediante l'utilizzo di una rete neurale feed-forward implementata in Matlab e parleremo delle problematiche riguardanti l'utilizzo del nostro modello per il controllo real-time del braccio robotico costruito.

7.1 INTRODUZIONE

Molto spesso la soluzione matematica della cinematica inversa di un robot manipolatore non è

risolvibile in forma chiusa oppure prevede un elevato numero di calcoli che rende il

procedimento molto pesante da un punto di vista strettamente computazionale e quindi poco

adatto a problemi di controllo real-time come il nostro; proprio per questa ragione da alcuni

anni vengono utilizzate le reti neurali nella risoluzione del problema cinematico inverso, al

posto di altri metodi, come ad esempio quello proposto da Pieper e Paul [ 6 ], che invece si

basano su un procedimento matematico euristico e quindi, oltre a non garantire il

raggiungimento della soluzione, sono di difficile implementazione algoritmica. Questo è

particolarmente vero nell’ambito della robotica umanoide; infatti per i robot manipolatori

antropomorfi la complessità strutturale fa sì che siano impraticabili modi di procedere diversi

dai metodi iterativi o da quelli di approssimazione, fra i quali appunto le reti neurali. Grazie

all’utilizzo di quest’ultime invece, la funzione cinematica inversa può essere approssimata


- 65 -

semplicemente con un insieme di dati di addestramento, coppie input-output che, cosa questa

particolarmente interessante, possono essere anche misurate sul campo direttamente con il

robot; addirittura, come nel caso del robot Cog, un robot umanoide sviluppato dal M.I.T.,

anche lo stesso training può essere effettuato real-time, in maniera certamente complessa,

tramite interazioni coi sensori ed auto-apprendimento basato su sistemi di intelligenza

artificiale che permettono in sostanza al robot di raggiungere target sempre più precisi in base

all’esperienza diretta di movimento compiuta: esattamente come avviene negli esseri umani.

Per quanto ci riguarda comunque, svilupperemo prima un modello di rete neurale tramite

l’utilizzo di Matlab, implementando con esso delle funzioni necessarie per lo sviluppo del

nostro modello, ovvero funzioni per la creazione di una rete neurale adatta come complessità

alla risoluzione del nostro problema, per la generazione dei dati di training in base al modello

virtuale del braccio, per il training vero e proprio della rete generata e per la simulazione del

problema cinematico inverso con essa; inoltre implementeremo delle demo che ci

permetteranno di analizzare la bontà del nostro modello in termini di precisione raggiunta ed

uniformità di risultati. In seguito ci occuperemo della creazione di un modello a blocchi in

Simulink necessario per l’utilizzo real-time della rete neurale generata e ci occuperemo dei

problemi di interfacciamento al robot costruito per ispezionare le possibilità di controllo real-

time del braccio antropomorfo mediante l’utilizzo di una rete neurale per la risoluzione del

problema cinematico inverso.

7.2 MODELLAZIONE DI RETI NEURALI IN MATLAB

Come descritto in precedenza è stato utilizzato Matlab per implementare tutte le funzioni

necessarie per la modellazione di reti neurali (vedi Allegato B); in particolare sono stati

utilizzati dei nuovi tools e delle nuove funzioni, da poco sviluppati da Mathworks ed aggiunti

alle ultime versioni di Matlab; ricordiamo in particolare “NNTool”, tool grafico per la gestione

e la visualizzazione delle reti (vedi figura 7.1), e alcune funzioni quali “newff.m”, “train.m” e

“sim.m” delle quali riporteremo nell’Allegato C il funzionamento tratto dalla spiegazione

stessa degli autori.


- 66 -

Figura 7.1 : La veste grafica di NNTool

7.2.1 CREAZIONE DELLA RETE NEURALE

Per la risoluzione ottimale del nostro problema cinematico, è stata implementata una rete

neurale feed-forward generata tramite la funzione “newnet.m”, appositamente creata, che si

basa sull’uso della funzione già esistente “newff.m” (vedi Allegato C). La rete è formata da 3

strati costituiti i primi due da 20 neuroni e il terzo da 7 (vedi figura 7.2) in quanto i parametri

che si vogliono controllare sono le lunghezze dei 7 muscoli. Da sottolineare il fatto che questo

tipo di architettura si è dimostrato essere il più efficace a dispetto di altre architetture che sono

state provate e che prevedevano la prima un numero più elevato di neuroni per i primi 2 strati

e la seconda al contrario una minore complessità derivante dall’utilizzo di soli 2 strati in tutto;

nel primo caso l’elevata complessità si è rivelata un ostacolo al momento di addestrare la rete,


- 67 -

causa le eccessive risorse fisiche e temporali che richiedeva ai calcolatori, mentre nel secondo

la poca complessità si è dimostrata inadatta per il nostro problema e non ci permetteva di

raggiungere una precisione soddisfacente nell’approssimazione. I 3 ingressi, rappresentanti le 3

coordinate spaziali x,y,z, possono assumere un range di valori fra 0 ed 1, mentre le uscite

assumeranno invece un range da -1 a 1 in quanto i neuroni utilizzano una funzione di

attivazione del tipo "tangente sigmoidale"; da qui la necessità di normalizzare in seguito i dati

per il training. Il numero di epoche previste per l’addestramento è pari a 1000.

Figura 7.2 : Architettura della rete neurale creata

7.2.2 GENERAZIONE DEI DATI DI TRAINING

La generazione dei dati per l’addestramento della rete si è rivelata essere uno dei problemi più

ardui da superare; se da una parte la generazione di un numero sempre più elevato di dati non

poteva che migliorare le prestazioni in termini di diminuzione dell’errore, dall’altro le

peggiorava in termini di tempo e di risorse allocate, cosa questa che spesso portava

all’esaurimento delle risorse stesse e dunque all’impossibilità di procedere oltre. Dopo molte

prove sperimentali comunque, siamo giunti al compromesso ottimale che prevede un

campionamento dello spazio tridimensionale in maniera uniforme con un passo di 5 cm lungo

ogni asse, tramite dei cicli di campionamento nei quali gli estremi di scansione sono

rappresentati da i massimi valori spaziali raggiungibili dal braccio. Ovviamente non tutti i dati

generati in questo modo risultano essere dati validi per il braccio, per cui sono stati

implementati dei controlli che prevedono in particolare la verifica che la terna di valori x,y,z


- 68 -

risulti all’interno dello spazio di lavoro e dello spazio di raggiungibilità del braccio. Questo

modo di procedere ci ha quindi portato ad ottenere 1081 dati validi per il training, numero

questo che si è rivelato sufficientemente elevato per l’ottenimento di una buona

approssimazione senza un eccessivo dispendio di risorse fisiche dei calcolatori e di tempo di

elaborazione. I dati generati vengono salvati nell'oggetto "trainingDataFile", costituito da 2

matrici rappresentanti rispettivamente gli ingressi ed i target corrispondenti. (vedi figure 7.3 e

7.4 e Allegato B)

Figura 7.3 : Le prime 8 colonne della matrice 3x1081 di input per il training.

Figura 7.4 : Le prime 8 colonne della matrice 3x1081 di target per il training.

7.2.3 NORMALIZZAZIONE DEI DATI DI TRAINING


- 69 -

Dopo aver generato i dati di training tramite la funzione “generatetd.m”, il cui funzionamento

è stato descritto in precedenza, si è reso necessario procedere con la normalizzazione di questi

ultimi in modo che essi possano effettivamente risultare input ed output corretti per

l’addestramento della rete neurale, la cui architettura, descritta in precedenza, prevede come

input un range di valori fra 0 ed 1 e come output invece un range di valori fra -1 ed 1 (vedi

figure 7.5 e 7.6). Per fare questo è stata implementata la funzione “normalizetd.m” che, dopo

aver normalizzato i dati di input e di output nella maniera appena descritta, salva le due nuove

matrici generate nell’oggetto "trainingDataFileNormalized”.

Figura 7.5 : Le prime 7 colonne della matrice 3x1081 di input normalizzata.

Figura 7.6 : Le prime 7 colonne della matrice 3x1081 di target normalizzata.

7.2.4 ADDESTRAMENTO DELLA RETE NEURALE


- 70 -

L’addestramento della rete neurale, a partire dai dati di training generati e normalizzati in

precedenza, avviene tramite la funzione implementata “newtrain.m”, che si basa sulla funzione

già esistente “train.m” (vedi Allegato C); da notare che, come già specificato nella creazione

della rete neurale, le epoche di addestramento risultano essere pari a 1000, un numero questo

che a prima vista può sembrare eccessivamente riduttivo per l’ottenimento di buoni risultati in

termini di precisione finale raggiunta dalla rete. Invece i dati sperimentali ci hanno mostrato

che, grazie anche all’elevato numero di dati di training generati, 1000 epoche risultano essere

più che sufficienti dato che già dopo una cinquantina di epoche l’errore quadratico medio è

risultato di un ordine di grandezza pari a 0,2 x 10-3 come mostrato nel grafico in figura 7.7;

nelle restanti 950 epoche comunque l’errore è diminuito ulteriormente fino a raggiungere un

ordine di grandezza pari a 10-4, o più precisamente 0.000164688 : risultato questo altamente

soddisfacente, come vedremo anche in seguito. Punto debole del training che abbiamo

effettuato risulta comunque il fattore tempo, in quanto per addestrare la rete secondo questi

dati e parametri ci sono volute circa 16 ore, nonostante il fatto che il training sia stato eseguito

con l’ultima versione di Matlab (6.5 R13) su calcolatori fra i più moderni oggi esistenti

(computer con microprocessore Intel Pentium4 a 2 Ghz di clock e memoria RAM da 512 Mb)

e dedicati esclusivamente a questo processo.


- 71 -

Figura 7.7 : grafico rappresentante la diminuzione dell’errore quadratico medio dopo 50 epoche di addestramento.

7.3 SOLUZIONE DELLA CINEMATICA INVERSA

Il calcolo della cinematica inversa mediante rete neurale è stato implementato nella funzione

"ikine.m" dove innanzitutto la terna di input x,y,z fornita come parametro d’ingresso viene

normalizzata esattamente nello stesso modo in cui venivano normalizzati i dati di training,

ovvero ponendo i 3 input in un range di valori compreso da 0 a 1. Una volta effettuata questa

operazione, viene simulata la rete per produrre i valori dei 7 muscoli tramite la funzione

esistente “sim.m” che riportiamo anch’essa nell’Allegato C; ovviamente i valori prodotti dalla

rete dati gli input non rappresentano ancora le lunghezze dei 7 muscoli che ci interessano in

quanto, come visto nella definizione dell’architettura della rete, questi output risultano essere

compresi in un range di valori da -1 a 1 ed andranno quindi denormalizzati a loro volta per


- 72 -

ottenere infine i valori finali di nostro interesse e avere di fatto risolto il problema cinematico

inverso con l’utilizzo della rete neurale appositamente generata ed addestrata. (figura 7.8)

Figura 7.8 : Prompt di Matlab che mostra il funzionamento della funzione “ikine.m”

7.4 ANALISI DELLE PRESTAZIONI

I risultati ottenuti in termini di velocità di elaborazione sono sicuramente buoni: il calcolo della

cinematica inversa tramite l’utilizzo della rete, ovvero in sostanza l’esecuzione della funzione

“ikine.m” da parte del calcolatore, è immediato; in effetti ciò è dovuto alla natura stessa del

metodo di funzionamento delle reti neurali, come già visto in precedenza, e di fatto questo

comporta la perfetta adattabilità del nostro sistema ad un problema di controllo di tipo real-

time. Particolarmente significativo è il raffronto in questo senso con la funzione “inverse.m”

che risolve la cinematica inversa del nostro modello virtuale del braccio in maniera precisa;

essa infatti impiega un tempo che va dai 3 ai 4 secondi per calcolare le lunghezze dei 7 muscoli

ed è quindi ovviamente inadatta al problema di movimento in real-time del braccio. Anche per

quanto riguarda l’approssimazione ottenuta i risultati raggiunti sono abbastanza soddisfacenti:


- 73 -

all'interno del workspace e per dati esterni al dataset di training, la distanza che separa la

posizione approssimata dell’end-effector del braccio, calcolata secondo le lunghezze dei

muscoli generate dalla rete neurale tramite la funzione “ikine.m”, e quella esatta, calcolata

invece secondo le lunghezze dei muscoli generate dalla funzione “inverse.m”, oscilla

approssimativamente da un minimo di 0,05 cm a un massimo di 3,2 cm, come mostrato dalle

figure 7.10, 7.11, 7.12 e 7.13 ottenute mediante le funzioni demo implementate “bestdemo.m”

e “worstdemo.m”. Purtroppo per valori che si trovano al confine del workspace, seppur

ancora al suo interno, la rete fornisce degli errori molto grandi, anche superiori al limite

ragionevolmente accettabile di 10 cm di scostamento fra la posizione esatta ed approssimata.

Ciò è dovuto in parte ad errori di posizionamento dei muscoli poichè una non buona

approssimazione delle loro lunghezze porta il modello virtuale del braccio a compiere

movimenti scorretti che generano posizioni completamente diverse da quelle che si volevano

raggiungere: si spiegano così gli errori pessimi di approssimazione mostrati dai picchi nel

grafico in figura 7.9a prodotto dalla funzione implementata “mostraerrore.m”. Comunque,

come si può notare dai grafici in figura 7.9b e 7.9c, questi valori risultano essere solo il 12 %

dei 221 valori esterni al dataset di training testati, oltre che risultare in definitiva poco

significativi da un punto di vista del movimento del braccio, essendo per la maggior parte

valori di confine dello spazio di lavoro.


- 74 -

Figura 7.9 a-b : Oscillazione dell'errore di approssimazione testata con 221 valori esterni al dataset di training (a) e

curva rappresentante gli errori di approssimazione ricavati in ordine crescente (b).


- 75 -

Figura 7.9c : Istogramma rappresentante gli errori di approssimazione ricavati.


- 76 -

Figura 7.10 : Rappresentazione 3D del braccio che mostra la minima distanza ottenuta (0,05 cm) fra la posizione esatta

ed approssimata dell’end-effector.

Figura 7.11 : Rappresentazione 3D del braccio che mostra la massima distanza ottenuta (3,2 cm) fra la posizione esatta

ed approssimata dell’end-effector.


- 77 -

Figura 7.12 : Prompt di Matlab all’esecuzione della funzione demo "bestdemo.m".


- 78 -

Figura 7.13 : Prompt di Matlab all’esecuzione della funzione demo "worstdemo.m".

7.5 IMPLEMENTAZIONE DELLA RETE NEURALE IN SIMULINK

Per poter effettivamente usare la rete neurale generata ed addestrata in Matlab in un problema

di controllo in tempo reale, è innanzitutto necessario implementare la sua architettura nel tool


- 79 -

Simulink, modellandola come uno schema a blocchi. Facciamo comunque subito notare che in

Simulink esiste un blocco che permette l’utilizzo di una funzione definita dall’utente, come nel

nostro caso la funzione “ikine.m”, ma purtroppo esso non è ancora supportato dal

compilatore per xPC Target (di cui parleremo in seguito) nell’ultima versione di Matlab (R13

6.5) e quindi il suo uso per una simulazione esterna reale è per ora impossibile anche se in un

futuro prossimo con l’evoluzione di Matlab esso potrebbe venir supportato rendendo di fatto

molto più semplice la modellazione in Simulink del nostro lavoro. Dunque è necessario

usufruire del set di blocchi forniti dalla libreria grafica di Simulink sulle reti neurali (figura

7.14) per poter modellare in maniera esatta tutta l’architettura della nostra rete.

Figura 7.14 : Set di blocchi forniti dalla libreria grafica di Simulink sulle reti neurali.

Tuttavia, prima di descrivere la modellazione della rete neurale vera e propria, occorre creare

dei cosiddetti blocchi di normalizzazione e di denormalizzazione affinché sia l’input della rete

che l’output da esso generato siano corretti: ricordiamo infatti che la rete necessita di un input

formato da valori compresi in un range che va ria da 0 a 1 e fornisce un output formato da

valori compresi in un range che varia da -1 a 1. Questa operazione nella funzione “ikine.m”

era implementata da operazioni su vettori e matrici, le stesse che abbiamo implementato in


- 80 -

forma grafica secondo l’uso di blocchi appositamente esistenti in Simulink per questo tipo di

operazioni. I due blocchi creati sono visibili nelle figure 7.15 e 7.16. Da notare che il blocco

“Product” nel blocco di normalizzazione ha in realtà la funzione di divisione così come il

blocco “Product1” nel blocco di denormalizzazione.

Figura 7.15 : Blocco di normalizzazione degli input


- 81 -

Figura 7.16 : Blocco di denormalizzazione degli output

Una volta creati i suddetti blocchi, che verranno inseriti rispettivamente all’inizio e alla fine

dello schema a blocchi finale del nostro modello, possiamo passare a descrivere lo schema a

blocchi della rete neurale vera e propria. Con riferimento all’architettura mostrata nella figura

7.2 implementiamo ogni strato della rete nel seguente modo: gli input dello strato entreranno

in un blocco “somma” dopo essere stati opportunamente moltiplicati per la matrice dei pesi

“weights”; l’altro addendo sarà rappresentato dal vettore dei parametri di polarizzazione

“biases” e il vettore somma risultante verrà poi mandato in ingresso al blocco “tansig” che

modellizza la funzione di attivazione “tangente sigmoidale”. Il vettore di uscita da questo

blocco sarà il vettore di input di uno strato successivo o, nel caso dell’uscita dal terzo strato, il

vettore “output network” d’ingresso al blocco di denormalizzazione. Il modello finale

ottenuto è mostrato in figura 7.17. Da notare che i parametri inseriti sono stati copiati

manualmente da quelli della nostra rete grazie all’utilizzo del tool grafico descritto in

precedenza “NNTool”.


- 82 -

Figura 7.17 : Modello della rete neurale realizzato come schema a blocchi in Simulink.

7.6 PROBLEMATICHE DI INTERFACCIAMENTO AL ROBOT

Realizzato il modello a blocchi in Simulink per il controllo in tempo reale del robot secondo il

nostro sistema basato su rete neurale, resta il problema di come poter effettivamente usarlo

per muovere il braccio antropomorfo; per questa operazione risulta indispensabile l’utilizzo di

un altro tool di Matlab, ovvero “xPC Target”. Questo tool permette di simulare in tempo reale

qualsiasi modello di schema a blocchi creato in Simulink, purché supportato dal compilatore


- 83 -

xPC, tramite un ambiente basato sull’utilizzo di due computer: un computer host, dove si

trova Matlab e da dove vengono lanciate le simulazioni virtuali per mezzo di Simulink, e un

computer target che fornisce come output digitali valori compatibili con il modello creato,

tramite l’uso di codice eseguibile del modello generato dal compilatore xPC sull’host computer

e passato ad esso per mezzo di un collegamento fisico realizzato mediante porta seriale [ 7 ].

Nel nostro caso entrambi i computer utilizzati come host e target sono normali personal

computer oggi in commercio: il primo fornito di sistema operativo Microsoft Windows XP,

che supporta la versione di Matlab utilizzata (6.5 R13), mentre il secondo un qualsiasi

computer compatibile sul quale è stato caricato uno speciale sistema operativo Matlab, che ha

proprio lo scopo di far assolvere la funzione di target al computer su cui viene caricato,

tramite boot da floppy disk. Gli output digitali generati vengono indi acquisiti da una scheda

elettronica che si preoccupa di convertirli in segnali di controllo per il robot, nel nostro caso

valori di pressione per il rigonfiamento dei muscoli artificiali del braccio antropomorfo, e

quindi di attuarne il movimento. Purtroppo non è stato possibile effettuare la prova

sperimentale del controllo real-time in quanto il braccio robotico non era ancora stato

ultimato, ma il funzionamento teorico del sistema di interfacciamento implementato è senza

ombra di dubbio garantito e permetterà di attuare il movimento del robot quando esso sarà

ultimato e la rete neurale verrà addestrata secondo valori di input-output del braccio reali

misurati sul campo.

7.7 CONCLUSIONI

Considerando i lavori precedenti riguardanti l’utilizzo di reti neurali per la soluzione della

cinematica inversa, dai quali abbiamo preso spunto per arrivare alla definizione della nostra

soluzione del problema tramite l’utilizzo del software, dell’hardware e del modello Matlab

implementato di cui abbiamo parlato in questo capitolo, possiamo affermare che i risultati

ottenuti sono abbastanza buoni. Innanzitutto la complessità architetturale della rete neurale ha

portato ad una soddisfacente approssimazione della soluzione esatta grazie anche al nuovo

modello virtuale del braccio robotico creato, che utilizza le lunghezze dei muscoli come

variabili di controllo per il movimento al posto delle tradizionali variabili di giunto. Inoltre la


- 84 -

velocità di elaborazione delle soluzioni è istantanea, come già detto in precedenza, ed il sistema

implementato è completamente adattabile per la natura stessa del funzionamento delle reti

neurali. I punti deboli del nostro lavoro sembrerebbero essere innanzitutto il tempo necessario

ai calcolatori per la generazione dei dati di training del modello virtuale e per l’addestramento

con 1000 epoche della rete neurale, ovvero rispettivamente 10 e 16 ore; ovviamente le

prospettive di sviluppo dell’hardware ci fanno credere che questo problema sarà eliminato con

la nascita di computer dotati di microprocessori più potenti. Inoltre gli errori molto grandi,

dettati da approssimazioni non buone che portano i muscoli ad eseguire movimenti scorretti,

restano un problema comunque rilevante in quanto portano il braccio in posizioni abbastanza

diverse da quelle che dovrebbero assumere, anche se sono per la quasi totalità valori limite del

workspace. Un altro neo del nostro lavoro può essere il fatto che non è stato purtroppo

possibile effettuare una prova sperimentale del funzionamento reale del sistema di controllo

sviluppato; riteniamo comunque che esso sia valido e che possa essere ulteriormente

migliorato a braccio robotico ultimato, grazie a un nuovo training della rete neurale basato su

nuovi dati di input-output ottenuti tramite campionamento sperimentale dei valori reali

misurati sul robot.

PARTE C

ALLEGATI

Bibliografia _________________________________________________________________________

-86-

Bibliografia

[ 1 ] http://www.univ.trieste.it/~brain/NeuroBiol/ Neuroscienze%20per%20tutti/what.html (neuroni e loro velocità di elaborazione) [ 2 ] “Cinematica inversa di un robot risolta mediante reti neurali” - A. Bonetti [ 3 ] “Grande dizionario enciclopedico” - UTET [ 4 ] “Identificazione dei modelli e sistemi adattativi” - S. Bittanti [ 5 ] “Soluzione della cinematica inversa di un robot manipolatore a sei gradi di libertà mediante reti neurali feedforward e rbf ” - S. De Marco, G. Fontana [ 6 ] “Robotica“ – G. Gini, V. Caglioti [ 7 ] “Matlab R13 Release Notes: xPC Target 2 Release Notes” - The Mathworks [ 8 ] "Generation of human reaching movement using a recurrent neural network model" - Ogihara & Yamazaki [ 9 ] "Trattato di anatomia umana" - A. Bairati (ed. Minerva Medica) [ 10 ] "Braccio robotico per la cinematica inversa" - M. Mulas [ 11 ] "Sensori e attuatori, gli organi del robot" - G. Gini [ 12 ] http://www.shadow.org.uk/products/airmuscles.shtml (una descrizione dei muscoli artificiali di McKibben) [ 13 ] "development of anthropomorphic upper limb prostheses with human-like interphalangian and interdigital coupling" - F.L. da Cunha, H-J A. Schneebeli, V.I Dynnikov [ 14 ] "Fundamental issues, recent advances, and future directions in myodynamics" - h.Hatze [ 15 ] http://www.pieltje.nl/ara/index2.html (anthropomorphic robot arm for "zappo") [ 16 ] "Grasping and manipulation in humanoid robotics" - Scuola superiore S.Anna. [ 17 ] "Biologically inspired control architecture for a humanoid robot" - S. Northrup, N. Sarkar, K.Kawamura [ 18 ] http://brl.ee.washington.edu/index.html [ 19 ] http://www.imagesco.com/index.html [ 20 ] http://www.kronosrobotics.com [ 21 ] http://www.omega.com [ 22 ] http://www.shadow.org.uk [ 23 ] “Abissi d’acciaio” – Isaac Asimov

Il braccio antropomorfo: il modello reale _________________________________________________________________________

-87-

Allegato A

Il braccio antropomorfo: il modello reale

Quella che segue è una breve descrizione del braccio umano . [ 3 ].

“L’arto o appendice superiore dell’uomo è un apparato osteo-artro-muscolare dotato di grandi libertà di

movimento che vengono particolarmente sfruttate per l’orientamento spaziale della sua parte distale, la mano,

che funziona da organo di presa.”

A.1 CARATTERI GENERALI COSTRUTTIVI

Lo scheletro dell’arto superiore comprende la cintura scapolare di attacco allo scheletro assile e

lo scheletro della parte libera. Lo scheletro della parte libera comprende tre settori

corrispondenti alle tre parti anatomiche della parte libera, cioè al braccio, all’avambraccio e alla

mano. Nel braccio si trova un solo osso, l’omero. Nell’avambraccio stanno due ossa circa

parallele radio e ulna, unite da una lamina fibrosa interossea.

Figura A.1 : scheletro dell’arto superiore


-88-

Nella posizione anatomica i tre settori sono allineati l’uno dopo l’altro in senso cranio-caudale

paralleli circa all’asse generale corporeo ed ortogonali al piano formato dalla cintura

scapolare:gli assi dei segmenti non sono però allineati in linea retta, ma angolati tra di loro. Tra

l’asse dell’omero e l’asse dello scheletro dell’avambraccio si trovano un angolo ottuso aperto in

avanti di circa 170° ed un angolo aperto lateralmente di circa 120°.

A.1.1 SCHELETRO DEL BRACCIO

L’omero è l’osso lungo che costituisce lo scheletro del braccio. Ha morfologia abbastanza

caratteristica, perché l’estremità superiore presenta un rigonfiamento sferoidale, la testa,

mentre la estremità inferiore è sensibilmente appiattita a formare una sorta di puleggia,

chiamata appunto troclea.

A.1.2 SCHELETRO DELL’AVAMBRACCIO

Nell’avambraccio sono presenti due ossa unite da una membrana detta interossea. Nella

posizione anatomica del cadavere il radio è sito lateralmente, l’ulna medialmente: essa è

dominante con il giunto dell’omero, mentre il radio ha la prevalenza nell’articolazione

dell’avambraccio con la mano.

a b


-89-

Figura A.2 a-b : ossa del braccio e della cinta scapolare(a) e dell’avambraccio (b)

A.2 LE ARTICOLAZIONI DELL’ARTO SUPERIORE

Le articolazioni dell’arto superiore sono molto numerose ed è banale constatare che, come gli

elementi ossei, esse aumentano di numero in senso prossimo-distale, avendosi il massimo

numero nel sistema osseo della mano. Tenendo presenti caratteri morfologici e funzionali, le

articolazioni dell’arto superiore possono essere raggruppate in tre gruppi: articolazioni della

cintura che provvedono ai movimenti complessivi dell’arto superiore rispetto allo scheletro

assile, le grandi articolazioni tra i tre segmenti della parte libera che provvedono alle loro

libertà di movimento,il gruppo delle piccole articolazioni dello scheletro della mano deputate

ai movimenti intrinseci della mano e delle dita.

A.2.1 ARTICOLAZIONE SCAPOLO-OMERALE

L’articolazione scapolo-omerale o articolazione della spalla è una enartrosi tra la testa

dell’omero e la cavità glenoidea della scapola.

Figura A.3 : articolazione della spalla


-90-

La enartrosi della spalla è dotata di tutti i movimenti angolari e dei movimenti di rotazione:

tutti i movimenti hanno notevoli gradi di libertà. I movimenti di allontanamento e di

avvicinamento dell’estremità distale dell’omero rispetto al piano di simmetria sono detti

movimenti di abduzione e di adduzione: possono avvenire nel piano frontale passante per

l’arto nella posizione anatomica o in tutti gli altri piani, quando l’omero sia spostato nei diversi

gradi di rotazione nel piano sagittale. Nel movimento di abduzione la testa in parte ruota e in

parte si sposta nell’interno della cavità glenoide, permettendo all’asse dell’omero di arrivare ad

una posizione quasi ortogonale all’asse corporeo con una escursione di circa 80°. I movimenti

di flessione e rispettivamente di estensione dell’omero avvengono lungo un piano sagittale, in

avanti o all’indietro. Nel movimento di flessione l’escursione è assai notevole, facilitata dai

movimenti rotatori della testa onde l’estremità distale dell’omero può essere portata a livello

del piano craniale con una escursione di 120°.

Figura A.4 :Traduzione grafica dell’escursione massima di circumduzione della parte libera dell’arto sul tronco per

effetto della sommazione delle libertà di movimento dell’articolazione scapolo-omerale e della articolazione sterno-

claveare: in rosso cono di circumduzione dell’articolazione scapolo-omerale, la linea blu indica l’escursione per

sommazione del movimento dell’articolazione sterno-claveare

Dalla composizione dei movimenti angolari si ottiene la circonduzione dell’omero:la cavità

glenoide è allora l’apice di un cono di escursione abbastanza svasato che arriva circa


-91-

all’emisfera . Il movimento può sommarsi con i movimenti del medesimo tipo

dell’articolazione acromio-clavicolare i quali aumentano notevolmente il cono totale di

escursione dell’arto.

A.2.2 ARTICOLAZIONE DEL GOMITO

L’articolazione del gomito è un complesso articolare nel quale entrano in contatto l’estremità

distale dell’omero e le estremità prossimali dell’ulna e del radio.

Figura A.5 : articolazione del gomito

Per i caratteri delle superfici articolari i tre segmenti realizzano tre articolazioni. Tale

distinzione morfologica non trova però una corrispondenza in una ripartizione di prestazioni

funzionali:l’articolazione del gomito è infatti l’articolazione dei movimenti di flessione ed

estensione dell’avambraccio sul braccio e detti movimenti sono essenzialmente dettati

dall’articolazione omero-ulnare che permette libertà di movimento solo su un determinato

piano.

A.3 MUSCOLI DELL’ARTO SUPERIORE

Gli organi motori dell’arto superore sono una cinquantina di muscoli ben individualizzati

aventi in generale specifiche prestazioni funzionali:solo nella mano si trovano muscoli


-92-

omodinami per i movimenti delle singole dita. In base a criteri principalmente topografici

(dettati dalla scomposizione dell’arto nei diversi settori), ma che però tengono conto di dati

funzionali e qualche volta embriologici, i muscoli dell’arto superiore vengono distinti nei

seguenti gruppi. Il primo gruppo comprende i muscoli di unione della parte prossimale

dell’arto superiore con lo scheletro assile ed è formato quindi da muscoli axo-appendicolari.

L’altro grande gruppo comprende i muscoli sistemati nell’interno dell’arto, aventi cioè le due

estremità di inserzione su elementi scheletrici dell’appendice:detto gruppo forma quindi la

muscolatura intrinseca dell’arto. Il primo gruppo muscolare viene diviso in due gruppi,

denominati muscoli spino-appendicolari e muscoli toraco-appendicolari, in rapporto alla loro

origine o dal rachide o dal torace. La muscolatura intrinseca viene divisa in muscoli dei

successivi settori dell’arto, e quindi si hanno i muscoli della spalla, del braccio,

dell’avambraccio e della mano.

A.3.1 MUSCOLI AXO-APPENDICOLARI

La cintura dell’arto superiore è congiunta allo scheletro assile da imponenti lamine muscolari

dotate di grande potenza. Si riconoscono due gruppi muscolari, uno dorsale detto spino-

appendicolare ed uno ventrale detto toraco-appendicolare per le peculiarità delle loro

inserzioni assiali rispettivamente alla colonna vertebrale ed alla gabbia toracica.

MUSCOLI TORACO-APPENDICOLARI

Muscolo grande pettorale

Il muscolo grande pettorale è un muscolo largo laminare, ma in alcuni punti anche spesso, al

quale si può assegnare una forma circa triangolare con un lato maggiore di origine (supero–

medio-inferiore) dal manubrio al corpo dello sterno, un margine libero supero-laterale, un

altro margine libero quasi orizzontale inferiore ed un apice tendineo ad inserzione anteriore

sull’omero. Data la diversa orientazione dei fasci, il muscolo presenta diverse linee di trazione

sull’arto, che possono essere in parte antagoniste. Quando l’omero è nella posizione anatomica

del cadavere la contrazione del muscolo avvicina l’omero alla linea mediana avendo una

potente azione adduttrice: lo ruota anche un poco all’interno.


-93-

MUSCOLI SPINO-APPENDICOLARI

Muscolo grande dorsale

Il muscolo grande dorsale è un muscolo laminare che origina dalla linea delle spine dei

processi spinosi della colonna vertebrale lombare e faccia posteriore del bacino raggiunge una

ristretta inserzione omerale. Ha forma triangolare con un lato maggiore lungo la colonna

vertebrale, un lato superiore un po’ curvilineo, ma quasi orizzontale guardante in alto, ed un

margine infero-laterale obliquo dal basso all’alto e in fuori. Il muscolo gran dorsale traendo

sull’omero lo porta indietro e in dentro funzionando quindi da estensore e adduttore

dell’omero: ha anche una componente rotatoria interna che si accentua quando l’omero venga

ruotato fortemente all’esterno.

a b

Figura A.6 a-b: I muscoli axo – appendicolari, muscolo gran pettorale (a) e muscolo gran dorsale (b)

A.3.2 MUSCOLATURA INTRINSECA DELL’ARTO

MUSCOLI DELLA SPALLA

I muscoli della spalla prendono origine dalle ossa della cintura scapolare e terminano sul tratto

prossimale dell’omero.

Muscolo deltoide


-94-

E’ un muscolo voluminoso, laminare, ma in certi punti assai spesso che , distaccato dalle sue

inserzioni e disteso in superficie, ha un contorno triangolare con larga base superiore, un

margine anteriore, uno posteriore ed apice rivolto in basso. In sito il muscolo è foggiato a

doccia, perché il largo margine superiore è curvilineo e con la sua concavità ricopre la testa

omerale inserendosi al contorno dell’arco della cintura. Data la direzione dei fasci l’azione del

muscolo è molteplice. I fasci anteriori hanno azione di abduzione e proiezione in avanti

dell’omero, quindi di flessione. I fasci posteriori sono antagonisti, proiettano indietro l’omero

e lo estendono. I fasci centrali più potenti sono decisamente abduttori ed arrivano a portare

l’omero in posizione di massima abduzione.

Muscolo sottoscapolare

Ha la forma di una lamina triangolare contenuta per la massima parte nella fossa

sottoscapolare. Il muscolo ha azione rotatrice sull’omero: precisamente tirando sulla piccola

tuberosità lo fa ruotare all’interno.

Muscolo sovraspinato

E’ un muscolo allungato, appiattito alla sua origine, poi successivamente carnoso, a sezione

quasi triangolare, sistemato nell’angolo diedro della fossa spinata. L’azione del muscolo è

principalmente rotatoria dell’omero verso l’esterno essendo antagonista dei fasci superiori del

muscolo sottoscapolare.

a b c

Figura A.7 a-b-c : Muscolatura intrinseca dell’arto, muscolo deltoide (a), muscolo sottoscapolare (b) e muscolo

sopraspinato (c)


-95-

MUSCOLI DEL BRACCIO

I muscoli del braccio sono muscoli lunghi, con asse maggiore all’incirca parallelo all’asse

dell’omero che essi rivestono quasi completamente.

Muscolo bicipite

Il nome è dovuto all’origine prossimale che avviene tramite due capi lungo e breve che hanno

punti ossei di inserzione alla cintura e che si fondono in un grosso ventre il cui tendine

terminale si porta al radio:il bicipite è quindi un muscolo che non ha inserzioni all’omero, ma

che si serve dell’omero come di una leva intermedia per la sua azione sull’avambraccio. Dato

che l’inserzione tendinea distale gira sul contorno del radio la contrazione del bicipite tende in

primo luogo a far ruotare il radio verso l’esterno e quindi a determinare un movimento

supinatorio della mano. Detta azione è molto netta quando la mano è in pronazione e in tale

caso la contrazione nella fase iniziale porta la mano e l’avambraccio in posizione intermedia tra

pronazione e supinazione. Raggiunta la posizione citata il muscolo determina la flessione

dell’avambraccio sul braccio.

Muscolo tricipite

E’ un muscolo voluminoso che origina con tre capi lungo, mediale e laterale e che col suo

ventre occupa da solo la loggia posteriore del braccio. L’azione del muscolo è univoca ed

evidente : risulta estensore dell’avambraccio che esso riporta nella posizione anatomica del

cadavere dopo la flessione.

a b


-96-

Figura A.8 a-b: Muscoli del braccio, muscolo bicipite (a), muscolo tricipite (b)

Funzioni implementate _________________________________________________________________________

-97-

Allegato B

Funzioni implementate

Bestdemo % BESTDEMO - Mostra l'errore ottimo di approssimazione percentuale della rete neurale. % % Sintassi % % bestdemo % % Descrizione % % Per un valore di ottima approssimazione del braccio, la demo riporta a video l'errore di approssimazione percentuale % della rete neurale calcolato come differenza normalizzata fra i valori precisi, calcolati dalla funzione "inverse.m" % che risolve matematicamente la cinematica inversa del braccio, e la funzione "ikine.m" che invece fornisce i valori % prodotti dalla rete neurale % % bestdemo.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 2.1.1 % Data di creazione: 25 Agosto 2003, 12:05 % Ultima modifica: 26 Settembre 2003, 15.49 function bestdemo % carico il workspace load('workspace final'); % definisco i valori validi di approssimazione ottima delle coordinate x,y,z dell'end-effector braccio= [31.5; 29; 16.5]; % calcolo i corrispondenti valori dei muscoli in maniera precisa muscoli = inverse(braccio); % calcolo i valori approssimati forniti dalla rete neurale muscolikine = ikine(mynet,braccio)


-98-

% calcolo la differenza percentuale fra le due configurazioni dei muscoli ottenute in precedenza errore = ((muscolikine - (muscoli.length))./muscolikine)*100; % stampo a video il risultato disp('Errore di approssimazione percentuale della rete neurale: '); errore % disegno i due bracci secondo i valori dei muscoli precisi e di quelli approssimati init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=muscoli.length(1,1); pect.length=muscoli.length(3,1); bic.length=muscoli.length(4,1); supr.length=muscoli.length(5,1); movearm; rotarm; moveforearm; plotarm; wrist polso = wrist; init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=muscolikine(1,1); pect.length=muscolikine(3,1); bic.length=muscolikine(4,1); supr.length=muscolikine(5,1); movearm; rotarm; moveforearm; plotarm; %calcolo la distanza spaziale fra gli end-effector dei due bracci. wrist polsoap=wrist; distanza = dist(polso,polsoap) return


-99-

Datanalizer % DATANALIZER - Mostra graficamente lo scostamento fra la posizione % corretta del polso e quella approssimata calcolata dalla rete neurale. % % Sintassi % % datanalizer() % % Descrizione % % DATANALIZER % % datanalizer.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 1.0.0 % Data di creazione: 26 Settembre 2003, 14:46 % Ultima modifica: 26 Settembre 2003, 14:46 function datanalizer() load('wrkspcvettoredistanze'); i=1; for count=1:1:210 if vettoredistanze(count)>5 vettorepos(:,i)=vettoreposizioni(:,count); i=i+1; end end i=i-1; for count2=1:1:i dist(count2)=abs(vettorepos(1,count2)-XMin); end for count2=1:1:i distanza=abs(vettorepos(1,count2)-XMax); if distanza<dist(count2) dist(count2)=distanza; end end for count2=1:1:i distanza=abs(vettorepos(2,count2)-YMin); if distanza<dist(count2) dist(count2)=distanza; end end for count2=1:1:i distanza=abs(vettorepos(2,count2)-YMax); if distanza<dist(count2) dist(count2)=distanza; end end for count2=1:1:i distanza=abs(vettorepos(3,count2)-ZMin); if distanza<dist(count2) dist(count2)=distanza; end end for count2=1:1:i distanza=abs(vettorepos(3,count2)-ZMax); if distanza<dist(count2) dist(count2)=distanza; end end save('wrkspcanalisi'); return


-100-


-101-

Demoarm %DEMOARM - Animazione del braccio con valori non generati da una rete %neurale. % % Sintassi % % demoarm % % Descrizione % % DEMOARM % % demoarm.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 1.0.0 % Data di creazione: 14 Giugno 2003 % Ultima modifica: 14 Giugno 2003 %movimento: partendo dalla posizione di riposo, afferrare un oggetto che si %trova di fronte alla spalla, di coordinate [0 40 10] init; %inizializza le costanti geometriche resetarm; %porta il braccio nella posizione di riposo polso=[44;44;0]; %questo è il target del polso muscoli=inverse(polso); %muscoli contiene i valori dei muscoli necessari per raggiungere il target. %processo di decisione: quali sono i muscoli attivi? quelli che si %contraggono di piu percentualmente. Per le coppie di muscoli è facile %pichè uno si contrae e l'altro si espande, per la terna pect-delt-dors %devo calcolare le elongazioni percentuali! deltapect=(muscoli(3,1)-pect.length)/(PECT.MAX-PECT.MIN); deltadelt=(muscoli(1,1)-delt.length)/(DELT.MAX-DELT.MIN); deltadors=(muscoli(2,1)-dors.length)/(DORS.MAX-DORS.MIN); if (deltapect>deltadelt) delt.active='si'; if (deltapect>deltadors) dors.active='si'; else pect.active='si'; end else pect.active='si'; if(deltadelt>deltadors) dors.active='si'; else delt.active='si'; end end clear deltapect deltadelt deltadors; if subs.length>muscoli(6,1) subs.active='si'; else supr.active='si';


-102-

end if bic.length>muscoli(4,1) bic.active='si'; else tric.active='si'; end delt.length=muscoli(1,1); dors.length=muscoli(2,1); pect.length=muscoli(3,1); bic.length=muscoli(4,1); supr.length=muscoli(5,1); subs.length=muscoli(6,1); tric.length=muscoli(7,1); movearm; rotarm; moveforearm; plotarm; %clear muscoli polso


-103-

Dist %DIST - Calcola la distanza euclidea tra due punti espressi % in coordinate omogenee. % % Sintassi % % d = dist(P, Q) % % Descrizione % % DIST % % dist.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 Giugno 2003 % Ultima modifica: 12 Giugno 2003 function [d] = dist(P1, P2) d = sqrt(sum((P1-P2).^2)); return


-104-

Generatetd %GENERATETD - Crea i dati necessari per l'addestramento della rete neurale. % % Sintassi % % generatetd() % % Descrizione % % GENERATETD % % generatetd.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 1.3.2 % Data di creazione: 20 Giugno 2003, 13:40 % Ultima modifica: 28 Agosto 2003, 17:08 function generatetd() % clear % init %definisco il valore del fattore di scala del training intFactor = 5; %inizializzo le costanti rappresentanti i valori minimi e massimi ammissibili per i dati di %input x,y,z XMin = 0; XMax = 60; YMin = 20; YMax = 60; ZMin = -60; ZMax = 20; %inizializzo i contatori XCount = XMin; YCount = YMin; ZCount = ZMin; trainingCount = 1; %cicli di addestramento for XCount = XMin :intFactor: XMax for YCount = YMin :intFactor: YMax for ZCount = ZMin :intFactor: ZMax if ((XCount)^2+(YCount)^2+(ZCount)^2)^(1/2) > 15 & ((XCount)^2+(YCount)^2+(ZCount)^2)^(1/2) < 65 disp(sprintf('dato valido: memorizza!')); %variabili polso e muscoli inputData = [(XCount); (YCount); (ZCount)] ; targetData = inverse(inputData); %variabili generali per il training if (targetData.valid == 'si') inputTrainingData(1, trainingCount) = inputData(1, 1); inputTrainingData(2, trainingCount) = inputData(2, 1); inputTrainingData(3, trainingCount) = inputData(3, 1); targetTrainingData(1, trainingCount) = targetData.length(1, 1);


-105-

targetTrainingData(2, trainingCount) = targetData.length(2, 1); targetTrainingData(3, trainingCount) = targetData.length(3, 1); targetTrainingData(4, trainingCount) = targetData.length(4, 1); targetTrainingData(5, trainingCount) = targetData.length(5, 1); targetTrainingData(6, trainingCount) = targetData.length(6, 1); targetTrainingData(7, trainingCount) = targetData.length(7, 1); disp(sprintf('contatore generale = %d', trainingCount)); %aggiorno il contatore generale trainingCount = trainingCount + 1; else disp(sprintf('dato non valido INVERSE: non memorizza!')); end else disp(sprintf('dato non valido TRAINING: non memorizza!')); end end end end save('trainingDataFile'); return


-106-

Ikine %IKINE - Algoritmo per la cinematica inversa. % % Sintassi % % muscoli = ikine(mynet, polso); % % Descrizione % % IKINE calcola i valori dei muscoli che determinano la configurazione % del braccio per portare la mano il più possibile vicino % al punto "polso", in base alla rete neurale mynet. % ikine.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 3.0.0 % Data di creazione: 24 Giugno 2003, 16.16 % Ultima modifica: 17 Settembre, 18.49 function [muscoliOK] = ikine(mynet, polso) init %inizializzo i fattori di scala XinputMaxFactor = 60; YinputMaxFactor = 60; ZinputMaxFactor = 20; XinputMinFactor = 0; YinputMinFactor = 20; ZinputMinFactor = -60; % normalizzo gli input polsoNormalizzato = (polso-[XinputMinFactor;YinputMinFactor;ZinputMinFactor])./ ([XinputMaxFactor;YinputMaxFactor;ZinputMaxFactor]- [XinputMinFactor;YinputMinFactor;ZinputMinFactor]); % disp(polsoNormalizzato); % simulo la rete muscoli = sim(mynet, polsoNormalizzato); % disp(muscoli); % denormalizzo gli output muscoli2 = (muscoli+1)./2; % disp(muscoli2); muscoliOK = (muscoli2.*([DELT.MAX;DORS.MAX;PECT.MAX;BIC.MAX;SUPR.MAX;SUBS.MAX;TRIC.MAX]- [DELT.MIN;DORS.MIN;PECT.MIN;BIC.MIN;SUPR.MIN;SUBS.MIN;TRIC.MIN])) +[DELT.MIN;DORS.MIN;PECT.MIN;BIC.MIN;SUPR.MIN;SUBS.MIN;TRIC.MIN]; return


-107-

Init %INIT - Inizializza le costanti geometriche. % % Sintassi % % init % % Descrizione % % INIT % % init.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 Giugno 2003 % Ultima modifica: 12 Giugno 2003 %PARAMETRI INIZIALI DEL BRACCIO POSIZIONATO IN VERTICALE LUNGO IL CORPO %Sistema di riferimento "busto" SHOULDER=[0;0;0]; PECT.ORIGIN=[-20;0;0]; DORS.ORIGIN=[0;-20;-30]; DELT.ORIGIN=[0;0;3]; SUBS.ORIGIN=[-sqrt(3);sqrt(3);sqrt(3)]; SUPR.ORIGIN=[sqrt(3);-sqrt(3);-sqrt(3)]; SUPR.ATTACH=[-10;-10;-3]; SUBS.ATTACH=[-10;-10;-3]; %Sistema di riferimento "braccio" ELBOW=[0;0;-34]; PECT.INSERT=[0;0;-5]; DORS.INSERT=[0;0;-5]; DELT.INSERT=[0;0;-15]; SUPR.INSERT=[3;0;0]; SUBS.INSERT=[3;0;0]; TRIC.ATTACH=[0;0;-8]; BIC.ORIGIN=[0;0;-8]; TRIC.ORIGIN=[0;0;-37]; %sistema di riferimento "avambraccio" BIC.INSERT=[0;0;-37]; %magari da accorciare TRIC.INSERT=[0;0;-37]; WRIST=[0;0;-65]; %LUNGHEZZE DELT.LENGTH=dist(DELT.ORIGIN,DELT.INSERT); DORS.LENGTH=dist(DORS.ORIGIN,DORS.INSERT); PECT.LENGTH=dist(PECT.ORIGIN,PECT.INSERT); BIC.LENGTH=dist(BIC.ORIGIN,BIC.INSERT); SUPR.LENGTH=dist(SUPR.ORIGIN,SUPR.INSERT)+dist(SUPR.ORIGIN,SUPR.ATTACH); SUBS.LENGTH=dist(SUBS.ORIGIN,SUBS.INSERT)+dist(SUBS.ORIGIN,SUBS.ATTACH); TRIC.LENGTH=dist(TRIC.ORIGIN,TRIC.INSERT)+dist(TRIC.ORIGIN,TRIC.ATTACH); %STATO INIZIALE , MUSCOLI A RIPOSO DELT.ACTIVE='no'; DORS.ACTIVE='no'; PECT.ACTIVE='no'; BIC.ACTIVE='no'; SUPR.ACTIVE='no'; SUBS.ACTIVE='no'; TRIC.ACTIVE='no';


-108-

%lunghezze massime e minime sperimentali PECT.MAX=24.7939; PECT.MIN=20.6154; DELT.MAX=18; DELT.MIN=15.3114; DORS.MAX=39.0134; DORS.MIN=32.0465; SUPR.MAX=17.1669; SUPR.MIN=16.2259; SUBS.MAX=20.8309; SUBS.MIN=20.441; TRIC.MAX=34.7151; TRIC.MIN=29.4619; BIC.MAX=28.9682; BIC.MIN=23.6206; % %lunghezze massime e minime teoriche % % PECT.MAX=dist(PECT.ORIGIN,SHOULDER)+dist(PECT.INSERT,SHOULDER); % %situazione in cui il braccio è esteso a lato % PECT.MIN=sqrt(dist(PECT.ORIGIN,SHOULDER)^2+dist(PECT.INSERT,SHOULDER)^2); % %situazione in cui il braccio è esteso frontalmente % % DELT.MAX=dist(DELT.ORIGIN,SHOULDER)+dist(DELT.INSERT,SHOULDER); % %situazione in cui il braccio è a riposo % DELT.MIN=sqrt(dist(DELT.ORIGIN,SHOULDER)^2+dist(DELT.INSERT,SHOULDER)^2); % %situazione in cui il braccio è elevato orizzontalmente % % DORS.MAX=sqrt(dist(DORS.ORIGIN,[0;-20;0])^2+dist([0;7;0],[0;-20;0])^2); % %situazione in cui il braccio è esteso frontalmente % DORS.MIN=dist(DORS.ORIGIN,DORS.INSERT); % %situazione in cui il braccio è a riposo % % BIC.MIN=dist(BIC.ORIGIN,ELBOW)-dist(BIC.INSERT,ELBOW); % %situazione in cui l'avambraccio è completamente piegato sul braccio % BIC.MAX=dist(BIC.ORIGIN,ELBOW)+dist(BIC.INSERT,ELBOW); % %situazione in cui l'avambraccio è completamente esteso rispetto al braccio % % TRIC.MIN=dist(TRIC.ATTACH,ELBOW)+dist(TRIC.INSERT,ELBOW); % %situazione in cui l'avambraccio è completamente esteso rispetto al braccio % TRIC.MAX=dist(TRIC.ATTACH,TRIC.ORIGIN)+dist(TRIC.ORIGIN,ELBOW)+dist(TRIC.INSERT,ELBOW); % %situazione in cui l'avambraccio è completamente piegato sul braccio % % %PER SOTTOSCAPOLARE E SOPRASPINATO NON VI SONO METODI SEMPLICI. % %do quindi dei valori approssimativi % % %in base al modello usato, si impone nella risoluzione dei sistemi di % %equazioni simboliche che la grande tuberosità dell'omero a cui si % %agganciano i muscoli sopraspinato e sottoscapolare giaccia sullo spicchio % %di sfera con coordinate X e Z positive (ossia la parte superiore a destra). % %Stante questo, ed essendo la grande tuberosità lunga 3 cm, si sono trovati % %in maniera non troppo rigorosa delle posizioni in cui i due muscoli % %assumono lunghezze massime e minime. % % SUBS.MAX=dist(SUBS.ORIGIN,SUBS.ATTACH)+dist(SUBS.ORIGIN,[3/sqrt(2);-3/sqrt(2);0]); % SUBS.MIN=dist(SUBS.ORIGIN,SUBS.ATTACH)+dist(SUBS.ORIGIN,[0;3/sqrt(2);3/sqrt(2)]); % % SUPR.MAX=dist(SUPR.ORIGIN,SUPR.ATTACH)+dist([0;3/sqrt(2);3/sqrt(2)],SUPR.ORIGIN); % SUPR.MIN=dist(SUPR.ORIGIN,SUPR.ATTACH)+dist([3/sqrt(2);-3/sqrt(2);0],SUPR.ORIGIN); %calcolo contrazioni percentuali. %la contrazione percentuale permessa dai muscoli di McKibben utilizzati in %progettazione è del 20%. PECT.CONTRAZ=(PECT.MAX-PECT.MIN)/PECT.MAX; DORS.CONTRAZ=(DORS.MAX-DORS.MIN)/DORS.MAX; DELT.CONTRAZ=(DELT.MAX-DELT.MIN)/DELT.MAX; SUPR.CONTRAZ=(SUPR.MAX-SUPR.MIN)/SUPR.MAX; SUBS.CONTRAZ=(SUBS.MAX-SUBS.MIN)/SUBS.MAX; BIC.CONTRAZ=(BIC.MAX-BIC.MIN)/BIC.MAX; TRIC.CONTRAZ=(TRIC.MAX-TRIC.MIN)/TRIC.MAX;


-109-

Inverse %INVERSE - algoritmo per il calcolo della cinematica inversa % % Sintassi % % inverse([x y z]) % % Descrizione % % INVERSE % % inverse.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 1.0.0 % Data di creazione: 14 Giugno 2003 % Ultima modifica: 14 Giugno 2003 %con questo algoritmo dovrebbero funzionare i valori che hanno x compresa %tra 0 e 60, y compresa tra 15 e 60, z compresa tra -60 e 30 e che vanno tra %x^2+y^2+z^2=30 a x^2+y^2+z^2=64. function [muscoli]=inverse(polso) init muscoli.valid='si'; %primo passo: non controllo che i valori siano ammissibili, scrivo %l'algoritmo per il calcolo delle lunghezze dei muscoli %devo trovare il vettore perpendicolare al piano del braccio, inclinato di %20 gradi rispetto all'orizzonte syms x y z r=x*polso(1,1)+y*polso(2,1); %r impone che il vettore giaccia sul piano perpendicolare al vettore che %collega spalla a polso s=x^2+y^2-1; %s impone che sia un versore %t impone che l'angolo con il piano verticale... [x,y]=solve(r,s); X=sym2poly(x(1,1)); Y=sym2poly(y(1,1)); Z=eps; %Z=sym2poly(z(1,1)); if X<0 X=sym2poly(x(2,1)); Y=sym2poly(y(2,1)); if X<0 disp(sprintf('errore del gomito!')) muscoli.valid='no'; end end clear x y z r s t %trovo la posizione del gomito! syms x y z r=(x-SHOULDER(1,1))^2+(y-SHOULDER(2,1))^2+(z-SHOULDER(3,1))^2-dist(SHOULDER,ELBOW)^2; %r impone la distanza tra gomito e spalla s=(x-polso(1,1))^2+(y-polso(2,1))^2+(z-polso(3,1))^2-dist(ELBOW,WRIST)^2; %r impone la distanza tra gomito e polso t=x*X+y*Y+z*Z; %t impone che il braccio giaccia sul piano perpendicolare al vettore


-110-

%individuato prima [x,y,z]=solve(r,s,t); wrist=polso; elbow=[sym2poly(x(1,1));sym2poly(y(1,1));sym2poly(z(1,1))]; %disp(sprintf('GOMITO1')) if (elbow(1,1)<0 | elbow(2,1)<0 | elbow(3,1)>0) elbow=[sym2poly(x(2,1));sym2poly(y(2,1));sym2poly(z(2,1))]; %disp(sprintf('GOMITO2')) if elbow(1,1)<0 | elbow(2,1)<0 | elbow(3,1)>0 disp(sprintf('errore della spalla!')); muscoli.valid='no'; end end % % if (elbow(1,1)*X+elbow(2,1)*Y+elbow(3,1)*Z<0) %deventa negativo quando il gomito sta ruotando al contrario. .. da verificare. % muscoli.valid='no'; % end shoulder=SHOULDER; clear x y z r s t; %Sistema di riferimento "busto" pect.origin=PECT.ORIGIN; delt.origin=DELT.ORIGIN; dors.origin=DORS.ORIGIN; subs.origin=SUBS.ORIGIN; supr.origin=SUPR.ORIGIN; supr.attach=SUPR.ATTACH; subs.attach=SUBS.ATTACH; %Sistema di riferimento "braccio" pect.insert=elbow.*(dist(PECT.INSERT,SHOULDER)/dist(ELBOW,SHOULDER)); dors.insert=elbow.*(dist(DORS.INSERT,SHOULDER)/dist(ELBOW,SHOULDER)); delt.insert=elbow.*(dist(DELT.INSERT,SHOULDER)/dist(ELBOW,SHOULDER)); tric.attach=elbow.*(dist(TRIC.ATTACH,SHOULDER)/dist(ELBOW,SHOULDER)); bic.origin=elbow.*(dist(BIC.ORIGIN,SHOULDER)/dist(ELBOW,SHOULDER)); tric.origin=elbow.*(dist(TRIC.ORIGIN,SHOULDER)/dist(ELBOW,SHOULDER)); %devo trovare l'inserzione di sottoscapolare e sopraspinato syms x y z; r=(x*(wrist(1,1)-elbow(1,1)))+(y*(wrist(2,1)-elbow(2,1)))+(z*(wrist(3,1)-elbow(3,1))); %r impone la perpendicolarità con il piano dell'avambraccio s=(x*elbow(1,1))+(y*elbow(2,1))+(z*elbow(3,1)); %s impone che l'osso non si deformi(perpendicolarità dei due tratti) t=(x-shoulder(1,1))^2+(y-shoulder(2,1))^2+(z-shoulder(3,1))^2-dist(SHOULDER,SUPR.INSERT)^2; %t impone che il muscolo non si stacchi dall'osso [x,y,z]=solve(r,s,t); if (sym2poly(z(1,1))>=-0.0001) & (sym2poly(x(1,1))>=-0.00001) supr.insert(1,1)=sym2poly(x(1,1)); supr.insert(2,1)=sym2poly(y(1,1)); supr.insert(3,1)=sym2poly(z(1,1)); %disp('caso 1') elseif (sym2poly(z(2,1))>=-0.0001) & (sym2poly(x(2,1))>=-0.0001) supr.insert(1,1)=sym2poly(x(2,1)); supr.insert(2,1)=sym2poly(y(2,1)); supr.insert(3,1)=sym2poly(z(2,1)); %disp('caso 2') else


-111-

supr.insert(1,1)=sym2poly(x(1,1)); %fittizio supr.insert(2,1)=sym2poly(y(1,1)); %fittizio supr.insert(3,1)=sym2poly(z(1,1)); %fittizio disp(sprintf('errore della rotazione della spalla!')); muscoli.valid='no'; end subs.insert=supr.insert; clear x y z r s t; %sistema di riferimento "avambraccio" bic.insert=elbow+(polso-elbow).*(dist(BIC.INSERT,ELBOW)/dist(ELBOW,WRIST)); tric.insert=elbow+(polso-elbow).*(dist(TRIC.INSERT,ELBOW)/dist(ELBOW,WRIST)); %CALCOLO LUNGHEZZE!!! pect.length=dist(pect.origin,pect.insert); delt.length=dist(delt.origin,delt.insert); dors.length=dist(dors.origin,dors.insert); subs.length=dist(subs.origin,subs.insert)+dist(subs.origin,subs.attach); supr.length=dist(supr.origin,supr.insert)+dist(supr.origin,supr.attach); bic.length=dist(bic.origin,bic.insert); tric.length=dist(tric.origin,tric.insert)+dist(tric.origin,tric.attach); muscoli.length(1,1)=delt.length; muscoli.length(2,1)=dors.length; muscoli.length(3,1)=pect.length; muscoli.length(4,1)=bic.length; muscoli.length(5,1)=supr.length; muscoli.length(6,1)=subs.length; muscoli.length(7,1)=tric.length; return


-112-

Mostraerrore % MOSTRAERRORE - Mostra graficamente lo scostamento fra la posizione % corretta del polso e quella approssimata calcolata dalla rete neurale. % % Sintassi % % mostraerrore() % % Descrizione % % MOSTRAERRORE % % mostraerrore.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 3.1.0 % Data di creazione: 28 Agosto 2003, 15:40 % Ultima modifica: 26 Settembre 2003, 12:48 function mostraerrore() % carico il workspace load ('workspace final'); init %definisco il valore del fattore di scala del campionamento intFactor = 7.5; %inizializzo le costanti rappresentanti i valori minimi e massimi ammissibili per i dati di input x,y,z XMin = 0; XMax = 60; YMin = 20; YMax = 60; ZMin = -60; ZMax = 20; XMin=XMin+1.5; YMin=YMin+1.5; ZMin=ZMin+1.5; %si sottolinea che il dataset generato per il test non ha valori in comune con il dataset del training %inizializzo i contatori XCount = XMin; YCount = YMin; ZCount = ZMin; count = 1; %cicli di generazione dati for XCount = XMin :intFactor: XMax for YCount = YMin :intFactor: YMax for ZCount = ZMin :intFactor: ZMax if ((XCount)^2+(YCount)^2+(ZCount)^2)^(1/2) > 15 & ((XCount)^2+(YCount)^2+(ZCount)^2)^(1/2) < 65 %variabili polso e muscoli input = [(XCount); (YCount); (ZCount)]; %input è il valore voluto targetok = inverse(input); %valori dei muscoli calcolati tramite inverse targetap = ikine(mynet,input); %valori dei muscoli calcolati con la rete


-113-

if (targetok.valid == 'si') init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=targetok.length(1,1); pect.length=targetok.length(3,1); bic.length=targetok.length(4,1); supr.length=targetok.length(5,1); movearm; rotarm; moveforearm; %wrist contiene i valori del polso cacolati sulla base della inverse % plotarm; if (dist(input(1),wrist(1)) < 0.1) & (dist(input(2),wrist(2)) < 0.1) & (dist(input(3),wrist(3)) < 0.1) %se si entra qui, la inverse è corretta input polso = wrist %polso contiene il valore calcolato con la inverse init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=targetap(1,1); pect.length=targetap(3,1); bic.length=targetap(4,1); supr.length=targetap(5,1); movearm; rotarm; moveforearm; % plotarm; polsoap = wrist %polsoap contiene il valore cacolato con rete distanza = dist(input,polsoap); distanzaOk = real(distanza) vettoredistanze(count) = distanzaOk; vettoreposizioni(1,count) = XCount; vettoreposizioni(2,count) = YCount; vettoreposizioni(3,count) = ZCount; %aggiorno il contatore gener count = count+1; end end end end end end save('wrkspcvettoredistanze'); figure(1) grid on; hold on; plot(vettoredistanze); return


-114-

Movearm %MOVEARM - genera il movimento del braccio a partire dalle informazioni sui %muscoli % % Sintassi % % movearm % % Descrizione % % movearm % % movearm.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 Giugno 2003 % Ultima modifica: 21 Giugno 2003 %questo sistema trova la posizione dell'inserzione del pettorale syms x y z; if (pect.active=='si') r=(x-pect.origin(1,1))^2+(y-pect.origin(2,1))^2+(z-pect.origin(3,1))^2-pect.length^2; %r impone l'azione del pettorale if (dors.active=='si') s=(x-dors.origin(1,1))^2+(y-dors.origin(2,1))^2+(z-dors.origin(3,1))^2-dors.length^2; %s impone l'azione del dorsale if (delt.active=='si') disp(sprintf('errore nel movimento dei muscoli')); end elseif (delt.active=='si') s=(x*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT)-delt.origin(1,1))^2+(y*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT)-delt.origin(2,1))^2+(z*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT)-delt.origin(3,1))^2-delt.length^2; %s impone l'azione del deltoide else disp(sprintf('errore nel movimento dei muscoli')); end elseif (dors.active=='si')&(delt.active=='si') r=(x-dors.origin(1,1))^2+(y-dors.origin(2,1))^2+(z-dors.origin(3,1))^2-dors.length^2; %s impone l'azione del dorsale s=(x*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT)-delt.origin(1,1))^2+(y*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT)-delt.origin(2,1))^2+(z*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT)-delt.origin(3,1))^2-delt.length^2; %s impone l'azione del deltoide else disp(sprintf('errore nel movimento dei muscoli')); end t=(x-shoulder(1,1))^2+(y-shoulder(2,1))^2+(z-shoulder(3,1))^2-dist(SHOULDER,PECT.INSERT)^2; %t impone che il muscolo non si stacchi dall'osso [x,y,z]=solve(r,s,t); %ora seleziono la soluzione corretta pect.insert(1,1)=sym2poly(x(1,1)); pect.insert(2,1)=sym2poly(y(1,1)); pect.insert(3,1)=sym2poly(z(1,1)); if pect.insert(1,1)<0 | pect.insert(2,1)<0 | pect.insert(3,1)>0 pect.insert(1,1)=sym2poly(x(2,1)); pect.insert(2,1)=sym2poly(y(2,1)); pect.insert(3,1)=sym2poly(z(2,1));


-115-

if pect.insert(1,1)<0 | pect.insert(2,1)<0 | pect.insert(3,1)>0 disp(sprintf('il braccio è in una posizione scorretta!!! (movearm)')); end end %aggiorno i restanti punti del braccio. dors.insert=pect.insert; delt.insert=pect.insert*dist(SHOULDER,DELT.INSERT)/dist(SHOULDER,PECT.INSERT); elbow=pect.insert*dist(SHOULDER,ELBOW)/dist(SHOULDER,PECT.INSERT); tric.attach=pect.insert*dist(SHOULDER,TRIC.ATTACH)/dist(SHOULDER,PECT.INSERT); tric.origin=pect.insert*dist(SHOULDER,TRIC.ORIGIN)/dist(SHOULDER,PECT.INSERT); bic.origin=tric.attach; %aggiorno le lunghezze pect.length=dist(pect.origin,pect.insert); delt.length=dist(delt.origin,delt.insert); dors.length=dist(dors.origin,dors.insert); clear x y z r s t;


-116-

Moveforearm %MOVEFOREARM - genera il movimento del braccio a partire dalle informazioni sui %muscoli % % Sintassi % % moveforearm % % Descrizione % % moveforearm % % moveforearm.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 13 Giugno 2003 % Ultima modifica: 13 Giugno 2003 %questo sistema trova la posizione dell'inserzione del bicipite syms x y z; if (bic.active=='si') r=(x-bic.origin(1,1))^2+(y-bic.origin(2,1))^2+(z-bic.origin(3,1))^2-bic.length^2; %r impone l'azione del bicipite if (tric.active=='si') disp(sprintf('errore nel movimento dei muscoli')); end elseif (tric.active=='si') r=(x-tric.origin(1,1))^2+(y-tric.origin(2,1))^2+(z-tric.origin(3,1))^2-(tric.length-dist(TRIC.ORIGIN,TRIC.ATTACH))^2; %r impone l'azione del tricipite else disp(sprintf('errore nel movimento dei muscoli')); end s=(x*subs.insert(1,1))+(y*subs.insert(2,1))+(z*subs.insert(3,1)); %s impone che il gomito non si sloghi (perpendicolarità con la cuffia) t=(x-elbow(1,1))^2+(y-elbow(2,1))^2+(z-elbow(3,1))^2-dist(ELBOW,BIC.INSERT)^2; %t impone che il muscolo non si stacchi dall'osso [x,y,z]=solve(r,s,t); %ora seleziono la soluzione corretta bic.insert(1,1)=sym2poly(x(1,1)); bic.insert(2,1)=sym2poly(y(1,1)); bic.insert(3,1)=sym2poly(z(1,1)); %aggiorno i restanti punti del braccio. tric.insert=bic.insert; wrist=elbow+(bic.insert-elbow)*dist(ELBOW,WRIST)/dist(ELBOW,BIC.INSERT); bic.length=dist(bic.origin,bic.insert); tric.length=dist(tric.origin,tric.insert)+dist(tric.origin,tric.attach); clear x y z r s t;


-117-

Muovibraccio %muovibraccio - algoritmo per il movimento del braccio % % Sintassi % % % % Descrizione % % % % % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 1.0.0 % Data di creazione: 25 Agosto 2003 % Ultima modifica: 25 Agosto 2003 function muovibraccio(muscoli) init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=muscoli(1,1); pect.length=muscoli(3,1); bic.length=muscoli(4,1); supr.length=muscoli(5,1); movearm; rotarm; moveforearm; plotarm; wrist return


-118-

Newnet %NEWNET - Crea una rete neurale per risolvere la cinematica inversa % e la inizializza. % % Sintassi % % mynet = newnet() % % Descrizione % % NEWNET % % newnet.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 1.1.2 % Data di creazione: 20 Giugno 2003, 12:01 % Ultima modifica: 26 Giugno 2003, 15:10 function [mynet] = newnet() mynet = newff([0 1; 0 1; 0 1], [20 20 7], {'tansig', 'tansig', 'tansig'},'trainlm'); mynet.trainParam.epochs = 1000; mynet.trainParam.show = 10; mynet.trainParam.lr = 0.1; mynet.performFcn = 'mse'; mynet.trainParam.goal = 0; mynet = init(mynet); return


-119-

Newtrain %NEWTRAIN - Allena la rete neurale creata con la funzione 'newnet'. % % Sintassi % % mynet = newtrain(mynet) % % Descrizione % % NEWTRAIN % % newtrain.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 3.1.0 % Data di creazione: 20 Giugno 2003, 12:01 % Ultima modifica: 11 Settembre 2003, 16.55 function [mynet] = newtrain(mynet) % carico i dati di training normalizzati load('trainingDataFileNormalized'); % alleno la rete neurale mynet = train(mynet, inputTrainingDataMod, targetTrainingDataNormalized); % salvo la rete ed i dati in un workspace save('workspace final'); return


-120-

Normalizetd %NORMALIZETD - Normalizza i dati di training generati dalla funzione "generatetd.m" % % Sintassi % % normalizetd() % % Descrizione % % NORMALIZETD % % normalizetd.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 1.1.2 % Data di creazione: 25 Agosto 2003, 10:57 % Ultima modifica: 26 Agosto 2003, 11:50 function normalizetd() %inizializzo i fattori di scala XinputMaxFactor = 60; YinputMaxFactor = 60; ZinputMaxFactor = 20; XinputMinFactor = 0; YinputMinFactor = 20; ZinputMinFactor = -60; %dichiaro il numero dei dati da normalizzare NumDati = 1081; %carico i dati necessari per la normalizzazione load('trainingDataFile'); init; %normalizzo i dati di input for i=1:NumDati inputTrainingDataMod(:,i) = (inputTrainingData(:,i)- [XinputMinFactor;YinputMinFactor;ZinputMinFactor])./ ([XinputMaxFactor;YinputMaxFactor;ZinputMaxFactor]- [XinputMinFactor;YinputMinFactor;ZinputMinFactor]); end %normalizzo i dati di output for j=1:NumDati targetTrainingDataMod(:,j) = (targetTrainingData(:,j)- [DELT.MIN;DORS.MIN;PECT.MIN;BIC.MIN;SUPR.MIN;SUBS.MIN;TRIC.MIN])./ ([DELT.MAX;DORS.MAX;PECT.MAX;BIC.MAX;SUPR.MAX;SUBS.MAX;TRIC.MAX]- [DELT.MIN;DORS.MIN;PECT.MIN;BIC.MIN;SUPR.MIN;SUBS.MIN;TRIC.MIN]); end targetTrainingDataNormalized = (targetTrainingDataMod * 2) - 1; %salvo le nuove matrici normalizzate save('trainingDataFileNormalized'); return


-121-

Plotarm %PLOTARM - Visualizza il braccio nello spazio 3D. % % Sintassi % % plotarm % % Descrizione % % PLOTARM % % plotarm.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 Giugno 2003 % Ultima modifica: 12 Giugno 2003 axis([-40 50 -40 50 -60 30]) axis vis3d campos([ 570 500 190]); %valori sperimentali camtarget([5 5 -15]); %braccio plotlink(shoulder,elbow,'b.-'); plotlink(shoulder,subs.insert,'b.-'); plotlink(elbow,tric.origin,'b.-'); %avambraccio plotlink(elbow,wrist,'b.-'); %pettorale if pect.active=='si' plotlink(pect.origin,pect.insert,'r.-'); elseif pect.active=='no' plotlink(pect.origin,pect.insert,'g.-'); end %deltoide if delt.active=='si' plotlink(delt.origin,delt.insert,'r.-'); elseif delt.active=='no' plotlink(delt.origin,delt.insert,'g.-'); end %dorsale if dors.active=='si' plotlink(dors.origin,dors.insert,'r.-'); elseif dors.active=='no' plotlink(dors.origin,dors.insert,'g.-'); end %bicipite if bic.active=='si' plotlink(bic.origin,bic.insert,'r.-'); elseif bic.active=='no' plotlink(bic.origin,bic.insert,'g.-'); end %tricipite if tric.active=='si' plotlink(tric.origin,tric.insert,'r.-'); plotlink(tric.origin,tric.attach,'r.-'); elseif tric.active=='no' plotlink(tric.origin,tric.insert,'g.-'); plotlink(tric.origin,tric.attach,'g.-'); end %subscapolare if subs.active=='si' plotlink(subs.origin,subs.insert,'r.-'); plotlink(subs.origin,subs.attach,'r.-');


-122-

elseif subs.active=='no' plotlink(subs.origin,subs.insert,'g.-'); plotlink(subs.origin,subs.attach,'g.-'); end %sopraspinato if supr.active=='si' plotlink(supr.origin,supr.insert,'r.-'); plotlink(supr.origin,supr.attach,'r.-'); elseif supr.active=='no' plotlink(supr.origin,supr.insert,'g.-'); plotlink(supr.origin,supr.attach,'g.-'); end


-123-

Plotlink %PLOTLINK - Visualizza nello spazio 3D il segmento specificato. % % Sintassi % % plotlink(P1, P2, style) % % Descrizione % % PLOTLINK % % plotlink.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 giugno 2003 % Ultima modifica: 12 giugno 2003 function plotlink(P1, P2, style) x(1, 1) = P1(1,1); y(1, 1) = P1(2,1); z(1, 1) = P1(3,1); x(2, 1) = P2(1,1); y(2, 1) = P2(2,1); z(2, 1) = P2(3,1); hold on grid on plot3(x, y, z, style); hold off return


-124-

Resetarm %RESETARM - Inizializza le costanti geometriche. % % Sintassi % % resetarm % % Descrizione % % RESETARM % % resetarm.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 Giugno 2003 % Ultima modifica: 12 Giugno 2003 %PARAMETRI INIZIALI DEL BRACCIO POSIZIONATO IN VERTICALE LUNGO IL CORPO %Sistema di riferimento "busto" shoulder=SHOULDER; pect.origin=PECT.ORIGIN; dors.origin=DORS.ORIGIN; delt.origin=DELT.ORIGIN; supr.origin=SUPR.ORIGIN; subs.origin=SUBS.ORIGIN; supr.attach=SUPR.ATTACH; subs.attach=SUBS.ATTACH; %Sistema di riferimento "braccio" elbow=ELBOW; pect.insert=PECT.INSERT; dors.insert=DORS.INSERT; delt.insert=DELT.INSERT; supr.insert=SUPR.INSERT; subs.insert=SUBS.INSERT; tric.attach=TRIC.ATTACH; bic.origin=BIC.ORIGIN; tric.origin=TRIC.ORIGIN; %sistema di riferimento "avambraccio" bic.insert=BIC.INSERT; tric.insert=TRIC.INSERT; wrist=WRIST; %LUNGHEZZE delt.length=DELT.LENGTH; dors.length=DORS.LENGTH; pect.length=PECT.LENGTH; bic.length=BIC.LENGTH; supr.length=SUPR.LENGTH; subs.length=SUBS.LENGTH; tric.length=TRIC.LENGTH; %STATO INIZIALE , MUSCOLI A RIPOSO delt.active=DELT.ACTIVE; dors.active=DORS.ACTIVE; pect.active=PECT.ACTIVE; bic.active=BIC.ACTIVE; supr.active=SUPR.ACTIVE; subs.active=SUBS.ACTIVE; tric.active=TRIC.ACTIVE;


-125-

Rotarm %ROTARM - genera LA ROTAZIONE del braccio a partire dalle informazioni sui %muscoli % % Sintassi % % rotarm % % Descrizione % % rotarm % % rotarm.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 12 Giugno 2003 % Ultima modifica: 12 Giugno 2003 %questo sistema trova la posizione dell'inserzione della cuffia rotatoria syms x y z; if (subs.active=='si') r=(x-subs.origin(1,1))^2+(y-subs.origin(2,1))^2+(z-subs.origin(3,1))^2-(subs.length-dist(SUBS.ORIGIN,SUBS.ATTACH))^2; %r impone l'azione del SOTTOSCAPOLARE if (supr.active=='si') disp(sprintf('errore nel movimento dei muscoli')); end elseif (supr.active=='si') r=(x-supr.origin(1,1))^2+(y-supr.origin(2,1))^2+(z-supr.origin(3,1))^2-(supr.length-dist(SUPR.ORIGIN,SUPR.ATTACH))^2; %r impone l'azione del SOPRASPINATO else disp(sprintf('errore nel movimento dei muscoli')); end s=(x*elbow(1,1))+(y*elbow(2,1))+(z*elbow(3,1)); %s impone che il muscolo non si deformi(perpendicolarità dei due tratti) t=(x-shoulder(1,1))^2+(y-shoulder(2,1))^2+(z-shoulder(3,1))^2-dist(SHOULDER,SUPR.INSERT)^2; %t impone che il muscolo non si stacchi dall'osso [x,y,z]=solve(r,s,t); %ora seleziono la soluzione corretta supr.insert(1,1)=sym2poly(x(1,1)); supr.insert(2,1)=sym2poly(y(1,1)); supr.insert(3,1)=sym2poly(z(1,1)); if (supr.insert(3,1)<-0.01) | (supr.insert(1,1)<-0.01) supr.insert(1,1)=sym2poly(x(2,1)); supr.insert(2,1)=sym2poly(y(2,1)); supr.insert(3,1)=sym2poly(z(2,1)); if (supr.insert(3,1)<-0.01) | (supr.insert(1,1)<-0.01) disp(sprintf('errore nel movimento dei muscoli!!! (rotarm)')); end end %aggiorno i restanti punti del braccio. subs.insert=supr.insert; subs.length=dist(subs.origin,subs.insert)+dist(subs.origin,subs.attach); supr.length=dist(supr.origin,supr.insert)+dist(supr.origin,supr.attach); clear x y z r s t;


-126-

Test %TEST - VERIFICA CHE IL BRACCIO SIA CONSISTENTE % % Sintassi % % test % % Descrizione % % test % % test.m % % Copyright (c) 2003 Fortunato Marzagalli % % Versione: 2.0.0 % Data di creazione: 13 Giugno 2003 % Ultima modifica: 13 Giugno 2003 disp(sprintf('verifica presenza di stiramenti')); %uno stiramento corrisponde nel modello ad un muscolo la cui lunghezza non %corrisponde alla distanza tra i suoi estremi!! if abs(pect.length-dist(pect.origin,pect.insert))>0.000001 disp(sprintf('muscolo pettorale stirato!!')); end if abs(delt.length-dist(delt.origin,delt.insert))>0.000001 disp(sprintf('muscolo deltoide stirato!!')); end if abs(dors.length-dist(dors.origin,pect.insert))>0.000001 disp(sprintf('muscolo dorsale stirato!!')); end if abs(subs.length-(dist(subs.origin,subs.insert)+dist(subs.origin,subs.attach)))>0.000001 disp(sprintf('muscolo sottoscapolare stirato!!')); end if abs(supr.length-(dist(supr.origin,supr.insert)+dist(supr.origin,supr.attach)))>0.000001 disp(sprintf('muscolo sopraspinato stirato!!')); end if abs(bic.length-dist(bic.origin,bic.insert))>0.000001 disp(sprintf('muscolo bicipite stirato!!')); end if abs(tric.length-(dist(tric.origin,tric.insert)+dist(tric.origin,tric.attach)))>0.000001 disp(sprintf('muscolo tricipite stirato!!')); end disp(sprintf('ok')); disp(sprintf('verifica presenza di strappi')); %uno strappo corrisponde nel modello ad un muscolo per cui uno dei suoi %capi modifica la posizione sull'osso!!! if abs(dist(pect.insert,shoulder)-dist(PECT.INSERT,SHOULDER))>0.000001 disp(sprintf('muscolo pettorale strappato!!')); end if abs(dist(delt.insert,shoulder)-dist(DELT.INSERT,SHOULDER))>0.000001 disp(sprintf('muscolo deltoide strappato!!')); end if abs(dist(dors.insert,shoulder)-dist(DORS.INSERT,SHOULDER))>0.000001 disp(sprintf('muscolo dorsale strappato!!')); end


-127-

if abs(dist(subs.insert,shoulder)-dist(SUBS.INSERT,SHOULDER))>0.000001 disp(sprintf('muscolo sottoscapolare strappato!!')); end if abs(dist(supr.insert,shoulder)-dist(SUPR.INSERT,SHOULDER))>0.0000001 disp(sprintf('muscolo sopraspinato strappato!!')); end if abs(dist(bic.insert,elbow)-dist(BIC.INSERT,ELBOW))>0.0000001 %stranamente qui l'errore non è 0 disp(sprintf('muscolo bicipite strappato!!')); end if abs(dist(tric.insert,elbow)-dist(TRIC.INSERT,ELBOW))>0.0000001 %stranamente qui l'errore non è 0 disp(sprintf('muscolo tricipite strappato!!')); end disp(sprintf('ok')); disp(sprintf('verifica presenza di slogature')); %un giunto il cui movimento è vincolato dalla mancanza di alcuni gradi di %libertà si sloga se uno dei vincoli viene rotto. if abs(transp(subs.insert)*(wrist-elbow))>0.0000001 %stranamente qui l'errore non è 0 disp(sprintf('il gomito è slogato')); end disp(sprintf('ok')); disp(sprintf('verifica presenza di fratture')); %un osso si frattura quando la sua struttura si deforma if abs(transp(subs.insert)*(elbow))>0.0000001 %stranamente qui l'errore non è 0 disp(sprintf('il braccio si è rrrotto')); end disp(sprintf('ok'));


-128-

Worstdemo % WORSTDEMO - Mostra l'errore pessimo di approssimazione percentuale della rete neurale. % % Sintassi % % worstdemo % % Descrizione % % Per un valore di pessima approssimazione del braccio, la demo riporta a video l'errore di approssimazione percentuale % della rete neurale calcolato come differenza normalizzata fra i valori precisi, calcolati dalla funzione "inverse.m" % che risolve matematicamente la cinematica inversa del braccio, e la funzione "ikine.m" che invece fornisce i valori % prodotti dalla rete neurale % % worstdemo.m % % Copyright (c) 2003 Claudio Sergio Mattioni % % Versione: 2.1.1 % Data di creazione: 25 Agosto 2003, 12:05 % Ultima modifica: 26 Settembre 2003, 15.50 function worstdemo % carico il workspace load('workspace final'); % definisco i valori validi di approssimazione pessima delle coordinate x,y,z dell'end-effector braccio= [46.5; 21.5; -13.5]; % calcolo i corrispondenti valori dei muscoli in maniera precisa muscoli = inverse(braccio); % calcolo i valori approssimati forniti dalla rete neurale muscolikine = ikine(mynet,braccio) % calcolo la differenza percentuale fra le due configurazioni dei muscoli ottenute in precedenza errore = ((muscolikine - (muscoli.length))./muscolikine)*100; % stampo a video il risultato disp('Errore di approssimazione percentuale della rete neurale: '); errore % disegno i due bracci secondo i valori dei muscoli precisi e di quelli approssimati init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=muscoli.length(1,1); pect.length=muscoli.length(3,1); bic.length=muscoli.length(4,1); supr.length=muscoli.length(5,1); movearm; rotarm;


-129-

moveforearm; plotarm; wrist polso = wrist; init; resetarm; delt.active='si'; pect.active='si'; supr.active='si'; bic.active='si'; delt.length=muscolikine(1,1); pect.length=muscolikine(3,1); bic.length=muscolikine(4,1); supr.length=muscolikine(5,1); movearm; rotarm; moveforearm; plotarm; %calcolo la distanza spaziale fra gli end-effector dei due bracci. wrist polsoap=wrist; distanza = dist(polso,polsoap) return

Allegato C

Funzioni utilizzate

Sim %SIM Simulate a neural network. % %Syntax % % [Y,Pf,Af,E,perf] = sim(net,P,Pi,Ai,T) % [Y,Pf,Af,E,perf] = sim(net,{Q TS},Pi,Ai,T) % [Y,Pf,Af,E,perf] = sim(net,Q,Pi,Ai,T) % %Description % % SIM simulates neural networks. % % [Y,Pf,Af,E,perf] = SIM(net,P,Pi,Ai,T) takes: % % NET - Network. % P - Network inputs. % Pi - Initial input delay conditions, default = zeros. % Ai - Initial layer delay conditions, default = zeros. % T - Network targets, default = zeros. % % and returns: % % Y - Network outputs. % Pf - Final input delay conditions. % Af - Final layer delay conditions. % E - Network errors. % perf - Network performance. % % Note that arguments Pi, Ai, Pf, and Af are optional and % need only be used for networks that have input or layer % delays. % % SIM's signal arguments can have two formats: cell array or % matrix. % % The cell array format is easiest to describe. It is most % convenient for networks with multiple inputs and outputs, % and allows sequences of inputs to be presented: % % P - NixTS cell array, each element P{i,ts} is an RixQ matrix. % Pi - NixID cell array, each element Pi{i,k} is an RixQ matrix. % Ai - NlxLD cell array, each element Ai{i,k} is an SixQ matrix. % T - NtxTS cell array, each element P{i,ts} is an VixQ matrix.

% Y - NOxTS cell array, each element Y{i,ts} is a UixQ matrix. % Pf - NixID cell array, each element Pf{i,k} is an RixQ matrix. % Af - NlxLD cell array, each element Af{i,k} is an SixQ matrix. % E - NtxTS cell array, each element P{i,ts} is an VixQ matrix. % % Where: % % Ni = net.numInputs % Nl = net.numLayers, % No = net.numOutputs % ID = net.numInputDelays % LD = net.numLayerDelays % TS = number of time steps % Q = batch size % Ri = net.inputs{i}.size % Si = net.layers{i}.size % Ui = net.outputs{i}.size % % The columns of Pi, Pf, Ai,and Af are ordered from oldest delay % condition to most recent: % % Pi{i,k} = input i at time ts=k-ID. % Pf{i,k} = input i at time ts=TS+k-ID. % Ai{i,k} = layer output i at time ts=k-LD. % Af{i,k} = layer output i at time ts=TS+k-LD. % % The matrix format can be used if only one time step is to be % simulated (TS = 1). It is convenient for networks with only % one input and output, but can also be used with networks % that have more. % % Each matrix argument is found by storing the elements of % the corresponding cell array argument into a single matrix: % % P - (sum of Ri)xQ matrix % Pi - (sum of Ri)x(ID*Q) matrix. % Ai - (sum of Si)x(LD*Q) matrix. % T - (sum of Vi)xQ matrix % Y - (sum of Ui)xQ matrix. % Pf - (sum of Ri)x(ID*Q) matrix. % Af - (sum of Si)x(LD*Q) matrix. % E - (sum of Vi)xQ matrix % % [Y,Pf,Af] = SIM(net,{Q TS},Pi,Ai) is used for networks % which do not have an input, such as Hopfield networks % when cell array notation is used. % %Algorithm % % SIM uses these properties to simulate a network NET. % % NET.numInputs, NET.numLayers % NET.outputConnect, NET.biasConnect % NET.inputConnect, NET.layerConnect % % These properties determine the network's weight and bias % values,and the number of delays associated with each weight: % % NET.inputWeights{i,j}.value % NET.layerWeights{i,j}.value % NET.layers{i}.value % NET.inputWeights{i,j}.delays % NET.layerWeights{i,j}.delays % % These function properties indicate how SIM applies weight and % bias values to inputs to get each layer's output: % % NET.inputWeights{i,j}.weightFcn % NET.layerWeights{i,j}.weightFcn % NET.layers{i}.netInputFcn % NET.layers{i}.transferFcn % %Mark Beale, 11-31-97 %Copyright 1992-2000 The MathWorks, Inc. %$Revision: 1.5 $ $Date: 2000/06/15 04:20:37 $

Train %TRAIN Train a neural network. % %Syntax % % [net,tr,Y,E,Pf,Af] = train(NET,P,T,Pi,Ai,VV,TV) % %Description % % TRAIN trains a network NET according to NET.trainFcn and % NET.trainParam. % % TRAIN(NET,P,T,Pi,Ai) takes: % % NET - Network. % P - Network inputs. % T - Network targets, default = zeros. % Pi - Initial input delay conditions, default = zeros. % Ai - Initial layer delay conditions, default = zeros. % VV - Structure of validation vectors, default = []. % TV - Structure of test vectors, default = []. % % and returns: % % NET - New network. % TR - Training record (epoch and perf). % Y - Network outputs. % E - Network errors. % Pf - Final input delay conditions. % Af - Final layer delay conditions. % % Note that T is optional and need only be used for networks % that require targets. Pi and Pf are also optional and need % only be used for networks that have input or layer delays. % Optional arguments VV and TV are described below. % % TRAIN's signal arguments can have two formats: cell array or % matrix. % % The cell array format is easiest to describe. It is most % convenient for networks with multiple inputs and outputs, % and allows sequences of inputs to be presented: % % P - NixTS cell array, each element P{i,ts} is an RixQ matrix. % T - NtxTS cell array, each element P{i,ts} is an VixQ matrix. % Pi - NixID cell array, each element Pi{i,k} is an RixQ matrix. % Ai - NlxLD cell array, each element Ai{i,k} is an SixQ matrix. % Y - NOxTS cell array, each element Y{i,ts} is an UixQ matrix. % E - NtxTS cell array, each element P{i,ts} is an VixQ matrix. % Pf - NixID cell array, each element Pf{i,k} is an RixQ matrix. % Af - NlxLD cell array, each element Af{i,k} is an SixQ matrix. % % Where: % % Ni = net.numInputs % Nl = net.numLayers % Nt = net.numTargets % ID = net.numInputDelays % LD = net.numLayerDelays % TS = number of time steps % Q = batch size % Ri = net.inputs{i}.size % Si = net.layers{i}.size % Vi = net.targets{i}.size % % The columns of Pi, Pf, Ai, and Af are ordered from the oldest % delay condition to most recent: % % Pi{i,k} = input i at time ts=k-ID. % Pf{i,k} = input i at time ts=TS+k-ID. % Ai{i,k} = layer output i at time ts=k-LD. % Af{i,k} = layer output i at time ts=TS+k-LD.

% % The matrix format can be used if only one time step is to be % simulated (TS = 1). It is convenient for network's with % only one input and output, but can be used with networks that % have more. % % Each matrix argument is found by storing the elements of % the corresponding cell array argument into a single matrix: % % P - (sum of Ri)xQ matrix % T - (sum of Vi)xQ matrix % Pi - (sum of Ri)x(ID*Q) matrix. % Ai - (sum of Si)x(LD*Q) matrix. % Y - (sum of Ui)xQ matrix. % E - (sum of Vi)xQ matrix % Pf - (sum of Ri)x(ID*Q) matrix. % Af - (sum of Si)x(LD*Q) matrix. % % If VV and TV are supplied they should be an empty matrix [] or % a structure with the following fields: % % VV.P, TV.P - Validation/test inputs. % VV.T, TV.T - Validation/test targets, default = zeros. % VV.Pi, TV.Pi - Validation/test initial input delay % conditions, default = zeros. % VV.Ai, TV.Ai - Validation/test layer delay conditions, % default = zeros. % % The validation vectors are used to stop training early if % further training on the primary vectors will hurt % generalization to the validation vectors. Test vector % performance can be used to measure how well the network % generalizes beyond primary and validation vectors. % % If VV.T, VV.Pi, or VV.Ai are set to an empty matrix or cell % array, default values will be used. The same is true for TV.T, % TV.Pi, TV.Ai. % % Not all training functions support validation and test % vectors. Those that do not ignore the VV and TV arguments. % %Algorithm % % TRAIN calls the function indicated by NET.trainFcn, using the % training parameter values indicated by NET.trainParam. % % Typically one epoch of training is defined as a single % presentation of all input vectors to the network. The network % is then updated according to the results of all those % presentations. % % Training occurs until a maximum number of epochs occurs, the % performance goal is met, or any other stopping condition of % the function NET.trainFcn occurs. % % Some training functions depart from this norm by presenting % only one input vector (or sequence) each epoch. An input % vector (or sequence)is chosen randomly each epoch from % concurrent input vectors (or sequences). % %Mark Beale, 11-31-97 %Copyright 1992-2000 The MathWorks, Inc. %$Revision: 1.7 $ $Date: 2000/06/15 04:20:39 $

Newff %NEWFF Create a feed-forward backpropagation network. % %Syntax % % net = newff % net = newff(PR,[S1 S2...SNl],{TF1 TF2...TFNl},BTF,BLF,PF) % %Description % % NET = NEWFF creates a new network with a dialog box. % % NEWFF(PR,[S1 S2...SNl],{TF1 TF2...TFNl},BTF,BLF,PF) takes: % % PR - Rx2 matrix of min and max values for R input elements. % Si - Size of ith layer, for Nl layers. % TFi - Transfer function of ith layer, default = 'tansig'. % BTF - Backprop network training function, default='trainlm'. % BLF - Backprop weight/bias learning function, default = % 'learngdm'. % PF - Performance function, default = 'mse'. % % and returns an N layer feed-forward backprop network. % % The transfer functions TFi can be any differentiable transfer % function such as TANSIG, LOGSIG, or PURELIN. % % The training function BTF can be any of the backprop training % functions such as TRAINLM, TRAINBFG, TRAINRP, TRAINGD, etc. % % %Algorithm % % Feed-forward networks consist of Nl layers using the DOTPROD % weight function, NETSUM net input function, and the specified % transfer functions. % % The first layer has weights coming from the input. Each % subsequent layer has a weight coming from the previous layer. % All layers have biases. The last layer is the network output. % % Each layer's weights and biases are initialized with INITNW. % % Adaption is done with TRAINS which updates weights with the % specified learning function. Training is done with the % specified training function. Performance is measured according % to the specified performance function. % %Mark Beale, 11-31-97 %Copyright 1992-2000 The MathWorks, Inc. %$Revision: 1.5 $

tesi - leet.it · Title: Microsoft Word - tesi.doc Author: Claudio Created Date: 12/23/2005 2:15:41 PM

Documents