POLITECNICO DI MILANO FACOLTÀ DI INGEGNERIA

Corso di laurea in ingegneria informatica

Dipartimento di elettronica e informazione

Progetto di intelligenza artificiale e robotica

&21752//2�,1�5(0272�',�)/277(�',�52%27�02%,/,�$872120,�,1�81�$0%,(17(�6,08/$72�08/7,87(17(��

Tesi di laurea di: Carlo CECCHI Matricola 619782 Stefano FRONTEDDU Matricola 618740 Relatore: Chiar.ma Prof.ssa Giusepina GINI Correlatore: Ing. Andrea BAZZI

Anno accademico 1998/99

II

5,1*5$=,$0(17,�

'REELDPR�LQQDQ]L�WXWWR�ULQJUD]LDUH�OD�SURI�VVD�*LQL�SHU�OD�VXD�GLVSRQLELOLWj�H�SHU�WXWWR�ODLXWR�FKH�FL�KD�IRUQLWR�GXUDQWH�OR�VYROJLPHQWR�GL�TXHVWR�ODYRUR��

8Q�JURVVR�JUD]LH�q�ULYROWR�DQFKH�D�WXWWR�LO�SHUVRQDOH�GHO�FHQWUR�0HWLG�GHO�3ROLWHF�QLFR�GL�0LODQR�FKH�FL�KD�PHVVR�D�GLVSRVL]LRQH�WXWWR�LO�VRIWZDUH�H�OKDUGZDUH�QHFHVVD�ULR�DOOD�SURJHWWD]LRQH�H�DOOR�VYLOXSSR�GHOOD�QRVWUD�DSSOLFD]LRQH��

9RJOLDPR� LQROWUH� ULFRUGDUH� LQ�TXHVWD�VHGH�DOFXQH�SHUVRQH�FKH�FL�KDQQR�FRUWHVH�PHQWH�DLXWDWR�IRUQHQGRFL�FRQVLJOL�H�DUWLFROL�YDUL�FRUUHODWL�DO�QRVWUR�ODYRUR��

6X�WXWWL�LO�SURI��%RQDULQL��FKH�FRQ�L�VXL�FRQVLJOL�H�LO�VXR�DLXWR�FL�KD�SHUPHVVR�GL�UL�VROYHUH�DOFXQL�SUREOHPL�UHODWLYL�DO�FRQWUROOR�GHL�URERW�ROWUH�D�IRUQLFL�PROWR�PDWHULDOH�FKH�KD�LVSLUDWR�TXHVWR�ODYRUR��

7UD� JOL� DOWUL� FLWLDPR� LO� SURI�� 6LQLFKL� <XWD� GHOOXQLYHUVLWj� GL� 7VXNXED�� LO� SURI�� (�GZDUG�7XQVWHO�GHO�-HW�3URSXOVLRQ�/DERUDWRU\�GL�3DVDGHQD�&$��LO�SURI��5DPRQ�/ySH]�GH 0QWDUDV�� GLUHWWRUH�GHO�FRQVLJOLR� VXSHULRUH�SHU� OD� ULFHUFD�VFLHQWLILFD� VSDJQROR�H��LQILQH��OD�SURI�VVD�0DWDULF�GHOO¶XQLYHUVLWj�GHOOD�&DOLIRUQLD�GHO�6XG��

8Q�GRYHURVR�JUD]LH�YD¶�LQILQH�ULYROWR�DL�QRVWUL�JHQLWRUL�FKH�FL�KDQQR�VRVWHQXWR�SHU�WXWWR�LO�FRUVR�GHL�QRVWUL�VWXGL��

*OL�$XWRUL�0LODQR��*LXJQR������

III

6200$5,2�

Questa tesi si pone all'interno di un più vasto progetto dell'Enea che è interessata

allo sviluppo di applicazioni per la teleoperazione di robot mobili al fine di monitora-

re aree protette da postazioni remote.

Il progetto da noi sviluppato è volto a soddisfare l'esigenza di avere un simulatore af-

fidabile per questo tipo di problematiche.

Il nostro simulatore offre caratteristiche peculiari di portabilità ed estensibilità. È sta-

to sviluppato pensando a una sua possibile evoluzione verso un'applicazione con ro-

bot reali, e sfrutta appieno le capacità dei linguaggi Java e VRML.

La struttura adottata è quella del client-server: in questo modo il simulatore è in gra-

do di gestire la presenza contemporanea di più utenti operanti in parallelo da posta-

zioni remote.

In questa tesi presenteremo lo stato dell'arte relativo ai simulatori per robot mobili

disponibili sul WWW, e descriveremo la struttura del nostro codice, così da favorire

il lavoro di futuri sviluppatori.

IV

,1',&(�

5,1*5$=,$0(17,� ,,�

6200$5,2� ,,,�

,1',&(� ,9�

,1752'8=,21(� ������ 0RWLYD]LRQL� ������ ,O�FRQWHVWR� ������ 2ELHWWLYL�GHOOD�WHVL� ������ 6WUXWWXUD�GHOOD�WHVL� ��

67$72�'(//¶$57(� ������ ,O�950/��FHQQL�VWRULFL� ������ ,O�950/�H�O¶($,� ������� -DYD� ������� 5RERW�PRELOL� ������� ,�VLPXODWRUL�GL�URERW�PRELOL�VXO�:::� ������� /D�FRRSHUD]LRQH�H�L�URERW�PRELOL� ���

02'(//,�(�6&(/7(�,03/(0(17$7,9(� ������� &DUDWWHULVWLFKH�GHO�VLPXODWRUH� ������� ,O�PRGHOOR�GHO�PRQGR� ������� ,O�PRGHOOR�GHL�FRUSL� ���

3.3.1 Dinamica del corpo 28 3.3.2 Dinamica dell’urto 30 3.3.3 Le forze di attrito 35

���� ,O�PRGHOOR�GHL�URERW� ������� ,O�FRQWUROOR�GHL�URERW� ���

3.5.1 I sensori 39 3.5.2 L’architettura Subsumption 41 3.5.3 Il metodo dei potenziali 44

5($/,==$=,21(�'(/�62)7:$5(� ���

V

���� &DUDWWHULVWLFKH�JHQHUDOL� ������� ,O�VHUYHU� ���

4.2.1 Specifica dei requisiti 47 4.2.2 Struttura del programma 47 4.2.3 La creazione di un nuovo mondo virtuale 54

���� /D�DSSOHW�FOLHQW� ���4.3.1 Specifica dei requisiti 55 4.3.2 Struttura del programma 55

���� /R�VFDPELR�GL�PHVVDJJL�WUD�FOLHQW�H�VHUYHU�� ���7(67,1*�(�3529(�63(5,0(17$/,� ������� 7HVWLQJ� ������� 3URYH�VSHULPHQWDOL� ���

0$18$/,�87(17(� ������� 0DQXDOH�SHU�O¶DPPLQLVWUDWRUH�GHO�VHUYHU� ������� 0DQXDOH�XWHQWH�SHU�O¶XWLOL]]R�GHO�FOLHQW� ���

&21&/86,21,� ���

%,%/,2*5$),$� ���

&2',&(�625*(17(� ���$��� ,O�SDFNDJH�JHRPHWULD� ���$��� ,O�SDFNDJH�ILVLFD� ����$��� ,O�SDFNDJH�FRUSL� ����$��� ,O�SDFNDJH�FRQWUROOR� ����$��� ,O�SDFNDJH�PRQGR� ����$��� ,O�SDFNDJH�WHVW� ����$��� /H�DOWUH�FODVVL� ����

1

�,1752'8=,21(�

���� 0RWLYD]LRQL�I sistemi multirobot stanno diventando sempre più importanti nelle applicazioni

industriali, commerciali e scientifiche. Il numero di robot attualmente utilizzato nei

progetti industriali è in rapida crescita e il livello di sviluppo scientifico ed industria-

le rende possibile l’utilizzo di robot in vari campi.

Molte sono state le ricerche indirizzate allo studio delle possibili problematiche lega-

te all’uso di più robot, e ai possibili vantaggi. Di particolare interesse sono gli studi

sulla cooperazione e la teleoperazione grazie anche alle innumerevoli applicazioni

possibili di queste nuove tecnologie. Si consideri il compito di trovare e recuperare

degli esseri umani intrappolati in un’area rischiosa, come ad esempio il sito di un di-

sastro naturale o industriale. Possiamo vedere di continuo esempi di queste situazioni

in cui team di professionisti mettono le loro vite in pericolo per raggiungere l’area

disastrata, valutare la situazione, e utilizzare gli oggetti nell’ambiente per raggiunge-

re il loro obiettivo.

Consideriamo poi il caso della sorveglianza di aree riservate, dove l’attenzione e la

prontezza sono in genere affidate a più persone che collaborano per monitorare il più

ampio perimetro possibile, garantendo un livello di efficienza minimo.

Entrambe queste situazioni hanno in comune il fatto che rappresentano dei compiti

che possono essere affidati a gruppi di robot mobili. In un caso evitando la presenza

umana in zone ad alto rischio, nell’altro garantendo alti livelli di efficienza a fronte

di un ridotto impiego di risorse umane.

2

Per affrontare queste situazioni è nata la teleoperazione che si occupa di studiare le

modalità e le possibili applicazioni del controllo remoto di agenti mobili. La combi-

nazione della teleoperazione e delle tecniche utilizzate per rendere i robot autonomi e

in grado di cooperare tra loro è indicata in genere col termine WHOHURERWLFD, e il corri-

spondente robot è chiamato telerobot [Callaghan, 1998].

I telerobot possono essere classificati in base al loro ambiente, alle dimensioni e al

compito. L’ambiente può essere terrestre (ad es. ricerca di mine, trasporto e lavora-

zione di agenti tossici, sorveglianza, …), marino o sottomarino (ad es. ricerche su-

bacquee e mappature del fondale), aereo (ad es. ricognizione) o spaziale (ad es.

esplorazione o manutenzione). Le dimensioni possono variare dai micro-robot sino a

raggiungere strutture di grandi dimensioni. I task infine possono essere di tipo attivo

(ad es. assemblaggio) o passivo (ad. es. sorveglianza).

La diffusione di mezzi di trasmissione dati come la rete Internet, combinati alla mas-

siccia diffusione di satelliti per le telecomunicazioni, garantiscono la base ideale per

il diffondersi di queste nuove tecnologie su scala globale.

L’unico limite, allo stato attuale delle cose, è imposto dal costo ancora relativamente

alto delle flotte di robot mobili, elemento che costringe i ricercatori ad affidarsi ai

simulatori, almeno nelle prime fasi dello sviluppo di nuovi progetti.

Rimane comunque chiaro che nel futuro robot e uomini lavoreranno insieme in modo

armonioso. In tale sistema multi-agente ogni agente dovrà lavorare in modo autono-

mo e dovrà essere in grado di cooperare con gli altri agenti per raggiungere il proprio

obiettivo e l’obiettivo dell’intero sistema.

È in questo contesto che si inserisce il nostro progetto rivolto allo sviluppo di un si-

mulatore per la teleoperazione di robot in ambienti multirobot autonomi simulati.

���� ,O�FRQWHVWR�Lo scenario su cui si basa il nostro lavoro è il seguente: abbiamo un ambiente de-

limitato da pareti e articolato in più stanze comunicanti tra loro, in questo ambiente è

presente un certo numero di robot che hanno il compito di andare alla ricerca di og-

getti che noi indicheremo col termine di FDVVH e, una volta individuati, raggiungerli.

3

L’individuazione delle casse è possibile grazie all’uso di un opportuno marcatore, il

robot, infatti, può distinguere gli oggetti in base al loro colore.

La comunicazione è affidata a un sistema radio che permette la trasmissione in tempo

reale di semplici messaggi.

Tutti i robot possono essere prodotti a basso costo su grande scala.

Questa popolazione di robot omogenei tra loro costituisce un sistema modulare. Ogni

robot può essere sostituito da ogni altro robot. L’eventuale guasto di un robot non

impedisce, in linea di principio, il corretto funzionamento del sistema nel suo

complesso.

Ma vediamo in dettaglio le caratteristiche di questi robot simulati:

I sensori disponibili, che possono o no essere montati sui robot, sono:

• 7 sensori di distanza di produzione della Massa Products Corporation (modello

E-220/XXX) le cui specifiche sono indicate in [Borenstein, 1996]

• 1 telemetro laser montato su piattaforma rotante

• 5 sensori a infrarossi in grado di riconoscere otto livelli di colore

• 1 bussola che permette di conoscere l’orientamento del robot

• una cintura di sensori di contatto per segnalare eventuali urti

• un sensore di velocità

I robot sono inoltre dotati di un sistema radio ricetrasmittente per la trasmissione

di dati in modalità seriale.

Per quanto riguarda il problema della conoscenza della posizione assoluta del robot

assumiamo di disporre del sistema di localizzazione IS Robotics 2D Location System

capace di una precisione di 12.7 millimetri su un’area di 9.1x9.1 metri [Borenstein,

1996]. Per dare un’idea più chiara al lettore sul tipo di robot di cui stiamo parlando

alleghiamo qui di seguito un’immagine di un tipico robot mobile

4

)LJXUD����� 5RERW�PRELOH��

Il robot è dotato di tre ruote di cui due motrici e una libera, è quindi caratterizzato

da un sistema di locomozione omnidirezionale.

Per quanto riguarda il controllore montato sul robot possiamo dire che la struttura

software adottata è quella della architettura subsumption articolata su più livelli ispi-

rata da quella descritta da Rodney A. Brooks nel suo articolo dal titolo $ UREXVW�OD\H�UHG� FRQWURO� V\VWHP� IRU� D� PRELOH� URERW [Brooks, 1986] e di cui parleremo più

diffusamente nei capitoli successivi.

Rimane comunque sempre possibile il controllo manuale diretto di un singolo robot

da parte di un utente tramite assegnamento di velocità e direzione volute.

���� 2ELHWWLYL�GHOOD�WHVL�La realizzazione del nostro simulatore ci ha permesso di raggiungere i seguenti

obiettivi:

• Buon livello di realismo.

• Possibilità di sviluppare nuovi sistemi di controllo più sofisticati a partire da

quelli esistenti.

5

• Robot con un certo grado di autonomia e in grado di essere controllati da un ope-

ratore.

• Alto livello di portabilità ed estensibilità.

• Buone prestazioni su elaboratori di fascia bassa.

Vediamoli in dettaglio uno per uno.

%XRQ�OLYHOOR�GL�UHDOLVPR�Per un simulatore questo è forse uno dei punti più importanti. I problemi che ab-

biamo dovuto affrontare e risolvere erano correlati in parte alle limitatezze del

VRML, nato come linguaggio di descrizione di scene statiche, e da noi usato per

rappresentare scene dinamiche, e in parte ai problemi di velocità propri del linguag-

gio Java.

Nel complesso abbiamo raggiunto un buon livello di realismo nel modello fisico dei

robot mobili, compatibilmente coi limiti imposti dalla complessità e dalla velocità di

downloading su rete. Questo ci ha permesso di ottenere una buona accuratezza nella

rappresentazione dei risultati con un apprezzabile realismo dei movimenti dei robot.

Realizzare un modello fisico credibile all’interno di scene VRML ha richiesto uno

studio approfondito e un uso intensivo dell’External Autoring Interface (EAI) e di

Java. Uno dei problemi più grossi che abbiamo dovuto affrontare riguarda il supe-

ramento dei limiti del VRML che non permette di rilevare le collisioni tra oggetti ge-

nerici presenti nella scena. La soluzione si è trovata spostando il problema dal

VRML a Java, realizzando metodi ad hoc capaci di buoni livelli di performance e fa-

cilmente riusabili.

Per quanto riguarda la simulazione della teleoperazione, il progetto è stato sviluppato

come applicazione client-server, in grado di sfruttare la rete Internet per garantirne

l’usabilità.

6

3RVVLELOLWj�GL�VYLOXSSDUH�QXRYL�VLVWHPL�GL�FRQWUROOR�SL��VRILVWLFDWL�D�SDUWLUH�GD�TXHOOL�HVLVWHQWL�

Questo obiettivo è stato raggiunto realizzando una stratificazione che permette di

PRQWDUH un nuovo controllore sopra uno esistente. Esiste un controllore di base che si

occupa di agire direttamente sugli attuatori, e su questo si appoggiano gli altri con-

trollori, come quello che permette di assegnare la velocità e la direzione di un certo

robot. Il controllore behavior, che si trova a un livello di astrazione ancora superiore,

si appoggia su quello di velocità/direzione.

È chiaro quindi che una semplice analisi del nostro codice permette di realizzare

nuovi metodi in grado di implementare nuovi e più sofisticati sistemi di controllo.

5RERW�FRQ�XQ�FHUWR�JUDGR�GL�DXWRQRPLD�H�LQ�JUDGR�GL�HVVHUH�FRQWUROODWL�GD�XQ�RSHUD�WRUH�

Questo punto ha richiesto lo sviluppo di alcuni controllori, che possono essere

montati su ogni tipo di robot simulabile, richiedendo al più piccole modifiche.

L’autonomia è stata raggiunta implementando un controllore behavior così come ipo-

tizzato da Brooks in [Brooks, 1986]. Grazie a questo controllore i robot sono in gra-

do di esplorare un ambiente dinamico non noto a priori, di evitare gli ostacoli, di

individuare e raggiungere oggetti caratterizzati da un particolare colore.

Il controllo da parte di un operatore, che può intervenire da una postazione remota, è

possibile grazie a tre controllori distinti:

• Il controllore velocità/direzione, con cui si può assegnare velocità e direzione di

un certo robot.

• Il controllore posizione, realizzato sfruttando il metodo dei potenziali, che per-

mette di raggiungere una posizione assegnata.

• Il controllore di inseguimento che impone al robot di raggiungere un certo ogget-

to presente nella scena e di seguirlo in ogni suo movimento.

In ogni situazione il robot è in grado di costruirsi una mappa locale dell’ambiente.

Questa mappa viene aggiornata ad ogni iterazione con le rilevazioni sensoriali, ma

7

non solo. I robot, infatti, sono dotati di un sensore radio che li rende in grado di co-

municare tra loro. Grazie a questo sistema due robot che si trovano vicini tra loro so-

no in grado di scambiarsi le relative mappe così da ottenere una mappa complessiva

più ampia e aggiornata.

$OWR�OLYHOOR�GL�SRUWDELOLWj�HG�HVWHQVLELOLWj�Il codice è stato scritto interamente in Java, sfruttando le librerie per l’EAI, al fine

di permettere l’interfacciamento con il VRML. Entrambi questi linguaggi sono con-

siderati uno standard che garantisce la portabilità dell’applicazione su diverse piatta-

forme senza che si renda necessaria una ricompilazione o un adattamento del codice

stesso.

Per realizzare il programma abbiamo fatto un uso intensivo della programmazione ad

oggetti al fine di rendere il progetto facilmente estensibile e riusabile.

Abbiamo inoltre utilizzato modelli accurati dei sensori e dei robot così da rendere

possibile un futuro utilizzo con robot reali.

L’estensibilità del simulatore è garantita anche dal fatto che è possibile usare in uno

stesso ambiente robot di diverso tipo e con diverse caratteristiche, a patto di imple-

mentare, se necessario, i metodi propri di ogni agente.

%XRQH�SUHVWD]LRQL�VX�HODERUDWRUL�GL�IDVFLD�EDVVD�Questo obiettivo è stato raggiunto grazie alla realizzazione di un client OHJJHUR,

che implementa l’interfaccia utente. Questo permette l’utilizzo, come client, di mac-

chine poco costose ed eterogenee tra loro. Le prestazioni sui vari client sono unifor-

mi tra loro e legate a quelle del server che gestisce la simulazione vera e propria.

���� 6WUXWWXUD�GHOOD�WHVL�Nel capitolo 1 è stato presentato al lettore il contesto in cui si pone la realizzazio-

ne del nostro simulatore e sono stati introdotti i concetti base di teleoperazione, coo-

perazione e di telerobot.

8

Nel capitolo 2, dopo una breve introduzione ai linguaggi Java e VRML, e alle possi-

bilità offerte dall’External Authoring Interface, ci occuperemo di presentare lo stato

dell’arte nel campo dei robot mobili e della simulazione di agenti robotici.

Nel capitolo 3 motiveremo al lettore alcune scelte implementative che ci hanno gui-

dato nella realizzazione del simulatore e descriveremo in modo sintetico alcuni mo-

delli che stanno alla base del nostro lavoro. Per la precisione verranno descritti i

modelli del mondo, dei corpi e dei robot, oltre ai modelli dei sensori e alle dinamiche

dei corpi e degli urti tra oggetti. In chiusura si troverà una breve introduzione

all’architettura subsumption utilizzata per realizzare uno dei controllori montabili sui

robot.

Nel capitolo 4 descriveremo in dettaglio la struttura del simulatore, così da facilitarne

un’eventuale successiva rielaborazione od estensione. Presenteremo la struttura del

server e a seguire quella del client. In questo capitolo verranno inoltre chiarite alcu-

ne tecniche utilizzate per la realizzazione di alcuni algoritmi come quello per il rile-

vamento delle collisioni.

Nel capitolo 5 parleremo dell’attività di testing e delle prove effettuate sul simulato-

re. Per quanto riguarda il testing verranno descritte le varie fasi in cui questa attività

è stata articolata: il built-in self test, la prototipazione, il test di unità e il test di inte-

grazione.

Nel nel capitolo 6 verrà poi presentato il manuale utente. Il manuale sarà diviso in

due parti distinte: il manuale per l’amministratore del server e il manuale utente.

Segue il capitolo relativo alle conclusioni dove illustreremo i pregi del nostro simula-

tore, i problemi noti e i possibili sviluppi futuri.

Chiudono la tesi la bibliografia, con tutti i riferimenti ai testi citati, e un’appendice

contenente alcuni estratti del nostro codice.

9

�67$72�'(//¶$57(��

���� ,O�950/��FHQQL�VWRULFL�Il termine VRML (Virtual Reality Markup Language) è stato coniato da Dave

Raggett del laboratorio di ricerca europeo della Hewlett Packard, che è stato uno dei

primi sviluppatori del WWW e che si è molto interessato del Cyberspazio.

Nell’Ottobre 1994 il VRML venne presentato per la prima volta alla seconda confe-

renza sul WWW a Chicago, e venne lanciato ufficialmente sul mercato nell’Aprile

1995 nella sua prima versione: il VRML 1.0.

Il VRML 1.0 era però un linguaggio per la descrizione di scene statiche, non offriva

quindi la possibilità, da parte dell’utente, di interagire con la scena. La prima società

a muoversi per colmare questa lacuna fu la Sony che sviluppò l’E-VRML basato sul

concetto di evento e di script. Il modello di esecuzione dell’E-VRML può essere vi-

sualizzato nella figura 2.1

10

Entità nellascena

Script

Gestionedell’evento

Click del mouse

)LJXUD����� 0RGHOOR�GL�HVHFX]LRQH�GHOO¶(�950/��

Nell’Agosto 1995 la Sony propose sulla mailing list internazionale di usare l’E-

VRML come base del VRML 2.0. Nel Novembre 1995 i vari gruppi interessati allo

sviluppo di questo nuovo linguaggio si riunirono e decisero una linea guida comune.

L’obiettivo principale del VRML 2.0 consisteva nell’offrire un sistema aperto ed e-

stensibile che supportasse scene 3D interattive sul WWW. La versione definitiva

delle specifiche del VRML 2.0 venne pubblicata e resa disponibile al Siggraph

nell’Agosto 1996.

All’indirizzo www.vrml.org è possibile trovare le specifiche dell’ultima versione ri-

lasciata del VRML denominata VRML97. Qui è possibile leggere una buona sintesi

delle caratteristiche del linguaggio: il VRML è capace di rappresentare oggetti mul-

timediali ed oggetti 3D sia statici che dinamici con hyperlink ad altri contenuti mul-

timediali come testo, suono, animazioni, ed immagini. Il VRML supporta un modello

estensibile che permette di definire nuovi oggetti 3D, così da permettere agli svilup-

patori la creazione di estensioni interoperabili sul linguaggio standard di base.

In ultimo ricordiamo che la visualizzazione di ambienti virtuali sviluppati col VRML

richiede l’uso di appositi browser o plug-in shareware, disponibili on-line, tra cui è

doveroso ricordare il Cosmo Player 2.1 scaricabile nel sito della Cosmo Software

[COSMO] e l’Intervista World View 2.1 [INTERVISTA].

11

���� ,O�950/�H�O¶($,�La necessità di gestire gli eventi generati dall’interazione con gli utenti ha posto

gli sviluppatori di fronte problema di sviluppare un mezzo per far comunicare tra lo-

ro il VRML e un linguaggio di programmazione ad alto livello.

La scelta riguardo al linguaggio è caduta su Java date le sue caratteristiche di

flessibilità e di portabilità e per la sua naturale predisposizione all’uso sul WWW.

L’EAI (External Authoring Interface), le cui specifiche sono tuttora in fase di defi-

nizione, è stata studiata per interfacciarsi e controllare un browser VRML

dall’esterno.

ActiveXBinding

Live ConnectBinding

ExternalScript

VRMLBROWSER

ScriptNode

ProtoNode

ImageTextureNode

JavaInterpreter

JavaScriptInterpreter

Native ProtoImplementation

ImageContent

Interpreter

([WHUQDO�$XWKRULQJ�,QWHUIDFH

6FULSW$XWKRULQJ,QWHUIDFH

)LJXUD����� 6FKHPD�ULDVVXQWLYR�GL�FRPH�L�YDUL�HOHPHQWL�GHO�950/�VRQR�FRUUHODWL�WUD�ORUR��

12

In effetti la gestione degli eventi può essere affidata anche a degli script in Java-

Script. Ci sono però sensibili differenze tra l’EAI e l’uso degli script. Gli script sono

parte integrante dei sorgenti VRML e possono comunicare con porzioni di codice Ja-

va solo tramite l’uso della rete. D’altro canto è possibile usare l’EAI solo come parte

di una applet Java. Entrambi gli ambienti utilizzano parti diverse delle librerie per

l’uso del VRML e gestiscono in maniera completamente diversa gli eventi.

Gli script hanno un metodo predefinito per tutti gli eventi, mentre nell’EAI esistono

ascoltatori specifici per ogni evento.

In linea di massima si può dire che Java è adatto in tutte quelle situazioni che richie-

dono una grossa computazione e un ridotto numero di scambi di messaggi tra i due

ambienti. JavaScript, invece, risulta particolarmente utile e veloce in quei casi in cui

è necessario un continuo scambio di informazione tra lo script e il codice VRML.

���� -DYD�Java è un linguaggio object oriented nato nei laboratori della Sun Microsystem per

venire incontro a una richiesta della Time Warner che era interessata allo sviluppo di

un computer per navigare in Internet, economico e riducibile ad un elettrodomestico.

Gli obiettivi iniziali per gli sviluppatori furono quindi le ridotte dimensioni, la veloci-

tà, l’efficienza e soprattutto la portabilità su una vasta gamma di apparecchi.

Per le sue caratteristiche Java era un linguaggio particolarmente adatto all’uso sul

WWW. Tra le prime società ad intuirne le potenzialità fu Netscape che decise di in-

corporare il supporto per l’esecuzione di applet Java nel proprio browser.

Il successo fu da subito travolgente, tanto che la Sun dovette costituire una sussidia-

ria indipendente chiamata JavaSoft.

Java deriva principalmente dal C++, ma risulta di molto semplificato per la mancan-

za dei puntatori, dell’ereditarietà multipla e dei metodi per la ridefinizione degli ope-

ratori. Offre però caratteristiche innovative rispetto al C++ come il garbage collector,

che si occupa di eliminare dalla memoria gli eventuali “rifiuti” presenti, e il multi-

threading, cioè la possibilità di eseguire contemporaneamente più flussi di istruzioni.

13

La portabilità di Java è dovuta al fatto che la compilazione non produce un pro-

gramma in codice macchina, bensì un bytecode, una forma intermedia tra sorgente ed

eseguibile. Questo codice può essere eseguito su qualsiasi piattaforma dotata di una

Java Virtual Machine, un interprete che si occupa di tradurre il bytecode nel codice

macchina proprio della stazione di lavoro.

Per questo suo aspetto di linguaggio interpretato Java non offre grandi prestazioni in

termini di velocità, ma la sua caratteristica di portabilità lo ha reso molto popolare tra

gli sviluppatori.

Questo linguaggio è in continua evoluzione, attualmente siamo arrivati alla versione

1.2, che, rispetto alle precedenti, è stata potenziata e migliorata in tutti quegli aspetti

che riguardano la sicurezza.

���� 5RERW�PRELOL�Un robot è costituito da un insieme di sottosistemi integrati tra loro, alcuni incor-

porano le funzioni di più alto livello come la pianificazione e il controllo, altri inglo-

bano le funzioni di più basso livello, i sensori, gli attuatori, …

La maggior parte dei robot utilizza ruote o zampe per muoversi. Queste sono solita-

mente attaccate a una base così da formare un veicolo. L’equipaggiamento necessa-

rio a svolgere compiti specifici viene montato su questa base.

L’utilizzo delle ruote come strumento preferenziale per la locomozione dei robot è da

attribuire al fatto che queste sono semplici da controllare, offrono ridotti problemi di

stabilità, utilizzano meno energia per unità di distanza, e sono in grado di garantire

velocità maggiori rispetto alle zampe.

14

Robot a 4 ruote Robot a 3 ruote

Robot a 2 ruote Robot a 2 ruote

)LJXUD����� 3RVVLELOL�VLVWHPD]LRQL�GHOOH�UXRWH�VX�XQ�URERW�PRELOH��

I robot dotati di ruote sono facilmente manovrabili, ma possono essere usati solo

su superfici relativamente compatte e prive di asperità. Le ruote infatti devono essere

più larghe degli ostacoli che dovranno superare.

)LJXUD����� 8Q�URERW�PRELOH�GRWDWR�GL�UXRWH��

Esistono robot che montano da due a quattro o più ruote (figura 2.3). I robot a tre

ruote però offrono alcuni vantaggi peculiari: il contatto ruota-terra può essere mante-

nuto per tutte le ruote senza un sistema di sospensioni, sono quindi più semplici da

realizzare e meno costosi.

I robot dotati di zampe sono più difficili da realizzare, ma offrono molti vantaggi.

Sono in grado di superare gli ostacoli, possono salire e scendere scale, e permettono

di affrontare superfici anche molto sconnesse. Attualmente però sono ancora pochi i

15

robot dotati di questa tecnologia, e risultano, in genere, più costosi dei robot dotati di

ruote. È anche per questo motivo che negli esperimenti che coinvolgono più robot

sono utilizzati robot con ruote piuttosto che robot con zampe, salvo rare eccezioni

([Mataric, 1995b]).

I robot mobili affidano i loro movimenti alla percezione sensoriale dell’ambiente che

li circonda. Una buona dotazione di sensori e un buon sistema di controllo sono

quindi necessari per un utilizzo proficuo di queste macchine.

Il loop di controllo infatti deve essere realizzato in modo tale che le azioni intraprese

dal robot siano coerenti con i dati ricavati sia dai sensori propriocettivi, che da quelli

esterni. Il problema deriva dal fatto che i sensori sono in grado di cogliere, in fun-

zione del tipo usato, solo pochi aspetti della realtà. È necessario quindi prestare at-

tenzione alle scelte progettuali effettuate e alle modalità seguite per integrare le varie

letture, al fine di ottenere una descrizione verosimile del mondo esterno.

Anche se la cinematica e la dinamica del robot possono essere semplici, l’interazione

col mondo è molto difficile da modellizzare, a meno che il mondo non sia stato pre-

strutturato.

Per

cezi

one

Mod

ella

zion

e

Pia

nific

azio

ne

Ese

cuzi

one

Con

trol

lo M

otor

i

Sensori Attuatori

)LJXUD����� $UFKLWHWWXUD�XWLOL]]DWD�QHOO¶DSSURFFLR�FODVVLFR��

Ad oggi non esiste ancora un metodo preferenziale per realizzare il controllo dei

robot mobili. In un estremo si trovano gli approcci tradizionali basati sulla pianifica-

zione top-down o su strategie deliberative che tipicamente si appoggiano a modelli

del mondo per verificare le informazioni sensoriali e per decidere le azioni da svolge-

16

re ([Meystel, 1991]). Dall’altro lato troviamo i sistemi bottom-up puramente reattivi

che utilizzano un insieme di condizioni-azioni preprogrammate con un uso minimo

di stati interni ([Alami, 1993; Brooks 1991]). Ci sono poi le architetture ibride, come

quella denominata behavior-based ([Brooks, 1986]), che illustreremo in dettaglio più

avanti, che utilizzano nei livelli più bassi comportamenti di tipo reattivo, ma che fan-

no uso di stati interni e implementano vari tipi di rappresentazioni. Ad esempio si

può esplorare il mondo, mantenendone in memoria una rappresentazione in forma di

mappa ([Tunstel, 1994]). Il problema più grosso in questo caso risulta essere quello

di memorizzare la mappa di un ambiente che non è statico, bensì dinamico.

Identificazione degli oggetti

Costruzione della mappa

Esplorazione

Evitamento degli ostacoli

Sensori Attuatori

)LJXUD����� $UFKLWHWWXUD�VXEVXPSWLRQ��

Le possibili scelte sono quindi le seguenti: guardare, pianificare ed eseguire, op-

pure eseguire guardando, o, in alternativa, un’integrazione dei due metodi.

Risulta chiaro che implementare l’autonomia per i robot mobili è indispensabile per

le funzioni dei robot come la navigazione e l’esplorazione dell’ambiente.

17

SensoriLivello diControllo

PianificatoreTattico

PianificatoreStrategico

Attuatori

)LJXUD����� $UFKLWHWWXUD�LEULGD��

Nella ricerca sui robot mobili autonomi, gli esperimenti sono molto importanti e

molti approcci sperimentali verso la ricerca sui robot mobili sono stati tentati. Co-

munque, l’alto costo di un gran numero di esperimenti è un problema serio nello svi-

luppo di algoritmi behavior.

Livello 0

Livello 1

Livello 2

Livello 3

Sensori Attuatori

)LJXUD����� $UFKLWHWWXUD�EHKDYLRU��

Per ridurre i costi degli esperimenti, la simulazione è stata un mezzo popolare per

la ricerca sulla robotica mobile, ad esempio, per mostrare i risultati degli algoritmi di

pianificazione ([Noborio, 1992]), per analizzare e progettare sistemi di controllo ([Ii-

dia, 1990]), e per investigare le caratteristiche dei sensori ([Kuc, 1987]).

18

���� ,�VLPXODWRUL�GL�URERW�PRELOL�VXO�:::�Già da alcuni anni molti ricercatori si sono impegnati nello sviluppo di simulatori

per applicazioni legate alla robotica. Uno degli esempi più noti è quello del robot

Khepera, opera di Oliver Michel dell’Università di Nice. Questo simulatore permette

di controllare da remoto un robot Khepera reale, per provarlo è possibile andare a vi-

sitare il sito del microcomputing laboratory [LAMI] presso lo Swiss Federal Institute

of technology . Ricordiamo che il controllo del robot è affidato ad un utente per volta

che dispone al massimo di dieci minuti, al termine dei quali si viene automaticamen-

te disconnessi.

Meno noto, ma forse più interessante, è l’XRaptor, un ambiente di simulazione per

un sistema continuo di multi-agenti virtuali [XRAPTOR]. Xraptor è stato realizzato

tra gli altri da Daniel Polani e René Spalt presso l’università di Mainz. Questo simu-

latore è scritto in C++ per piattaforme UNIX e permette lo studio di agenti simulati

sia in ambienti 2D che 3D. Nella versione attuale l’agente è pensato come un punto,

un corpo circolare o sferico, il cui controllo è affidato a un algoritmo definito a prio-

ri dall’utente.

Altri esempi di simulatori sul WWW sono Flakey, simulatore di un robot mobile e

relativo controllore, sviluppato presso i laboratori dello SRI e reperibile in

[FLAKEY], e il simulatore basato su SGI (Silicon Graphics) presso l’università di

Melbourne che si distingue per l’uso intensivo di grafica avanzata e l’elevata velocità

di visualizzazione delle scene.

Anche se il tool di simulazione EASY-ROB è stato sviluppato per la simulazione di

un braccio robotico e non di un robot mobile è doveroso citarlo dato che fa uso delle

librerie grafiche dell’OpenGL e utilizza un’interfaccia utente basata sul VRML. È

possibile scaricarne una versione demo in [EASYROB].

Il numero dei simulatori di ambienti multi robot è decisamente inferiore rispetto a

quello dei simulatori di robot mobili stand-alone. Oltre all’XRaptor bisogna segnala-

re il lavoro fatto dal prof. RamonLópez de Màntaras presso l’Artificial Intelligence

Research Institute di Bellaterra in Spagna. RamonLópez infatti ha realizzato un sem-

plice ma efficiente simulatore bidimensionale che permette di studiare l’interazione

19

di più agenti posti in uno stesso ambiente al fine di generare una mappa dello stesso e

di eseguire semplici compiti quali la pianificazione del percorso tra due punti prefis-

sati. Caratteristiche simili le ritroviamo nel simulatore di multi-robot EyeSim

[EYESIM] che si offre come strumento per studiare la navigazione di multi-robot in

ambienti noti a priori di cui è possibile fornire al robot una mappa.

)LJXUD����� ,QWHUIDFFLD�XWHQWH�GHO�VLPXODWRUH�(\H6LP��

L’ultimo simulatore di cui parleremo è MOBS. MOBS è un simulatore tridimen-

sionale di ambienti in cui sono presenti più robot mobili. Risulta particolarmente in-

teressante per il suo ricorso al VRML per la visualizzazione delle scene, ma presenta

dei limiti di portabilità. MOBS infatti è stato sviluppato utilizzando il C++ e le libre-

rie Open Inventor della Silicon. MOBS fa parte del progetto CoMoRoS (Cooperative

20

Mobile Robot System Stuttgart) che ha come obiettivo quello di sviluppare un’archi-

tettura software per un gruppo di robot mobili autonomi per il loro futuro utilizzo in

ambienti dinamici quali fabbriche e uffici. Il simulatore è reperibile in [MOBSFTP].

���� /D�FRRSHUD]LRQH�H�L�URERW�PRELOL�I robot mobili hanno fatto molti passi in avanti negli ultimi dieci anni. Siamo pas-

sati dai primi kit della Heath al robot Sojourner della NASA. Ma solitamente, lo stato

dell’arte è rappresentato da un singolo robot che persegue singoli obiettivi.

La robotica mobile cooperativa è la disciplina che si occupa di integrare singoli robot

in una società organizzata capace di raggiungere determinati obiettivi e di garantire

il suo funzionamento anche a fronte del danneggiamento di un singolo elemento del

gruppo [Fleisher, 1998].

L’uso di più robot può dare origine a situazioni complesse, ma ci sono molti poten-

ziali benefici nell’uso di questo sistema. Dudek ed altri [Dudek, 1996] hanno dimo-

strato che ci sono compiti che richiedono l’uso di più agenti per essere svolti.

Il lavoro nel campo della cooperazione per la robotica è stata inizialmente divisa tra

chi sosteneva che il controllo dei robot si dovesse basare sulla Symbol System Hypo-

thesis, secondo cui qualunque tipo di attività intelligente deve necessariamente ap-

poggiarsi a una rappresentazione simbolica del mondo su cui opera [Nilsson, 1984],

e chi credeva che la cosa migliore fosse usare un approccio reattivo, in cui

l’interazione tra diversi comportamenti, o behavior, desse origine a un comporta-

mento intelligente [Brooks, 1986].

Gli approcci reattivi [Lucarini, 1993; Stilwell, 1993; Doty, 1993; Mataric, 1995] ten-

dono a vedere gli agenti cooperativi come gruppi decentralizzati di omologhi; ogni

agente segue il suo programma reattivo, e l’intelligenza emerge dall’interazione tra i

singoli agenti. I sistemi reattivi sono molto attraenti per le loro doti di robustezza e

modularità modularità [Mataric, 1995; Mataric, 1992; Stilwell, 1993]. I gruppi di a-

genti reattivi cooperativi sono spesso indicati col nome di sciame [Lucarini, 1993;

Stilwell, 1993; Doty, 1993] per ricordare la società degli insetti sulla quale si basano.

21

Gli approcci simbolici alla cooperazione [Rosenschein, 1994; Ephrati, 1995; Rosen-

schein,1993] usano strutture centralizzate o gerarchiche, nelle quali alcuni agenti

guidano gli altri al fine di raggiungere un certo obiettivo. Questi agenti usano la pro-

grammazione logica e una rappresentazione esplicita del mondo per la pianificazione

dei compiti.

Entrambi i metodi hanno i loro difetti. Mentre da un lato i sistemi reattivi sono robu-

sti e modulari, dall’altro sono in genere inefficienti. I sistemi simbolici, che in genere

presentano una migliore predicibilità dei sistemi reattivi e il cui comportamento a li-

vello globale è più semplice da capire, hanno però molti problemi: non sono robusti e

in genere non sono tolleranti ai guasti di un membro del gruppo coinvolto nello svol-

gimento di un certo piano. Inoltre un compito difficile può portare a una drastica ri-

duzione delle prestazioni da parte del sistema simbolico, anche per il sovraccarico

dovuto alla pianificazione dei sotto-obiettivi da assegnare ai singoli agenti, che può

portare al deadlock [Rosenschein,1994; Mataric, 1995].

Tenuto conto di questi aspetti alcuni ricercatori hanno cercato di realizzare sistemi

ibridi in grado di racchiudere in sé gli aspetti positivi di entrambi i sistemi.

In [Tunstel, 1992] Edward Tunstel sottolinea i vantaggi di usare un comportamento

reattivo per evitare gli ostacoli durante la navigazione locale data la sua robustezza e

i bassi tempi di risposta necessari. Viene però anche messo in evidenza il fatto che i

comportamenti di un robot reattivo possono essere insufficienti per decidere quale

strada seguire intorno agli ostacoli. Per questo viene suggerito l’uso di una mappa e

viene proposta un’architettura software che sfrutta a livello più basso le tecniche

proprie dei robot reattivi e a livello più alto le caratteristiche proprie dei sistemi non

reattivi, quali la pianificazione del percorso e degli obiettivi.

Altri ricercatori hanno riconosciuto la praticità di integrare il ragionamento ad alto

livello con il comportamento reattivo di robot mobili al fine di generare mappe utili

per la successiva pianificazione del percorso e la navigazione [Connell, 1992; Miller,

1991; Bou-Ghannam, 1992 ;Lim, 1990].

In questo contesto si inserisce anche il lavoro di Lòpez de Màntaras ed altri [Mànta-

ras, 1998], i quali si sono impegnati nello sviluppo di robot mobili in grado di esplo-

22

rare un ambiente strutturato al fine di generarne una mappa. La loro ricerca ha dimo-

strato la fattibilità e l’efficienza di una flotta di robot a basso costo capace di svolgere

un compito complesso e ha messo in risalto i vantaggi di questo approccio. Innanzi

tutto la capacità dei robot di sopperire all’eventuale guasto di uno di loro, e soprattut-

to la riduzione del tempo complessivo per l’esecuzione del compito rispetto all’uso

di un singolo robot.

Veniamo ora ad analizzare un altro aspetto della cooperazione tra robot. I due più

importanti assi lungo i quali i sistemi cooperativi differiscono sono la comunicazione

e l’organizzazione. Per comunicazione si intende il metodo che i robot usano per

scambiarsi le informazioni; per organizzazione si intende il tipo di struttura utilizza-

to: bottom-up o top-down [Asama, 1994; Gasser, 1989]. Si parla di sistemi bottom-

up quando il comportamento globale emerge dall’interazione di molti agenti auto-

nomi. Si parla di sistemi top-down quando il comportamento globale è progettato dal

programmatore e rigidamente rafforzato dalla struttura complessiva del sistema.

Miller è stato tra i primi ad ipotizzare l’applicazione di più robot mobili per missioni

planetarie in [Miller, 1990]. In questo lavoro Miller asserisce che gruppi di più robot

autonomi hanno molti vantaggi, come il basso costo, piccole dimensioni, efficacia,

rispetto a robot più grandi. Miller ipotizza per questi robot un’architettura behavior,

intravedendo la necessità dell’uso di riferimenti radio fissi e della selezione di un

leader per la coordinazione del gruppo. Miller insieme ad altri [Arkin, 1993; Parker

1993] intravide la necessità dell’uso della comunicazione tra i robot al fine di miglio-

rare le prestazioni del sistema complessivo.

Arkin esamina un semplice compito di ricerca del cibo usando vari livelli di comuni-

cazione. Senza comunicazione i robot vagano sino a quando non trovano del cibo,

che raccolgono e riportano D FDVD. Quando i robot possono comunicare, il robot che

trova il cibo manda un messaggio a tutti gli altri robot per comunicare la sua posizio-

ne, così da poter ricevere il loro aiuto durante il trasporto verso casa.

Al contrario Balch [Balch, 1994] descrive una situazione in cui la comunicazione

non è necessariamente d’aiuto agli agenti cooperativi. Lui studia tre diversi obiettivi:

ricerca di un obiettivo al fine di riportarlo in una certa posizione (foraging), ricerca di

23

un obiettivo al fine di manipolarlo in loco (consuming), copertura totale dell’area li-

bera percorribile dal robot (grazing).

Balch utilizza tre livelli di comunicazione: niente comunicazione, comunicazione

dello stato, comunicazione dell’obiettivo. I risultati della ricerca dimostrano che nel

caso del foraging e del consuming, la comunicazione dello stato e del goal offrono

vantaggi maggiori rispetto alla non comunicazione. Sorprendentemente né la comu-

nicazione dello stato, né la comunicazione del goal, incrementano in modo significa-

tivo le prestazioni per il compito del grazing.

Risulta chiaro comunque che i robot autonomi in grado di comunicare tra loro pre-

sentano diversi vantaggi tra cui il fatto che sono localmente organizzati e in grado di

raggiungere un certo obiettivo in tempi minori. D’altro canto però l’uso della comu-

nicazione implica la scelta di un gruppo di robot in grado di usare lo stesso metodo di

comunicazione, senza il quale la cooperazione risulta impossibile.

Un esempio interessante di comunicazione tra robot ci viene offerto da Genovese ed

altri [Genovese, 1992], i quali hanno lavorato alla simulazione di sistemi robotici di-

stribuiti (DRS) basati su sistemi biologici e sull’architettura subsumption. La comu-

nicazione tra gli agenti include la trasmissione radio codificata su un singolo canale e

l’uso dei messaggi di DFNQRZOHGJH.

24

�02'(//,�(�6&(/7(�,03/(0(17$7,9(�

���� &DUDWWHULVWLFKH�GHO�VLPXODWRUH�Simulare un ambiente reale è un’operazione complessa, che deve tenere conto di

diversi fattori fra loro contrastanti. Da un lato c’è la necessità di sviluppare un

modello il più possibile fedele alla realtà, poiché un modello che fornisce risultati

molto distanti dal caso reale non è di nessuna utilità per l’utilizzatore. Dall’altro si

cerca di introdurre delle approssimazioni per rendere il modello più semplice così

che sia veloce e fornisca i risultati numerici che interessano in tempi ragionevoli.

Questi fattori sono entrambi importanti ma in evidente contrasto fra loro. Sviluppare

un modello per un simulatore che deve essere eseguito su di un personal computer

richiede l’adozione di alcuni criteri di progetto che derivano direttamente

dall’architettura della macchina. Per questo simulatore sono stati adottati i seguenti

criteri: • 0RGHOOL]]D]LRQH�GHO� WHPSR��Nel mondo reale gli eventi evolvono in parallelo,

mentre i computer sono macchine intrinsecamente sequenziali. È dunque neces-

sario introdurre una sincronizzazione e simulare una evoluzione in parallelo degli

eventi.

• 0RGHOOL]]D]LRQH�GHOOD�FRPXQLFD]LRQH� I robot possono comunicare tra loro spe-

dendosi dei messaggi radio. Abbiamo assunto che ogni robot possa spedire mes-

saggi senza dover verificare che la ricezione sia avvenuta correttamente,

ipotizzando cioè che i messaggi vengano trasmessi senza errore.

25

• ,PSUHGLFLELOLWj�GHJOL� HYHQWL� Un ambiente reale introduce eventi impredicibili,

ovvero esogeni, che mutano lo stato del sistema in modo non prevedibile. Può es-

sere interessante vedere come il sistema controllato reagisce a questi eventi, per

verificare se il sistema è robusto ed in grado di far fronte agli imprevisti. Elimi-

nando invece tutte le possibilità di eventi non previsti diventa possibile studiare

alcune proprietà intrinseche del sistema simulato. Diventa quindi interessante po-

ter gestire entrambe le possibilità.

• 0RGHOOL]]D]LRQH�GHL�VHQVRUL� I sensori sono l’unico mezzo con cui i robot pos-

sono percepire la realtà che li circonda. La loro precisione non è infinita, così

come la loro portata. Diventa allora fondamentale gestire le limitazioni intrinse-

che dei sensori, che possono influenzare pesantemente le prestazioni del sistema

di controllo, e permettere all’utilizzatore di variare i parametri come preferisce.

• 0RGHOOL]]D]LRQH�GHJOL�DWWXDWRUL��Gli attuatori sono le componenti che permetto-

no a un robot di muoversi e interagire con l’ambiente circostante. Come i sensori

anche gli attuatori sono soggetti a imprecisioni di vario tipo, possono rispondere

approssimativamente al segnale di comando imposto e inoltre possono guastarsi.

In questa simulazione gli attuatori più importanti sono i motori delle ruote del ro-

bot e per questi si è ipotizzata la perfetta risposta dell’attuatore al segnale impo-

sto dal controllore (il segnale di ingresso è la coppia da applicare alla ruota del

robot e l’attuatore risponde senza errore al riferimento).

• 'LQDPLFD� GHO� URERW�� Il robot simulato deve potersi muovere nell’ambiente in

modo realistico, seguendo con buona approssimazione le leggi della fisica e po-

tendo variare velocità e accelerazioni entro i limiti imposti dai motori montati.�• 0LVXUD�GHOOH�SUHVWD]LRQL��Utilizzando un simulatore è comodo avere dei mezzi

che permettano di valutare le prestazioni ottenute dalla flotta di robot. È possibile

valutare qualitativamente le prestazioni guardando l’evoluzione temporale degli

eventi simulata a video.�• &RPSOHVVLWj�GHO�PRQGR: Il mondo reale è certamente più complesso di quanto

possa simulare qualsiasi programma. Per avere un riscontro plausibile con la real-

26

tà gli oggetti presenti nella simulazione dovrebbero avere caratteristiche un po’

più che elementari e controllabili dall’utente.

Per realizzare il codice eseguibile del simulatore si è scelto il linguaggio Java, uni-

tamente a VRML per la rappresentazione degli ambienti simulati. Questa scelta deri-

va dal carattere fortemente multi utente del simulatore. In effetti il linguaggio Java,

avendo la possibilità di generare programmi applet che restano contenuti all’interno

di pagine HTML scaricabili e visualizzabili da Internet con un normale browser, ha

semplificato di molto lo sviluppo di un interfaccia per il controllo in remoto della si-

mulazione, e ha permesso di non vincolare l’utilizzatore ad usare un particolare tipo

di computer, grazie alla portabilità del linguaggio. L’interfaccia di controllo svilup-

pata quindi può girare su qualunque computer dotato di un browser Internet che sup-

porti Jdk 1.1 e VRML 2.0 o superiori.

���� ,O�PRGHOOR�GHO�PRQGR�Tutta la simulazione avviene all’interno di uno spazio virtuale chiamato 0RQGR.

Questo può essere immaginato come un piano orizzontale di area infinita sul quale

poggiano uno o più corpi. Tutti gli oggetti presenti nella simulazione infatti, dai robot

alle pareti delle stanze e con la sola esclusione del pavimento, sono dei corpi. Il pa-

vimento è perfettamente orizzontale senza scale, salite o discese e dunque non è pos-

sibile nessun movimento verticale durante la simulazione, tutti i corpi restano sempre

alla stessa altezza. Inserendo opportunamente degli oggetti di tipo 3DUHWH e 3RUWD è

possibile dividere il mondo in stanze, o racchiudere in una area di spazio finita tutti

gli altri corpi che prendono parte alla simulazione. Si ricorda che l’ambiente non ha

limitazioni spaziali e dunque, se si vuole che i robot operino in un’area limitata, è ne-

cessario inserire delle pareti che la chiudano completamente.

Nell’utilizzo più comune quindi il mondo dovrebbe essere una zona delimitata di

spazio, racchiusa da delle pareti invalicabili e divisa in due o più stanze collegate fra

loro da porte. Si può vedere un esempio in figura 3.1:

27

)LJXUD����� 8Q�HVHPSLR�GL�PRQGR�YLUWXDOH�IRUPDWR�GD�TXDWWUR�VWDQ]H�FROOHJDWH�IUD�ORUR���

���� ,O�PRGHOOR�GHL�FRUSL�Il simulatore crea e gestisce un ambiente virtuale popolato di corpi. Ciascun corpo

nella simulazione modella un corpo fisico, come una cassa, una parete di una stanza

o un robot, e cerca di essere un modello il più fedele possibile della realtà. Ogni cor-

po presente nell’ambiente è caratterizzato da tre elementi:

• ,O� QRPH� L’elemento nome viene usato per identificare univocamente ciascun

corpo nell’ambiente: ogni corpo deve avere un nome diverso da tutti gli altri,

qualunque sia la sua classe di appartenenza.

• ,O�EDULFHQWUR: Questo oggetto incapsula tutta la descrizione fisica del corpo. Qui

sono inclusi la massa, il momento d’inerzia, le velocità lineare e angolare correnti

del corpo e le equazioni differenziali che permettono di calcolare il percorso nel

tempo.

• ,O� YROXPH��Questo oggetto incapsula tutta la descrizione geometrica del corpo.

Attraverso di esso è possibile sapere se due corpi sono in collisione, oppure cal-

colare la distanza di un corpo da un punto specifico.

28

Gli elementi che caratterizzano la struttura fisica di un generico corpo sono:

• La massa

• Il tensore d’inerzia

• La forma geometrica

• La posizione lineare e angolare

• La velocità lineare e angolare

Questa struttura modulare ha il notevole vantaggio di disaccoppiare gli aspetti fi-

sici da quelli geometrici, così da poter gestire ciascun corpo come se fosse puntifor-

me per quanto riguarda le equazioni differenziali che descrivono il movimento, e

risolvendo dei problemi di semplice geometria a due o tre dimensioni per tutti i pro-

blemi legati alla forma del corpo. Per contro questo disaccoppiamento non può avve-

nire senza introdurre alcune approssimazioni per quanto riguarda l’aspetto fisico, in

particolare sulle formule che descrivono il movimento di rotazione.

������ 'LQDPLFD�GHO�FRUSR�Ogni corpo presente nell’ambiente può spostarsi solo seguendo le leggi fisiche,

quindi un corpo può cominciare a muoversi solo se è sottoposto un insieme di forze

che hanno risultante non nulla. Se poi la risultante diventa nulla il corpo continua a

muoversi di moto rettilineo uniforme. Le equazioni che descrivono il movimento

sono le seguenti:

=

⋅+=⋅+⋅+=

=

⋅+=⋅+⋅+=

HVW0

HVWHVW

-0

GWGWW

P)D

GWDYYGWDGWYSS

&

&&

&&&

&&

&&

&&&

&&&&

α

αωωαωϑϑ 22

Le variabili che compaiono sono descritte di seguito.

29

• S& è il vettore che indica la posizione del baricentro misurata in metri.

• Y& è il vettore che indica la velocità corrente del baricentro misurata in metri al

secondo.

• D& è il vettore che indica l’accelerazione corrente del baricentro misurata in metri

al secondo quadro.

• HVW)& è la risultante delle forze esterne supposte applicate nel baricentro (comprese

le forze di attrito), misurata in joule.

• P è la massa del corpo supposta concentrata nel baricentro, misurata in

kilogrammi.

• ϑ rappresenta l’orientamento corrente del corpo. Questo valore non è un vettore

né un angolo semplice. Si tratta di un oggetto composto da un vettore che

rappresenta la direzione dell’asse passante per il baricentro attorno a cui avviene

la rotazione e uno scalare che rappresenta l’angolo di rotazione. L’operazione di

somma con vettore che si vede nelle equazioni è una rappresentazione comoda

per descrivere in realtà un’operazione complessa, e cioè la modifica che la

velocità e accelerazione angolari applicano sull’orientamento del corpo. L’asse è

adimensionale poiché deve rappresentare solo una direzione e non una lunghezza,

mentre l’angolo è misurato in radianti.

• ω& è il vettore velocità angolare corrente del corpo, misurata in radianti al

secondo. A differenza dell’orientamento, la velocità angolare può essere

rappresentata efficacemente da un vettore, di cui la direzione indica l’asse di

rotazione, il verso la direzione (antiorario nel piano a esso normale) e il modulo

la velocità angolare in modulo.

• α& è l’accelerazione angolare corrente del corpo, misurata in radianti al secondo

quadro. Come la velocità angolare anche questa grandezza è un vettore.

• HVW0& è il risultante dei momenti esterni supposti applicati al baricentro, misurata

in joule per metro.

30

•HVW0- è il momento d’inerzia del corpo rispetto all’asse passante per il baricentro

e parallelo all’asse del momento applicato, misurato in kilogrammi per metro

quadro.

• GW è il passo di integrazione temporale, misurato in secondi.

Queste formule sono esatte se HVW)& e HVW0& restano costanti nel tempo. Se ciò non

avviene sono formule approssimate tanto più precise quanto più GW è piccolo.

Queste proprietà sono possedute da ogni corpo presente nella simulazione, ciascun

corpo può poi avere altre caratteristiche specifiche non possedute dagli altri, ad e-

sempio i robot hanno due motori che permettono il movimento e le casse hanno dei

coefficienti di attrito da cui vengono calcolate le forze resistive.

������ 'LQDPLFD�GHOO¶XUWR�È stata data molta importanza alla dinamica dell’urto fra corpi. Nella simulazione

tutte le interazioni fra due o più corpi, compresa la spinta delle casse da parte dei ro-

bot, sono gestite come urti. Poiché i corpi in urto non sono puntiformi per calcolare

correttamente le velocità dopo l’urto sarebbe necessario conoscere non solo la massa,

il momento d’inerzia e le velocità prima dell’urto, ma anche la forma che hanno i

corpi e le coordinate esatte del punto di contatto, per ricavare da questi il piano di

contatto e la linea d’urto, come si vede in figura 3.2.

• Piano di contatto: piano tangente nel punto di contatto ai due corpi in urto.�• Linea d’urto: normale al piano di contatto passante per il punto di contatto.

31

1Y2Y

Linea d’urto

Piano dicontatto

)LJXUD����� /LQHD�G¶XUWR�H�SLDQR�GL�FRQWDWWR��

Non tutti questi valori sono noti né facilmente calcolabili (in particolare il punto

di contatto fra i corpi), inoltre le equazioni che calcolano le velocità dopo l’urto, do-

vendo dipendere anche dalla forma che hanno i due corpi, risulterebbero molto com-

plesse, per cui sono state introdotte delle approssimazioni per semplificare i calcoli.

Innanzitutto si è completamente eliminata la dipendenza dalla forma geometrica del

corpo, che resta nelle equazioni solo attraverso il momento d’inerzia. Come linea

d’urto viene considerata la linea passante per i baricentri dei due corpi e come piano

di contatto il piano dei punti equidistanti dai due baricentri. È facile rendersi conto

che la linea d’urto e il piano di contatto approssimati sono ancora normali fra loro,

come si vede in figura 3.3.

1Y2Y

Linea d’urtoPiano dicontatto

)LJXUD����� /LQHD�G¶XUWR�H�SLDQR�GL�FRQWDWWR�DSSURVVLPDWL��

32

Questa approssimazione ha l’ulteriore vantaggio di trasformare l’urto eccentrico

in urto centrale:

• Urto eccentrico: i baricentri dei due corpi stanno in posizioni generiche.

• Urto centrale: i baricentri dei due corpi stanno sulla linea d’urto.

In questo modo diventa possibile usare le note formule dell’urto obliquo centrale,

che permettono di ricavare le velocità lineari dopo l’urto semplicemente da quelle

prima dell’urto e dalle masse dei due corpi, senza dover conoscere nessuna altra va-

riabile.

Considerando un riferimento solidale con l’urto, avente come asse x la linea d’urto e

come asse z la normale al piano di contatto passante per i baricentri (si veda la figura

3.4), è possibile scomporre le velocità in componenti lungo gli assi x e z. Le velocità

lineari dopo l’urto si calcolano allora secondo le seguenti formule:

+⋅⋅−+⋅⋅+=

+⋅⋅++⋅⋅−=

=

=

21

21211112

21

22212111

212

111

)()(

)()(

PPYPNPYPNPY

PPYPNPYPNPY

YYYY

]]]

]]]

[[

[[

dove N è un valore compreso tra 0 e 1 e vale 0 per un urto perfettamente anelastico

e 1 per un urto perfettamente elastico.

33

1Y2Y

z

x

O

)LJXUD����� &RPSRQHQWL�QRUPDOL�H�WDQJHQ]LDOL�GHOOH�YHORFLWj�QHO�ULIHULPHQWR�VROLGDOH�FRQ�OD�OLQHD�G¶XUWR�H�LO�SLDQR�GL�FRQWDWWR��

Il calcolo delle velocità angolari dopo l’urto è meno preciso perchè, oltre ad usare

anch’esso una linea d’urto e un piano di contatto approssimati, calcola le velocità

angolari usando le equazioni per l’urto eccentrico diretto di corpi in rotazione, che

sono valide però solo nelle ipotesi di corpi in movimento puramente rotatorio attorno

ad assi di rotazione paralleli e fissi. L’ipotesi che gli assi siano fissi qui non è

verificata e quindi il calcolo risulta approssimato.

È necessario conoscere il centro di istantanea rotazione dei due corpi o, più precisa-

mente, la distanza di questo dal relativo baricentro, e questa si può ottenere facilmen-

te essendo noti le velocità lineare e angolare nel baricentro. Se il corpo ha velocità

lineare o angolare nulla si assume che il centro di istantanea rotazione coincida col

baricentro. Una volta noti questi valori è possibile calcolare le velocità assolute dei

due corpi nel centro di percossa, che nelle approssimazioni fatte coincide con

l’origine del riferimento solidale con l’urto (visibile in figura 3.4), e da queste calco-

lare le velocità rotazionali approssimate dopo l’urto secondo le seguenti formule:

34

⋅−−=

⋅−=

+⋅⋅−+⋅⋅+

=

+⋅⋅++⋅⋅−

=

⋅+

≡

⋅+

≡

=

=

⋅−=

⋅+=

GYYGYY

PPYPNPYPNPY

PPYPNPYPNPY

HP-

PPHP

-PP

YH

YH

GYY

GYY

[[$\

[[$\

[$[$[$

[$[$[$

\

\

\[[$

\[[$

2)(

2)(

)()(

)()(

1

1

2

2

12

12

11

11

11

11

12

11

211

121

11

111

2

12

11

212

121

12

111

1

222

2

212

211

1

111

2

22

1

11

222

111

ω

ω

ω

ω

ω

ω

&

&

&

&

Si è fatta l’ipotesi che gli assi di rotazione siano sempre paralleli all’asse y del

riferimento assoluto. 1F e 2F sono i centri di istantanea rotazione dei due corpi, 11P e

12P sono le masse supposte concentrate nel centro di percossa approssimato e [$Y 1 e

[$Y 2 sono le velocità assolute nel centro di percossa approssimato, mentre le altre

variabili hanno il significato indicato in figura 3.5.

35

1Y2Y

x

2ω

1ω1F

2F

d

O

1H

2H

)LJXUD����� &DOFROR�GHOOH�YHORFLWj�DQJRODUL�GRSR�O¶XUWR��

Le velocità risultanti da queste equazioni sono, come già detto sopra, non le velo-

cità esatte ma solo delle approssimazioni, tuttavia il risultato è sufficientemente pre-

ciso per gli scopi di questo lavoro.

������ /H�IRU]H�GL�DWWULWR�Tutti i corpi reali durante il loro movimento sono costantemente soggetti a delle

forze di attrito che tendono a frenarli. Abbiamo classificato tre diversi tipi di forze di

attrito che possono influire sul movimento dei corpi all’interno della simulazione:

forze di attrito statico, forze di attrito dinamico e forze di attrito di rotolamento. Le

forze di attrito di rotolamento sono le forze che frenano una ruota che rotola sul pia-

no.

/H IRU]H�GL�DWWULWR�VWDWLFR�Un corpo fermo comincia a muoversi quando è sottoposto a un insieme di forze

esterne tali da vincere la resistenza causata dalla forza di attrito statico, descritta dalla

formula JPI) VV ⋅⋅= , dove VI è il coefficiente di attrito statico e J è

l’accelerazione di gravità. Se la risultante delle forze esterne ha modulo minore di V)il corpo resta fermo.

36

/H�IRU]H�GL�DWWULWR�GLQDPLFR�Un corpo in movimento è costantemente sottoposto a una forza frenante definita

dalla formula JPI) GG ⋅⋅= dove GI è il coefficiente di attrito statico e J è

l’accelerazione di gravità. Tale forza ha sempre direzione opposta alla velocità

corrente del corpo. La forza di attrito dinamico si manifesta finchè il corpo è in

movimento. Se questa è l’unica forza presente il corpo decelera fino a fermarsi e

quando è completamente fermo la forza di attrito dinamico si annulla. Il coefficiente

di attrito dinamico è sempre minore del coefficiente di attrito statico dello stesso

corpo.

/H IRU]H�GL�DWWULWR�GL�URWRODPHQWR�Fra i corpi presenti nella simulazione ci sono anche corpi dotati di ruote, che

quindi non strisciano ma rotolano sul piano. Questa struttura genera delle forze di at-

trito diverse dalle precedenti.

Questo è il tipo più complesso di forza di attrito e per gestirlo abbiamo fatto le se-

guenti ipotesi semplificative:

• Le ruote non possono slittare.

• Ogni corpo dotato di ruote ha due sole ruote, simmetriche e collegate da un asse

il cui centro è contenuto nella retta verticale passante per il baricentro del corpo.

In queste ipotesi le ruote possono muoversi sul piano solo verso la loro direzione

di rotolamento e sono sottoposte a una forza resistiva che ha stessa direzione, verso

opposto e modulo UXRWD

UU UJPI)

⋅⋅=

2, dove UI è il coefficiente di attrito di rotolamento

e UXRWDU è il raggio delle ruote.

37

)LJXUD����� 9LVXDOH�GDOO¶DOWR�GL�XQ�FRUSR�GRWDWR�GL�UXRWH��

, PRPHQWL�GL�DWWULWR�I corpi sono soggetti all’attrito anche quando ruotano, in questo caso si parla di

momenti di attrito. Ognuna delle forze di attrito descritte precedentemente ha un

momento di attrito duale che si manifesta contemporaneamente ad essa. Le formule

per i momenti di attrito sono le seguenti:

DVVHUXRWD

PUU

PGG

PVV

/UJPI0

JPI0JPI0

⋅⋅=

⋅⋅=⋅⋅=

2

I nuovi coefficienti sono i duali dei coefficienti per le forze di attrito visti prece-

dentemente, mentre l’unica vera nuova variabile è DVVH/ ed è la lunghezza dell’asse

che collega le due ruote del corpo.

���� ,O�PRGHOOR�GHL�URERW�I robot sono a loro volta dei corpi nell’ambiente virtuale, dunque valgono per essi

le formule descritte nel paragrafo precedente per il caso di corpo dotato di ruote che

rotolano sul piano. In più le loro ruote sono motorizzate e quindi i robot possono ge-

nerare essi stessi delle forze e momenti oltre che reagire a quelli esterni, potendo così

38

muoversi autonomamente e spingere oggetti. I parametri aggiuntivi che caratterizza-

no i robot sono:

• La distanza fra le due ruote motrici

• Il raggio delle ruote motrici

• Il coefficiente di attrito di rotolamento delle ruote motrici

• I riferimenti per le coppie in ingresso ai motori

Di questi parametri i primi tre erano già stati introdotti nella precedente trattazione

delle forze di attrito di rotolamento. Ogni robot è dotato di due ruote motrici simme-

triche che non slittano, montate su un asse il cui centro è contenuto nella retta verti-

cale passante per il baricentro del robot. Ogni ruota ha un motore indipendente

comandato dalla coppia che deve generare sulla ruota. È dunque possibile progettare

sistemi di controllo per far seguire al robot traiettorie arbitrarie dandogli come in-

gressi i riferimenti per le coppie che i due motori devono generare.

Ogni robot può montare un singolo controllore per il controllo del movimento e un

numero arbitrario di sensori utilizzabili dal controllore per generare l’azione di con-

trollo. Sono disponibili sensori di distanza, sensori di colore, sensori di contatto e

sensori radio per la comunicazione.

)LJXUD����� 0RGHOOR�950/�GL�XQR�GHL�URERW�PRELOL�LPSOHPHQWDWL��LO�.KHSHUD��

39

���� ,O�FRQWUROOR�GHL�URERW�Ogni robot è pilotato da un sistema di controllo più o meno sofisticato che gli

permette di muoversi ed esplorare l’ambiente che lo circonda con una certa autono-

mia. Sono stati implementati diversi sistemi di controllo per i robot, più o meno ele-

mentari:

• Controllore di velocità e direzione: permette a un operatore di controllare ma-

nualmente il robot impostando l’angolo di orientamento e la velocità lineare che

deve mantenere.

• Controllore di posizione: l’operatore può specificare un punto nello spazio e il

robot lo raggiungerà.

• Controllore di inseguimento: L’operatore può specificare un oggetto fisso da rag-

giungere o un oggetto mobile da inseguire.

• Controllore behavior: questo controllore non ha bisogno della supervisione diret-

ta di un operatore come i precedenti e si basa sulla architettura subsumption defi-

nita da Brooks.

Ogni robot può montare uno a scelta fra questi controllori. Il suo comportamento

nella simulazione e le opzioni disponibili per il telecontrollo saranno fortemente di-

pendenti dal controllore che monta. I controllori possono far uso dei sensori montati

sul robot per decidere l’azione di controllo.

������ ,�VHQVRUL�Un sistema di controllo sofisticato per funzionare ha bisogno di elaborare dei rile-

vamenti sullo stato dell’ambiente che lo circonda e questo può essere fatto solo at-

traverso dei sensori. A seconda del tipo di controllo possono essere necessari diversi

tipi di sensori, come funzionalità e precisione, ed in numero sufficiente. Abbiamo in-

serito nella simulazione cinque diversi tipi di sensore:

• Sensori di distanza

40

• Sensori di rilevamento del colore

• Sensori di contatto

• Sensori radio

• Telecamere

6HQVRUL�GL�GLVWDQ]D�Tutti i sensori di distanza sono caratterizzati da cinque variabili: la posizione e

l’orientamento rispetto al baricentro del robot su cui sono montati, la minima e la

massima distanza rilevabili, e la precisione della misura (cioè il massimo errore sulla

distanza rilevata).

6HQVRUL�GL�ULOHYDPHQWR�GHO�FRORUH�Questi sensori possono essere usati dal robot per riconoscere e classificare gli og-

getti che trova durante i suoi spostamenti. Essi sono caratterizzati da quattro variabi-

li: la posizione e l’orientamento rispetto al baricentro del robot su cui sono montati e

la minima e la massima distanza rilevabili.

6HQVRUL�GL�FRQWDWWR�I sensori di contatto sono il tipo concettualmente più semplice di sensore, si limi-

tano infatti a segnalare al robot quando urta un altro corpo.

6HQVRUL�UDGLR�Questi sensori sono usati dai robot per comunicare tra loro. È possibile spedire un

messaggio radio a uno specifico robot oppure in broadcast. I messaggi ricevuti ven-

gono memorizzati in una coda messaggi in attesa di essere elaborati dal sistema di

controllo montato sul robot.

41

7HOHFDPHUH�Il sensore telecamera in realtà non può essere usato dai controllori ed è stato rea-

lizzato solo per permettere agli utenti di vedere l’ambiente attraverso delle inquadra-

ture predefinite. In questo modo si può studiare l’evoluzione della simulazione da

una visuale solidale con un robot, oppure da un punto fisso su di una parete. È possi-

bile montare una o più telecamere su qualunque corpo (fisso o mobile), e poi spostare

l’inquadratura da una telecamera all’altra in ogni momento durante la simulazione.

Le telecamere sono caratterizzate da tre variabili: la posizione e l’orientamento ri-

spetto al baricentro del corpo su cui sono montate (non necessariamente un robot) e

un nome che deve essere unico per ogni telecamera, per permettere all’utilizzatore di

scegliere di volta in volta la telecamera attiva.

������ /¶DUFKLWHWWXUD�6XEVXPSWLRQ� In questo paragrafo descriveremo brevemente la Subsumption Architecture così

com’è stata definita da Brooks in [Brooks, 1986].

L’idea di fondo è che i diversi comportamenti elementari vengono realizzati da mo-

duli altamente disaccoppiati, che qui chiameremo moduli comportamentali. I moduli

comportamentali interagiscono opportunamente per generare il comportamento com-

plessivo.

Attraverso questa architettura è possibile connettere strettamente percezione e azio-

ne, collegando concretamente un robot al proprio mondo.

I principi su cui si basa la subsumption architecture sono:

• La computazione è organizzata sotto forma di rete asincrona di elementi compu-

tazionalmente attivi che prendono il nome di Augmented Finite State Machines

(AFSM). La topologia della rete è fissa.

• I messaggi spediti lungo la rete non hanno alcun significato implicito. Il loro si-

gnificato dipende dalle dinamiche che si instaurano tra chi spedisce e chi riceve il

messaggio.

• Sensori e attuatori sono connessi a questa rete.

42

In pratica l’applicazione delle tecniche suggerite da Brooks porta a strutturare

l’architettura dell’agente in un insieme stratificato di moduli creati per il raggiungi-

mento di un ben determinato obiettivo.

Ogni modulo implementa una specifica strategia di controllo, o behavior, come ad

esempio HYLWD�JOL�RVWDFROL o VHJXL�LO�PXUR. Così, con questo approccio, ogni modulo

deve risolvere solo una parte del problema di percezione o pianificazione. Inoltre,

questo tipo di tecnica porta a miglioramenti incrementali, dato che, nuovi strati pos-

sono essere facilmente aggiunti sopra quelli già esistenti. Nel nostro caso la struttura

utilizzata è quella rappresentata in figura 3.8.

Esegui un certo piano

Pianifica cambiamenti nel mondo

Identifica gli oggetti

Monitorizza i cambiamenti

Costruisci la mappa

AttuatoriSensori

Evita le collisioni

Esplora

)LJXUD����� 6WUDWLILFD]LRQH�GHL�PRGXOL��

Il controllo così realizzato permette di unire i vantaggi del comportamento reatti-

vo, insito nei livelli più bassi, con i vantaggi del comportamento deliberativo, grazie

all’uso delle informazioni mantenute nel livello &RVWUXLVFL�OD�PDSSD.

La mappa contiene un modello parziale del mondo. Strutturata come una griglia la

mappa memorizza, per ogni cella, una delle seguenti tre informazioni: cella libera,

cella occupata, cella non ancora esplorata.

43

Ogni blocco funzionale può essere ulteriormente strutturato in più livelli. Ad esem-

pio il livello (VSORUD (figura 3.9) è così strutturato :

• 6HJXL�PXUR: ogni qual volta un robot individua una parete, cerca di allinearsi ad

essa e di seguirla. Se a causa di un ostacolo non può proseguire per questa strada

si allontana dal muro e riprende a girovagare.

• 5HDJLVFL�DOOH�FROOLVLRQL: in caso di collisione il robot reagisce cambiando brusca-

mente direzione, così da allontanarsi subito dall’ostacolo.

• *LURYDJD: il robot tende a seguire sempre al tempo t la direzione che aveva al

tempo t-1, anche se, con un certo margine di probabilità, la sua traiettoria può es-

sere perturbata, strumento questo che aiuta ad evitare gli stalli.

Segui muro

Reagisci alle collisioni

Girovaga

)LJXUD����� ,O�OLYHOOR�(VSORUD��

I robot realizzati con questi criteri vengono detti behavior-based per sottolineare il

fatto che durante la fase di progetto e di programmazione della macchina si vuole

porre l’accento sul comportamento prodotto dal robot a fronte delle situazioni che gli

si presentano.

È compito del programmatore intuire quali possono essere quelle dinamiche che con-

sentono al robot di raggiungere i propri obiettivi e programmarlo di conseguenza.

Brooks, in [Brooks, 1986], propone l’adozione di un linguaggio detto behavior, un

linguaggio funzionale che si rifà al lisp, per la realizzazione del controllore software.

Nel nostro lavoro i singoli behavior sono stati ovviamente scritti interamente in Java,

per mantenere la portabilità verso varie piattaforme hardware, e per semplificare il

compito dei futuri sviluppatori.

44

������ ,O�PHWRGR�GHL�SRWHQ]LDOL�Il metodo dei potenziali è stato da noi utilizzato per realizzare il controllore che

permette di far raggiungere a un robot un oggetto o una posizione assegnata.

Il robot si muove in un campo di forze. La posizione da raggiungere è un polo di at-

trazione, gli ostacoli sono superfici repulsive. La forza risultante è quindi pari alla

somma della forza attrattiva e della risultante delle forze repulsive.

In formula si ha che:

∑+=L

UHSDWW L))) &&&

dove

• DWW)& è un vettore che ha per direzione la direzione assoluta dell’obiettivo rispetto

al punto in cui si trova il robot, ha per modulo la distanza tra obiettivo e robot pe-

sata con un’opportuna costante e, per verso, quello che va dal robot all’obiettivo.

•LUHS)& è il vettore che ha per direzione la direzione del sensore i-esimo, per modu-

lo la distanza rilevata dal sensore pesata con un’opportuna costante e, per verso,

quello che porta dall’ostacolo verso il robot.

• La sommatoria è estesa a tutti i sensori di distanza montati sul robot.

45

Ostacolo 1

Ostacolo 2

Obiettivo

DWW)& 1UHS)&

2UHS)&

)&

)LJXUD������0HWRGR�GHL�SRWHQ]LDOL��

La formula utilizzata per calcolare i moduli è la seguente:

β

α

−

−

=

=

LUHS

RDWW

G)G)

L

&

&

dove

• RG è la distanza tra robot ed obiettivo

• LG è la distanza rilevata dal sensore i-esimo

• α e β sono costanti opportune da determinare sperimentalmente.

Il vettore risultante indica al robot la direzione da seguire per avvicinarsi

all’obiettivo evitando gli ostacoli. La velocità è proporzionale al minore fra RG e )& .

Per ulteriori chiarimenti è possibile trovare altre informazioni su questo metodo in

[Koren, 1991] e in [Khatib, 1985].

46

�5($/,==$=,21(�'(/�62)7:$5(�

���� &DUDWWHULVWLFKH�JHQHUDOL�Il progetto del simulatore è stato diviso in due blocchi distinti: una applicazione

server che gestisce la simulazione dell’ambiente virtuale, e una applicazione client

che permette a un utente di vedere come evolve il sistema e di interagire con esso.

Ogni esecuzione dell’applicazione server crea e gestisce un ambiente simulato com-

pleto, a cui si può collegare una o più applicazioni client, per permettere a più utiliz-

zatori di interagire contemporaneamente in un ambiente multi utente. Il client è

incorporato in una pagina HTML e il dialogo fra client e server avviene usando il

protocollo TCP/IP attraverso una porta nota a priori da entrambi, così da permettere

la comunicazione attraverso i canali standard forniti da Internet.

Sia l’applicazione server che l’applicazione client sono scritte in linguaggio Java e

sono completamente portabili su ogni piattaforma che abbia il supporto per il Jdk 1.2

o superiore, più il supporto per il VRML 2.0 o superiore per la sola applicazione

client.

47

)LJXUD����� 6WUXWWXUD�FOLHQW�VHUYHU�YLD�,QWHUQHW��

���� ,O�VHUYHU������� 6SHFLILFD�GHL�UHTXLVLWL�

L’applicazione server deve gestire l’evoluzione nel tempo di una simulazione di

un ambiente virtuale popolato di oggetti e robot mobili. Nel contempo deve permet-

tere il collegamento di applicazioni esterne che possano visionare e interagire con la

simulazione. Il collegamento deve avvenire secondo i canali standard di Internet.

������ 6WUXWWXUD�GHO�SURJUDPPD�Il server è una applicazione Java funzionante in modalità carattere, sviluppata con

Jdk 1.2. L’implementazione del server fa uso del meccanismo dei thread messo a di-

sposizione da Java: viene creato un thread principale con priorità standard, che si oc-

cupa di far evolvere la simulazione, più un nuovo thread con priorità massima per

ogni applicazione che si collega per trasmettere e ricevere dati da essa.

48

)LJXUD����� 6HUYHU�LQ�DWWHVD�GL�XQD�FRQQHVVLRQH��

L’utilizzo di un thread separato per ogni connessione esterna evita il blocco della

simulazione ogni volta che una applicazione esterna richiede dei dati, in questo modo

è possibile gestire contemporaneamente un numero teoricamente arbitrario di utenti

esterni che controllano la simulazione, in pratica il limite sarà imposto dalla potenza

della macchina su cui gira il programma e dalla velocità della connessione. I thread

dedicati alle connessioni esterne non occupano tempo macchina perché passano la

maggior parte del loro tempo bloccati in attesa di una richiesta da parte del client.

Appena questa arriva la elaborano, spediscono gli eventuali dati di risposta e si bloc-

cano nuovamente.

La connessione avviene mediante il protocollo TCP/IP e dunque l’applicazione

server deve essere eseguita su di un computer server collegato a Internet o a una rete

con tale protocollo.

)LJXUD����� 6HYHU�GRSR�OD�GLVFRQQHVVLRQH�GL�XQ�FOLHQW��

49

Si noti che l’evoluzione della simulazione del mondo viene gestita da un solo

thread e dunque avviene per passi strettamente sequenziali. Si è fatta questa scelta in

conseguenza del comportamento fortemente dipendente dalla piattaforma di Java nel-

la gestione di diversi thread attivi con uguale priorità: in effetti si è osservato che, as-

segnando un thread separato a ogni oggetto, la simulazione si comportava in maniera

differente a seconda della macchina usata per la simulazione: in certi casi alcuni dei

corpi si muovevano correttamente ma altri restavano bloccati per alcuni secondi pri-

ma di spostarsi.

/D VLPXOD]LRQH�Come detto nel paragrafo precedente, la simulazione viene gestita da un singolo

thread che esegue quindi tutte le operazioni necessarie in modo strettamente sequen-

ziale. La scelta di un solo thread per fare evolvere in sequenza eventi fisicamente pa-

ralleli ha richiesto però l’introduzione di una discretizzazione temporale: a ogni

passo in un ciclo vengono aggiornati tutti gli oggetti e gestite tutte le interazioni fra i

corpi, ma questa approssimazione risulta accettabile solo se i passi temporali sono

sufficientemente brevi. Si è allora imposto un limite sul massimo intervallo tempora-

le: l’istante corrente viene letto dall’orologio della macchina su cui viene eseguito e

se il tempo fra due letture consecutive è minore di un decimo di secondo allora

l’evoluzione avviene in tempo reale, altrimenti la simulazione viene rallentata facen-

dola evolvere di un decimo di secondo a ogni iterazione indipendentemente da quan-

to tempo è passato realmente.

La simulazione dell’ambiente virtuale viene gestita come insieme di interazioni fra

oggetti &RUSR inseriti nell’ambiente 0RQGR� Ogni corpo è caratterizzato da un aspet-

to fisico e da uno geometrico, incapsulati nelle classi %DULFHQWUR e 9ROXPH. La strut-

tura delle classi che gestiscono la simulazione è rappresentata in figura 4.4.

50

0RQGR

9ROXPH

RobotMobile

Corpo0..n 1..1

1..1

1..1

Cassa

Parete

Porta

Baricentro

BaricentroAttrito

BaricentroFisso

BaricentroAttritoDirezionale

VolumeParallelepipedo

VolumeCilindro

VolumePorta

6HQVRUH

&RQWUROORUHControlloreVelocità

1..1 1..1

ControllorePosizione

ControlloreBehavior

0..n

SensoreTelecamera

SensoreRadio

SensoreColore

SensoreDistanza

1..1

Cortile

AirLab

Khepera

Labmate

…

…

)LJXUD����� 'LDJUDPPD�8PO�GHOOH�FODVVL�XVDWH�SHU�OD�VLPXOD]LRQH�QHOO¶DSSOLFD]LRQH�VHUYHU��

Come si può notare del diagramma, la classe 6HQVRUH è collegata direttamente alla

classe &RUSR e non a 5RERW0RELOH come potrebbe sembrare più logico. Questo è sta-

to fatto perché esiste un tipo di sensore che può essere collegato anche a casse o pa-

reti ed è la telecamera, che ha il solo scopo di fare delle inquadrature dell’ambiente

da mostrare all’utente del simulatore. Questa struttura delle classi permetterebbe in

effetti di collegare anche sensori radio o di distanza a pareti e casse ma poiché tali

51

corpi, non montando un sistema di controllo, sono completamente passivi durante la

simulazione tali sensori resterebbero sempre disattivati.

Durante la simulazione ad ogni aggiornamento dell’istante temporale un ciclo con-

trolla ogni corpo, aggiornandone posizione e velocità in funzione delle forze a cui è

sottoposto. Le forze possono essere generate dal corpo stesso se è un robot oppure

derivare dall’interazione con altri corpi.

5LOHYDPHQWR�GHOOH�GLVWDQ]H�Ogni robot monta un certo numero di sensori fra cui sensori di distanza. Per poter

utilizzare tali sensori nella simulazione è stato necessario scrivere degli algoritmi che

calcolassero la distanza di un punto da un corpo lungo una data direzione. Per gestire

efficientemente il calcolo di tali distanze si sono fatte le seguenti ipotesi:

• La parte di superficie del corpo che può essere toccata dalla retta del sensore è

una superficie geometrica regolare: un cilindro o un parallelepipedo.

• I corpi possono ruotare solo attorno all’asse verticale y.

• Il sensore ha inclinazione verticale nulla.

In figura 4.5 si può vedere un esempio di rilevamento della distanza di un punto

da un parallelepipedo secondo una data direzione.

Direzione

Distanza

Origine

)LJXUD����� 'LVWDQ]D�GL�XQ�SXQWR�GD�XQ�FRUSR�VHFRQGR�XQD�GDWD�GLUH]LRQH��

52

Le ipotesi fatte non sono eccessivamente restrittive se si tiene conto che l’ipotesi

sulla forma si riferisce solo a quella parte di superficie che può essere rilevata dal

sensore, quindi tipicamente la parte più vicina al terreno della superficie laterale; i-

noltre tutti i corpi usati nella simulazione, cioè pareti casse e robot, non possono ruo-

tare che attorno all’asse verticale a meno di non ricevere dall’esterno spinte che li

rovescino, possibilità esclusa nel simulatore.

Poiché il calcolo della distanza è fortemente dipendente dalla forma che ha il corpo

sono stati scritti due algoritmi distinti per il calcolo della distanza da un parallelepi-

pedo e da un cilindro. In esecuzione l’interprete Java sceglie di volta in volta quello

corretto fra i due grazie al meccanismo del binding dinamico dei metodi.

5LOHYDPHQWR�GHOOH�FROOLVLRQL�La gestione delle interazioni fra corpi richiede necessariamente degli algoritmi ef-

ficienti per il rilevamento delle collisioni. Questi algoritmi sono stati scritti basandosi

su ipotesi analoghe a quelle descritte nel paragrafo precedente per il calcolo delle di-

stanze:

• La parte di superficie del corpo che può essere in contatto con un’altra è una

superficie geometrica regolare: un cilindro o un parallelepipedo.

• I corpi possono ruotare solo attorno all’asse verticale y.

Come detto in precedenza tali ipotesi non sono eccessivamente restrittive per il

campo di applicazione del nostro simulatore.

In queste ipotesi sono stati implementati tre algoritmi differenti di rilevamento delle

collisioni: uno per i cilindri, uno per i parallelepipedi e uno per cilindri con parallele-

pipedi. L’interprete Java si preoccupa a runtime di decidere quale dei tre va applicato

caso per caso, questa volta mediante il meccanismo di UXQWLPH W\SH�LGHQWLILFDWLRQ�of-

ferto dal linguaggio.

53

3URWRFROOR�GL�FRPXQLFD]LRQH�WUD�L�URERW�I robot sono dotati di sensori radio con cui dialogano scambiandosi messaggi che

possono contenere ogni tipo di informazione. La struttura base del messaggio è im-

plementata nella classe VHUYHU�VHQVRUL�0HVVDJJLR5DGLR. Le informazioni necessarie

per ogni messaggio sono le seguenti:

• Il nome del mittente del messaggio.

• Il messaggio vero e proprio, identificato da un codice numerico ovvero una delle

costanti definita all’interno della classe VHUYHU�VHQVRUL�0HVVDJJLR5DGLR.

• I dati relativi al messaggio. Questo campo può contenere qualunque cosa: una

mappa, un vettore posizione, un nome di robot, eccetera.

I messaggi possono essere inviati in broadcast o a uno specifico destinatario. Si

deve ricordare che un messaggio spedito in broadcast sarà ricevuto anche dallo stesso

mittente.

*HVWLRQH�GHJOL�XWHQWL�L’applicazione server permette il collegamento da remoto di uno o più utenti auto-

rizzati. Per avere l’accesso ogni utente deve fornire un nome di ORJLQ e una SDVVZRUG

riconosciute dal server. Solo l’amministratore del server può dare l’accesso a nuovi

utenti. Sul lato server è presente infatti la classe 5HJLVWUR8WHQWL��Questa classe im-

plementa i seguenti metodi:

boolean addUtente(String login, String password, int diritti) void eliminaUtente (String login)

Il primo permette di aggiungere un nuovo utente specificandone le stringhe di lo-

gin e password e i relativi diritti: 121( per utenti generici, 683 per utenti con dirit-

ti di superuser. Il secondo metodo invece permette la cancellazione di un certo utente

dato il suo login.

Il file contenente l’elenco degli utenti e i relativi dati si trova nella directory principa-

le del programma ed è chiamato SDVVZG�SZG.

54

Vediamo qui di seguito il codice che ci permette di creare un nuovo utente generico

il cui login è 1RPH 8WHQWH e la cui password è 3DVVZRUG8WHQWH.

RegistroUtenti.addUtente("Nome Utente", "PasswordUtente", RegistroUtenti.NONE);

Attualmente il livello di sicurezza è relativamente basso. Sia il file delle password

che le password stesse inviate su rete Internet sono mantenute in chiaro. Questo per-

ché il problema sicurezza non era prioritario per lo svolgimento del progetto. È co-

munque possibile un miglioramento di questo aspetto del codice, e quindi si può

inserire tra gli obiettivi futuri della tesi.

������ /D�FUHD]LRQH�GL�XQ�QXRYR�PRQGR�YLUWXDOH�Il server contiene anche la descrizione del mondo simulato in cui si devono muo-

vere i robot. Nel codice è definita una classe astratta 0RQGR che rappresenta il mon-

do simulato. Da questa è necessario derivare una nuova classe per ogni nuovo

ambiente in cui si desidera condurre esperimenti. Il mondo usato dal simulatore è un

parametro che viene specificato nella linea di comando al momento del caricamento.

Un esempio di riga di comando per caricare il programma server è il seguente:

java SimServer server.mondo.Airlab

Il costruttore della classe 0RQGR deve ricevere in ingresso tre parametri: il primo

è un array di oggetti &RUSR, che deve contenere tutti i corpi (casse, pareti e robot) che

parteciperanno alla simulazione (l’ordinamento dell’array non è rilevante). Non sarà

possibile aggiungere o rimuovere corpi in seguito quindi è necessario specificare qui

tutti gli oggetti che interessano.

55

)LJXUD����� (VHPSLR�GL�XQ�PRQGR�VLPXODWR�XWLOL]]DWR�QHOOH�SURYH��

Gli altri due parametri sono due variabili in virgola mobile che indicano la preci-

sione con cui la simulazione deve confrontare i valori numerici. Questi parametri in-

fluenzano il risultato delle operazioni di confronto tra oggetti 9HWWRUH e tra oggetti

5RWD]LRQH. Il primo dei due numeri indica la precisione sui confronti fra misure linea-

ri espresse in metri, e il suo valore tipicamente è funzione delle dimensioni dell’area

in cui avviene la simulazione. Il secondo invece indica la precisione con cui fare i

confronti fra grandezze angolari espresse in radianti.

���� /D�DSSOHW�FOLHQW������� 6SHFLILFD�GHL�UHTXLVLWL�

L’applicazione client deve permettere a un utente da un collegamento in remoto di

vedere graficamente lo stato corrente della simulazione e di interagire con essa co-

mandando i robot presenti, in parallelo ad altri utenti su altre macchine.

������ 6WUXWWXUD�GHO�SURJUDPPD�L’applicazione client è una applet Java incorporata dentro una pagina HTML, che

contiene anche una finestra VRML dove viene visualizzato lo stato corrente della

simulazione. L’applicazione client può quindi essere utilizzata attraverso un qualsiasi

browser Internet che abbia il supporto per il Jdk 1.2 o superiore e VRML 2.0 o supe-

riore. L’uso di Java e VRML inoltre rende l’applicazione indipendente dalla piatta-

forma in uso.

56

)LJXUD����� 6FKHUPDWD�UHODWLYD�DO�FOLHQW��

Anche l’applicazione client fa uso, come l’applicazione server, del meccanismo

dei thread fornito da Java: esiste un thread con priorità standard sempre attivo con il

compito di spedire periodicamente al server una richiesta di aggiornamento e poi ri-

stampare la finestra a video con i nuovi dati ricevuti, così da mantenere aggiornata la

visualizzazione dell’ambiente virtuale. Le classi 0RQGR&OLHQW e &RUSR&OLHQW sono

dedicate all’aggiornamento della finestra VRML sulla base dei nuovi dati ricevuti.

Ogni volta che l’utilizzatore impartisce un comando, agendo su uno dei controlli di-

sponibili nella applet, l’applicazione spedisce immediatamente al server la richiesta

corrispondente, così che venga elaborata subito. La classe 6LP&OLHQW gestisce la spe-

dizione dei comandi al server. In figura 4.8 è mostrata la struttura delle classi che ge-

stiscono la applet.

57

SimClient MondoClient1..1 1..1

CorpoClient

Browser

0..n1..1

Applet

1..1

Socket1..1

)LJXUD����� 'LDJUDPPD�8PO�GHOOH�FODVVL�FKH�DJJLRUQDQR�L�GDWL�YLVXDOL]]DWL�VXOO¶DSSOLFD]LRQH�FOLHQW��

/¶LQWHUIDFFLD�WUD�-DYD�H�950/�Per prima cosa bisogna sottolineare che per utilizzare l’External Authoring Inter-

face all’interno di una applet è necessario importare i relativi package distribuiti in-

sieme ai plug-in VRML. Vediamo gli import necessari:

import vrml.external.Browser; import vrml.external.Node; import vrml.external.field.*;

Il collegamento tra la applet Java e la pagina VRML è svolto dalla classe 0RQGR�&OLHQW presente nel package FOLHQW. L’operazione viene affidata alla seguente porzione

di codice:

browser = Browser.getBrowser(applet); while((tentativi > 0) && (browser == null)) {

try { Thread.sleep(INTERVALLO_ATTESA); } catch(InterruptedException e) { }

browser = Browser.getBrowser(applet); tentativi--; }

Come si vede l’operazione di collegamento è svolta interamente dal metodo JH�W%URZVHU. L’operazione deve essere ritentata per un certo numero di volte per evitare

problemi di sincronizzazione dovuti alla diversa velocità di downloading della pagi-

na VRML e del codice Java della applet.

58

Una volta effettuata questa operazione il passo successivo consiste nel prendere un

riferimento a un nodo presente nel codice VRML così da poter aggiungere al suo in-

terno ulteriori nodi in modo dinamico (è inoltre possibile ottenere informazioni sugli

oggetti contenuti nel nodo). Vediamo anche in questo caso la porzione di codice rela-

tiva:

Node vista = browser.getNode(NODO_AVATAR);

Resta ora da chiarire come si possano spostare dinamicamente gli oggetti nella

scena. Ad esempio per ricavare dei riferimenti alla posizione ed orientamento della

visuale della pagina VRML sono sufficienti le seguenti istruzioni:

posizioneVista = (EventInSFVec3f)vista.getEventIn("translation"); orientamentoVista = (EventInSFRotation)vista.getEventIn("rotation");

Gli oggetti che ritornano i metodi sono delle classi Java che rappresentano i tipi di

dato usati nel codice VRML, definiti nei package della External Authoring Interface.

Queste due variabili sono a sola scrittura e attraverso di esse si può cambiare

l’inquadratura nella pagina VRML.

L’ultimo punto da trattare è la tecnica da usare per costruire, in modo dinamico, og-

getti tridimensionali all’interno della scena VRML. Questo compito è affidato al me-

todo %URZVHU�FUHDWH950/)URP6WULQJ�6WULQJ���La stringa da passare come parametro

deve contenere il codice relativo al nuovo oggetto da inserire all’interno della gerar-

chia di nodi del codice VRML.

���� /R�VFDPELR�GL�PHVVDJJL�WUD�FOLHQW�H�VHUYHU��Il dialogo fra client e server è una componente fondamentale della simulazione:

attraverso di esso infatti l’utente da una postazione remota può vedere evolvere la

simulazione e impartire comandi da far eseguire ai robot in tempo reale.

Tutti i dialoghi devono essere iniziati dal client, il server infatti si limita a restare in

ascolto sul canale di comunicazione finché non arriva qualche tipo di richiesta.

I messaggi spediti dal client hanno la seguente struttura:

59

• Un comando, identificato da un numero. Nella classe FRPXQH�5LFKLHVWD sono de-

finite delle costanti per identificare tutti i possibili comandi.

• Un nome che identifica univocamente il robot che dovrà eseguire il compito. Se

il comando è un comando di aggiornamento diretto al server e non riguarda un

particolare robot questo campo viene lasciato vuoto.

• Un nome che identifica il controllore da usare per il robot specificato. Se il co-

mando non deve essere eseguito da un controllore specifico questo campo resta

vuoto.

• Altri parametri aggiuntivi relativi al comando, memorizzati in una variabile di ti-

po 6HULDOL]DEOH. I parametri per i vari comandi sono definiti nelle classi FRPX�QH�3DUDPHWUL;[[�

A queste richieste il server risponde sempre con un messaggio che indica l’esito

della richiesta: comando riuscito o comando fallito se sono stati trovati degli errori

nella sintassi del comando o se sono stati specificati robot o controllori non presenti

nella simulazione.

In più nella risposta possono essere contenuti altri dati specifici del particolare co-

mando, ad esempio in risposta alla richiesta di aggiornamento il server spedisce le

seguenti informazioni per permettere al client di aggiornare la scena visualizzata:

• Per ogni corpo mobile: il nome, la posizione e l’orientamento del corpo.

• La posizione e l’orientamento della telecamera correntemente attiva.

Tutte le informazioni riguardanti il protocollo di comunicazione sono comunque

ricavabili dall’analisi del package FRPXQH.

Questa struttura rende inoltre molto semplice la creazione e gestione di nuovi mes-

saggi.

60

6HTXHQFH�GLDJUDP�GHL�PHVVDJJL�VFDPELDWL�WUD�FOLHQW�H�VHUYHU�In figura 4.9 si può vedere un esempio dell’evoluzione temporale relativa allo

scambio di messaggi tra client e server.

RichiestaIni

RispostaIni

Client ServerLogin

Password

Risultato

6H�LO�FOLHQW�q�VWDWR�YDOLGDWRSDUWH�O¶LQL]LDOL]]D]LRQH

RichiestaInf

RispostaInf

)DWWD�O¶LQL]LDOL]]D]LRQH�VL�FLFODDOO¶LQILQLWR�SHU�PDQWHQHUH

DJJLRUQDWR�LO�FOLHQW

RichiestaAck

RispostaAck

RichiestaInf

RispostaInf

)LJXUD����� 6HTXHQFH�GLDJUDP�UHODWLYR�DOOR�VFDPELR�GL�PHVVDJJL�WUD�FOLHQW�H�VHUYHU�

Il dialogo si può vedere come una successione di tre fasi ben distinte: la prima si

occupa di instaurare una connessione tra client e server al fine di poter validare

l’identità dell’utente. Nel caso in cui non vengano forniti un nome di login e una

password valide il server non autorizza il client e non accetta ulteriori richieste da

questo, chiudendo la connessione.

61

La seconda parte è dedicata all’inizializzazione del mondo. I messaggi scambiati

contengono tutte le informazioni relative agli oggetti che andranno inseriti nella sce-

na VRML del client.

Una volta terminata l’inizializzazione l’interfaccia utente viene attivata e l’utente è

pronto per interagire con la simulazione. A questo punto il client richiede periodica-

mente le informazioni necessarie per aggiornare la scena VRML così che questa resti

coerente con i dati in possesso del server. L’ultima fase viene quindi ripetuta in modo

ciclico per tutta la durata della connessione. I messaggi scambiati riguardano quindi

informazioni quali posizione ed orientamento relativi a tutti gli oggetti VRML pre-

senti nell’ambiente simulato.

Oltre a questi ci sono anche i messaggi che il client spedisce quando l’operatore vuo-

le impartire un comando a un robot, vediamone un esempio in figura 4.10:

Client ServerSetVelocitàDirezione

Risultato

)LJXUD������ ,O�FOLHQW�VSHGLVFH�XQ�PHVVDJJLR�FRQWHQHQWH�XQ�FRPDQ�GR SHU�XQ�URERW��

Il client spedisce una richiesta per impostare la velocità e la direzione del robot.

Fra i parametri sono inclusi il nome del robot che deve ricevere il comando e il nome

del controllore abilitato a questo tipo di richiesta (si tratta del tipo più elementare di

controllore: il controllore di velocità e direzione). Il risultato spedito dal server con-

tiene un codice che può indicare che il comando è stato eseguito correttamente oppu-

re che si è verificato un errore se ad esempio il nome del robot o del controllore non

erano nomi validi.

62

�7(67,1*�(�3529(�63(5,0(17$/,�

���� 7HVWLQJ�%XLOW�LQ�6HOI�7HVW�

L'attività di testing si è svolta in parallelo alla fase di sviluppo del codice.

Un primo livello di test è stato quello del built-in self test. Durante la stesura del co-

dice abbiamo inserito, in alcuni punti critici, dei test per controllare alcune pre e post

condizioni. Questo tipo di condizioni, nell’ipotesi di codice privo di errori, devono

valere sempre vero. Si tratta quindi di controlli ridondanti che si rivelano utili nella

fase di debugging.

3URWRWLSD]LRQH�Nella fase iniziale ci siamo poi avvalsi dell’uso della tecnica della prototipazione

rapida. Anche questo ci è stato d’aiuto per individuare alcuni problemi, e per valutare

la complessità dell’applicazione.

Durante la realizzazione del primo prototipo si sono riscontrati problemi relativi al

caricamento e scaricamento della pagina HTML che conteneva la applet Java e il

mondo VRML. Il link tra VRML e Java avviene attraverso l’interfaccia EAI, tutta-

via, quando la pagina viene caricata dal browser Internet, non c’è modo di sapere in

che ordine vengono caricati i plug-in VRML e Java e quindi può accadere che la ap-

plet Java parta quando il mondo VRML non è ancora disponibile e dualmente quan-

do si esce dalla pagina il mondo VRML può venire deallocato quando i thread della

applet sono ancora in esecuzione.

63

Durante il caricamento della pagina HTML questo non è un problema grave, in effet-

ti è sufficiente inserire una temporizzazione nella applet in modo che, se

l’interfacciamento EAI non riesce subito, vengano fatti più tentativi a distanza di al-

cuni secondi l’uno dall’altro. Il problema invece è più grave durante lo scaricamento

della pagina, perché nell’interfaccia EAI non ci sono metodi che permettano di sape-

re con certezza se in un qualche momento il mondo VRML è ancora caricato nella

pagina o se è stato già scaricato perché la pagina HTML sta per essere chiusa. Si ve-

rifica quindi il seguente problema: quando l’utente esce dalla pagina HTML viene

deallocato il mondo VRML prima della applet Java (senza che la applet abbia modo

di saperlo) e il thread Java che si occupa di aggiornare le coordinate del robot

nell’ambiente simulato continua ad essere eseguito ancora per qualche millisecondo

prima che anche la applet venga fermata. Poiché però il mondo VRML è già stato

cancellato il tentativo di aggiornamento delle coordinate fatto dalla applet può gene-

rare gravi errori nel browser Internet causandone la chiusura. L’unico rimedio possi-

bile è richiamare periodicamente il metodo %URZVHU�JHW%URZVHU�$SSOHW� per

verificare che la pagina VRML sia ancora disponibile.

7HVW�GL�XQLWj�Il test di unità è stato invece possibile grazie allo sviluppo di una apposita classe

denominata 7HVW.La classe 7HVW rappresenta un gruppo di test per uno o più metodi di una classe. Co-

me è facile intuire i test più accurati sono stati quelli rivolti alla verifica della corret-

tezza delle classi del package JHRPHWULD. Nel nostro simulatore facciamo un grande

uso dei metodi da noi implementati per operare con vettori, rotazioni e rototraslazio-

ni. È chiaro quindi che la correttezza di questi metodi è fondamentale per il buon

funzionamento complessivo dell'applicazione.

L'attività di debugging è stata puntuale, anche se a volte i problemi rilevati erano do-

vuti a un cattivo funzionamento dell'interprete Java o della non totale aderenza agli

standard dei singoli browser.

64

Per chiarire la metodologia seguita e per facilitare un futuro riutilizzo di questa parte

del codice riportiamo come esempio la classe di test relativa al metodo

5RWRWUDVOD]LRQH�FRPSRVL]LRQH�5RWRWUDVOD]LRQH�, che calcola la matrice di

rototraslazione risultante dal prodotto di due sottomatrici.

/******************************************************* * Classe TestRototraslazioneComposizione ******************************************************/ package test; import server.geometria.*; import Test; /******************************************************* * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *******************************************************/ public class TestRototraslazioneComposizione extends Test {

private final static int NUMERO_TEST = 2; private final static float TOLL_ANG = (float)Math.pow(10, -7); private final static float TOLL_MOD = (float)Math.pow(10, -12); Rototraslazione[] i1 = new Rototraslazione[NUMERO_TEST]; Rototraslazione[] i2 = new Rototraslazione[NUMERO_TEST]; Rototraslazione[] o1 = new Rototraslazione[NUMERO_TEST];

/******************************************************* * Costruttore: Inizializza tutti i dati di test. *******************************************************/

public TestRototraslazioneComposizione() { super("Rototraslazione Rototraslazione.composizione(Rototraslazione)", NUMERO_TEST);

// Traslazione semplice con rototraslazione. i1[0] = new Rototraslazione(Rotazione.I, new Vettore(2, 2, 2)); i2[0] = new Rototraslazione(new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f), new Vettore(4, 0, 2)); o1[0] = new Rototraslazione(new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f), new Vettore(6, 2, 4));

// Due rotazioni pure. i1[1] = new Rototraslazione(new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f)); i2[1] = new Rototraslazione(new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f)); o1[1] = new Rototraslazione(new Rotazione(Vettore.j, -Rotazione.PIGRECO/2f)); }

/*********************************************************** * Metodo implementato: Esegue il test i-esimo del gruppo di test * incorporati nella classe. Deve essere implementato * nella classe che fornisce l’insieme dei test. * * @param i Indice del test da eseguire. * @return true se il test non ha trovato errori, * false altrimenti. ***********************************************************/

public boolean eseguiTest(int i) { Vettore .setPrecisione(TOLL_MOD);

65

Rotazione.setPrecisione(TOLL_ANG); Rototraslazione rot = i1[i].composizione(i2[i]) .composizione(o1[i].inversa());

return rot.isZero(); }

/*********************************************************** * Metodo implementato: Esegue il test i-esimo del gruppo di * test incorporati nella classe e ne ritorna l’output. * * @param i Indice del test da eseguire. * * @return Output del test i-esimo. ***********************************************************/

public String outputTest(int i) { return (i1[i].composizione(i2[i])).toString(); }

/************************************************************* * Metodo implementato: Ritorna l’output corretto per il test * i-esimo. * @param i Indice del test. * * @return Output corretto del test i-esimo. *************************************************************/

public String riferimentoTest(int i)

{ return o1[i].toString(); }

/******************************************************* }

/*******************************************************

Tutti i metodi di test seguono questa struttura:

• Costruttore: contiene tutti i dati necessari ad eseguire i vari test.

• Metodo HVHJXL7HVW: si occupa dell’esecuzione vera e propria del test.

• Metodo RXWSXW7HVW: visualizza sullo standard output il risultato del test.

• Metodo ULIHULPHQWR7HVW: ritorna l’output corretto per il test i-esimo.

7HVW�GL�LQWHJUD]LRQH�Per quanto riguarda il test dell'applicazione su rete Internet, si è proceduto a una

serie di prove che simulassero un tipico scenario d'uso della nostra applicazione.

In tutti i casi le prove hanno dato esito negativo. Il simulatore risulta affidabile, sem-

pre in funzione della qualità della connessione Internet di cui si dispone.

66

In questa fase ci siamo anche occupati di provare l’applicazione su diverse piattafor-

me. Il server è stato testato su server Windows 95, su Windows NT e su Linux. Il

client è stato provato sulle sole piattaforme Windows a causa della mancanza di di-

sponibilità di browser Internet e VRML compatibili con il Jdk 1.2 e col VRML 2.0,

problema questo che tratteremo più approfonditamente nelle conclusioni.

���� 3URYH�VSHULPHQWDOL�Le prove effettuate hanno avuto come obiettivo quello di verificare il buon com-

portamento dei controllori implementati.

Per quanto riguarda il controllore velocità/direzione le prove si sono limitate a con-

statare la corretta risposta, da parte del robot simulato, ai comandi forniti dall'utente.

Il controllore ha dimostrato di essere preciso e veloce nelle risposte. L'utente può

quindi effettuare un controllo puntuale dei movimenti del robot. Questo tipo di con-

trollo non presenta inconvenienti di sorta e si propone come base per una futura ap-

plicazione su robot reali.

Le prove più interessanti sono state però quelle effettuate con i controllori di inse-

guimento e behavior.

Ostacolo 2

Repulsioneostacolo 1

Repulsioneostacolo 2Repulsione

risultante

Ostacolo 1

)LJXUD����� ,O�PHWRGR�GHL�SRWHQ]LDOL��

67

Per il primo, sono state necessarie diverse simulazioni per tarare opportunamente i

pesi utilizzati nel metodo dei potenziali. L'importanza di questi pesi è legata in parti-

colar modo al problema dello stallo. Il robot infatti, se tarato con valori non opportu-

ni, iniziava a seguire traiettorie circolari o arrivava a bloccarsi proprio a causa delle

situazioni di stallo. In questi casi il vettore attrattore viene bilanciato dal vettore re-

pulsore e il robot quindi si ritrova bloccato in una posizione fissa.

La soluzione a questo problema consiste nel generare piccole perturbazioni casuali al

moto del robot, così da evitare situazioni di stallo prolungate.

Le prove effettuate sul controllore behavior avevano come obiettivo l'analisi delle

capacità da parte di un robot di:

• Esplorare un ambiente non noto a priori.

• Evitare gli ostacoli, fissi e in movimento, presenti nell'ambiente.

• Individuare una cassa all'interno di un ambiente al fine di raggiungerla.

Qui di seguito riportiamo le mappe generate dal robot mobile durante l'esplora-

zione dell'ambiente da noi realizzato, costituito da quattro ambienti collegati tra loro

(figura 5.2).

Cassa

Robot

)LJXUD����� 0DSSD�ELGLPHQVLRQDOH�GHOODPELHQWH��

68

Le mappe sono state generate dopo un certo numero di iterazioni del simulatore,

per avere un’idea dei tempi, 500 iterazioni equivalgono a circa 5 secondi.

)LJXUD����� 0DSSD�GRSR�����LWHUD]LRQL��

In figura 5.3 si vede il robot nella sua posizione iniziale. Il colore rosa è utilizzato

per indicare lo spazio libero individuato dai sensori. Il rosso invece indica la presen-

za di un ostacolo.

)LJXUD����� 0DSSD�GRSR������LWHUD]LRQL��

In figura 5.4 si vede come il robot, sotto il controllo del behavior, inizi la sua e-

splorazione dello spazio circostante.

69

)LJXUD����� 0DSSD�GRSR������LWHUD]LRQL��

Dalla figura 5.5 si vede come il robot, dopo appena 3000 iterazioni, è già riuscito

ad esplorare le due stanze comunicanti.

)LJXUD����� 0DSSD�GRSR������LWHUD]LRQL��

Dopo 5000 iterazioni, la mappa dell'ambiente inizia ad essere abbastanza definita.

Lo spazio grigio al centro della stanza è dovuto alla presenza della cassa. In questa

fase non era richiesto al robot di individuare la cassa, che quindi è vista come un o-

stacolo.

70

)LJXUD����� 0DSSD�GRSR�������LWHUD]LRQL��

Dopo 10000 iterazioni (figura 5.7), il robot ha ormai visitato quasi tutto l’ambien-

te, e a 20000 iterazioni la mappa ottenuta si può dire quasi del tutto completa.

)LJXUD����� 0DSSD�GRSR�������LWHUD]LRQL��

L'algoritmo implementato ha dimostrato la sua efficienza. Il robot è in grado di

esplorare un ambiente ignoto in un tempo ragionevolmente breve. In ogni caso, e per

ogni evenienza, è sempre possibile un intervento diretto da parte dell'utente. Questo

serve per risolvere eventuali stalli o per ottimizzare i tempi.

Questa simulazione ci ha permesso di verificare anche la robustezza dell'algoritmo

che si occupa di evitare gli ostacoli statici. Per quanto riguarda quelli dinamici invece

le prove sono state fatte utilizzando due robot. Il primo controllato da un operatore, il

secondo dal controllore behavior.

71

In questo caso il robot è riuscito a evitare le collisioni solo per velocità ridotte del se-

condo robot. In ogni caso, dopo la collisione, il robot effettua una virata che lo porta

ad allontanarsi il più velocemente possibile dal punto di impatto.

La simulazione relativa alla ricerca e al raggiungimento della cassa ha dato ugual-

mente esito positivo. Il robot inizia ad esplorare l'ambiente seguendo il comporta-

mento (VSORUD�� Questo comportamento viene inibito non appena i sensori

individuano un oggetto di un certo colore. Nei nostri esperimenti abbiamo fatto uso

di casse bianche.

Il robot una volta raggiunta la cassa evita di speronarla. Il movimento quindi risulta

essere di continua attrazione e repulsione.

)LJXUD����� 5RERW�FKH�FHUFD�XQD�FDVVD��

In figura 5.9 abbiamo evidenziato il percorso seguito dal robot durante la simula-

zione. Come si può notare la traiettoria in prossimità dell'obiettivo non è regolare. Il

controllo, una volta raggiunta la cassa, dovrebbe essere assunto dall'operatore, al fi-

ne di muovere la cassa mediante il robot.

Il passaggio dal controllore behavior a quello manuale non crea problemi ed è imme-

diato.

Ultimo aspetto da noi esaminato è stato il comportamento di più robot. In questa fase

ci siamo occupati di verificare le funzionalità relative allo scambio messaggi,

all’aggiornamento delle mappe, e alla disposizione in gruppo.

72

)LJXUD������6LPXOD]LRQH�GL�GXH�URERW�/DEPDWH��

In figura 5.10 si possono vedere alcune schermate relative alle prove che abbiamo

effettuato utilizzando i modelli del robot Labmate. L’esperimento consisteva nel di-

mostrare la capacità dei robot di riunirsi al fine di navigare in modo congiunto. Il

comportamento è stato corretto. Il robot verde ha raggiunto il robot rosso e lo ha poi

seguito in ogni su movimento, evitando di collidere con esso e con altri ostacoli pre-

senti nell’ambiente circostante.

)LJXUD������5DJJUXSSDPHQWR�GL�SL��URERW��

73

Abbiamo ripetuto lo stesso esperimento utilizzando più robot di tipi differenti. I

modelli utilizzati sono quelli del Khepera e di un robot cilindrico generico.

L’obiettivo assegnato ai robot rosso, giallo e blu era quello di raggiungere e seguire

il robot verde. In figura 5.11 possiamo vedere sulla sinistra la disposizione iniziale

dei vari robot e sulla destra le posizioni assunte dopo alcuni secondi di simulazione.

Anche in questo caso il comportamento è stato corretto. I robot hanno evitato le col-

lisioni tra loro e quelle con gli ostacoli presenti nell’ambiente. La prova ci è stata an-

che utile per verificare le prestazioni del simulatore in termini di velocità. Il

passaggio da due a quattro robot ha comportato una limitata riduzione delle presta-

zioni.

)LJXUD������3URYD�UHODWLYD�DOOR�VFDPELR�GHOOH�LQIRUPD]LRQL��

74

In figura 5.12 vengono illustrate le varie fasi che hanno caratterizzato una delle

prove relative allo scambio delle informazioni sulla mappa dell’ambiente tra due ro-

bot.

In questo caso abbiamo pilotato il robot rosso al fine di portarlo in prossimità del ro-

bot verde. Una volta raggiunta la posizione desiderata abbiamo avviato su tutte e due

i robot il controllore behavior. La mappa del robot verde, già dopo pochissime itera-

zioni, era quella visibile nella figura in basso a destra. È chiaro che il robot verde ha

potuto beneficiare di tutte le informazioni in possesso del robot rosso. Questo sistema

permette ai robot di ottenere una mappa completa dell’ambiente in tempi ridotti ri-

spetto all’esplorazione in solitario.

Un altro esperimento che abbiamo condotto riguardava la capacità da parte di più ro-

bot di esplorare un ambiente al fine di individuare un certo obiettivo. Compito del

primo robot che riusciva in questo intento era quello di chiamare a raccolta intorno a

sé tutti gli altri robot presenti nell’ambiente grazie all’invio di un messaggio radio in

broadcast.

In figura 5.13 si possono vedere le varie fasi che hanno caratterizzato questa prova.

Si può vedere che il primo robot ad individuare la cassa è il robot arancione (quello

più in basso nella fase iniziale). Nelle schermate successive risulta evidente che il

comportamento degli altri robot passa dall’esplorazione random dell’ambiente al

comportamento di $SSURDFK�verso il robot arancione� Questa prova serve anche a

dimostrare l’efficienza dell’algoritmo che fa uso del metodo dei potenziali. È grazie a

questo infatti che i robot possono raggiungersi.

75

)LJXUD������5LFHUFD�H�UDJJLXQJLPHQWR�GL�XQ�RELHWWLYR��

76

�0$18$/,�87(17(�

���� 0DQXDOH�SHU�O¶DPPLQLVWUDWRUH�GHO�VHUYHU�5HTXLVLWL�0LQLPL�GL�6LVWHPD�

Essendo il codice scritto interamente in Java non esiste una piattaforma preferen-

ziale per l’uso di questo programma. Qualsiasi macchina dotata di una Java Virtual

Machine o di un Java runtime environment potrà sfruttare appieno le caratteristiche

di questo simulatore.

Questo significa che potrete usarlo con eguali risultati su una workstation Pentium,

su una Sun o su una Silicon Graphics, quindi sia con sistema operativo Windows

95/98, NT, Solaris, Mac o altro.

Per quanto riguarda la parte video il server è pensato per lavorare in modalità alfa-

numerica, è quindi possibile installarlo anche su macchine che dispongano di una

semplice scheda video.

5HTXLVLWL�VRIWZDUH�Prima di iniziare l’installazione del programma dovremo assicurarci di avere una

macchina configurata in modo adeguato e con le versioni corrette del software neces-

sario.

Iniziamo col dire che il server è stato sviluppato utilizzando la versione 1.2 del Jdk

della Sun. Sarà quindi cura dell’utente procurarsi questa versione o una superiore di-

rettamente dal sito della Sun all’indirizzo http://www.sun.com.

77

/¶LQVWDOOD]LRQH��Una volta effettuate queste operazioni preliminari per procedere all’installazione

dell'applicazione sarà sufficiente scompattare il file zip, contenuto nel dischetto for-

nito a corredo, nella directory open del vostro server web.

A questo punto dovreste trovare nella suddetta directory la sub-directory SimCS.

All’interno di questa saranno presenti i file HTML, quelli ZUO, i file FODVV e alcune

sub-directory (server, client, comune, texture, …).

Se avete correttamente configurato il PATH e il CLASSPATH come indicato nelle

istruzioni del Jdk, e se il vostro server WEB è configurato correttamente

l’installazione del simulatore si può dire conclusa.

Siamo ora pronti ad avviare il nostro server, vedremo come nel prossimo paragrafo.

/¶DYYLR�GHO�VHUYHU�La prima cosa da fare una volta installato il programma è quella di avviare il

server stesso.

Per farlo sarà sufficiente eseguire il comando MDYD�6LP6HUYHU QRPHPRQGR una volta

entrati nella directory SimCS. Col termine QRPHPRQGR si vuole indicare il nome del-

la classe Java che contiene gli elementi costituenti dell’ambiente in cui svolgere la

simulazione. Il mondo da noi realizzato e distribuito con l’applicazione si chiama

0RQGR&RQ7UH6WDQ]H ed è localizzato nel package VHUYHU�PRQGR.

Una volta avviato il server apparirà a video il seguente messaggio:

Avvio del server... Inizializzazione simulatore riuscita. Mondo in evoluzione...

Questo messaggio indica che il server è stato avviato correttamente e che è in atte-

sa di connessioni.

&RQQHVVLRQH�GL�XQ�&OLHQW�Ogni volta che il server riceve una nuova richiesta di connessione da parte di un

client verrà visualizzato un messaggio simile al seguente:

78

Richiesta da Socket[addr=xanadu06.metid.polimi.it/131.175.10.166, port=1055,localport=9000]

Questo messaggio mette in evidenza che il Server ha ricevuto una richiesta di

connessione ed evidenzia i dati relativi alla connessione stessa, successivamente

comparirà a video un messaggio di questo tipo:

Attivato il thread di I/O sulla porta 1055

Che indica al gestore del server la porta sulla quale è attiva la connessione, segui-

to a sua volta da:

Verifica login e password... Client validato, instaurata connessione con “login”

In questo caso il server verifica i dati provenienti dal client, e una volta validati

comunica che è stata instaurata una connessione con un certo utente contraddistinto

dal suo login.

'LVFRQQHVVLRQH�GL�XQ�&OLHQW�In caso di disconnessione di un client il server si occuperà di informare

l’amministratore visualizzando a video un messaggio d’avvertimento simile al se-

guente:

Disconnesso client dalla porta 1055

0HVVDJJL�GL�HUURUH�Nel caso in cui ci siano problemi nella fase iniziale di stabilimento della connes-

sione potrebbe comparire uno dei seguenti messaggi d’errore:

Errore durante l� inizializzazione del client Errore durante la creazione del socket

L’errore, in questo caso dipende dalla cattiva connessione dati o dall’impossibilità

di creare un socket attivo. Si suggerisce quindi di fare un controllo accurato della

propria linea dati e della configurazione della propria scheda di rete.

79

6KXW�GRZQ�GHO�VHUYHU�In caso si rendesse necessario il shut-down del server sarà sufficiente portarsi nel-

la finestra in cui è attiva l'applicazione e premere invio per far terminare l’esecuzione

del programma. Questo comporterà l’automatica disconnessione di tutti i client con-

nessi, e l’impossibilità dell’uso del simulatore fino al successivo riavvio del pro-

gramma stesso.

Il riavvio dovrà seguire le stesse procedure viste per l'avvio dell'applicazione.

���� 0DQXDOH�XWHQWH�SHU�O¶XWLOL]]R�GHO�FOLHQW�5HTXLVLWL�0LQLPL�GL�6LVWHPD�

Essendo il codice scritto interamente in Java non esiste una piattaforma preferen-

ziale per l’uso di questo programma. Qualsiasi macchina dotata di un browser Java

compatibile e di un browser VRML potrà sfruttare appieno le caratteristiche di que-

sto simulatore.

I requisiti di memoria sono quelli necessari all’avvio delle applicazioni suddette. Lo

stesso discorso vale per quanto riguarda i requisiti video, anche se per una visione ot-

timale è consigliata una risoluzione minima di 800x600 pixel.

5HTXLVLWL�6RIWZDUH�L’applicazione client per essere utilizzata necessita di un browser dell’ultima ge-

nerazione quale Internet Explorer 4.x o superiore.

80

Si rende inoltre necessaria l’installazione di un plug-in che permetta la visione di

pagine contenenti codice VRML. Noi suggeriamo all’utente di scaricare direttamente

dalla rete il CosmoPlayer 2.1 (o successivo) reperibile nel sito

http://www.cosmosoftware.com oppure il più efficiente Intervista World View repe-

ribile all’indirizzo http://www.intervista.com.

$YYLR�GHO�FOLHQW�Essendo il simulatore inglobato in una pagina HTML, per avviarlo sarà sufficiente

richiamare dal vostro browser l’url relativa alla pagina stessa.

Fatto questo, dopo qualche breve istante d’attesa comparirà sul monitor una scherma-

ta che ricorda i requisiti minimi per la corretta visione del simulatore, così come in-

dicato nella figura 6.1.

81

)LJXUD����� 6FKHUPDWD�LQL]LDOH��

Sarà sufficiente premere il tasto 6WDUW 6LP&OLHQW per avviare il client in una nuova

finestra priva dei consueti tasti per la navigazione nel WEB.

Prima di iniziare è necessario fornire i dati relativi al proprio login e password

nell’apposita finestra denominata ,GHQWLILFD]LRQH che apparirà sullo schermo così

come in figura 6.2. Per farlo sarà sufficiente digitare i dati richiesti e poi premere il

tasto 2.. Il tasto &DQFHOOD serve per cancellare la finestra nel caso in cui l’utente che

si è collegato non possieda i dati richiesti per l’autenticazione.

82

)LJXUD����� )LQHVWUD�SHU�O¶LGHQWLILFD]LRQH�GHOO¶XWHQWH��

Una volta terminata questa fase, dopo che il server avrà validato i dati, vedremo i

controlli della applet passare da disattivi ad attivi.

8VR�GHO�FOLHQW�Una volta terminate queste fasi preliminari il nostro client è pronto per essere uti-

lizzato. Nella figura 6.3 possiamo vedere come appare la applet simulatore nelle pri-

me fasi di avvio in cui dialoga col server per ottenere i dati necessari

all’inizializzazione del mondo VRML.

Come è facile notare la schermata è suddivisa fondamentalmente in due parti. Sul la-

to sinistro troviamo il browser VRML, i dati relativi agli autori e un pulsante

&ORVH�WKLV�ZLQGRZ che se premuto provvede alla rimozione della finestra contenente

la applet.

83

)LJXUD����� $SSOHW�6LP&OLHQW��

Sul lato destro dello schermo troviamo invece la finestra contenente i controlli at-

tivi della applet.

La applet a sua volta è suddivisa fondamentalmente in quattro parti così come indica-

to in figura 6.4.

Elementi perselezionare lavisuale, il robot

e il relativocontrollore

Velocità,direzione e

orientamento delrobot

attualmente inuso

Elementi relativial controllore

attualmente in uso

Finestra contenenteI messaggi

)LJXUD����� 6WUXWWXUD�GHOOD�DSSOHW��

84

Nella zona in alto a sinistra si trovano tre menu a tendina. Il primo, denominato

9LVXDOL]]D, permette la selezione della telecamera da usare per visualizzare le imma-

gini nella finestra VRML.

Sotto si trova il menu 5RERW�che permette di selezionare il robot da usare tra quelli

disponibili.

Infine il menu &RQWUROOR permette di selezionare il tipo di controllore da utilizzare tra

quelli disponibili montati sul robot scelto.

)LJXUD����� 6FKHUPDWD�UHODWLYD�DO�FRQWUROORUH�Velocità/Posizione.

Veniamo ora a descrivere gli elementi contenuti nell’area in alto a destra. Qui

vengono visualizzate le informazioni relative al robot attualmente in uso: la velocità,

espressa in metri al secondo, la posizione, espressa in metri e riferita a un punto pre-

fissato che risulta essere l’angolo in alto a sinistra dell’ambiente, ed infine la direzio-

ne, espressa in radianti con convenzione antioraria.

Nella zona centrale della applet trovano posto gli elementi che permettono di impar-

tire i comandi allo specifico controllore attualmente in uso. Quest’area della applet

varia al variare del controllore. Vedremo ora di descrivere i vari pannelli di controllo

uno ad uno.

85

Nel caso in cui si utilizzi il controllore 9HORFLWj�'LUH]LRQH la applet si presenterà così

come appare in figura 6.5.

Come si vede i pulsanti presenti sono dodici. I primi nove permettono di assegnare

una direzione di riferimento e di fermare il robot: nord, sud, est, ovest, nord-est,

nord-ovest, sud-est, sud-ovest e stop. I tre bottoni posti sull’ultima colonna a destra

permettono invece di impostare la velocità del robot a uno dei tre valori predefiniti:

minima, media, massima. I singoli valori di velocità possono variare in funzione del

tipo di robot.

Per quanto riguarda il controllore ,QVHJXLPHQWR il relativo pannello di controllo è

mostrato in figura 6.6.

)LJXUD����� 6FKHUPDWD�UHODWLYD�DO�FRQWUROORUH�Inseguimento.�

Questo tipo di controllore può essere utilizzato per chiedere al robot di raggiunge-

re un qualsiasi elemento presente nell’ambiente simulato, un robot o una cassa. Una

volta raggiunto l’elemento il robot lo inseguirà in ogni suo movimento.

Questo pannello permette quindi di selezionare l’oggetto da inseguire tra quelli di-

sponibili, e di avviare il processo di ricerca e inseguimento.

86

Il controllore 3RVL]LRQH serve per indicare al robot una posizione specifica da rag-

giungere. Com’è semplice intuire vedendo la figura 6.7, l’utente dovrà semplicemen-

te fornire le coordinate volute e premere il tasto ,PSRVWD�3RVL]LRQH.

)LJXUD����� 6FKHUPDWD�UHODWLYD�DO�FRQWUROORUH�Posizione.�

Vediamo in ultimo di analizzare la schermata relativa al controllore %HKDYLRU (fi-gura 6.8).

Questo controllore è forse quello che presenta l’interfaccia più semplice. L’unico

comando possibile è infatti quello che permette l’avvio del controllore, ottenibile con

un semplice click del mouse sul bottone $YYLD.

87

)LJXUD����� 6FKHUPDWD�UHODWLYD�DO�FRQWUROORUH�Behavior.�

In questo pannello appare inoltre il bottone 0RVWUD�0DSSD. Grazie a questo co-

mando è possibile visualizzare in ogni momento la mappa dell’ambiente così com’è

memorizzata dal robot. La mappa viene visualizzata in una nuova finestra (figura

6.9) che è possibile chiudere premendo il tasto in alto a destra, contraddistinto dal

simbolo X.

)LJXUD����� )LQHVWUD�LQ�FXL�YLHQH�YLVXDOL]]DWD�OD�PDSSD�GHOO¶DPELHQWH��

88

Terminata questa rassegna non resta che da esaminare l’ultimo elemento della ap-

plet: la finestra dei messaggi. In quest’area vengono visualizzati i messaggi di stato

della applet (Collegamento alla pagina VRML, connessione col server, …), i possibi-

li messaggi di errore dovuti a problemi sulla linea dati, e tutte le altre informazioni

che vengono passate alla applet dal server.

3RVVLELOL�SUREOHPL�H�ORUR�VROX]LRQH�Nel caso in cui si verificassero problemi durante la comunicazione col server ver-

rebbe visualizzato nella finestra dei messaggi l’avviso 3UREOHPL FRQ�LO�6HUYHU. Questa

condizione non si è mai presentata durante le sessioni di lavoro a cui è stato sottopo-

sto il programma in fase di testing, comunque sia una cattiva linea dati potrebbe por-

tare a un messaggio di questo tipo.

In questo caso l’utente verrà automaticamente disconnesso dal server e perderà ogni

informazione relativa alla sua sessione di lavoro. Per continuare ad utilizzare il pro-

gramma non resterà che chiudere la finestra contenente la sessione terminata e ricon-

nettersi.

Un caso analogo è quello relativo al messaggio d’errore ^LQLW�,QSXW`��(UURUH�,2�QQ��Anche in questo caso si sono verificati problemi durane la trasmissione dati. Sarà ne-

cessario ristabilire la connessione e riprovare.

Nel caso venga visualizzato il messaggio ,PSRVVLELOH� FROOHJDUH� LO�PRQGR�YUPO�sarà

necessario accertarsi di aver correttamente installato un browser per il VRML e ri-

provare.

Nel caso in cui non si riuscisse a stabilire la connessione potrebbe darsi che il servi-

zio sia momentaneamente non disponibile a causa di problemi sul lato server.

89

&21&/86,21,�

&RQVLGHUD]LRQL�ILQDOL�Tutti gli obiettivi previsti dallo svolgimento di questa tesi sono stati raggiunti. Il

simulatore ha raggiunto un buon livello di stabilità e funzionalità, e, rispetto ad altri

ambienti di simulazione analoghi presenta indubbi vantaggi, tra cui ricordiamo:

• La multiutenza, gestita all'interno di ambienti simulati virtuali.

• Il fatto di poter essere riutilizzato per simulare diversi robot, anche all'interno di

uno stesso ambiente.

• La portabilità del codice dovuta all'uso di linguaggi di programmazione standard.

• L'estensibilità dovuta all'uso intensivo della programmazione ad oggetti, che

permette di costruire nuovi metodi e classi a partire da quelle esistenti.

• La rappresentazione della scena in tre dimensioni, e non come accade in genere

in due dimensioni.

• La capacità di sfruttare Internet, così da essere usabile da un qualsiasi nodo della

rete, in qualsiasi parte del mondo.

• La possibilità di osservare la simulazione da diversi punti di vista.

• La possibilità di sviluppare l'applicazione per un uso con robot reali, a patto di

sostituire alcune classi, come le classi del package VHQVRUL, con altre in grado di

interfacciarsi con i sensori e gli attuatori reali del robot.

• In ultimo bisogna ricordare la possibilità di interagire in real-time con la simula-

zione, che risulta in continua evoluzione.

90

/LPLWL�DWWXDOL�Attualmente i limiti di usabilità del codice dipendono esclusivamente dalla dispo-

nibilità di versioni sufficientemente aggiornate di browser Internet e VRML per le

varie piattaforme.

Il nostro simulatore ad esempio richiede Internet Explorer 4.x o superiore, ma questo

dipende solo dal fatto che Netscape non ha ancora rilasciato una versione aggiornata

del suo browser con una Java Virtual Machine compatibile col Jdk 1.2.

Per quanto riguarda VRML, la Cosmo Software, ha rilasciato versioni diverse del

suo browser per le piattaforme Windows 3.11/9x/NT e per PowerMac. Dal lato

UNIX esistono dei visualizzatori per questo linguaggio, ma non ci è stato possibile

trovare un plug-in adatto ai nostri scopi.

Da quanto è emerso alla prima conferenza italiana sul VRML, comunque, la Cosmo-

Software rilascerà a breve il codice sorgente del suo browser. Sarà così possibile svi-

luppare delle versioni personalizzate del CosmoPlayer e si renderà possibile una

migrazione anche verso piattaforme UNIX o Linux.

2ELHWWLYL�IXWXUL�Tra gli obiettivi futuri da noi ipotizzati ce ne sono due particolarmente interessanti

che qui riportiamo:

• Far sì che i robot, una volta individuato un certo obiettivo, nella fattispecie una

cassa, siano in grado di spingerla, cooperando tra loro, se necessario, al fine di

portarla in un punto di raccolta prefissato.

• Trasformare il simulatore in un’applicazione utilizzabile per il controllo di robot

mobili reali.

Il primo obiettivo è raggiungibile sfruttando la capacità di comunicare dei singoli

robot e la possibilità di pianificare un percorso basandosi sulla mappa costruita dai

robot durante la loro esplorazione.

91

Il secondo obiettivo è quello più impegnativo, ipotizzabile grazie alle scelte fatte che

ci hanno fatto optare per l'utilizzo di modelli accurati dei sensori e dei robot così da

rendere possibile una futuro utilizzo con robot reali.

Altri possibili lavori ipotizzabili riguardano lo sviluppo di nuovi e più sofisticati con-

trollori, l’implementazione di nuovi modelli di robot e la migrazione da VRML a

Java3D, quando quest’ultima tecnologia avrà raggiunto un sufficiente livello di ma-

turità e di diffusione

92

%,%/,2*5$),$�

[Alami, 1993] Alami, Chatilla, Espiau (1993). 'HVLJQLQJ� DQ� LQWHOOLJHQW�FRQWURO� DUFKLWHFWXUH� IRU� DXWRQRPRXV� URERWV��Proceedings 7th International Conference on Advanced Robotics, Tokyo, 1993.

[Arkin, 1993] Arkin R.C., Balch T, Nitz E. (1993). &RPPXQLFDWLRQ�RI�EH�KDYLRUDO� VWDWH� LQ� PXOWL� DJHQW� UHWULHYDO� WDVNV�� Proceedings, IEEE International Conference on Robotics and Automation, 3, 1993.

[Arnold, 1996] Ken Arnold, James Gosling (1996). -DYD 'LGDWWLFD� H�3URJUDPPD]LRQH, Addison-Wesley, 1996.

[Asama, 1994] Asama H. (1994), 7UHQGV�RI�GLVWULEXWHG�DXWRQRPRXV�URERWLF�V\VWHPV��3-8, 1994.

[Balch, 1994] Balch T., Arkin R.C. (1994). &RPPXQLFDWLRQ�LQ�UHDFWLYH�PXO�WL�DJHQW� URERWLF� V\VWHP�� Autonomous Robots, 1(1):27-53, 1994.

[Borenstein, 1996] Borenstein J., Everett H.R., Feng L. (1996). :KHUH�DP�,, The University of Michigan, Michigan.

[Bou-Ghannam,1992] Bou Ghannam A. (1992). &RQWUROOLQJ�UHDFWLYH�EHKDYLRU�ZLWK�FRQVLVWHQW� ZRUOG� PRGHOLQJ� DQG� UHDVRQLQJ�� SPIE vol.1708, Applications of Artificial Intelligence X: Machine Vision and Robotics, 1992.

[Brooks, 1986] Brooks R. (1986). $ UREXVW�OD\HUHG�&RQWURO�6\VWHP�IRU�D�PR�ELOH�URERW, IEEE Journal of Robotics and Automation, RA-2, April (1986) 14-23.

[Brooks, 1991] Brooks R. (1991). ,QWHOOLJHQFH� ZLWKRXW� UHDVRQ�� Proceedings International Joint Conference of Artificial Intelligence, 569-595, Sydney, Australia, 1991.

93

[Callaghan, 1998] Callaghan M. (1998), 'HILQLWLRQ� RI� WHOHURERWV��http://freedom.artm.ulst.ac.uk/~robot/telerobot/, Gennaio 1998.

[Connell, 1992] Connell J.H. (1992). 666� D� K\EULG� DUFKLWHFWXUH� DSSOLHG� WR�URERW QDYLJDWLRQ��Proceedings, IEEE International Conferen-ce on Robotics and Automation, Maggio 1992.

[Doty, 1993] Doty K., Aken R.E. (1993). 6ZDUP URERW�PDWHULDO�KDQGOLQJ�SDUDGLJP� IRU� D� PDQLIDFWXULQJ� ZRUNFHOO�� Proceedings, IEEE International Conference on Robotic and Automation, 1, 1993.

[Dudek, 1996] Dudek G., Jenkin M., Milios E., Wilkes D. (1996). $ WD[R�QRP\ IRU� PXOWL�DJHQW� URERWLFV��Autonomous Robots, 3,375-397.

[Eckel,1997] Bruce Eckel (1997). 7KLQNLQJ�LQ�-DYD��������[Ephrati, 1995] Ephrati E., Pollack M., Rosenschein J.(1995). $ WUDFWDEOH�

KHXULVWLF� WKDW� PD[LPL]HV� JOREDO� XWLOLW\� WKURXJK� ORFDO� SODQ�FRPELQDWLRQ�� First International Conference on Multi-Agent System, 1995.

[Fleisher, 1998] Fleisher J. (1998). &RRSHUDWLYH� PRELOH� URERW� DUFKLWHFWXUHV�IRU� DQ� H[SORUDWLRQ� DQG� UHWULYLDO� WDVN, Summer progress re-port� Colorado State University, Colorado.

[Gasser, 1989] Gasser L., Huhns M.N. (1989). 7KHPHV� LQ�GLVWULEXWHG�DUWLIL�FLDO� LQWHOOLJHQFH�UHVHDUFK��Distributed Artificial Intelligence, 2, 1989.

[Genovese, 1992] Genovese V., Dario P., Magni R., Odetti L. (1992). 6HOI�RUJDQL]LLQJ� EHKDYLRU� DQG� VZDUP� LQWHOOLJHQFH� LQ� D� SDFN� RI�PRELOH� PLQLDWXUH� URERWV� LQ� VHDUFK� RI� SROOXWDQWV. IEEE/RSJ International Conference on Intelligent Robot and System, Raleigh, NC, Luglio 1992, 1575-1582.

[Gosling, 1996] James Gosling, Bill Joy, Guy Steele (1996)� 7KH� -DYD� /DQ�JXDJH 6SHFLILFDWLRQ, Addison-Wesley, 1996.

[Hoepli, 1994] Autori vari (1994). 0DQXDOH GHOO¶,QJHJQHUH�0HFFDQLFR, Ho-epli, 1994.

94

[Iidia, 1990] Iidia S., Yuta S. (1990). &RQWURO RI�D�YHLFKOH�VXEV\VWHP�IRU�DQ�DXWRQRPRXV�PRELOH�URERW�ZLWK�SRZHU�ZKHHOHG�VWHHULQJV��Pro-ceedings of IEEE International Workshop on Intelligent Mo-tion Control, Turkey, 859-866, 1990.

[Khatib, 1985] Khatib O. (1985). 5HDO�WLPH�REVWDFOH�DYRLGDQFH�IRU�PDQLSX�ODWRUV� DQG� PRELOH� URERW�� IEEE International Conference on Robotics and Automation, 500-505, 1985.

[Koren, 1991] Koren Y., Borenstein J. (1991). 3RWHQWLDO� ILHOG�PHWKRGV�DQG�WKHLU�LQKHUHQW�OLPLWDWLRQV�IRU�PRELOH�URERW�QDYLJDWLRQ��Proce-edings, IEEE International Conference on Robotics and Au-tomation, Sacramento, California, Aprile 1991.

[Kuc, 1987] Kuc R., Siegel M.W. (1987). 3K\VLFDOO\� EDVHG� VLPXODWLRQ�PRGHO IRU�DFRXVWLF�VHQVRU�URERW�QDYLJDWLRQ��IEEE Trans. On Pami Vol. Pami-9, n.6, 776-778.

[Lim, 1990] Lim W., Eilbert J. (1990). 3ODQ�EHKDYLRU�LQWHUDFWLRQ�LQ�DXWR�QRPRXV QDYLJDWLRQ��SPIE vol 1388, Mobile Robots V, 1990.

[Lucarini, 1993] Lucarini G., Varioli M., Cerutti R., Sandini G. (1993). &HOOX�ODU URERWLFV��VLPXODWLRQ�DQG�KZ�LPSOHPHQWDWLRQ��Proceedings, IEEE International Conference on Robotics and Automation, 3, 1993.

[Malavasi,1980] Malavasi C. (1980), 9DGHPHFXP SHU�O¶,QJHJQHUH�&RVWUXWWRUH�0HFFDQLFR�;9�(GL]LRQH, Hoepli, 1980.

[Màntaras, 1998] Lòpez de Màntaras R., Lòpez-Sànchez M., Esteva F., Sierra C. (1998). 0DS *HQHUDWLRQ�E\�FRRSHUDWLYH�ORZ�FRVW�URERWV�LQ�VWUXFWXUHG� XQNQRZQ� HQYLURQPHQWV�� Autonomous Robots 5, 53-61.

[Mataric, 1992] Mataric M.J. (1992). %HKDYLRU�EDVHG�V\VWHPV��NH\�SURSHUWLHV�DQG LPSOLFDWLRQV��Proceedings, IEEE International Conferen-ce on Robotics and Automation, Workshop on Architectures for Intelligent Control System, 1992.

[Mataric, 1995] Mataric M.J. (1995). ,VVXHV�DQG�DSSURDFKHV�LQ�WKH�GHVLJQ�RI�FROOHFWLYH�DXWRQRPRXV�DJHQWV��Robotics and Automation Sy-stems, 16(2-4), 321-331,1995.

95

[Mataric, 1995b] Mataric M.J., Simsarian K.T. (1995). /HDUQLQJ WR�FRRSHUDWH�XVLQJ WZR�VL[�OHJJHG�PRELOH�URERWV��Proceedings Third Euro-pean Workshop of Learning Robots, Heraklion, Crete, Gree-ce.

[Meystel, 1991] Meystel A. (1991). $XWRQRPRXV� 0RELOH� 5RERWV�� 9HLFKOHV�ZLWK� &RJQLWLYH� &RQWURO�� World Scientific Publishing Co., New Jersey, 1991.

[Miller, 1990] Miller D.P. (1990). 0XOWLSOH� EHKDYLRU�FRQWUROOHG� PLFUR�URERWV IRU� SODQHWDU\� VXUIDFH�PLVVLRQV��Proceedings in IEEE International Conference on System, Man and Cybernetics, 281-292,LA, Ca, November 1990.�

[Miller, 1991] Miller D.P., Slack M.G. (1991). *OREDO V\PEROLF�PDSV�IURP�ORFDO�QDYLJDWLRQ��AAAI-91 Proceedings of the ninth national cnference on artificial intelligence, 750-755, Luglio 1991.

[Nilsson, 1984] Nilsson N.J. (1984). 6KDNH\�WKH�URERW��Technical report 323, SRI International, Artificial Intelligence Center, 1984.

[Noborio, 1992] Noborio H. (1992). $ FROOLVLRQ� IUHH� DQG� GHDGORFN�IUHH� SDWK�SODQQLQJ�DOJRULWKP�IRU�PXOWLSOH�PRELOH�URERWV�ZLWKRXW�PXWXDO�FRPPXQLFDWLRQ. Proceedings IEEE/RSJ International Confe-rence on Intelligent Robots and Systems ’92, Raleigh,North Carolina,USA, 479-486.

[Parker, 1993] Parker L.E. (1993). 'HVLJQLQ� &RQWURO� ODZV� IRU� FRRSHUDWLYH�DJHQW� WHDPV��Proceedings, IEEE International Conference on Robotics and Automation, 3, 1993.

[Roehl, 1997] Bernie Roehl, Justin Couch, Cindy Reed-Ballreich, Tim Ro-haly, and Geoff Brown (1997). /DWH 1LJKW�9UPO�����ZLWK�-D�YD, Ziff-Davis Press, 1997.

[Rosenschein, 1993] Ephrati E., Rosenschein J. (1993). 0XOWL� DJHQW� SODQQLQJ� DV�G\QDPLF�VHDUFK�IRU�VRFLDO�FRQVHQVXV��Thirteenth International Joint Conference on Artificial Intelligence, 423-429, 1993.

[Rosenschein, 1994] Ephrati E., Rosenschein J. (1994). 'LYLGH� DQG� FRQTXHU� LQ�PXOWL DJHQW� SODQQLQJ�� Proceedings of the Twelfth National Conference on Artificial Intelligence, Luglio-Agosto, 1994.

96

[Sciavicco, 1995] Lorenzo Sciavicco, Bruno Siciliano (1995).� 5RERWLFD� ,QGX�VWULDOH, McGraw-Hill, 1995.

[Stilwell, 1993] Stilwell D.J., Bay J.S. (1993). 7RZDUG WKH�GHYHORSPHQW�RI�D�PDWHULDO� WUDQVSRUW� V\VWHP� XVLQJ� VZDUPV� RI� DQW� OLNH� URERWV��Proceedings, IEEE International Conference on Robotics and Automation, 1, 1993.

[Tunstel, 1992] Tunstel E. (1992), $XWRQRPRXV� 5RERW�0DSSLQJ�:LWK�%HKD�YLRU�EDVHG� 1DYLJDWLRQ. JPL Internal Document, JPL D-10458, Jet Propulsion Laboratory, Pasadena CA, December, 1992.

[Tunstel, 1994] Tunstel E., Jamshidi M. (1994). )X]]\� /RJLF� DQG� %HKDYLRU�&RQWURO� 6WUDWHJ\� IRU� $XWRQRPRXV� 0RELOH� 5RERW� 0DSSLQJ��IEEE Intl. Conference on Fuzzy Systems, Orlando, Florida, Giugno 1994 .

[Vivarelli,1996] Maria Dina Vivarelli (1996). $SSXQWL�GL�0HFFDQLFD�5D]LRQD�OH, Masson, 1996.

[Waite, 1998] Mitchell Waite and Robert Lafore (1998). 2EMHFW�2ULHQWHG�'HVLJQ LQ�-DYD, Gilbert & McCarty, 1998.

[COSMO] &RVPR 3OD\HU��SOXJ�LQ�SHU�950/, CosmoSoftware http://www.cosmosoftware.com

[EASYROB] EASY-ROB Robot Simulation Tool, http://www.easy-rob.de

[EYESIM] Simulatore di ambienti multi-robot EyeSim, http://www.ee.uwa.edu.au/~braunl/eyebot/doc/mk2/sim/sim.html

[FLAKEY] Simulatore di robot mobile, ftp://ftp.ai.sri.com/pub/konolige

[INTERVISTA] ,QWHUYLVWD�:RUOG9LHZ��SOXJ�LQ�950/, Intervista http://www.intervista.com

[LAMI] Simulatore del robot Khepera presso il LAMI all’EPFL, http://diwww.epfl.ch/lami/

[MOBSFTP] MOBS – Mobile Robot Simulator,

97

ftp://ftp.ee.uwa.edu.au/users/braunl/mobs

[SRI] SRI International, :KDW�LV�7(/(URERWLFV,http://www.erg.sri.com/div-services/aatc/html/what-telerobotics.html

[XRAPTOR] Simulatore di multi-agenti virtuali presso l’università di Mainz, http://www.informatik.uni-mainz.de/~polani/XRaptor/XRaptor.html

98

$&2',&(�625*(17(�

$��� ,O�SDFNDJH�JHRPHWULD�Questo package contiene le classi usate per i calcoli vettoriali basilari, sono pre-

senti le classi 9HWWRUH, 5RWD]LRQH, 5RWRWUDVOD]LRQH, più una classe astratta 9ROXPH in

cui sono dichiarati i metodi per il calcolo delle distanze e il rilevamento delle colli-

sioni. Di tale classe sono state definite le implementazioni per i volumi cilindro, pa-

rallelepipedo e porta.

Di seguito è allegato il codice sorgente delle classi 9ROXPH, 9ROXPH&LOLQGUR e 9ROX�PH3DUDOOHOHSLSHGR.

99

/****************************************************************************** * Classe astratta Volume * * Modificatori: * void setPosizione (Vettore) * void setOrientamento (Rotazione) * * Metodi di accesso: * final Vettore posizione () * final Rotazione orientamento () * static int intersezione (Volume, Volume) * abstract float distanzaDirezionale (Rototraslazione) * throws EccezioneNonInterseca * Metodi ridefiniti: * Object clone () throws CloneNotSupportedException *****************************************************************************/ package server.geometria; import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import server.geometria.eccezione.*; /****************************************************************************** * Questa classe rappresenta un arbitrario volume immerso nello spazio * tridimensionale. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public abstract class Volume implements Cloneable {

public static final int INDETERMINATO = 0; public static final int NON_INTERSECA = 1; public static final int INTERSECA = 2; public static final int CONTIENE = 3; public static final int CONTENUTO = 4;

// Questo vettore serve alla classe per calcolare il risultato // dell’intersezione del volume v1 con v2 quando il chiamante vuole // il risultato dell’intersezione di v2 con v1. private static final int[] INVERSO = { INDETERMINATO, NON_INTERSECA, INTERSECA, CONTENUTO, CONTIENE };

private Vettore posizione = Vettore.o; private Rotazione orientamento = Rotazione.I;

/************************************************************************** * Modificatore: Cambia la posizione del volume. * * @param posizione Nuova posizione del volume. *************************************************************************/

public final void setPosizione(Vettore posizione) { this.posizione = posizione; }

/************************************************************************** * Modificatore: Cambia l’orientamnto del volume. * * Questa implementazione della classe volume funziona correttamente solo

100

* se gli oggetti ruotano esclusivamente attorno all’asse delle y, per cui * sonno ammesse rotazioni solo attorno a questa’asse. * * @param orientamento Nuovo orientamento del volume. *************************************************************************/

public final void setOrientamento(Rotazione orientamento) { // Precondizioni: /// if(orientamento.x() != 0f) throw new IllegalArgumentException(); /// if(orientamento.z() != 0f) throw new IllegalArgumentException();

this.orientamento = orientamento; }

/************************************************************************** * Metodo di accesso: Ritorna la posizione corrente del volume. * * @return Posizione del volume. *************************************************************************/

public final Vettore posizione() { return posizione; }

/************************************************************************** * Metodo di accesso: Ritorna l’orientamento corrente del volume. * * @return Orientamento del volume. *************************************************************************/

public final Rotazione orientamento() { return orientamento; }

/************************************************************************** * Metodo di accesso: Calcola l’intersezione tra i due volumi passati come * parametri. Il valore ritornato e’ una delle costanti definite dentro * questa classe. * * @param v1 Primo volume. * @param v2 Secondo volume. * * @return INDETERMINATO | INTERSECA | NON_INTERSECA | CONTIENE | * CONTENUTO *************************************************************************/

public static int intersezione(Volume v1, Volume v2) { // Questo metodo usa le caratteristiche avanzate di RTTI // (Run Time Type Identification) offerte da Java: // // Il metodo legge dinamicamente il tipo esatto di entrambi i // volumi passati come parametro (supponiamo Vol1 v1 e Vol2 v2) // dopo di che cerca nelle due classi ouno dei seguenti metodi: // // int Vol1.intersezione(Vol1, Vol2) // int Vol2.intersezione(Vol2, Vol1) // int Vol1.intersezione(Vol1, Volume) // int Vol2.intersezione(Vol2, Volume) // // Se uno di essi viene trovato viene invocato e ne ritorna il // risultato. // Se non ne trova nessuno allora ritorna Volume.INDETERMINATO. // // E’ importante che non si possano istanziare oggetti Volume // altrimenti questo algoritmo richiamerebbe ricorsivamente questo

101

// stesso metodo all’infinito. Per questo la classe Volume e’ // dichiarata astratta, anche se implementa tutti i suoi metodi. // // Questa implementazione permette di aggiungere nuovi tipi di // volume senza dover riscrivere le classi preesistenti. Inoltre // per confrontare due volumi di tipo diverso e’ indifferente // in quale dei due tipi viene implementato il metodo per il // confronto, poiche’ questo metodo risolve automaticamente // il problema invertendo i parametri e chiamando sempre il // metodo corretto. // // Nell’implementare i metodi e’ importante ricordare la regola: // il primo parametro passato deve essere dello stesso tipo della // classe che contiene il metodo.

Method metodo = null; Class[][] classe = { { v1.getClass(), v2.getClass() }, { v2.getClass(), v1.getClass() }, { v1.getClass(), v2.getClass().getSuperclass() }, { v2.getClass(), v1.getClass().getSuperclass() }, };

for(int i = 0; (i < classe.length) && (metodo == null); ++i) { try { metodo = classe[i][0].getMethod("intersezione", classe[i]); } catch(NoSuchMethodException nsme) { } }

if(metodo == null) return INDETERMINATO;

try { if(metodo.getDeclaringClass().equals(v1.getClass())) { Object[] parametri = { v1, v2 };

return ((Integer)metodo.invoke(null, parametri)).intValue(); } else { Object[] parametri = { v2, v1 };

return inverso(((Integer)metodo.invoke(null, parametri)).intValue()); } } catch(InvocationTargetException ite) { throw new InternalError(); } catch(IllegalAccessException iae) { throw new InternalError(); } }

/************************************************************************** * Metodo di accesso: Ritorna il risultato dell’intersezione nel caso i * volumi vengano scambiati: * Volume.intersezione(v1, v2) == Volume.inverso(Volume.intersezione(v2, v1)) * * @return INDETERMINATO | INTERSECA | NON_INTERSECA | CONTIENE | * CONTENUTO *************************************************************************/

protected static int inverso(int intersezione) { return INVERSO[intersezione]; }

/************************************************************************** * Metodo ridefinito: Crea una copia identica del volume. *

102

* @return Copia del volume. *************************************************************************/

public Object clone() throws CloneNotSupportedException { return super.clone(); }

/************************************************************************** * Metodo astratto: Considero un sistema di riferimento relativo * identificato dal parametro r01 (matrice di rototraslazione). Partendo * dall’origine di tale riferimento e spostandomi lungo la direzione * positiva dell’asse delle x arrivo a toccare un punto della superficie * del volume. Questo metodo ritorna la distanza percorsa. * * @param r01 Matrice di rototraslazione che identifica il rifermento * relativo (porta dal riferimento relativo a quello * assoluto) * * @return Minima distanza dell’origine del riferimento relativo * dal corpo lungo l’asse x del riferimento relativo * (solo lungo la direzione positiva, se il volume e’ * dalla parte opposta non viene considerato). * * @exception EccezioneNonInterseca Lanciata se il volume non interseca * l’asse x del riferimento relativo * o se si trova dalla parte negativa * dell’asse. * * @exception EccezioneContieneOrigine Lanciata se il volume contiene * l’origine del riferimento * relativo. *************************************************************************/

public abstract float distanzaDirezionale(Rototraslazione r01) throws EccezioneNonInterseca, EccezioneContieneOrigine;

//************************************************************************* }

//*****************************************************************************

103

/****************************************************************************** * Classe VolumeCilindro * * Metodi di accesso: * float raggio () * float altezza () * static int intersezione (VolumeCilindro, VolumeCilindro) *****************************************************************************/ package server.geometria; import server.geometria.Vettore; import server.geometria.Rotazione; import server.geometria.Volume; import server.geometria.eccezione.*; /****************************************************************************** * Questa classe rappresenta un volume cilindrico. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class VolumeCilindro extends Volume {

private final float raggio; private final float altezza;

/************************************************************************** * Costruttore: Crea un volume cilindrico. * * @param raggio Raggio della base del cilindro [m] (> 0). * @param altezza Altezza del cilindro [m] (> 0). *************************************************************************/

public VolumeCilindro(float raggio, float altezza) { // Precondizioni: if(raggio <= 0) throw new IllegalArgumentException(); if(altezza <= 0) throw new IllegalArgumentException();

this.raggio = raggio; this.altezza = altezza; }

/************************************************************************** * Metodi di acccesso: Ritorna il raggio della base del cilindro. * * @return Raggio della base del cilindro. *************************************************************************/

public final float raggio() { return raggio; }

/************************************************************************** * Metodi di acccesso: Ritorna l’altezza del cilindro. * * @return Raggio l’altezza del cilindro. *************************************************************************/

public final float altezza() { return altezza; }

/************************************************************************** * Metodo di accesso: Calcola l’intersezione tra i

104

* due volumi passati come parametri. Il valore ritornato e’ una delle * costanti definite dentro questa classe. * * [Nota]: Il volume deve avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param v1 Primo volume. * @param v2 Secondo volume. * * @return INDETERMINATO | INTERSECA | NON_INTERSECA | CONTIENE | * CONTENUTO *************************************************************************/

public static int intersezione(VolumeCilindro v1, VolumeCilindro v2) { int intersezioneXZ = INDETERMINATO; int intersezioneY = INDETERMINATO;

// Calcolo dell’intersezione sul piano X-Z. float x = v1.posizione().x() - v2.posizione().x(); float z = v1.posizione().z() - v2.posizione().z(); float d = (float)Math.sqrt(x*x + z*z); float r1 = v1.raggio(); float r2 = v2.raggio();

if(d > r1 + r2) return NON_INTERSECA;

if (d + r2 < r1) intersezioneXZ = CONTIENE; else if(d + r1 < r2) intersezioneXZ = CONTENUTO;

// Calcolo dell’intersezione sull’asse Y. float b1 = v1.posizione().y() - v1.altezza()/2f; float h1 = v1.posizione().y() + v1.altezza()/2f; float b2 = v2.posizione().y() - v2.altezza()/2f; float h2 = v2.posizione().y() + v2.altezza()/2f;

if((b2 <= b1) && (b1 < h2)) if((b2 <= h1) && (h1 < h2)) intersezioneY = CONTENUTO; else intersezioneY = INTERSECA; else if((b2 <= h1) && (h1 < h2)) intersezioneY = INTERSECA; else if((b1 <= b2) && (b2 < h1)) intersezioneY = CONTIENE; else return NON_INTERSECA;

if(intersezioneXZ == intersezioneY) return intersezioneXZ;

return INTERSECA; }

/************************************************************************** * Metodo implementato: Considero un sistema di riferimento relativo * identificato dal parametro rot (matrice di rototraslazione). Partendo * dall’origine di tale riferimento e spostandomi lungo la direzione * positiva dell’asse delle x arrivo a toccare un punto della superficie * del volume. Questo metodo ritorna la distanza percorsa. * * [Nota]: Il volume deve avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param r01 Matrice di rototraslazione che identifica il rifermento * relativo (porta dal riferimento relativo a quello

105

* assoluto) * * @return Minima distanza dell’origine del riferimento relativo * dal corpo lungo l’asse x del riferimento relativo. * * @exception EccezioneNonInterseca Lanciata se il volume non interseca * l’asse x del riferimento relativo. * * @exception EccezioneContieneOrigine Lanciata se il volume contiene * l’origine del riferimento * relativo. *************************************************************************/

public float distanzaDirezionale(Rototraslazione r01) throws EccezioneNonInterseca, EccezioneContieneOrigine { // Calcolo il centro del cilindro nel riferimento relativo. // 0 = Riferimento assoluto. // 1 = Riferimento relativo (di cui interessa l’asse x). Vettore centro = r01.inversa().rototrasla(this).posizione();

if(centro.x()*centro.x() + centro.z()*centro.z() < raggio()*raggio()) throw new EccezioneContieneOrigine();

if(centro.x() < 0f) throw new EccezioneNonInterseca(); if(centro.y() < -altezza()/2f) throw new EccezioneNonInterseca(); if(centro.y() > altezza()/2f) throw new EccezioneNonInterseca();

float corda2 = raggio()*raggio() - centro.z()*centro.z();

if(corda2 < 0f) throw new EccezioneNonInterseca();

return centro.x() - (float)Math.sqrt(corda2); }

//************************************************************************* }

//*****************************************************************************

106

/****************************************************************************** * Classe VolumeParallelepipedo * * Metodi di accesso: * float larghezza () * float altezza () * float profondita () * static int intersezione (VolumeParallelepipedo, VolumeParallelepipedo) * static int intersezione (VolumeParallelepipedo, VolumeCilindro) *****************************************************************************/ package server.geometria; import server.geometria.Vettore; import server.geometria.Rotazione; import server.geometria.Volume; import server.geometria.eccezione.*; /****************************************************************************** * Questa classe rappresenta un volume a forma di parallelepipedo. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class VolumeParallelepipedo extends Volume {

private final float larghezza; private final float altezza; private final float profondita;

/************************************************************************** * Costruttore: Crea un volume a forma di parallelpeipedo. * * @param larghezza Larghezza del parallelepipedo [m] (> 0). * @param altezza Altezza del parallelepipedo [m] (> 0). * @param profondita Profondita’ del parallelepipedo [m] (> 0). *************************************************************************/

public VolumeParallelepipedo(float larghezza, float altezza, float profondita) { // Precondizioni: if(larghezza <= 0) throw new IllegalArgumentException(); if(altezza <= 0) throw new IllegalArgumentException(); if(profondita <= 0) throw new IllegalArgumentException();

this.larghezza = larghezza; this.altezza = altezza; this.profondita = profondita; }

/************************************************************************** * Metodi di acccesso: Ritorna la larghezza del parallelpeipedo. * * @return Larghezza del parallelpeipedo. *************************************************************************/

public final float larghezza() { return larghezza; }

/************************************************************************** * Metodi di acccesso: Ritorna l’altezza del parallelpeipedo. * * @return Raggio l’altezza del parallelpeipedo. *************************************************************************/

107

public final float altezza() { return altezza; }

/************************************************************************** * Metodi di acccesso: Ritorna la profondita’ del parallelpeipedo. * * @return Raggio la profondita’ del parallelpeipedo. *************************************************************************/

public final float profondita() { return profondita; }

/************************************************************************** * Metodo di accesso con accesso package: Calcola l’intersezione tra i * due volumi passati come parametri. Il valore ritornato e’ una delle * costanti definite dentro questa classe. * * @param v1 Primo volume. * @param v2 Secondo volume. * * @return INDETERMINATO | INTERSECA | NON_INTERSECA | CONTIENE | * CONTENUTO *************************************************************************/

public static int intersezione(VolumeParallelepipedo v1, VolumeParallelepipedo v2) { //********************************************************************* // Questo metodo funziona correttamente solo se la rotazione del // volume ha asse parallelo a Vettore.j. //*********************************************************************

int intersezioneXZ = INDETERMINATO; int intersezioneY = INDETERMINATO;

// Calcolo dell’intersezione sul piano X-Z. intersezioneXZ = semiIntersezioneXZ(v1, v2);

if(intersezioneXZ == INDETERMINATO) intersezioneXZ = inverso(semiIntersezioneXZ(v2, v1));

if(intersezioneXZ == INDETERMINATO) intersezioneXZ = INTERSECA; ///* * *

if(intersezioneXZ == NON_INTERSECA) return NON_INTERSECA;

// Calcolo dell’intersezione sull’asse Y. float b1 = v1.posizione().y() - v1.altezza()/2f; float h1 = v1.posizione().y() + v1.altezza()/2f; float b2 = v2.posizione().y() - v2.altezza()/2f; float h2 = v2.posizione().y() + v2.altezza()/2f;

if((b2 <= b1) && (b1 < h2)) if((b2 <= h1) && (h1 < h2)) intersezioneY = CONTENUTO; else intersezioneY = INTERSECA; else if((b2 <= h1) && (h1 < h2)) intersezioneY = INTERSECA; else if((b1 <= b2) && (b2 < h1)) intersezioneY = CONTIENE; else return NON_INTERSECA;

108

if(intersezioneXZ == intersezioneY) return intersezioneXZ;

return INTERSECA; }

//*************************************************************************

private static int semiIntersezioneXZ(VolumeParallelepipedo v1, VolumeParallelepipedo v2) { float p1x = v1.larghezza()/2f; float p1z = v1.profondita()/2f;

float p2x = v2.larghezza()/2f; float p2z = v2.profondita()/2f;

Vettore p1 = new Vettore( p2x, 0, p2z); Vettore p2 = new Vettore( p2x, 0, -p2z); Vettore p3 = new Vettore(-p2x, 0, -p2z); Vettore p4 = new Vettore(-p2x, 0, p2z);

Rototraslazione r10 = new Rototraslazione(v1.orientamento(), v1.posizione()).inversa(); Rototraslazione r02 = new Rototraslazione(v2.orientamento(), v2.posizione()); Rototraslazione r12 = r10.composizione(r02);

p1 = r12.rototrasla(p1); p2 = r12.rototrasla(p2); p3 = r12.rototrasla(p3); p4 = r12.rototrasla(p4);

boolean attraversaX = (p1.x()*p2.x() < 0f) || (p1.x()*p3.x() < 0f) || (p1.x()*p4.x() < 0f) || (p2.x()*p3.x() < 0f) || (p2.x()*p4.x() < 0f) || (p3.x()*p4.x() < 0f);

boolean attraversaZ = (p1.z()*p2.z() < 0f) || (p1.z()*p3.z() < 0f) || (p1.z()*p4.z() < 0f) || (p2.z()*p3.z() < 0f) || (p2.z()*p4.z() < 0f) || (p3.z()*p4.z() < 0f);

p1 = new Vettore(Math.abs(p1.x()), 0f, Math.abs(p1.z())); p2 = new Vettore(Math.abs(p2.x()), 0f, Math.abs(p2.z())); p3 = new Vettore(Math.abs(p3.x()), 0f, Math.abs(p3.z())); p4 = new Vettore(Math.abs(p4.x()), 0f, Math.abs(p4.z()));

if((p1.x() < p1x) && (p2.x() < p1x) && (p3.x() < p1x) && (p4.x() < p1x) && (p1.z() < p1z) && (p2.z() < p1z) && (p3.z() < p1z) && (p4.z() < p1z)) return CONTIENE;

if((p1.x() < p1x) && (p1.z() < p1z)) return INTERSECA; if((p2.x() < p1x) && (p2.z() < p1z)) return INTERSECA; if((p3.x() < p1x) && (p3.z() < p1z)) return INTERSECA; if((p4.x() < p1x) && (p4.z() < p1z)) return INTERSECA;

if((p1.x() > p1x) && (p2.x() > p1x) && (p3.x() > p1x) && (p4.x() > p1x) && !attraversaX) return NON_INTERSECA; if((p1.z() > p1z) && (p2.z() > p1z) && (p3.z() > p1z) && (p4.z() > p1z) && !attraversaZ) return NON_INTERSECA;

return INDETERMINATO; }

/************************************************************************** * Metodo di accesso: Calcola l’intersezione tra i

109

* due volumi passati come parametri. Il valore ritornato e’ una delle * costanti definite dentro questa classe. * * [Nota]: Il volume deve avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param v1 Primo volume. * @param v2 Secondo volume. * * @return INDETERMINATO | INTERSECA | NON_INTERSECA | CONTIENE | * CONTENUTO *************************************************************************/

public static int intersezione(VolumeParallelepipedo vp, VolumeCilindro vc) { int intersezioneXZ = INDETERMINATO; int intersezioneY = INDETERMINATO;

// Calcolo dell’intersezione sul piano X-Z. Rototraslazione r10 = new Rototraslazione(vp.orientamento(), vp.posizione()).inversa(); Vettore c = r10.rototrasla(vc.posizione());

float cx = Math.abs(c.x()); float cz = Math.abs(c.z()); float px = vp.larghezza()/2f; float pz = vp.profondita()/2f; float r = vc.raggio();

if((cx > px + r) || (cz > pz + r)) return NON_INTERSECA;

if ((cx + r < px ) && (cz + r < pz )) intersezioneXZ = CONTIENE; else if((cx+px)*(cx+px) + (cz+pz)*(cz+pz) < r*r) intersezioneXZ = CONTENUTO; else if((cx-px)*(cx-px) + (cz-pz)*(cz-pz) < r*r) intersezioneXZ = INTERSECA; else if(cx < px + r) intersezioneXZ = INTERSECA; else if(cz < pz + r) intersezioneXZ = INTERSECA; else return NON_INTERSECA;

// Calcolo dell’intersezione sull’asse Y. float b1 = vp.posizione().y() - vp.altezza()/2f; float h1 = vp.posizione().y() + vp.altezza()/2f; float b2 = vc.posizione().y() - vc.altezza()/2f; float h2 = vc.posizione().y() + vc.altezza()/2f;

if((b2 <= b1) && (b1 < h2)) if((b2 <= h1) && (h1 < h2)) intersezioneY = CONTENUTO; else intersezioneY = INTERSECA; else if((b2 <= h1) && (h1 < h2)) intersezioneY = INTERSECA; else if((b1 <= b2) && (b2 < h1)) intersezioneY = CONTIENE; else return NON_INTERSECA;

if(intersezioneXZ == intersezioneY) return intersezioneXZ;

return INTERSECA; }

/************************************************************************** * Metodo implementato: Considero un sistema di riferimento relativo * identificato dal parametro rot (matrice di rototraslazione). Partendo * dall’origine di tale riferimento e spostandomi lungo la direzione * positiva dell’asse delle x arrivo a toccare un punto della superficie

110

* del volume. Questo metodo ritorna la distanza percorsa. * * @param r01 Matrice di rototraslazione che identifica il rifermento * relativo (porta dal riferimento relativo a quello * assoluto) * * @return Minima distanza dell’origine del riferimento relativo * dal corpo lungo l’asse x del riferimento relativo. * * @exception EccezioneNonInterseca Lanciata se il volume non interseca * l’asse x del riferimento relativo. * * @exception EccezioneContieneOrigine Lanciata se il volume contiene * l’origine del riferimento * relativo. *************************************************************************/

public float distanzaDirezionale(Rototraslazione r01) throws EccezioneNonInterseca,

EccezioneContieneOrigine { // Calcolo l’origine del riferimento relativo e la direzione verso // cui guarda l’asse x del riferimento relativo nelle coordinate del // riferimento solidale con il parallelepipedo. // 0 = Riferimento assoluto. // 1 = Riferimento relativo (di cui interessa l’asse x). // v = Rifermento solidale con il volume parallelepipedare. Rototraslazione r0v = new Rototraslazione(orientamento(),

posizione()); Rototraslazione rv1 = r0v.inversa().composizione(r01);

Vettore origine = rv1.traslazione(); Vettore direzione = rv1.rotazione().direzione();

Vettore v[] = { Vettore.o, Vettore.o, Vettore.o, Vettore.o, Vettore.o, Vettore.o };

float l = larghezza()/2f; float h = altezza()/2f; float p = profondita()/2f;

if((Math.abs(origine.x()) < l) && (Math.abs(origine.y()) < h) && (Math.abs(origine.z()) < p) ) throw new EccezioneContieneOrigine();

// Considero i 6 piani che contengono le 6 facce del parallelepipedo e // calcolo il punto di intersezione del prolungamento di "direzione" da // "origine" che interseca tali piani. Se "direzione" e’ parallelo a // uno dei piani al vettore corrispondente resta assegnato Vettore.o. // Se il punto di intersezione e’ contenuto nella faccia lo tengo, // altrimenti riassegno Vettore.o. if(direzione.x() != 0f) { v[0] = origine.sottrazione(direzione.prodotto((origine.x() – l)/direzione.x())); v[1] = origine.sottrazione(direzione.prodotto((origine.x() + l)/direzione.x()));

if((Math.abs(v[0].y()) > h) || (Math.abs(v[0].z()) > p)) v[0] = Vettore.o; if((Math.abs(v[1].y()) > h) || (Math.abs(v[1].z()) > p)) v[1] = Vettore.o; }

if(direzione.y() != 0f)

111

{ v[2] = origine.sottrazione(direzione.prodotto((origine.y() – h)/direzione.y())); v[3] = origine.sottrazione(direzione.prodotto((origine.y() + h)/direzione.y()));

if((Math.abs(v[2].x()) > l) || (Math.abs(v[2].z()) > p)) v[2] = Vettore.o; if((Math.abs(v[3].x()) > l) || (Math.abs(v[3].z()) > p)) v[3] = Vettore.o; }

if(direzione.z() != 0f) { v[4] = origine.sottrazione(direzione.prodotto((origine.z() – p)/direzione.z())); v[5] = origine.sottrazione(direzione.prodotto((origine.z() + p)/direzione.z()));

if((Math.abs(v[4].x()) > l) || (Math.abs(v[4].y()) > h)) v[4] = Vettore.o; if((Math.abs(v[5].x()) > l) || (Math.abs(v[5].y()) > h)) v[5] = Vettore.o; }

float distanza = origine.modulo(); boolean interseca = false;

// I punti candidati a validi punti di intersezione sono fra i vettori // calcolati in precedenza quelli che intersecano nella direzione di // "direzione". for(int i = 0; i < 6; ++i) { if((v[i] != Vettore.o) && (v[i].sottrazione(origine).scalare(direzione) >= 0)) { interseca = true;

float d = v[i].sottrazione(origine).modulo();

if(d < distanza) distanza = d; } }

if(!interseca) throw new EccezioneNonInterseca();

return distanza; }

//************************************************************************* }

//*****************************************************************************

112

$��� ,O�SDFNDJH�ILVLFD�Questo package contiene tutte le classi relative al modello fisico dei corpi. Fra

queste la più importante è la classe %DULFHQWUR insieme alle sue derivate %DULFHQWUR�)LVVR, %DULFHQWUR$WWULWR e %DULFHQWUR$WWULWR'LUH]LRQDOH, quest’ultima relativa alla ge-

stione di corpi dotati di ruote. Ciascuna di queste classi è in grado di calcolare gli

spostamenti del corpo nel tempo in funzione della risultante delle forze e dei momen-

ti esterni applicati ad esso.

Di seguito è allegato il codice sorgente delle classi %DULFHQWUR, %DULFHQWUR$WWULWR e

%DULFHQWUR$WWULWR'LUH]LRQDOH.

113

/****************************************************************************** * Classe Baricentro * * Metodi statici: * void urto (Baricentro, Baricentro, float) * * Costruttori: * Baricentro (Vettore, Rotazione, float massa, * Vettore inerzia) * Metodi di accesso: * final float massa () * final Vettore posizione () * final Vettore velocita () * * final float inerzia (Vettore) * final float inerzia () * final Rotazione orientamento () * final Vettore velocitaAngolare () * * Modificatori: * void aggiorna (float dt, Vettore forza, Vettore momento) *****************************************************************************/ package server.fisica; import server.geometria.*; /****************************************************************************** * Questa classe descrive un oggetto che rappresenta un punto fisico dotato * di posizione e orientamento nello spazio tridimensionale e che risponde * a forze e momenti applicati dall’esterno alterando le proprie posizioni * e velocita’ lineari e angolari. * * @version 1.00 * @date 3 Ottobre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class Baricentro {

/** Costante di accelerazione di gravita’ terrestre [m/s^2]. */ public static final float g = 9.806056f;

/** Massa del baricentro [Kg]. */ private final float massa;

/** Diagonale del tensore d’inerzia riferito agli assi principali d’inerzia [Kg*m^2]. */ private final Vettore inerzia;

/** Posizione del baricentro [m]. */ private Vettore p;

/** Velocita’ del baricentro [m/s]. */ private Vettore v;

/** Orientamento del baricentro [rad]. */ private Rotazione pa;

/** Velocita’ angolare del baricentro [rad/s]. La velocita’ angolare e’ un vettore e non una rotazione perche’ una rotazione deve avere l’angolo compreso tra 0 e due pigreco mentre la velocita’ angolare puo’ assumere qualunque valore. La direzione del vettore rappresenta l’asse di rotazione mentre il suo modulo la velocita’ angolare in senso antiorario rispetto alla direzione dell’asse. */ private Vettore va;

/************************************************************************** * Costruttore: Costruisce un nuovo baricentro con massa e tensore * d’inerzia specificati dal chiamante e con velocita’ iniziali nulle.

114

* Se vengono specificati parametri invalidi (come una massa negativa) * viene lanciata una eccezione di runtime. * * @param p Posizione inziale del baricentro. * @param pa Orientamento iniziale del baricentro. * @param massa Massa del baricentro (maggiore di zero). * @param inerzia Tensore d’inerzia del corpo riferito agli assi * principali d’inerzia (poiche’ si tratta di una * matrice diagonale viene passato come un vettore che * contiene gli elementi sulla diagonale). I tre * elementi devono essere numeri non negativi e * non identicamente nulli. *************************************************************************/

public Baricentro(Vettore p, Rotazione pa, float massa, Vettore inerzia) { // Precondizioni: if(massa <= 0) throw new IllegalArgumentException(); if(inerzia.x() <= 0) throw new IllegalArgumentException(); if(inerzia.y() <= 0) throw new IllegalArgumentException(); if(inerzia.z() <= 0) throw new IllegalArgumentException();

this.massa = massa; this.p = p; this.v = Vettore.o;

this.inerzia = inerzia; this.pa = pa; this.va = Vettore.o; }

/************************************************************************** * Metodo di accesso: Ritorna la massa del baricentro. * * @return Posizione corrente del baricentro. *************************************************************************/

public final float massa() { return massa; }

/************************************************************************** * Metodo di accesso: Ritorna la posizione corrente del baricentro. * * @return Posizione corrente del baricentro. *************************************************************************/

public final Vettore posizione() { return p; }

/************************************************************************** * Metodo di accesso: Ritorna la velocita’ corrente del baricentro. * * @return Velocita’ corrente del baricentro. *************************************************************************/

public final Vettore velocita() { return v; }

/************************************************************************** * Metodo di accesso: Ritorna il momento di inerzia rispetto all’asse * passato come parametro (il vettore indica la direzione dell’asse * passante per il baricentro). L’asse deve avere modulo maggiore di 0 e * deve essere espresso nelle coordinate relative del baricentro.

115

* * @param asse Asse rispetto a cui calcolare il momento di inerzia (deve * avere modulo maggiore di zero) nelle coordinate * relative del baricentro. * * @return Momento di inerzia rispetto all’asse. *************************************************************************/

public final float inerzia(Vettore asse) { // Precondizioni: if(asse.isZero()) throw new IllegalArgumentException();

float m = asse.modulo();

float x = asse.x()/m; float y = asse.y()/m; float z = asse.z()/m;

float i = x*x*inerzia.x() + y*y*inerzia.y() + z*z*inerzia.z();

// Postcondizioni: if(i == 0f) throw new InternalError();

return i; }

/************************************************************************** * Metodo di accesso: Ritorna il momento di inerzia rispetto all’asse * di orientamento corrente del baricentro. * * @return Momento di inerzia rispetto all’asse corrente. *************************************************************************/

public final float inerzia() { return inerzia(orientamento().asse()); }

/************************************************************************** * Metodo di accesso: Ritorna l’orientamento corrente del baricentro. * * @return Orientamento corrente del baricentro. *************************************************************************/

public final Rotazione orientamento() { return pa; }

/************************************************************************** * Metodo di accesso: Ritorna la velocita’ angolare corrente del * baricentro. La velocita’ angolare e’ un vettore e non una rotazione, * perche’ in una rotazione l’angolo di rotazione e’ un numero compreso * tra 0 e 2 pigreco, mentre la velocita’ angolare puo’ assumere * un valore qualsiasi. * * @return Vettore che rappresenta la velocita’ angolare del baricentro. * La direzione del vettore indica l’asse di rotazione e il * suo modulo la velocita’ angolare. *************************************************************************/

public final Vettore velocitaAngolare() { return va; }

/************************************************************************** * Metodo privato: Ritorna l’accelerazione che la forza passata come

116

* parametro causa sul corpo. * * @param forza Forza applicata al baricentro nelle coordinate relative * del baricentro. * * @return Accelerazione generata. *************************************************************************/

private Vettore accelerazione(Vettore forza) { return forza.divisione(massa()); }

/************************************************************************** * Metodo privato: Ritorna l’accelerazione angolare che il momento * passato come parametro causa sul corpo. * * @param momento Momento applicato al baricentro nelle coordinate * relative del baricentro. * * @return Accelerazione angolare generata. *************************************************************************/

private Vettore accelerazioneAngolare(Vettore momento) { return momento.isZero() ? Vettore.o : momento.divisione(inerzia(momento)); }

/************************************************************************** * Modificatore: Aggiorna la posizione e velocita’ del baricentro * nell’istante corrente (t) in funzione della forza e momento risultanti * applicati all’istante precedente (t-dt). Le formule di aggiornamento * sono ESATTE per forza e momento costanti nel tempo, altrimenti sono * solo delle approssimazioni tanto piu’ precise quanto piu’ dt e’ * piccolo. * I nuovi valori di posizione e velocita’ sono calcolati in base ai valori * ritornati dai metodi accelerazione e acelerazioneAngolare. * * @param dt Intervallo fra i due istanti di tempo considerati. * @param forza Risultante delle forze applicate al baricentro. * @param momento Risultante dei momenti applicati al baricentro. *************************************************************************/

public void aggiorna(float dt, Vettore forza, Vettore momento) { // Aggiorna posizione e velocita’ lineari. Vettore a = accelerazione(forza); p = p.somma(v, dt).somma(a, 0.5f*dt*dt); v = v.somma(a, dt);

// Aggiorna posizione e velocita’ angolari. Vettore aa = accelerazioneAngolare(momento); pa = pa.composizione(va, dt).composizione(aa, 0.5f*dt*dt); va = va.somma(aa, dt);

// Se non normalizzo la rotazione e’ possibile che il suo asse si // avvicini al vettore identicamente nullo dando luogo a errori di // approssimazione, dunque e’ meglio normalizzare sempre. pa.normalizza(); }

/************************************************************************** * Modificatore: I due baricentri in ingresso sono supposti avere urtato * fra loro. Questo metodo calcola le nuove velocita’ derivanti dall’urto. * I due baricentri devono avere posizioni differenti, NON possono * coincidere. * Attenzione: lo stato di entrambi i baricentri in ingresso viene * ovviamente modificato.

117

* * [Nota]: I baricentri devono avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param b1 Primo baricentro in urto. * @param b2 Secondo baricentro in urto. * @param k 0 <= k <= 1 dove k = 0 per un urto perfettamente anelastico * e k = 1 per un urto perfettamente elastico. *************************************************************************/

public static void urto(Baricentro b1, Baricentro b2, float k) { // Precondizioni: if((k < 0f) || (k > 1f)) throw new InternalError();

// d e’ il vettore che va da b2 a b1 proiettato sul piano x-z. Vettore d = new Vettore( b1.posizione().x() - b2.posizione().x(), 0f, b1.posizione().z() - b2.posizione().z() );

if(d.isZero()) throw new InternalError();

// Velocita’ relativa del primo baricentro rispetto al secondo // proiettata sul piano x-z. Vettore vr = new Vettore( b1.velocita().x() - b2.velocita().x(), 0f, b1.velocita().z() - b2.velocita().z() );

// Se i due corpi si stanno allontanando allora non e’ un urto reale // e non modifico le velocita’. if(vr.scalare(d) >= 0f) return;

// Matrici di rototraslazione che mi portano le velocita’ dei // baricentri da un riferimento solidale con la linea d’urto // proiettata sul piano x-z a quello assoluto e viceversa. // L’asse z e’ la linea che congiunge i due baricentri (da b2 a b1), // l’asse y coincide con l’asse y del riferimento assoluto. Rototraslazione r01 = new Rototraslazione( Vettore.j.vettore(d), Vettore.j, d, Vettore.o ); Rototraslazione r10 = r01.inversa();

//* * * Calcolo delle velocita’ lineari dei baricentri * * *

// Velocita’ in coordinate relative prima dell’urto (pedice a). Vettore v1a = r10.rototrasla(b1.velocita()); Vettore v2a = r10.rototrasla(b2.velocita());

float m1 = b1.massa(); float m2 = b2.massa();

// Velocita’ in coordinate relative dopo l’urto (pedice b). Vettore v1b; Vettore v2b;

if(b1 instanceof BaricentroFisso) { v1b = Vettore.o; v2b = v2a.prodotto(-k); } else if (b2 instanceof BaricentroFisso)

118

{ v1b = v1a.prodotto(-k); v2b = Vettore.o; } else { v1b = new Vettore( v1a.x(), v1a.y(), ((m1 - k*m2)*v1a.z() + (m2 + k*m2)*v2a.z())/(m1 + m2) );

v2b = new Vettore( v2a.x(), v2a.y(), ((m1 + k*m1)*v1a.z() + (m2 - k*m1)*v2a.z())/(m1 + m2) ); }

// * * * Calcolo delle velocita’ angolari dei baricentri * * *

// Componenti y delle velocita’ angolari in coordinate // relative prima dell’urto (pedice a). Vettore va1a = b1.velocitaAngolare(); Vettore va2a = b2.velocitaAngolare();

// Masse contentrate nel centro di percossa. float j1 = (v1a.isZero()) ? 0f : m1/(1 + b1.inerzia()*va1a.modulo2()/(m1*v1a.modulo2())); float j2 = (v2a.isZero()) ? 0f : m2/(1 + b2.inerzia()*va2a.modulo2()/(m2*v2a.modulo2()));

// Velocita’ assolute (traslazione + rotazione) nel centro di percossa // in coordinate relative prima dell’urto (pedice a). float vv1ax = v1a.x() + va1a.y()*d.modulo()/2f; float vv2ax = v2a.x() - va2a.y()*d.modulo()/2f;

// Velocita’ assolute nel centro di percossa in coordinate relative // dopo l’urto (pedice b). float vv1bx; float vv2bx;

if(b1 instanceof BaricentroFisso) { vv1bx = 0f; vv2bx = -vv2ax*k; } else if (b2 instanceof BaricentroFisso) { vv1bx = -vv1ax*k; vv2bx = 0f; } else { vv1bx = ((j1 - k*j2)*vv1ax + (j2 + k*j2)*vv2ax)/(j1 + j2); vv2bx = ((j1 + k*j1)*vv1ax + (j2 - k*j1)*vv2ax)/(j1 + j2); }

// Velocita’ angolari in coordinate relative dopo l’urto (pedice b). Vettore va1b = new Vettore(0f, 2f*(v1b.x() - vv1bx)/d.modulo(), 0f); Vettore va2b = new Vettore(0f, -2f*(v2b.x() - vv2bx)/d.modulo(), 0f);

// Aggiorno le velocita’ dei baricentri. b1.v = r01.rototrasla(v1b); b2.v = r01.rototrasla(v2b);

b1.va = va1b; b2.va = va2b; }

119

//*************************************************************************

}

//*****************************************************************************

120

/****************************************************************************** * Classe BaricentroAttrito (estende Baricentro) * * Costruttori: * BaricentroAttrito (Vettore p, Vettore pa, float massa, Vettore inerzia, * float cas, float cad, float cam) *****************************************************************************/ package server.fisica; import server.geometria.Vettore; import server.geometria.Rotazione; import server.fisica.Baricentro; /****************************************************************************** * Questa classe descrive un baricentro sottoposto alle forze di attrito. * * @version 1.00 * @date 3 Ottobre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class BaricentroAttrito extends Baricentro {

/** Coefficiente di attrito statico. */ private final float cas;

/** Coefficiente di attrito dinamico. */ private final float cad;

/** Fattore moltiplicativo per ottenere i coefficienti di attrito di momento da quelli di forza. */ private final float cam;

/************************************************************************** * Costruttore: Costruisce un nuovo baricentro sottoposto a forze di * attrito e inizialmente fermo. * * @param p Posizione inziale del baricentro. * @param pa Orientamento iniziale del baricentro. * @param massa Massa del baricentro (maggiore di zero). * @param inerzia Tensore di inerzia del baricentro. * @param cas Coefficiente di attrito statico (non negativo). * @param cad Coefficiente di attrito dinamico (non maggiore di cas). * @param cam Fattore correttivo per ottenere i coefficienti * di attrito relativi ai momenti da quelli relativi * alle forze. *************************************************************************/

public BaricentroAttrito(Vettore p, Rotazione pa, float massa, Vettore inerzia, float cas, float cad, float cam) { super(p, pa, massa, inerzia);

if(cad < 0f) throw new IllegalArgumentException(); if(cas < cad) throw new IllegalArgumentException(); if(cam < 0f) throw new IllegalArgumentException();

this.cas = cas; this.cad = cad; this.cam = cam; }

/************************************************************************** * Modificatore: Aggiorna la posizione e velocita’ del baricentro * nell’istante corrente (t) in funzione della forza e momento risultanti * applicati all’istante precedente (t-dt). * * [Nota]: Il baricentro deve avere orientamento parallelo a y cosi’ da

121

* disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param dt Distanza fra i due istanti di tempo considerati. * @param forza Risultante delle forze applicate al baricentro. * @param momento Risultante dei momenti applicati al baricentro. *************************************************************************/

public void aggiorna(float dt, Vettore forza, Vettore momento) { // Forze di attrito statico e dinamico che agiscono sul corpo. float fas = cas * (massa()*Baricentro.g - forza.y()); float fad = cad * (massa()*Baricentro.g - forza.y());

if(velocita().isZero()) { // Se il corpo e’ fermo e la forza e’ superiore a fas il corpo // comincia a muoversi altrimenti resta fermo. if(forza.modulo() > fas) forza = forza.sottrazione(forza.normalizzato(fad)); else forza = Vettore.o; } else { // Se il corpo e’ in moto l’attrito fad lo rallenta fino a // fermarlo e senza mai invertire la direzione della velocita’. if(velocita().modulo() > fad*dt/massa()) forza = forza.sottrazione(velocita().normalizzato(fad)); else forza = forza.sottrazione(velocita().prodotto(massa()/dt)); }

// Momenti di attrito statico e dinamico che agiscono sul corpo. float mas = cam*fas; float mad = cam*fad;

if(velocitaAngolare().isZero()) { // Se il corpo e’ fermo e il momento e’ superiore a mas il corpo // comincia a ruotare altrimenti resta fermo. if(momento.modulo() > mas) momento = momento.sottrazione(momento.normalizzato(mad)); else momento = Vettore.o; } else { // Se il corpo e’ in movimento rotatorio l’attrito mad lo rallenta // fino a fermarlo ma senza mai invertire la direzione della // velocita’ angolare. float jmm = inerzia(orientamento().asse()/*velocitaAngolare()*/);

if(velocitaAngolare().modulo() > mad*dt/jmm) momento = momento .sottrazione(velocitaAngolare() .normalizzato(mad)); else momento = momento .sottrazione(velocitaAngolare() .prodotto(jmm/dt)); } super.aggiorna(dt, forza, momento); } //************************************************************************* }

122

/****************************************************************************** * Classe BaricentroAttritoDirezionale (estende Baricentro) * * Costruttori: * BaricentroAttritoDirezionale(Vettore p, Rotazione pa, * float massa, Vettore inerzia, * float raggio, float cav) *****************************************************************************/ package server.fisica; import server.geometria.*; import server.fisica.Baricentro; /****************************************************************************** * Questa classe descrive un baricentro di un corpo dotato di ruote. Il corpo * puo’ spostarso solo lungo l’asse perpendicolare all’asse delle ruote e puo’ * ruotare solo attorno all’asse perpendicolare ai due precedenti. * * @version 1.00 * @date 3 Ottobre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class BaricentroAttritoDirezionale extends Baricentro {

/** Coefficiente di attrito di rotolamento. */ private final float cav;

/** Distanza fra le ruote del corpo [m]. */ private final float diametro;

/** Raggio delle ruote su cui rotola il corpo [m]. */ private final float raggio;

/************************************************************************** * Costruttore: Costruisce un nuovo baricentro sottoposto a forze di * attrito direzionali e inizialmente fermo. * * @param p Posizione inziale del baricentro. * @param pa Orientamento iniziale del baricentro. * @param massa Massa del baricentro (maggiore di zero). * @param inerzia Tensore di inerzia del baricentro. * @param diametro Distanza fra le ruote del corpo (> 0). * @param raggio Raggio delle ruote su cui rotola il corpo (> 0). * @param cav Coefficiente di attrito viscoso (>= 0). *************************************************************************/

public BaricentroAttritoDirezionale(Vettore p, Rotazione pa, float massa, Vettore inerzia, float diametro, float raggio, float cav) { super(p, pa, massa, inerzia);

if(cav < 0f) throw new IllegalArgumentException(); if(diametro <= 0f) throw new IllegalArgumentException(); if(raggio <= 0f) throw new IllegalArgumentException();

this.cav = cav; this.diametro = diametro; this.raggio = raggio; }

/************************************************************************** * Modificatore: Aggiorna la posizione e velocita’ del baricentro * nell’istante corrente (t) in funzione della forza e momento risultanti * applicati all’istante precedente (t-dt). *

123

* [Nota]: Il baricentro deve avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param dt Distanza fra i due istanti di tempo considerati. * @param forza Risultante delle forze applicate al baricentro. * @param momento Risultante dei momenti applicati al baricentro. *************************************************************************/

public void aggiorna(float dt, Vettore forza, Vettore momento) { if(dt == 0f) return;

// Della forza in ingresso viene conservata solo la componente // lungo l’asse delle x nel riferimento solidale col baricentro. Rototraslazione rt = new Rototraslazione(orientamento()); Rototraslazione rti = rt.inversa();

Vettore vr = rti.rototrasla(velocita()); Vettore var = rti.rototrasla(velocitaAngolare()); float frx = rti.rototrasla(forza).x(); float mry = rti.rototrasla(momento).y();

// Forze di attrito viscoso che agiscono sul corpo. float fav = 0.5f*cav*(massa()*Baricentro.g - forza.y())/raggio;

// Se il corpo e’ in moto l’attrito fad lo rallenta fino a // fermarlo e senza mai invertire la direzione della velocita’. if(velocita().modulo() > fav*dt/massa()) frx -= fav; else frx -= velocita().modulo() * massa()/dt;

// Momenti di attrito viscoso che agiscono sulo corpo. float mav = fav*diametro; float jmm = (velocitaAngolare().modulo() > 0f) ? inerzia(orientamento().asse()/*velocitaAngolare()*/) : 0;

// Se il corpo e’ in movimento rotatorio l’attrito mad lo rallenta // fino a fermarlo ma senza mai invertire la direzione della // velocita’ angolare. if(velocitaAngolare().modulo() * jmm > mav*dt) mry -= mav; else mry -= velocitaAngolare().modulo() * jmm/dt;

// Forze risultanti applicate al robot in coordinate relative. // Sommo alle forze/momenti altre forze/momenti tali da annulare le // componenti y e z relative della velocita’ e le componenti x e // z relative della velocita’ angolare. Vettore fr = new Vettore( frx, -vr.y()*massa()/dt, -vr.z()*massa()/dt );

Vettore mr = new Vettore( -var.x()*jmm/dt, mry, -var.z()*jmm/dt );

// Aggiorno trasformando le forza e momenti in coordinate assolute. super.aggiorna(dt, rt.rototrasla(fr), rt.rototrasla(mr)); } //************************************************************************* }

124

$��� ,O�SDFNDJH�FRUSL�Qui sono contenuti tutti gli oggetti che rappresentano dei corpi fisici: c’è la classe

&RUSR, da cui sono ereditate &DVVD, 3DUHWH, 5RERW0RELOH, e altre ancora. Ognuno di

questi oggetti rappresenta un corpo fisico che può prendere parte alla simulazione.

Queste classi non dispongono di particolari metodi, sono infatti dei semplici conteni-

tori composti ciascuno da una classe %DULFHQWUR e da una classe 9ROXPH, che insieme

caratterizzano completamente le proprietà del corpo. Ogni corpo ha anche un nome,

che viene usato all’interno del simulatore come chiave per distinguere ed ordinare

tutti i corpi.

Di seguito è allegato il codice sorgente delle classi &RUSR e 5RERW0RELOH.

125

/****************************************************************************** * Classe Corpo * * metodi statici: * String colore (float r, float g, float b) * String texture (String) * * Costruttori: * Corpo (String, Baricentro, Volume, String vrml) * Corpo (Baricentro, Volume, String vrml) * * Metodi di accesso: * * final String nome () * final Baricentro baricentro () * final Volume volume () * final String vrml () * final String colore () * * Modificatori: * void aggiorna (float dt, Vettore forza, Vettore momento) *****************************************************************************/ package server.corpi; import server.fisica.Baricentro; import server.geometria.Vettore; import server.geometria.Rotazione; import server.geometria.Volume; /****************************************************************************** * La classe Corpo rappresenta un qualsiasi oggetto immerso nel mondo fisico. * E’ composta da un baricentro che riflette tutti gli aspetti fisici del * corpo e da un volume che riflette tutti gli aspetti geometrici. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class Corpo {

// Queste costanti definiscono i vari aspetti con cui il corpo puo’ // apparire a video nella pagina vrml. Possono essere sia semplici // colori che texture. public static final String COLORE_ROSSO = colore( 1, 0, 0); public static final String COLORE_VERDE = colore( 0, 1, 0); public static final String COLORE_GIALLO = colore( 1, 1, 0); public static final String COLORE_BLU = colore( 0, 0, 1); public static final String COLORE_BIANCO = colore( 1, 1, 1); public static final String COLORE_GRIGIO = colore(0.7f, 0.7f, 0.7f); public static final String COLORE_NERO = colore( 0, 0, 0);

public static final String TEXTURE_LEGNO = texture("texture/legno.jpg"); public static final String TEXTURE_INTONACO = texture("texture/Cardbrd2.jpg"); public static final String TEXTURE_MATTONI = texture("texture/mattoni.jpg");

private final String nome; private final Baricentro baricentro; private final Volume volume; private final String vrml; private final String colore;

/************************************************************************** * Costruttore: Crea un nuovo corpo specificando il tipo di baricentro e * di volume. La posizione e orientamento dell’oggetto sono quelle del * baricentro, NON quelle del volume, che vengono ignorate e riassegnate. * * @param nome Nome logico da assegnare all’oggetto (se e’ un robot * puo’ essere il nome del robot).

126

* @param baricentro Descrizione fisica del corpo (compresa la posizione). * @param volume Forma del corpo (esclusa la posizione). * @param vrml Descrizione vrml del corpo (esclusa la posizione: il * corpo vrml deve essere centrato nel suo * baricentro). * @param colore Una delle costanti definite in questa classe per * caratterizzare l’aspetto del corpo a video. *************************************************************************/

public Corpo(String nome, Baricentro baricentro, Volume volume, String vrml,

String colore) { // Precondizioni: if(nome == null) throw new IllegalArgumentException();

this.nome = nome; this.baricentro = baricentro; this.volume = volume; this.vrml = vrml; this.colore = colore;

volume.setPosizione (baricentro.posizione()); volume.setOrientamento(baricentro.orientamento()); }

/************************************************************************** * Metodo statico: Costruisce una stringa vrml per impostare sul corpo un * colore corrispondente alle componenti passate come parametro. * * @param r Componente rossa del colore (compresa fra 0 e 1). * @param g Componente verde del colore (compresa fra 0 e 1). * @param b Componente blu del colore (compresa fra 0 e 1). * * @return Stringa contenente la descrizione vrml dell’aspetto del corpo. *************************************************************************/

public static String colore(float r, float g, float b) { return "material Material { diffuseColor " + r + " " + g + " " + b + " }"; }

/************************************************************************** * Metodo statico: Costruisce una stringa vrml per impostare sul corpo una * texture corrispondente all’immagine identificata dal nome di file * passato come parametro. * * @param percorso Nome di un file immagine. * * @return Stringa contenente la descrizione vrml dell’aspetto del corpo. *************************************************************************/

public static String texture(String percorso) { return "texture ImageTexture { url \"" + percorso + "\" repeatS TRUE }"; }

/************************************************************************** * Metodo di accesso: Ritorna il nome del corpo. * * @return Nome del corpo. *************************************************************************/

public final String nome() { return nome; }

127

/************************************************************************** * Metodo di accesso: Ritorna il baricentro del corpo. * * @return Baricentro del corpo. *************************************************************************/

public final Baricentro baricentro() { return baricentro; }

/************************************************************************** * Metodo di accesso: Ritorna il volume geometrico del corpo. * * @return Volume del corpo. *************************************************************************/

public final Volume volume() { return volume; }

/************************************************************************** * Metodo di accesso: Ritorna la descrizione vrml del corpo. * * @return Descrizione vrml del corpo. *************************************************************************/

public final String vrml() { return vrml; }

/************************************************************************** * Metodo di accesso: Ritorna il colore del corpo. * * @return Colore del corpo. *************************************************************************/

public final String colore() { return colore; }

/************************************************************************** * Modificatore: Aggiorna la posizione e velocita’ del corpo * nell’istante corrente (t) in funzione della forza e momento risultanti * applicati all’istante precedente (t-dt). * * @param dt Distanza fra i due istanti di tempo considerati. * @param forza Risultante delle forze applicate al baricentro. * @param momento Risultante dei momenti applicati al baricentro. *************************************************************************/

public void aggiorna(float dt, Vettore forza, Vettore momento) { baricentro.aggiorna(dt, forza, momento);

volume.setPosizione (baricentro.posizione()); volume.setOrientamento(baricentro.orientamento()); }

//************************************************************************* }

//*****************************************************************************

128

/****************************************************************************** * Classe RobotMobile (estende Corpo) * * Costruttori: * RobotMobile (String nome, Vettore p, Rotazione pa, * float massa, * Vettore inerzia, * Volume volume, * float lunghezzaAsse, * float raggioRuote, * float cav, * String vrml, * SensoreDistanza[] sensoriDistanza, * SensoreColore[] sensoriColore, * SensoreContatto sensoreContatto, * SensoreRadio sensoreRadio, * Controllore controllore, * String colore) * Modificatori: * void setCoppiaRuotaDx (float) * void setCoppiaRuotaSx (float) * void aggiorna (float, Vettore, Vettore) * * Metodi di accesso: * float raggioRuote () * float lunghezzaAsse () * SensoreDistanza[] sensoriDistanza () * SensoreColore[] sensoriColore () * SensoreContatto sensoreContatto () * SensoreRadio sensoreRadio () * Controllore controllore () * Mappa mappa () *****************************************************************************/ package server.corpi; import server.controllo.*; import server.fisica.*; import server.geometria.*; import server.sensori.*; import server.mondo.Mappa; /****************************************************************************** * Questo oggetto rappresenta una robot mobile dotato di due ruote motorizzate. * Il robot sterza applicando velocita’ angolari alle sue due ruote. Inoltre il * robot e’ dotato di un controllore che ne puo’ regolare il movimento. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class RobotMobile extends Corpo {

private final float lunghezzaAsse; // [m]. private final float raggioRuote; // [m].

// Sensori montati sul robot divisi per categoria. private final SensoreDistanza[] sensoriDistanza; private final SensoreColore[] sensoriColore; private final SensoreContatto sensoreContatto; private final SensoreRadio sensoreRadio;

/** Sistema di controllo del robot. */ private final Controllore controllore;

private final Mappa mappa;

/** Coppia applicata dal motore della ruote sinistra [N*m]. */ private float coppiaRuotaSx = 0f;

129

/** Coppia applicata dal motore della ruote destra [N*m]. */

private float coppiaRuotaDx = 0f;

/************************************************************************** * Costruttore: Costruisce un nuovo robot con due ruote allineate su un * asse passante per il baricentro e mosse da due motori indipendenti. * * @param nome Nome identificativo del robot. * @param p Posizione inziale del baricentro del robot. E’ * importante assegnare la posizione iniziale * perche’ il robot si puo’ spostare solo * seguendo le leggi fisiche. * @param pa Orientamento iniziale del robot. E’ importante * importante assegnare l’orientamento iniziale * perche’ il robot si puo’ spostare solo * seguendo le leggi fisiche. * @param massa Massa del robot (> 0). * @param inerzia Tensore d’inerzia del robot (valori positivi). * @param volume Forma del corpo (esclusa la posizione). * @param lunghezzaAsse Lunghezza dell’asse che collega le due ruote * del robot, ovvero distanza fra le due ruote * (> 0). * @param raggioRuote Raggio delle ruote del robot (> 0). * @param cav Coefficiente di attrito di rotolamento delle ruote * (>= 0). * @param vrml Descrizione vrml del corpo (esclusa la posizione: * il corpo vrml deve essere centrato nel suo * baricentro). * @param sensoriDistanza Array dei sensori di distanza montati sul * robot. * @param sensoriDistanza Array dei sensori di colore montati sul * robot. * @param sensoreContatto Sensore di contatto montato sul robot (o null * se il robot non lo monta). * @param sensoreRadio Sensore di contatto montato sul robot (o null * se il robot non lo monta). * @param controllore Sistema di controllo del robot. * @param colore Una delle costanti definite in Corpo per * caratterizzare l’aspetto del robot a video. *************************************************************************/

public RobotMobile(String nome, Vettore p, Rotazione pa, float massa, Vettore inerzia, Volume volume, float lunghezzaAsse, float raggioRuote, float cav, String vrml, SensoreDistanza[] sensoriDistanza, SensoreColore[] sensoriColore, SensoreContatto sensoreContatto, SensoreRadio sensoreRadio, Controllore controllore, String colore) { super( nome, new BaricentroAttritoDirezionale( p, pa, massa, inerzia, lunghezzaAsse, raggioRuote, cav ), volume, vrml, colore );

130

// Precondizioni:

if(lunghezzaAsse <= 0f) throw new IllegalArgumentException(); if(raggioRuote <= 0f) throw new IllegalArgumentException();

if(sensoriDistanza != null) for(int i = 0; i < sensoriDistanza.length; ++i) if(sensoriDistanza[i] != null) sensoriDistanza[i].setCorpo(this);

if(sensoriColore != null) for(int i = 0; i < sensoriColore.length; ++i) if(sensoriColore[i] != null) sensoriColore[i].setCorpo(this);

if(sensoreContatto != null) sensoreContatto.setCorpo(this); if(sensoreRadio != null) sensoreRadio .setCorpo(this); if(controllore != null) controllore .setRobot(this);

this.lunghezzaAsse = lunghezzaAsse; this.raggioRuote = raggioRuote; this.controllore = controllore; this.sensoriDistanza = sensoriDistanza; this.sensoriColore = sensoriColore; this.sensoreContatto = sensoreContatto; this.sensoreRadio = sensoreRadio; this.mappa = new Mappa(300, 300, 0.1f, 0.1f/*,nome*/); }

/************************************************************************** * Modificatore: Imposta la coppia che il motore della ruota sinistra deve * applicare alla ruota. Attraverso questo metodo il controllore esercita * la sua azione di controllo. * * @param valore Coppia da applicare alla ruota sinistra [N*m]. *************************************************************************/

public final void setCoppiaRuotaSx(float valore) { coppiaRuotaSx = valore; }

/************************************************************************** * Modificatore: Imposta la coppia che il motore della ruota destra deve * applicare alla ruota. Attraverso questo metodo il controllore esercita * la sua azione di controllo. * * @param valore Coppia da applicare alla ruota destra [N*m]. *************************************************************************/

public final void setCoppiaRuotaDx(float valore) { coppiaRuotaDx = valore; }

/************************************************************************** * Metodo di accesso: Ritorna la distanza fra le due ruote del robot [m]. * * @return Distanza fra le ruote del robot [m]. *************************************************************************/

public final float lunghezzaAsse() { return lunghezzaAsse; }

/************************************************************************** * Metodo di accesso: Ritorna il raggio delle ruote del robot [m]. * * @return Raggio delle ruote [m].

131

*************************************************************************/

public final float raggioRuote() { return raggioRuote; }

/************************************************************************** * Metodo di accesso: Ritorna il controllore del robot. * * @return Controllore del robot. *************************************************************************/

public final Controllore controllore() { return controllore; }

/************************************************************************** * Metodo di accesso: Ritorna tutti i sensori di distanza montati sul * robot. * * @return Array dei sensori montati sul robot. *************************************************************************/

public final SensoreDistanza[] sensoriDistanza() { return sensoriDistanza; }

/************************************************************************** * Metodo di accesso: Ritorna tutti i sensori di colore montati sul robot. * * @return Array dei sensori montati sul robot. *************************************************************************/

public final SensoreColore[] sensoriColore() { return sensoriColore; }

/************************************************************************** * Metodo di accesso: Ritorna il sensore di contatto montato sul robot o * null se non ne monta. * * @return Sensore di contatto montato sul robot o null se non ne monta. *************************************************************************/

public final SensoreContatto sensoreContatto() { return sensoreContatto; }

/************************************************************************** * Metodo di accesso: Ritorna il sensore radio montato sul robot o * null se non ne monta. * * @return Sensore radio montato sul robot o null se non ne monta. *************************************************************************/

public final SensoreRadio sensoreRadio() { return sensoreRadio; }

/************************************************************************** * Metodo di accesso: Ritorna la mappa memorizzata dal robot * * @return mappa

132

*************************************************************************/

public final Mappa mappa() { return mappa; }

/************************************************************************** * Modificatore: Aggiorna la posizione e velocita’ del baricentro * nell’istante corrente (t) in funzione della forza e momento risultanti * applicati all’istante precedente (t-dt). * * [Nota]: Il robot deve avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. * * @param dt Distanza fra i due istanti di tempo considerati. * @param forza Risultante delle forze applicate al baricentro. * @param momento Risultante dei momenti applicati al baricentro. *************************************************************************/

public void aggiorna(float dt, Vettore forza, Vettore momento) { aggiornaMappa();

// Imposto l’azione di controllo determinata dal controllore. controllore.setAzioneControllo();

// Dalle coppie dei motori applicate all’asse delle ruote calcolo // le forze applicate agli estremi dell’asse. float forzaSx = coppiaRuotaSx / raggioRuote; float forzaDx = coppiaRuotaDx / raggioRuote;

// Calcolo forza e momento risultanti dalle due forze precedenti // applicate al baricentro nel riferimento relativo del baricentro. Vettore fr = new Vettore(forzaSx - forzaDx, 0, 0); Vettore mr = new Vettore(0, -(forzaDx + forzaSx) * lunghezzaAsse/2f, 0); Rototraslazione rot = new Rototraslazione(baricentro().orientamento());

// Sommo alla forza e momento quelle finali risultanti dai motori // nel sistema di riferimento corretto. forza = forza .somma(rot.rototrasla(fr)); momento = momento.somma(rot.rototrasla(mr));

super.aggiorna(dt, forza, momento); }

/************************************************************************** * Modificatore: Aggiorna la mappa interna del robot leggendo i dati dai * sensori di distanza. *************************************************************************/

public void aggiornaMappa() { for(int i = 0; i < sensoriDistanza.length; ++i) mappa.aggiorna(sensoriDistanza[i]); }

//************************************************************************* }

//*****************************************************************************

133

$��� ,O�SDFNDJH�FRQWUROOR�In questo package sono contenute le classi che costituiscono i sistemi di controllo

per i robot; tutte le classi derivano dalla classe astratta &RQWUROORUH. Sono presenti le

classi &RQWUROORUH9HORFLWD'LUH]LRQH, &RQWUROORUH3RVL]LRQH, &RQWUROORUH,QVHJXLWRUH e

&RQWUROORUH%HKDYLRU. In questo package è inclusa anche la classe 0DSSD, che i robot

usano per memorizzare le informazioni sull’ambiente circostante che ricevono dai

sensori.

Di seguito è allegato il codice sorgente delle classi &RQWUROORUH, &RQWUROORUH3RVL]LR�QH e 0DSSD.

134

/****************************************************************************** * Classe astratta Controllore * * Metodi di accesso: * abstract String nome () * abstract int tipo () * Modificatori: * abstract void setRobot (RobotMobile) * abstract void setAzioneControllo () *****************************************************************************/ package server.controllo; import server.corpi.RobotMobile; /****************************************************************************** * Controllore di un robot mobile. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public abstract class Controllore {

/************************************************************************** * Metodo astratto: Ritorna il nome del controllore (ad esempio: * "Behavior" o "Posizione". * * @return Nome del controllore. *************************************************************************/

public abstract String nome();

/************************************************************************** * Metodo astratto: Ritorna il tipo di controllore (una delle costanti * definite in comune.Richiesta del tipo "CONTROLLORE_"). * * @return Tipo di controllore. *************************************************************************/

public abstract String tipo();

/************************************************************************** * Metodo astratto: Imposta il robot che deve venire controllato. La * chiamata a questo metodo causa il reset interno di tutte le variabili * di stato del controllore compresi i valori dei riferimenti da far * seguire al robot. * Questo metodo deve essere chiamato una e una sola volta per * inizializzare il controllore. * * @param robot Robot da controllare. *************************************************************************/

public abstract void setRobot(RobotMobile robot);

/************************************************************************** * Metodo astratto: Esercita l’azione di controllo sul robot controllato. *************************************************************************/

public abstract void setAzioneControllo();

//************************************************************************* }

//*****************************************************************************

135

/****************************************************************************** * Classe ControllorePosizione (estende Controllore) * * Costruttori: * ControllorePosizione (float, float) * * Modificatori: * void setPosizione (Vettore) * *****************************************************************************/ package server.controllo; import server.geometria.*; import server.corpi.RobotMobile; import server.sensori.SensoreDistanza; /****************************************************************************** * Controllore velocita’ direzione di un robot mobile. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class ControllorePosizione extends Controllore {

/** Dato un vettore "v" il vettore "v.prodotto(AZZERA_Y)" ha le stesse componenti x e z di v ma la sua componente y vale 0. */ private static final Vettore AZZERA_Y = new Vettore(1f, 0f, 1f);

private final String nome; private final ControlloreVelocitaDirezione controllore;

/** Peso di repulsione degli ostacoli. */ private final float alfa;

/** Peso di attrazione del goal. */ private final float beta;

private RobotMobile robot;

/** punto che il robot deve raggiungere [m]. */ private Vettore posizioneRif;

/************************************************************************** * Costruttore: Crea un controllore posizione/direzione. * * @param tempoControlloDistanza Costante di tempo per il controllo di * spostamento del robot (> 0) [s]. * @param tempoControlloDirezione Costante di tempo per il controllo di * rotazione del robot (> 0) [s]. * @param angoloMax Se l’angolo che il bersaglio forma con * l’asse del robot e’ maggiore di questa * quantita’ il controllo di distanza si * disattiva cosi’ che il robot ruoti * soltanto (fra 0 e PIGRECO) [rad]. * @param alfa Peso di repulsione degli ostacoli. * @param beta Peso di attrazionme del goal. *************************************************************************/

public ControllorePosizione(String nome, float tempoControlloDistanza, float tempoControlloDirezione, float angoloMax, float alfa, float beta) { this.nome = nome; this.controllore = new ControlloreVelocitaDirezione( nome,

136

tempoControlloDistanza, tempoControlloDirezione ); this.alfa = alfa; this.beta = beta; this.robot = null; this.posizioneRif = Vettore.o; }

/************************************************************************** * Costruttore: Crea un controllore posizione/direzione con pesi * predefiniti. * * @param tempoControlloDistanza Costante di tempo per il controllo di * spostamento del robot (> 0) [s]. * @param tempoControlloDirezione Costante di tempo per il controllo di * rotazione del robot (> 0) [s]. * @param angoloMax Se l’angolo che il bersaglio forma con * l’asse del robot e’ maggiore di questa * quantita’ il controllo di distanza si * disattiva cosi’ che il robot ruoti * soltanto (fra 0 e PIGRECO) [rad]. *************************************************************************/

public ControllorePosizione(String nome, float tempoControlloDistanza, float tempoControlloDirezione, float angoloMax) { this(nome, tempoControlloDistanza, tempoControlloDirezione, angoloMax, 1.8f, -0.4f); }

/************************************************************************** * Metodo implementato: Ritorna il nome del controllore. * * @return Nome del controllore. *************************************************************************/

public String nome() { return nome; }

/************************************************************************** * Metodo implementato: Ritorna il tipo di controllore (una delle costanti * definite in comune.Richiesta). * * @return Tipo di controllore. *************************************************************************/

public String tipo() { return comune.Richiesta.CONTROLLORE_POSIZIONE; }

/************************************************************************** * Metodo di acccesso: Ritorna la posizione di riferimento che il robot * deve raggiungere. * * @return Posizione che il robot deve raggiungere. *************************************************************************/

public final Vettore getPosizione() { return posizioneRif; }

/************************************************************************** * Modificatore: Imposta la posizione di riferimento che il robot

137

* deve raggiungere. La coordinata y del vettore in ingresso non viene * considerata. * * @param posizione Posizione che il robot deve raggiungere. *************************************************************************/

public final void setPosizione(Vettore posizione) { posizioneRif = posizione; }

/************************************************************************** * Metodo implementato: Imposta il robot che deve venire controllato. La * chiamata a questo metodo causa il reset interno di tutte le variabili * di stato del controllore compresi i valori dei riferimenti da far * seguire al robot. * I riferimenti vengono impostati ai valori attuali del robot cosi’ da * fare in modo che il robot resti inizialmente fermo. * * @param robot Robot da controllare. *************************************************************************/

public void setRobot(RobotMobile robot) { this.robot = robot; this.posizioneRif = robot.baricentro().posizione();

this.controllore.setRobot(robot); }

/************************************************************************** * Metodo implementato: Esercita l’azione di controllo sul robot * controllato. * * [Nota]: Il robot deve avere orientamento parallelo a y cosi’ da * disaccopiare lo studio di x e z da quello di y. Se questa ipotesi non * e’ verificata il metodo non funziona correttamente. *************************************************************************/

public void setAzioneControllo() { final SensoreDistanza[] sensore = robot.sensoriDistanza();

// Il vettore "goal" e’ la distanza del goal dal baricentro del robot. // Il vettore "repulsione" conterra’ alla fine la componente // attrattiva del goal piu’ tutte le componenti repulsive // dovute agli ostacoli. Di tutti i vettori viene eliminata la // componente lungo l’asse y. final Vettore goal = posizioneRif.sottrazione( robot.baricentro().posizione() ).prodotto(AZZERA_Y);

// Se il goal s’ gia’ stato raggiunto ferma il robot. if(goal.isZero()) { controllore.setVelocita(0f); controllore.setAzioneControllo();

return; }

Vettore repulsione = goal.normalizzato( (float)Math.pow(goal.modulo(), -beta));

// Ciclo per tutti i sensori di distanza montati sul robot. if(sensore != null) for(int i = 0; i < sensore.length; ++i) { final float distanza = sensore[i].distanza();

138

// Se il sensore ha rilevato un ostacolo aggiungo al vettore // repulsione la componente che deriva da questo. if(distanza + sensore[i].passo() < sensore[i].maxDist()) { final Vettore direzione = sensore[i] .rototraslazioneAssoluta() .rotazione() .direzione() .prodotto(AZZERA_Y);

// Nota: assumo che distanza sia sempre strettamente positiva // altrimenti nella formula seguente si ottiene infinito. Ma // poiche’ i sensori tornano sempre una distanza superiore // alla loro distanza minima (sempre > 0) non dovrebbero // mai esserci distanze nulle. repulsione = repulsione.sottrazione(direzione.normalizzato( (float)Math.pow(distanza, -alfa))); } }

// Imposto i riferimenti del controllore velocita’ direzione. // Nota: il controllore si aspetta un angolo antiorario rispetto // all’asse y, mentre atan2, essendo x diretta verso destra e z verso // il basso, torna un angolo con la convenzione opposta, per cui devo // passare -z anziche’ z. float velocita = Math.min(repulsione.modulo(), goal.modulo()); float direzione = (float)Math.atan2(-repulsione.z(), repulsione.x());

// Metto un limite alla massima velocita’ del robot. if(velocita > 1.5f) velocita = 1.5f;

controllore.setVelocita (velocita); controllore.setDirezione(direzione);

controllore.setAzioneControllo(); }

//************************************************************************* }

//*****************************************************************************

139

/****************************************************************************** * Classe Mappa * * Costruttori: * Mappa (int, int, float, float) * * Metodi di accesso: * long[][] toLongArray () * * Modificatori: * void aggiorna (SensoreDistanza) * void aggiorna (Mappa) *****************************************************************************/ package server.controllo; import server.sensori.SensoreDistanza; import server.geometria.*; //import java.io.*; /****************************************************************************** * Struttura con cui il robot memorizza le informazioni sull’ambiente che * riceve dai sensori. * * @version 1.00 * @date 4 Aprile 1999 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class Mappa {

public static final long INDETERMINATO = 0; public static final long OCCUPATO = -1; public static final long LIBERO = 1;

private final long[][] mappa; private final int larghezza; private final int altezza;

/** Vettore che converte l’unita’ di misura da metri a numero di celle: dato un vettore "v" misurato in metri il vettore "v.prodotto(scala)" sara’ lo stesso vettore misurato in numero di celle (la componente y verra’ azzerata perche’ la mappa e’ bidimensionale in x e z). */ private final Vettore scala;

/** Orologio interno della mappa per ricordare quanto tempo e’ passato dall’ultimo aggiornamento di una data cella. */ private long contatore;

/************************************************************************* * Costruttore : Crea una nuova mappa. * * @param larghezza Numero di celle orizzontali (> 0). * @param altezza Numero di celle verticali (> 0). * @param larghezzaCella Larghezza di una cella [m] (> 0). * @param altezzaCella Altezza di una cella [m] (> 0). *************************************************************************/

public Mappa(int larghezza, int altezza,float larghezzaCella, float altezzaCella) { if(larghezza <= 0) throw new IllegalArgumentException(); if(altezza <= 0) throw new IllegalArgumentException(); if(larghezzaCella <= 0f) throw new IllegalArgumentException(); if(altezzaCella <= 0f) throw new IllegalArgumentException();

this.mappa = new long[larghezza][altezza]; this.larghezza = larghezza; this.altezza = altezza;

140

this.scala = new Vettore(1f/larghezzaCella, 0f, 1f/altezzaCella); this.contatore = 1;

for(int x = 0; x < larghezza; ++x) for(int z = 0; z < altezza; ++z) mappa[x][z] = INDETERMINATO; }

/************************************************************************* * Modificatore: Aggiorna la mappa utilizzando i valori forniti da un * sensore di distanza. * * @param sensore Sensore da cui rilevare. *************************************************************************/

public synchronized void aggiorna(SensoreDistanza sensore) { final Rototraslazione r0s = sensore.rototraslazioneAssoluta();

// direzione = orientamento del sensore. // distanza = distanza dell’ostacolo rilevato. // stato = come segnare le caselle tra il sensore e l’ostacolo. final Vettore direzione = r0s.rotazione().direzione(); final float distanza = sensore.distanza(); final long stato = (distanza > sensore.passo() + sensore.minDist()) ? LIBERO : OCCUPATO;

// inizio = dove si trova il sensore, misurato in numero di celle. // fine = dove si trova l’ostacolo, misurato in numero di celle. final Vettore inizio = r0s.traslazione().prodotto(scala); final Vettore fine = direzione.normalizzato(distanza) .prodotto(scala) .somma(inizio); final float dx = fine.x() - inizio.x(); final float dz = fine.z() - inizio.z();

aggiornaCasella((int)inizio.x(), (int)inizio.z(), LIBERO);

// Segno tutte le caselle libere tra il sensore e l’ostacolo in // due cicli (uno per l’asse x e uno per l’asse z). if(dx != 0f) { final float m = dz/dx; final float q = inizio.z() - m*inizio.x(); final int start = (dx > 0f) ? (int)inizio.x() : (int)fine.x(); final int goal = (dx > 0f) ? (int)fine.x() : (int)inizio.x();

for(int x = goal; x > start; --x) { aggiornaCasella(x, (int)(m*x + q), stato); } }

if(dz != 0f) { final float m = dx/dz; final float q = inizio.x() - m*inizio.z(); final int start = (dz > 0f) ? (int)inizio.z() : (int)fine.z(); final int goal = (dz > 0f) ? (int)fine.z() : (int)inizio.z();

for(int z = goal; z > start; --z) { aggiornaCasella((int)(m*z + q), z, stato); } }

// Segno l’ostacolo se la distanza e’ minore della massima distanza // rilevabile dal sensore. if(distanza + sensore.passo() < sensore.maxDist())

141

{ aggiornaCasella((int)fine.x(), (int)fine.z(), OCCUPATO); }

// Incremento il contatore (avanza di una unita’ temporale). contatore++; }

/************************************************************************** * Modificatore: Fonde la mappa con quella passata come parametro (che * resta invece invariata). * * @param secondaMappa Mappa da confrontare. * * @exception IllegalArgumentException Generata se le due mappe hanno * un differente numero di caselle. *************************************************************************/

public synchronized void aggiorna(Mappa secondaMappa) { // Precondizioni: if(larghezza != secondaMappa.larghezza) throw new IllegalArgumentException(); if(altezza != secondaMappa.altezza) throw new IllegalArgumentException();

for(int x = 0; x < larghezza; ++x) { for(int z = 0; z < altezza; ++z) { long casella = secondaMappa.mappa[x][z];

if(casella != INDETERMINATO) { // t1 e t2 indicano quanto tempo e’ passato dagli ultimi // aggiornamenti della casella x, y nelle due mappe. long t1 = contatore - Math.abs(mappa[x][z]); long t2 = secondaMappa.contatore - Math.abs(casella);

if((mappa[x][z] == INDETERMINATO) || (t1 > t2)) { aggiornaCasella(x, z, (casella > 0) ? LIBERO : OCCUPATO); } } } }

contatore++; }

/************************************************************************** * Metodo a uso interno: Cambia lo stato di una casella della mappa. * * @param x Colonna della matrice. * @param z Riga della matrice. * @param stato Nuovo stato della casella (x, z). *************************************************************************/

private final void aggiornaCasella(int x, int z, long stato) { if((x < 0) || (x >= larghezza)) return; if((z < 0) || (z >= altezza)) return;

this.mappa[x][z] = stato*contatore; }

/************************************************************************** * Metodo di accesso: Converte la mappa in una matrice di long.

142

* * @return Matrice di long. *************************************************************************/

public final long[][] toLongArray() { long[][] array = new long[larghezza][altezza];

for(int x = 0; x < larghezza; ++x) for(int z = 0; z < altezza; ++z) array[x][z] = mappa[x][z];

return array; }

//************************************************************************* }

//*****************************************************************************

143

$��� ,O�SDFNDJH�PRQGR�La classe principale contenuta in questo package è la classe 0RQGR, una rappre-

sentazione virtuale del mondo reale che contiene e gestisce tutti gli oggetti della si-

mulazione. Tutti i corpi come 5RERW0RELOH, &DVVD o 3DUHWH, che prendono parte alla

simulazione devono essere inseriti nell’istanza di questa classe che è unica

nell’applicazione.

144

/****************************************************************************** * Classe Mondo * * Costruttori: * Mondo (Corpo[]) * * Modificatori: * void aggiorna (float dt) * * Metodi di accesso: * final Corpo getCorpo (String) * final String[] getNomi () * final String[] getNomiRobot () * final String[] getNomiCasse () * final String[] getNomiCorpiMobili () *****************************************************************************/ package server.mondo; import java.util.Hashtable; import java.util.Vector; import server.corpi.*; import server.geometria.*; import server.fisica.*; import server.util.BufferStringhe; /****************************************************************************** * Questa classe rappresenta il mondo in cui sono immersi tutti i corpi che * partecipano alla simulazione. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public abstract class Mondo {

/** Contiene tutti i corpi del mondo. */ private final Hashtable elencoCorpi;

/** Nomi di tutti i corpi contenuti nel mondo. */ private final String[] nomiCorpi;

/** Nomi di tutti i corpi mobili nel mondo. */ private final String[] nomiCorpiMobili;

/** Nomi di tutte le casse contenute nel mondo. */ private final String[] nomiCasse;

/** Nomi di tutti i robot contenuti nel mondo. */ private final String[] nomiRobot;

/************************************************************************** * Costruttore: Crea un mondo contenente tutti i corpi passati come * parametro. I corpi dell’array devono avere un nome diverso da tutti * gli altri, in modo che sia possibile identificarli univocamente. * * @param arrayCorpi Array di tutti i corpi da inserire nel mondo. * @param precisioneVettore Precisione con cui vanno gestiti i vettori. * @param precisioneRotazione Precisione con cui vanno gestite le * rotazioni. *************************************************************************/

public Mondo(Corpo[] arrayCorpi, float precisioneVettore, float precisioneRotazione) { // Imposto le precisioni. Vettore .setPrecisione(precisioneVettore); Rotazione.setPrecisione(precisioneRotazione);

145

BufferStringhe vettoreNomiCorpi = new BufferStringhe();

BufferStringhe vettoreNomiCorpiMobili = new BufferStringhe(); BufferStringhe vettoreNomiCasse = new BufferStringhe(); BufferStringhe vettoreNomiRobot = new BufferStringhe();

elencoCorpi = new Hashtable(arrayCorpi.length);

for(int i = 0; i < arrayCorpi.length; ++i) { Corpo corpo = arrayCorpi[i];

// I nomi dei corpi devono essere tutti differenti. if(elencoCorpi.containsKey(corpo.nome())) throw new IllegalArgumentException("Nome di corpo duplicato");

// Inserisco il corpo nella hashtable usando il suo nome // come chiave. elencoCorpi.put(corpo.nome(), corpo);

// Memorizzo il nome del corpo in tutti i vettori che // gli competono. vettoreNomiCorpi.add(corpo.nome()); if(!(corpo instanceof CorpoFisso)) vettoreNomiCorpiMobili.add(corpo.nome()); if(corpo instanceof Cassa) vettoreNomiCasse.add(corpo.nome());

if(corpo instanceof RobotMobile) vettoreNomiRobot.add(corpo.nome()); }

this.nomiCorpi = vettoreNomiCorpi .toArray(); this.nomiCorpiMobili = vettoreNomiCorpiMobili.toArray(); this.nomiCasse = vettoreNomiCasse .toArray(); this.nomiRobot = vettoreNomiRobot .toArray(); }

/************************************************************************** * Modificatore: Calcola l’evoluzione del mondo nell’intervallo di tempo * dt passato come parametro e aggiorna tutti i corpi contenuti. * * @param dt Intervallo di tempo. *************************************************************************/

public void aggiorna(float dt) { // Ciclo per tutti i corpi mobili e li aggiorno uno per uno. I corpi // fissi sono esclusi dall’aggiornamento poiche’ non si possono // muovere. for(int i = 0; i < nomiCorpiMobili.length; ++i) { Corpo c1 = getCorpo(nomiCorpiMobili[i]);

c1.aggiorna(dt, Vettore.o, Vettore.o);

// Rilevo le collisioni fra i corpi. In questo ciclo devono // essere compresi anche i corpi fissi. for(int j = 0; j < nomiCorpi.length; ++j) { Corpo c2 = getCorpo(nomiCorpi[j]);

if(c1 != c2) { int intersezione = Volume.intersezione(c1.volume(), c2.volume());

switch(intersezione) {

146

case Volume.INTERSECA: case Volume.CONTIENE: case Volume.CONTENUTO: Baricentro.urto(c1.baricentro(), c2.baricentro(), 0.8f); break;

default: case Volume.NON_INTERSECA: break;

case Volume.INDETERMINATO: throw new InternalError(); } } } } }

/************************************************************************** * Metodo di accesso: Ritorna il corpo corrispondente al nome passato * come parametro. Il nome passato come parametro DEVE essere un nome * valido di un corpo contenuto nel mondo. * * @param nome Nome del corpo. * * @return Corpo corrispondente al nome. *************************************************************************/

public final Corpo getCorpo(String nome) { // Precondizioni: if(!elencoCorpi.containsKey(nome)) throw new IllegalArgumentException();

return (Corpo)elencoCorpi.get(nome); }

/************************************************************************** * Metodo di accesso: Ritorna l’elenco di tutti i nomi dei corpi contenuti * nel mondo. * * @return Elenco dei nomi di tutti i corpi contenuti nel mondo. *************************************************************************/

public final String[] getNomi() { return nomiCorpi; }

/************************************************************************** * Metodo di accesso: Ritorna l’elenco di tutti i nomi dei robot contenuti * nel mondo. * * @return Elenco dei nomi dei robot. *************************************************************************/

public final String[] getNomiRobot() { return nomiRobot; }

/************************************************************************** * Metodo di accesso: Ritorna l’elenco di tutti i nomi delle casse * contenute nel mondo. * * @return Elenco dei nomi delle casse. *************************************************************************/

147

public final String[] getNomiCasse() { return nomiCasse; }

/************************************************************************** * Metodo di accesso: Ritorna l’elenco di tutti i nomi dei corpi mobili * contenuti nel mondo. * * @return Elenco dei nomi dei corpi mobili. *************************************************************************/

public final String[] getNomiCorpiMobili() { return nomiCorpiMobili; }

//************************************************************************* }

//*****************************************************************************

148

$��� ,O�SDFNDJH�WHVW�In questo package sono state inserite delle classi contenenti una serie di dati di test

per i metodi e le classi del simulatore. Ogni classe di test testa un singolo metodo di

una data classe. Tutte le classi di test sono derivate dalla classe comune 7HVW che di-

chiara le funzioni per il testing e la stampa a video dei risultati. La classe 7HVW ha an-

che un metodo PDLQ che esegue un ciclo testando tutti i metodi per cui esiste una

classe di test, fermandosi al primo test che trova un errore.

Di seguito è allegato il codice sorgente delle classi 7HVW e 7HVW9ROXPH'LVWDQ]D'LUH�]LRQDOH.

149

/****************************************************************************** * Classe Test *****************************************************************************/ import test.*; /****************************************************************************** * Questa classe rappresenta un gruppo di test per una classe o per un metodo * di una classe. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public abstract class Test {

/** Nome della classe o metodo testato dalla classe. */ private String nomeTest;

/** Numero di test incorporati nella classe. */ private int numeroTest;

/************************************************************************** * Metodo astratto: Esegue il test i-esimo del gruppo di test incorporati * nella classe. Deve essere implementato nella classe che fornisce * l’insieme dei test. * * @param i Indice del test da eseguire. Deve essere compreso tra 0 * incluso e numeroTest escluso. * * @return true se il test non ha trovato errori, false altrimenti. *************************************************************************/

public abstract boolean eseguiTest(int i);

/************************************************************************** * Metodo implementato: Esegue il test i-esimo del gruppo di test * incorporati nella classe e ne ritorna l’output.Deve essere * implementato nella classe che fornisce l’insieme dei test. * * @param i Indice del test da eseguire. * * @return Output del test i-esimo. *************************************************************************/

public abstract String outputTest(int i);

/************************************************************************** * Metodo implementato: Ritorna l’output corretto per il test i-esimo. * * @param i Indice del test da eseguire. * * @return Output del test i-esimo. *************************************************************************/

public abstract String riferimentoTest(int i);

/************************************************************************** * Costruttore: Crea una nuova classe di test. * * @param nomeTest Nome dellaclasse/metodo testato dalla classe. * @param numeroTest Numero di test contenuti nella classe. *************************************************************************/

public Test(String nomeTest, int numeroTest) { this.nomeTest = nomeTest; this.numeroTest = numeroTest;

150

}

/************************************************************************** * Metodo di accesso: Esegue in sequenza tutti i test contenuti nella * classe. *************************************************************************/

public final int eseguiTest() { int falliti = 0;

System.out.print("\n [ " + nomeTest + " ] ");

for(int i = 0; i < numeroTest; ++i) { if((i % 5 == 0) && (i > 0)) System.out.print(i); else System.out.print(".");

if(!eseguiTest(i)) { System.out.print( "\n *** Fallito " + i + " - Output: " + outputTest(i) + " - Riferimento: " + riferimentoTest(i) + " " );

falliti++; } }

return falliti; }

/************************************************************************** * Punto di entrata del programma: Esegue tutti i test preparati per le * classi. *************************************************************************/

public static void main(String[] args) { System.out.println("\nTesting dei metodi e delle classi.");

Test[] test = { new TestRotazioneDirezione(), new TestRototraslazioneRototraslazione(), new TestRototraslazioneComposizione(), new TestRototraslazioneRototrasla(), new TestVolumeIntersezione(), new TestVolumeDistanzaDirezionale() };

int falliti = 0;

for(int i = 0; (i < test.length) && (falliti == 0); ++i) { falliti += test[i].eseguiTest(); }

System.out.println("\n\nFalliti " + falliti + " test."); }

//************************************************************************* }

//*****************************************************************************

151

/****************************************************************************** * Classe TestVolumeDistanzaDirezionale *****************************************************************************/ package test; import server.geometria.*; import Test; /****************************************************************************** * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class TestVolumeDistanzaDirezionale extends Test {

private final static int NUMERO_TEST = 4; private final static float TOLL = (float)Math.pow(10, -5);

Volume[] i1 = new Volume [NUMERO_TEST]; Rototraslazione[] i2 = new Rototraslazione [NUMERO_TEST]; float[] o1 = new float [NUMERO_TEST];

/************************************************************************** * Costruttore: Inizializza tutti i dati di test. *************************************************************************/

public TestVolumeDistanzaDirezionale() { super("float Volume.distanzaDirezionale(Rototraslazione)", NUMERO_TEST);

// Porta in (6, 3, 6) di dimensioni (6, 6, 2) di apertura (2, 4), // Riferimento relativo in (3, 2) ruotato di 45 gradi. i1[3] = new VolumePorta(6, 6, 2, 2, 4, 0); i1[3].setPosizione(new Vettore(6, 3, 6)); i2[3] = new Rototraslazione( new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f), new Vettore(3, 1, 2) ); o1[3] = (float)Math.sqrt(32f);

// Cubo in (8, 0, 6) di lato 2, // Riferimento relativo in (3, 2) ruotato di 45 gradi. i1[2] = new VolumeParallelepipedo(2, 2, 2); i1[2].setPosizione(new Vettore(8, 0, 6)); i2[2] = new Rototraslazione( new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f), new Vettore(3, 0, 2) ); o1[2] = (float)Math.sqrt(32f);

// Cilindro in (8, 7) di raggio 1, // Riferimento relativo in (3, 2) ruotato di 45 gradi. i1[1] = new VolumeCilindro(1, 2); i1[1].setPosizione(new Vettore(8, 0, 7)); i2[1] = new Rototraslazione( new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f), new Vettore(3, 0, 2) ); o1[1] = (float)Math.sqrt(50f) - 1;

// Cubo in (8, 7) di lato 2, // Riferimento relativo in (3, 2) ruotato di 45 gradi. i1[0] = new VolumeParallelepipedo(2, 2, 2); i1[0].setPosizione(new Vettore(8, 0, 7)); i2[0] = new Rototraslazione( new Rotazione(Vettore.j, -Rotazione.PIGRECO/4f), new Vettore(3, 0, 2)

152

); o1[0] = (float)Math.sqrt(32f); }

/************************************************************************** * Metodo implementato: Esegue il test i-esimo del gruppo di test * incorporati nella classe. Deve essere implementato nella classe che * fornisce l’insieme dei test. * * @param i Indice del test da eseguire. * * @return true se il test non ha trovato errori, false altrimenti. *************************************************************************/

public boolean eseguiTest(int i) { try { float v = Math.abs(o1[i] - i1[i].distanzaDirezionale(i2[i]));

return (v <= TOLL); } catch(server.geometria.eccezione.EccezioneNonInterseca eni) { return false; } catch(server.geometria.eccezione.EccezioneContieneOrigine eco) { return false; } }

/************************************************************************** * Metodo implementato: Esegue il test i-esimo del gruppo di test * incorporati nella classe e ne ritorna l’output. * * @param i Indice del test da eseguire. * * @return Output del test i-esimo. *************************************************************************/

public String outputTest(int i) { try { return Float.toString(i1[i].distanzaDirezionale(i2[i])); } catch(server.geometria.eccezione.EccezioneNonInterseca eni) { return "Eccezione Non interseca: " + eni; } catch(server.geometria.eccezione.EccezioneContieneOrigine eco) { return "Eccezione Contiene origine: " + eco; } } /************************************************************************** * Metodo implementato: Ritorna l’output corretto per il test i-esimo. * * @param i Indice del test. * * @return Output corretto del test i-esimo. *************************************************************************/

public String riferimentoTest(int i) { return Float.toString(o1[i]); }

//************************************************************************* }

//*****************************************************************************

153

$��� /H�DOWUH�FODVVL�Le tre classi principali che gestiscono la simulazione nel suo complesso sono 6LP�

6HUYHU e &RQQHVVLRQH sul lato server e 6LP&OLHQW sul lato client.

154

/****************************************************************************** * Classe SimServer * * Metodi statici: * void main (String[]) * * Mondo mondo () * * void print (String) * void println (String) *****************************************************************************/ import java.io.*; import java.net.*; import comune.Protocollo; import server.Connessione; import server.mondo.*; import server.corpi.*; import server.sensori.*; /****************************************************************************** * La classe Server contiene il metodo principale che inizializza il server, * crea e fa partire il mondo simulato e si mette in attesa di richieste da * parte dei client. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class SimServer {

private static final float DT_MAX = 0.1f;

private static volatile boolean inEsecuzione = true; private static Mondo mondo = null; private static ServerSocket serverSocket = null;

/************************************************************************** * Metodo statico: Inizializza il server. *************************************************************************/

public static void main(String[] args) { // Thread dedicato all’accettazione di richieste sul socket. Thread threadSocket = new Thread() { public void run() { try { println("Il server e’ in ascolto.");

while(true) { Socket socket = serverSocket.accept();

println("\nRichiesta da " + socket);

Connessione connessione = new Connessione(socket, mondo); } } catch(IOException ioe) { println("Errore IO: " + ioe); } finally{ inEsecuzione = false;

155

println("Il server non e’ piu’ in ascolto."); } } };

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

// Thread dedicato a evolvere il mondo simulato. Thread threadSimulatore = new Thread() { public void run() { println("La simulazione e’ in evoluzione.");

try { long t1 = System.currentTimeMillis(); long t0 = t1; float dt;

while(inEsecuzione) { do { Thread.yield();

t1 = System.currentTimeMillis(); dt = ((float)(t1-t0))/1000f; } while(dt == 0f);

if(dt > DT_MAX) { SimServer.println( "<Simulazione rallentata>"); dt = DT_MAX; }

t0 = t1;

mondo.aggiorna(dt); } } finally { inEsecuzione = false; println("La simulazione non e’ piu’ in evoluzione."); } } };

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

println("\nAvvio del server...");

try { if(args.length == 0) { println("Specificare il nome del mondo da caricare");

return; }

mondo = (Mondo)(Class.forName(args[0]).newInstance());

serverSocket = new ServerSocket(Protocollo.PORTA); println("Socket: " + serverSocket + " inizializzato.");

threadSimulatore.setDaemon(true); threadSimulatore.start();

threadSocket.setPriority(Thread.MAX_PRIORITY); threadSocket.setDaemon(true);

156

threadSocket.start();

println("Premere INVIO per terminare l’esecuzione.");

try { System.in.read(); } catch(IOException ioe) { }

println("\nRilevata pressione tasto INVIO. Chiusura server...");

inEsecuzione = false;

try { serverSocket.close(); } catch(IOException ioe) { } try { threadSimulatore.join(); } catch(InterruptedException ie) { } try { threadSocket.join(); } catch(InterruptedException ie) { }

threadSimulatore = null; threadSocket = null; mondo = null; serverSocket = null;

println("\nApplicazione terminata correttamente."); } catch(ClassNotFoundException cnfe) { println("Mondo " + args[0] + " non trovato."); println("Specificare come parametro un nome di classe che" + " contenga un mondo."); } catch(InstantiationException ie) { println("La classe " + args[0] + " non e’ un mondo valido."); } catch(IllegalAccessException iae) { println("La classe " + args[0] + " non e’ un mondo valido."); } catch(IOException ioe) { println("Errore io: " + ioe); } }

/************************************************************************** * Metodo statico: Ritorna il mondo su cui viene eseguita la simulazione. * Se il mondo non e’ stato ancora inizializzato ritorna null. * * @return Mondo su cui viene eseguita la simulazione. *************************************************************************/

public static Mondo mondo() { return mondo; }

/************************************************************************** * Metodo statico: Manda la stringa su un dispositivo di output * collegato al server (schermo, disco, stampante, eccetera). *************************************************************************/

public static void println(String str) { System.out.println(str); System.out.flush(); }

/************************************************************************** * Metodo statico: Manda la stringa su un dispositivo di output * collegato al server (schermo, disco, stampante, eccetera). *************************************************************************/

public static void print(String str) { System.out.print(str); }

157

//*************************************************************************

}

//*****************************************************************************

158

/****************************************************************************** * Classe Connessione * * Costruttori: * Connessione (Socket, Mondo) * * Metodi implementati: * void run () *****************************************************************************/ package server; import java.io.*; import java.net.*; import server.controllo.*; import server.sensori.*; import server.geometria.*; import server.fisica.*; import server.corpi.*; import server.mondo.*; import SimServer; import comune.*; /****************************************************************************** * La classe Connessione rappresenta il collegamento del server con un singolo * client. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class Connessione implements Runnable {

private String login = null; private Socket socket = null; private ObjectInputStream in = null; private ObjectOutputStream out = null; private Thread thread = null; private Mondo mondo = null;

/************************************************************************** * Costruttore: Inizializza il socket e i flussi. *************************************************************************/

public Connessione(Socket socket, Mondo mondo) { this.socket = socket; this.thread = new Thread(this); this.mondo = mondo;

SimServer.println(" Attivato il thread di I/O sulla porta " + socket.getPort()); thread.setPriority(Thread.MAX_PRIORITY); thread.setDaemon(true); thread.start(); }

/************************************************************************** * Metodo ridefinito: Resta in ascolto del client e a ogni richiesta di * questo risponde spedendo i dati richiesti. *************************************************************************/

public void run() { Richiesta richiesta = null; Risposta risposta = null;

159

try { SimServer.println(" Verifica login e password...");

out = new ObjectOutputStream(socket.getOutputStream()); in = new ObjectInputStream (socket.getInputStream());

// Verifica la login e la password. Se la verifica fallisce la // connessione viene chiusa. login = in.readUTF(); // Login dell’utente. String password = in.readUTF(); // Password dell’utente.

if(!RegistroUtenti.convalida(login, password)) { out.writeInt(Risposta.ERR_LOGIN_INVALIDO); return; }

password = null;

// Spedisce il messaggio di conferma e si mette in attesa dei // messaggi dal client. out.writeInt(Risposta.ERR_NESSUN_ERRORE); out.flush(); SimServer.println(" Client validato, instaurata connessione con " + login); while(true) { richiesta = Richiesta.ricevi(in);

switch(richiesta.comando) {

case Richiesta.INI: SimServer.println(" Spedizione dati di inizializzazione a " + login); risposta = rispondiIni(richiesta); break;

case Richiesta.ACK: risposta = rispondiAck(richiesta); break;

case Richiesta.INF: risposta = rispondiInf(richiesta); break;

case Richiesta.SET_VEL_DIR: SimServer.println(" Comando set velocità/direzione da" + login); risposta = rispondiSetVelDir(richiesta); break;

case Richiesta.SET_POSIZIONE: SimServer.println(" Comando set posizione da " + login); risposta = rispondiSetPosizione(richiesta); break;

case Richiesta.SET_INSEGUITO: SimServer.println(" Comando set inseguito da " + login); risposta = rispondiSetInseguito(richiesta); break;

case Richiesta.SET_BEHAVIOR: SimServer.println(" Comando set behavior da " + login); risposta = rispondiSetBehavior(richiesta); break;

case Richiesta.MANDA_MAPPA:

160

SimServer.println(" Richiesta mappa da " + login); risposta = rispondiInvioMappa(richiesta); break;

default: SimServer.println(" Messaggio sconosciuto <" + richiesta.comando + "> spedito da " + login);

risposta = new Risposta( Risposta.ERR_SINTASSI_MESSAGGIO, false); }

risposta.spedisci(out); out.flush(); } } catch(ClassNotFoundException cnfe) { SimServer.println(" Errore di cast: " + cnfe); } catch(IOException ioe) { SimServer.println(" Eccezione IO: " + ioe); } finally { SimServer.println("\n Disconnesso client " + login + "\n");

if(out != null) try { out.close(); } catch(IOException e) { } if(in != null) try { in .close(); } catch(IOException e) { }

try { socket.close(); } catch(IOException e) { }

thread = null; out = null; in = null; socket = null; } }

/************************************************************************** * Metodo privato: Spedisce al client i dati di aggiornamento. *************************************************************************/

private Risposta rispondiIni(Richiesta richiesta) { RisultatoIni ris = new RisultatoIni(); Corpo corpo = null;

// Assegno i nomi degli oggetti e dei robot. ris.nome = mondo.getNomi(); ris.nomeRobot = mondo.getNomiRobot();

// Alloco tutti gli array. ris.vrml = new String[ris.nome.length]; ris.posizione = new float [ris.nome.length][]; ris.orientamento = new float [ris.nome.length][];

ris.nomeControllore = new String[ris.nomeRobot.length][]; ris.tipoControllore = new String[ris.nomeRobot.length][];

ris.nomeTelecamera = SensoreTelecamera.nomi();

// Assegno tutti i valori per gli array di vrml, posizione e // orientamento. for(int i = 0; i < ris.nome.length; ++i) { corpo = mondo.getCorpo(ris.nome[i]);

ris.vrml[i] = corpo.vrml(); ris.posizione[i] = corpo.baricentro().posizione().toFloatArray();

161

ris.orientamento[i] = corpo.baricentro().orientamento() .toFloatArray(); }

// Assegno tutti i valori per gli array nomeControllore e // tipoControllore for(int i = 0; i < ris.nomeRobot.length; ++i) { RobotMobile robot = (RobotMobile)mondo.getCorpo(ris.nomeRobot[i]); Controllore controllo = robot.controllore();

if(controllo instanceof ControlloreSwitch) { ControlloreSwitch cs = (ControlloreSwitch)controllo;

ris.nomeControllore[i] = cs.nomi(); ris.tipoControllore[i] = cs.tipi(); } else { ris.nomeControllore[i] = new String[1]; ris.tipoControllore[i] = new String[1];

ris.nomeControllore[i][0] = controllo.nome(); ris.tipoControllore[i][0] = controllo.tipo(); } }

return new Risposta(ris); }

/************************************************************************** * Metodo privato: Spedisce al client i dati di inizialzzazione. *************************************************************************/

private Risposta rispondiAck(Richiesta richiesta) { RisultatoAck ris = new RisultatoAck();

Corpo corpo = null;

ris.nome = mondo.getNomiCorpiMobili(); ris.posizione = new float[ris.nome.length][]; ris.orientamento = new float[ris.nome.length][];

for(int i = 0; i < ris.nome.length; ++i) { corpo = mondo.getCorpo(ris.nome[i]);

ris.posizione[i] = corpo.baricentro().posizione().toFloatArray(); ris.orientamento[i] = corpo.baricentro().orientamento() .toFloatArray(); }

{ParametriAck par = (ParametriAck)richiesta.parametri;

Rototraslazione rot = SensoreTelecamera.telecamera(par.nomeTelecamera) .rototraslazioneAssoluta();

ris.posizioneTelecamera = rot.traslazione().toFloatArray(); ris.orientamentoTelecamera = rot.rotazione() .toFloatArray(); }

return new Risposta(ris); }

/************************************************************************** * Metodo privato: Spedisce al client i dati di inizialzzazione.

162

*************************************************************************/

private Risposta rispondiInvioMappa(Richiesta richiesta) { RisultatoInfMappa ris = new RisultatoInfMappa();

ris.mappa = ((RobotMobile)mondo.getCorpo(richiesta.nomeRobot)) .mappa().toLongArray();

return new Risposta(ris); }

/************************************************************************** * Metodo privato: Spedisce al client i dati di informazione. *************************************************************************/

private Risposta rispondiInf(Richiesta richiesta) { RisultatoInf ris = new RisultatoInf();

ris.velocita = mondo.getCorpo(richiesta.nomeRobot).baricentro() .velocita().modulo(); return new Risposta(ris); }

/************************************************************************** * Metodo privato: Processa il comando ricevuto dal client. *************************************************************************/

private Risposta rispondiSetVelDir(Richiesta richiesta) { RobotMobile robot = null; ParametriSetVelocitaDirezione parametri = null; ControlloreVelocitaDirezione controllore = null;

try { robot = (RobotMobile)mondo.getCorpo(richiesta.nomeRobot); parametri = (ParametriSetVelocitaDirezione)richiesta.parametri; controllore = (ControlloreVelocitaDirezione)getControllore( robot, richiesta.nomeControllore, Richiesta.CONTROLLORE_VELOCITA );

if(parametri.setVelocita) controllore.setVelocita (parametri.velocita); if(parametri.setDirezione) controllore.setDirezione(parametri.direzione);

return Risposta.RISPOSTA_OK; } catch(ClassCastException cce) { if(robot == null) return new Risposta(Risposta.ERR_NON_NOME_ROBOT, false); if(parametri == null) return new Risposta(Risposta.ERR_SINTASSI_MESSAGGIO, false); if(controllore == null) return new Risposta(Risposta.ERR_CONTROLLORE_INVALIDO, false);

return new Risposta(Risposta.ERR_NON_PREVISTO, false); } }

/************************************************************************** * Metodo privato: Processa il comando ricevuto dal client. *************************************************************************/

private Risposta rispondiSetPosizione(Richiesta richiesta) {

163

RobotMobile robot = null; ParametriSetPosizione parametri = null; ControllorePosizione controllore = null;

try { robot = (RobotMobile)mondo.getCorpo(richiesta.nomeRobot); parametri = (ParametriSetPosizione)richiesta.parametri; controllore = (ControllorePosizione)getControllore( robot, richiesta.nomeControllore, Richiesta.CONTROLLORE_POSIZIONE );

controllore.setPosizione( new Vettore(parametri.x, 0f, parametri.z) );

return Risposta.RISPOSTA_OK; } catch(ClassCastException cce) { if(robot == null) return new Risposta(Risposta.ERR_NON_NOME_ROBOT, false); if(parametri == null) return new Risposta(Risposta.ERR_SINTASSI_MESSAGGIO, false); if(controllore == null) return new Risposta(Risposta.ERR_CONTROLLORE_INVALIDO, false);

return new Risposta(Risposta.ERR_NON_PREVISTO, false); } }

/************************************************************************** * Metodo privato: Processa il comando ricevuto dal client. *************************************************************************/

private Risposta rispondiSetInseguito(Richiesta richiesta) { RobotMobile robot = null; ParametriSetInseguito parametri = null; ControlloreInseguitore controllore = null;

try { robot = (RobotMobile)mondo.getCorpo(richiesta.nomeRobot); parametri = (ParametriSetInseguito)richiesta.parametri; controllore = (ControlloreInseguitore)getControllore( robot, richiesta.nomeControllore, Richiesta.CONTROLLORE_INSEGUITORE );

controllore.setInseguito(mondo.getCorpo(parametri.inseguito));

return Risposta.RISPOSTA_OK; } catch(ClassCastException cce) { if(robot == null) return new Risposta(Risposta.ERR_NON_NOME_ROBOT, false); if(parametri == null) return new Risposta(Risposta.ERR_SINTASSI_MESSAGGIO, false); if(controllore == null) return new Risposta(Risposta.ERR_CONTROLLORE_INVALIDO, false);

return new Risposta(Risposta.ERR_NON_PREVISTO, false); } }

/************************************************************************** * Metodo privato: Processa il comando ricevuto dal client. *************************************************************************/

164

private Risposta rispondiSetBehavior(Richiesta richiesta)

{ RobotKhepera robot = null; ParametriSetBehavior parametri = null; ControlloreBehavior controllore = null;

try { robot = (RobotKhepera)mondo.getCorpo(richiesta.nomeRobot); parametri = (ParametriSetBehavior)richiesta.parametri; controllore = (ControlloreBehavior)getControllore( robot, richiesta.nomeControllore, Richiesta.CONTROLLORE_BEHAVIOR );

return Risposta.RISPOSTA_OK; } catch(ClassCastException cce) { if(robot == null) return new Risposta(Risposta.ERR_NON_NOME_ROBOT, false); if(parametri == null) return new Risposta(Risposta.ERR_SINTASSI_MESSAGGIO, false); if(controllore == null) return new Risposta(Risposta.ERR_CONTROLLORE_INVALIDO, false);

return new Risposta(Risposta.ERR_NON_PREVISTO, false); } }

/************************************************************************** * Metodo a uso interno: Ritorna il controllor emontato sul robot * corrispondente al nome passato come parametro. Se il nome non esiste o * se il controllore non corrisponde al tipo viene generata una eccezione * ClassCastException. * Se il controllore fa parte di uno switch di ControlloreSwitch allora * viene impostato come controllore attivo dello switch prima di essere * ritornato. * * @param robot Robot che monta il controllore. * @param nomeControllore Nome del controllore da ritornare * @param tipoControllore Tipo del controllore da ritornare * * @return Controllore richiesto. * * @exception ClassCastException Generata se il controllore non esiste o * se non e’ del tipo specificato. *************************************************************************/

private Controllore getControllore(RobotMobile robot, String nomeControllore, String tipoControllore ) throws ClassCastException { if(robot.controllore().tipo().equals(tipoControllore)) { return robot.controllore(); } else if(robot.controllore() instanceof ControlloreSwitch) { ControlloreSwitch cs = (ControlloreSwitch)robot.controllore();

if(!cs.contiene(nomeControllore)) throw new ClassCastException();

if(!cs.tipo(nomeControllore).equals(tipoControllore)) throw new ClassCastException();

// Se il controllore selezionato non e’ quello attivo lo attiva.

165

if(!cs.attivo().nome().equals(nomeControllore)) cs.attiva(nomeControllore);

return cs.attivo(); } else { throw new ClassCastException(); } }

//************************************************************************* }

//*****************************************************************************

166

/****************************************************************************** * Classe SimClient * * Metodi ridefiniti: * void init () * void stop () * * Metodi implementati: * void run() * void actionPerformed (ActionEvent) * void adjustmentValueChanged (AdjustmentEvent) * void itemStateChanged (ItemEvent) *****************************************************************************/ import java.applet.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; import client.*; import client.eccezione.*; import comune.*; /****************************************************************************** * La applet client crea un collegamento col server per ricevere tutte le * coordinate aggiornate degli oggetti e aggiorna gli oggetti corrispondenti * nella pagina vrml collegata. * * @version 1.00 * @date 21 Settembre 1998 * @author Carlo Cecchi, Stefano Fronteddu *****************************************************************************/ public class SimClient extends Applet implements Runnable, ActionListener, ItemListener {

private static final String VERSIONE = "SimClient versione 0.041c";

private MondoClient mondo = null; private Thread thread = null; private RisultatoIni ini = null;

private volatile boolean inEsecuzione = false;

private Socket socket = null; private ObjectInputStream in = null; private ObjectOutputStream out = null;

// Controlli della applet. private GridBagConstraints gbc = new GridBagConstraints(); private GridBagLayout gridBagLayout = new GridBagLayout(); private CardLayout cardLayout = new CardLayout(8, 8);

private Choice choiceTelecamera = new Choice(); private Choice choiceRobot = new Choice(); private Choice choiceControllore = new Choice();

private Label labelVelocita = new Label(""); private Label labelPosizione = new Label(""); private Label labelDirezione = new Label("");

private FinestraMessaggi finestra = new FinestraMessaggi(30);

private Panel pannelloControllore = new Panel();

// Controlli per il controllore manuale.

167

private Button buttonSinistra = new Button("Ovest"); private Button buttonDestra = new Button("Est"); private Button buttonSu = new Button("Nord"); private Button buttonGiu = new Button("Sud"); private Button buttonSuSinistra = new Button("NordOvest"); private Button buttonSuDestra = new Button("NordEst"); private Button buttonGiuSinistra = new Button("SudOvest"); private Button buttonGiuDestra = new Button("SudEst"); private Button buttonStop = new Button("Stop"); private Button buttonMin = new Button("min"); private Button buttonMed = new Button("med"); private Button buttonMax = new Button("max"); private Button buttonStartBehavior = new Button("Avvia"); private Button buttonMostraMappa = new Button("Mostra Mappa");

// Controlli per il controllore di posizione. private TextField textfieldX = new TextField("0", 4); private TextField textfieldZ = new TextField("0", 4); private Button buttonSetPosizione = new Button("Imposta Posizione");

// Controlli per il controllore di inseguimento private Choice choiceInseguito = new Choice(); private Button buttonSetInseguito = new Button("Insegui/Raggiungi");

/************************************************************************** * Metodo ridefinito: Inserisce i controlli sulla applet e fa partire il * thread di aggiornamento. *************************************************************************/

public void init() { // Questa riga serve per dimensionare la larghezza delle choice. choiceRobot.add("01234567890123456"); labelVelocita.setText("01234567890123");

gbc.insets = new Insets(8, 8, 8, 8); gbc.weightx = 1; gbc.weighty = 1;

Panel pannelloSelezioneRobot = new Panel(); Panel pannelloMessaggi = new Panel(); Panel pannelloControlloreManuale = new Panel(); Panel pannelloControllorePosizione = new Panel(); Panel pannelloControlloreInseguitore = new Panel(); Panel pannelloControlloreBehavior = new Panel();

pannelloSelezioneRobot .setLayout(gridBagLayout); pannelloControllore .setLayout(cardLayout); pannelloMessaggi .setLayout(gridBagLayout); pannelloControlloreManuale .setLayout(new GridLayout(3, 4, 8, 8)); pannelloControllorePosizione .setLayout(gridBagLayout); pannelloControlloreInseguitore.setLayout(gridBagLayout); pannelloControlloreBehavior .setLayout(gridBagLayout);

// Inserimento dei controlli di selezione del robot. x y l h gbc.fill = GridBagConstraints.HORIZONTAL; addControllo(new Label("Visuale:"), pannelloSelezioneRobot, 0, 0, 1, 1); addControllo(new Label("Robot:"), pannelloSelezioneRobot, 0, 1, 1, 1); addControllo(new Label("Controllo:"), pannelloSelezioneRobot, 0, 2, 1, 1); addControllo(new Label("Velocità:"), pannelloSelezioneRobot, 2, 0, 1, 1); addControllo(new Label("Posizione:"), pannelloSelezioneRobot, 2, 1, 1, 1); addControllo(new Label("Direzione:"), pannelloSelezioneRobot, 2, 2, 1, 1); addControllo(choiceTelecamera, pannelloSelezioneRobot, 1, 0, 1, 1); addControllo(choiceRobot, pannelloSelezioneRobot, 1, 1, 1, 1); addControllo(choiceControllore, pannelloSelezioneRobot, 1, 2, 1, 1); addControllo(labelVelocita, pannelloSelezioneRobot, 3, 0, 1, 1); addControllo(labelPosizione, pannelloSelezioneRobot, 3, 1, 1, 1); addControllo(labelDirezione, pannelloSelezioneRobot, 3, 2, 1, 1);

168

// Controlli per il controllore manuale. pannelloControlloreManuale.add(buttonSuSinistra); pannelloControlloreManuale.add(buttonSu); pannelloControlloreManuale.add(buttonSuDestra); pannelloControlloreManuale.add(buttonMax); pannelloControlloreManuale.add(buttonSinistra); pannelloControlloreManuale.add(buttonStop); pannelloControlloreManuale.add(buttonDestra); pannelloControlloreManuale.add(buttonMed); pannelloControlloreManuale.add(buttonGiuSinistra); pannelloControlloreManuale.add(buttonGiu); pannelloControlloreManuale.add(buttonGiuDestra); pannelloControlloreManuale.add(buttonMin);

// Controlli per il controllore di posizione. addControllo(new Label("Posizione X:"), pannelloControllorePosizione,0,0,1,1); addControllo(new Label("Posizione Z:"), pannelloControllorePosizione,0,1,1,1); addControllo(textfieldX, pannelloControllorePosizione,1,0,1,1); addControllo(textfieldZ, pannelloControllorePosizione,1,1,1,1); addControllo(buttonSetPosizione, pannelloControllorePosizione,2,1,1,1);

// Controlli per il controllore di inseguimento. addControllo(new Label("Inseguito:"), pannelloControlloreInseguitore,0,0,1,1); addControllo(choiceInseguito, pannelloControlloreInseguitore,1,0,1,1); addControllo(buttonSetInseguito, pannelloControlloreInseguitore,0,1,2,1);

// Controlli per il controllore Behavior addControllo(new Label("Controllo Behavior:"), pannelloControlloreBehavior, 0, 0, 1, 1); addControllo(buttonStartBehavior, pannelloControlloreBehavior, 1, 0, 1, 1); addControllo(buttonMostraMappa, pannelloControlloreBehavior, 1, 1, 1, 1);

cardLayout.addLayoutComponent(pannelloControlloreManuale, Richiesta.CONTROLLORE_VELOCITA); cardLayout.addLayoutComponent(pannelloControllorePosizione, Richiesta.CONTROLLORE_POSIZIONE); cardLayout.addLayoutComponent(pannelloControlloreInseguitore, Richiesta.CONTROLLORE_INSEGUITORE); cardLayout.addLayoutComponent(pannelloControlloreBehavior, Richiesta.CONTROLLORE_BEHAVIOR);

pannelloControllore.add(pannelloControlloreManuale); pannelloControllore.add(pannelloControllorePosizione); pannelloControllore.add(pannelloControlloreInseguitore); pannelloControllore.add(pannelloControlloreBehavior);

// Inserimento della finestra messaggi. gbc.fill = GridBagConstraints.BOTH; addControllo(finestra, pannelloMessaggi, 0, 0, 1, 1);

setLayout(new GridLayout(3, 1)); add(pannelloSelezioneRobot); add(pannelloControllore); add(pannelloMessaggi);

// Disattiva tutti i controlli. setEnabled(false);

// Aggancia ai controlli la classe che spedisce al server la richiesta // corrispondente (tale classe richiede che il socket sia gia’ stato // inizializzato prima che l’utente agisca sul controllo, altrimenti // viene fermata la applet). choiceTelecamera .addItemListener(this); choiceRobot .addItemListener(this); choiceControllore.addItemListener(this);

169

buttonSuSinistra .addActionListener(this); buttonSu .addActionListener(this); buttonSuDestra .addActionListener(this); buttonSinistra .addActionListener(this); buttonStop .addActionListener(this); buttonDestra .addActionListener(this); buttonGiuSinistra .addActionListener(this); buttonGiu .addActionListener(this); buttonGiuDestra .addActionListener(this); buttonMax .addActionListener(this); buttonMed .addActionListener(this); buttonMin .addActionListener(this); buttonSetPosizione .addActionListener(this); buttonSetInseguito .addActionListener(this); buttonStartBehavior.addActionListener(this); buttonMostraMappa .addActionListener(this);

// Creo il thread di connessione e aggiornamento verso il server. thread = new Thread(this); inEsecuzione = true;

thread.setDaemon(true); thread.start(); }

/************************************************************************** * Metodo ridefinito: Esegue il login con il server e spedisce * periodicamente le richieste di aggiornamento. *************************************************************************/

public void run() { // Tolgo la riga usata per dimensionare la larghezza delle choice. choiceRobot.removeAll();

finestra.println(VERSIONE);

try { finestra.println("Collegamento alla pagina vrml...");

mondo = new MondoClient(this);

finestra.println("Connessione col server...");

// Registrazione dell’utente. LoginDialogBox login = new LoginDialogBox(this);

setEnabled(false); // Disattiva i controlli della applet.

while(true) { // Inizializzazione delle classi di comunicazione // (se l’utente preme "Cancella" termina l’esecuzione). if(login.doModal() == LoginDialogBox.CANCELLA) { login.dispose(); login = null;

return; }

// Crea un collegamento al server e spedisce // login e password. socket = new Socket(getDocumentBase().getHost(), Protocollo.PORTA); in = new ObjectInputStream (socket.getInputStream()); out = new ObjectOutputStream(socket.getOutputStream());

out.writeUTF(login.getLogin());

170

out.writeUTF(login.getPassword()); out.flush();

int risultato = in.readInt();

if(risultato == Risposta.ERR_NESSUN_ERRORE) break;

// Se il server non convalida la password stampa // un messaggio d’errore e ripete la procedura. MessageBox errore = new MessageBox( "login errato, riprovare", this); errore.doModal(); errore.dispose();

try { out .close(); } catch(IOException e1) { } try { in .close(); } catch(IOException e1) { } try { socket.close(); } catch(IOException e1) { } }

login.dispose(); login = null;

finestra.println("Inizializzazione oggetti...");

spedisciIni(); spedisciInf();

// A questo punto posso riattivare i controlli della applet (prima // non potevo perche’ avrebbero potuto interferire sui messaggi di // inizializzazione spediti al server che NON sono gestiti come // sezione critica). setEnabled(true);

finestra.println("Inizializzazione completata.");

// Spedisco periodicamente al server una richiesta di // aggiornamento dei dati della simulazione. while(inEsecuzione) { spedisciAck(); spedisciInf(); Thread.yield(); } } catch(EccezioneMondoNonCollegato e) { finestra.println("run, Errore vrml: " + e); } catch(IOException e) { finestra.println("run, Errore IO: " + e); } catch(Exception e) { finestra.println("run, Errore imprevisto: " + e); } finally { finestra.println("Chiusura applet in corso...");

inEsecuzione = false;

// Disattivo tutti i controlli cosi’ che l’utente non possa piu’ // generare alcun evento. setEnabled(false);

// Chiudo il socket cosi’ che il server non possa piu’ generare // alcun evento. Il server spedisce messaggi solo in risposta a // richieste del client ma questo metodo potrebbe venire chiamato // anche durante un dialogo fra client e server. synchronized(this) { if(out != null) try { out .close(); }

171

catch(IOException e1) { } if(in != null) try { in .close(); } catch(IOException e1) { } if(socket != null) try { socket.close(); } catch(IOException e1) { }

out = null; in = null; socket = null; }

// A questo punto non puo’ piu’ generarsi nessun tipo di evento, // quindi e’ possibile rilasciare le risorse senza pericolo. thread = null; mondo = null;

finestra.println("Applet terminata correttamente."); } }

/************************************************************************** * Metodo ridefinito: Ferma la applet. *************************************************************************/

public void stop() { inEsecuzione = false; super.stop(); }

/************************************************************************** * Metodo ridefinito: Ferma la applet. *************************************************************************/

public void destroy() { inEsecuzione = false; super.destroy(); }

/************************************************************************** * Modificatore: Spedisce al server la richiesta di inizializzazione, * alla quale il server risponde spedendo tutti gli oggetti del mondo con * le loro posizioni e l’elenco dei nomi di robot controllabili. *************************************************************************/

private void spedisciIni() throws EccezioneMondoNonCollegato, IOException { Risposta risposta = spedisciRichiesta(Richiesta.RICHIESTA_INI);

if(risposta == null) return;

ini = (RisultatoIni)risposta.risultato;

for(int i = 0; i < ini.nome.length; ++i) { mondo.addCorpo( ini.nome[i], ini.vrml[i], ini.posizione[i], ini.orientamento[i] ); }

riempiChoice(choiceTelecamera, ini.nomeTelecamera); riempiChoice(choiceRobot, ini.nomeRobot); riempiChoice(choiceControllore, ini.nomeControllore[0]); riempiChoice(choiceInseguito, ini.nome); }

172

/**************************************************************************

* Modificatore: Spedisce al server la richiesta di ack, alla quale * il server risponde spedendo tutte le coordinate degli oggetti che si * sono spostati nel mondo. *************************************************************************/

private void spedisciAck() throws EccezioneMondoNonCollegato, IOException { Richiesta richiesta = new Richiesta( Richiesta.ACK, null, null, new ParametriAck(choiceTelecamera.getSelectedItem()) );

Risposta risposta = spedisciRichiesta(richiesta);

if(risposta == null) return;

RisultatoAck ris = (RisultatoAck)risposta.risultato;

CorpoClient corpo = null;

for(int i = 0; i < ris.nome.length; ++i) { corpo = mondo.getCorpo(ris.nome[i]);

if(ris.nome[i].equals(choiceRobot.getSelectedItem())) { labelPosizione.setText( "[" + Float(ris.posizione[i][0], 2) + ", " + Float(ris.posizione[i][2], 2) + "] [m]" );

// Calcolo l’angolo nel riferimento assoluto con l’asse // y diretto verso l’alto. float angolo = (ris.orientamento[i][1] > 0f) ? ris.orientamento[i][3] : 2f*(float)Math.PI - ris.orientamento[i][3];

labelDirezione.setText(Float(angolo, 3) + " [rad]"); }

corpo.setPosizione (ris.posizione[i]); corpo.setOrientamento(ris.orientamento[i]); }

mondo.setPosizioneVista (ris.posizioneTelecamera); mondo.setOrientamentoVista(ris.orientamentoTelecamera); }

/************************************************************************** * Modificatore: Spedisce al server la richiesta di inf e aggiorna i * controlli della applet sulla base dei valori ritornati dal server. *************************************************************************/

private void spedisciInf() throws IOException { Richiesta richiesta = new Richiesta( Richiesta.INF, choiceRobot.getSelectedItem(), null, null );

Risposta risposta = spedisciRichiesta(richiesta);

if(risposta == null) return;

173

RisultatoInf ris = (RisultatoInf)risposta.risultato;

labelVelocita.setText(Float(ris.velocita, 2) + " [m/s]");

}

/************************************************************************** * Modificatore: Spedisce al server la richiesta mappa e stampa a video * la mappa ritornata. *************************************************************************/

private void spedisciMappa() throws IOException { Richiesta richiesta = new Richiesta( Richiesta.MANDA_MAPPA, choiceRobot.getSelectedItem(), null, null );

Risposta risposta = spedisciRichiesta(richiesta);

if(risposta == null) return;

RisultatoInfMappa ris = (RisultatoInfMappa)risposta.risultato;

MapViewer finestraMappa = new MapViewer( "Mappa di " + choiceRobot.getSelectedItem(), 300, 200, ris.mappa );

finestraMappa.show(); finestraMappa.setVisible(true); }

/************************************************************************** * Metodo ridefinito: Abilita/Disabilita i controlli della finestra. * * @param stato Nuovo stato della finestra. *************************************************************************/

public void setEnabled(boolean stato) { choiceTelecamera .setEnabled(stato); choiceRobot .setEnabled(stato); choiceControllore .setEnabled(stato);

buttonSu .setEnabled(stato); buttonGiu .setEnabled(stato); buttonSinistra .setEnabled(stato); buttonDestra .setEnabled(stato); buttonSuSinistra .setEnabled(stato); buttonGiuSinistra .setEnabled(stato); buttonSuDestra .setEnabled(stato); buttonGiuDestra .setEnabled(stato); buttonStop .setEnabled(stato); buttonMax .setEnabled(stato); buttonMed .setEnabled(stato); buttonMin .setEnabled(stato);

textfieldX .setEnabled(stato); textfieldZ .setEnabled(stato); buttonSetPosizione.setEnabled(stato);

buttonSetInseguito.setEnabled(stato);

super .setEnabled(stato); }

174

/**************************************************************************

* Metodo privato usato per l’inizializzazione dei controlli della applet. * * @param componente Componente da inserire. * @param pannello Pannello in cui inserire il componente (configurato * con il layout GridBagLaoyut). * @param gx Parametro gridx di GridBagConstraints. * @param gy Parametro gridx di GridBagConstraints. * @param wx Parametro gridwidth di GridBagConstraints. *************************************************************************/

private void addControllo(Component componente, Panel pannello, int x, int y, int w, int h) { gbc.gridx = x; gbc.gridy = y; gbc.gridwidth = w; gbc.gridheight = h;

gridBagLayout.setConstraints(componente, gbc); pannello.add(componente); }

/************************************************************************** * Metodo privato usato per inserire strinche nelle choice. * * @param choice Choice da riempire (se contiene gia’ elementi questi * vengono eliminati). * @param stringhe Stringhe da inserire nella choice. *************************************************************************/

private void riempiChoice(Choice choice, String[] stringhe) { choice.removeAll();

for(int i = 0; i < stringhe.length; ++i) choice.addItem(stringhe[i]); }

/************************************************************************** * Metodo collegato all’evento pressione di un pulsante della applet. * Spedisce al server il comando corrispondente al pulsante premuto. * * Sintassi del messaggio di richiesta del client: * CMD <robot> <comando> [<parmetro1> <parametro2>...] *************************************************************************/

public void actionPerformed(ActionEvent ae) { int comando = -1; Serializable parametri = null;

try {

// Controllore manuale. if(ae.getSource() == buttonSuSinistra) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, 3f*Protocollo.PIGRECO/4f); } else if(ae.getSource() == buttonSu) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, Protocollo.PIGRECO/2f); } else if(ae.getSource() == buttonSuDestra) {

175

comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, Protocollo.PIGRECO/4f); } else if(ae.getSource() == buttonSinistra) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, Protocollo.PIGRECO); } else if(ae.getSource() == buttonDestra) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, 0); } else if(ae.getSource() == buttonGiuSinistra) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, 5f*Protocollo.PIGRECO/4f); } else if(ae.getSource() == buttonGiu) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, 3f*Protocollo.PIGRECO/2f); } else if(ae.getSource() == buttonGiuDestra) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(false, 0f, true, 7f*Protocollo.PIGRECO/4f); }

else if(ae.getSource() == buttonMax) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(true, 2f, false, 0); } else if(ae.getSource() == buttonMed) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(true, 1f, false, 0); } else if(ae.getSource() == buttonMin) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(true, 0.5f, false, 0); } else if(ae.getSource() == buttonStop) { comando = Richiesta.SET_VEL_DIR; parametri = new ParametriSetVelocitaDirezione(true, 0f, false, 0); }

// Controllore di posizione. else if(ae.getSource() == buttonSetPosizione) { float x = Float.valueOf(textfieldX.getText()).floatValue(); float z = Float.valueOf(textfieldZ.getText()).floatValue();

comando = Richiesta.SET_POSIZIONE; parametri = new ParametriSetPosizione(x, z);

176

}

// Controllore inseguitore. else if(ae.getSource() == buttonSetInseguito) { comando = Richiesta.SET_INSEGUITO; parametri = new ParametriSetInseguito( choiceInseguito.getSelectedItem()); }

// Controllore behavior. else if(ae.getSource() == buttonStartBehavior) { comando = Richiesta.SET_BEHAVIOR; parametri = new ParametriSetBehavior("start"); } /*else if(ae.getSource() == buttonStopBehavior) { comando = Richiesta.SET_BEHAVIOR; parametri = new ParametriSetBehavior("stop"); }*/ else if(ae.getSource() == buttonMostraMappa) { spedisciMappa(); return; }

spedisciRichiesta( new Richiesta( comando, choiceRobot.getSelectedItem(), choiceControllore.getSelectedItem(), parametri ) ); } catch(NumberFormatException nfe) { finestra.println("Valore numerico invalido"); } catch(IOException ioe) { finestra.println("actionPerformed, Errore IO: " + ioe); inEsecuzione = false; } }

/************************************************************************** * Metodo collegato all’evento selezione di una voce nella choice. * Spedisce al server il comando corrispondente alla choice selezionata. *************************************************************************/

public void itemStateChanged(ItemEvent ie) { if(ie.getSource() == choiceRobot) { riempiChoice( choiceControllore, ini.nomeControllore[choiceRobot.getSelectedIndex()] );

cardLayout.show( pannelloControllore, ini.tipoControllore[choiceRobot.getSelectedIndex()][0] ); } else if(ie.getSource() == choiceControllore) { cardLayout.show( pannelloControllore,

177

ini.tipoControllore[choiceRobot.getSelectedIndex()] [choiceControllore.getSelectedIndex()] ); } }

/************************************************************************** * Metodo statico: Converte un float uin una stringa mantenendo il numero * di decimali specificato come secondo parametro. * * @param numero Numero da convertire. * @param cifre Cifre decimali da conservare (> 0). * * @retrun Numero convertito in stringa con i decimali richiesti. *************************************************************************/

private static String Float(float numero, int cifre) { float ordine = (float)Math.pow(10, cifre);

numero = ((float)((int)(numero*ordine)))/ordine;

return String.valueOf(numero); }

/************************************************************************** * Metodo privato: Elabora la risposta che il server ritorna subito dopo * la spedizione di qualsiasi comando. Se il server risponde con un errore * fatale lo stampa a video e ritorna false. * * @return false se il server risponde con un errore fatale. *************************************************************************/

private Risposta spedisciRichiesta(Richiesta richiesta) throws IOException { Risposta risposta = null;

try { synchronized(this) { richiesta.spedisci(out); out.flush(); risposta = Risposta.ricevi(in); } } catch(ClassNotFoundException cnfe) { finestra.println("Errore di cast: " + cnfe); inEsecuzione = false; return null; }

if(risposta.errore != Risposta.ERR_NESSUN_ERRORE) { finestra.println("Il server ha risposto con un errore:"); finestra.println(" <" + risposta.descrizioneErrore() + ">");

if(risposta.fatale) inEsecuzione = false;

return null; }

return risposta; } //************************************************************************* }

//*****************************************************************************