RETE DI SCUOLE PER LA ROBOCUP JR ITALIA ROBOCUP JR ITALIA 2012 Riva del Garda (Tn) 19-21 aprile DELLA SQUADRA marconivr Istituto I.T.I.S G.Marconi
2
La Rete di scuole per la Robocup Jr ITALIA è espressione dell Autonomia scolastica regolata dal D.P.R. 275/99 (art. 7) che permette alle scuole statali di operare sinergicamente per obiettivi condivisi e ritenuti importanti per l offerta formativa erogata all utenza. La Rete di scuole è nata sulla condivisione di una serie di principi EDUCATIVI e DIDATTICI riferiti alla realtà della scuola italiana. Questi principi e le conseguenti proposte operative erano stati riportati in un documento del maggio 2008 dal titolo: Manifesto per una RoboCupJr italiana - una proposta per la diffusione dell utilizzo didattico della Robotica nelle scuole a cura di Andrea Bonarini, Augusto Chioccariello e Giovanni Marcianò. Maggio 2008 L obiettivo della Rete organizzare l edizione italiana della Robocup Jr concretizza una spinta al confronto e alla collaborazione tra Istituti scolastici, elementi che motivano docenti e studenti all impegno nell innovazione, sia didattica che tecnologica, affrontando i problemi che costituiscono uno standard internazionale dal 2000, quando la Robocup (manifestazione riservata alle Università di tutto il mondo) ha proposto le tre gare per la scuola: Dance Rescue Soccer. La Robocup Jr ITALIA è Una manifestazione nazionale fondata di tre punti forti: 1. una struttura che cura l organizzazione e gestisce gli aspetti di organizzazione, promozione, svolgimento ai diversi livelli, regionali e nazionali; 2. un contenuto condiviso, ovvero regolamenti, formule di gara, supporto formativo e informativo ai partecipanti; 3. una documentazione delle proposte didattiche e del lavoro degli studenti che coinvolgono l uso di kit o robot auto costruiti per la partecipazione agli eventi organizzati dalla Rete. Questo volumetto appartiene alla collana di documentazione. 3
Sul piano organizzativo e gestionale della Rete di scuole lo Statuto prevede organismi ben distinti ma fortemente integrati: COMITATO DI GESTIONE formato dai Dirigenti scolastici degli Istituti fondatori o associati alla Rete. Si riunisce due volte l anno in via ordinaria, e online per decisioni straordinarie. ISTITUTO CAPOFILA come previsto dal DPR 275/99 cura gli aspetti burocratici, amministrativi e contabili della Rete. Il Dirigente scolastico dell Istituto capofila è il legale rappresentante della Rete e provvede a dare esecuzione alle delibere del Comitato di Gestione. COMITATO TECNICO formato dai docenti referenti degli Istituti fondatori o associati alla Rete, provvede a definire il Bando e i Regolamenti di gara per la manifestazione annuale nazionale, trasmettendoli al Comitato di gestione che li deve approvare. COMITATO LOCALE - Cura l edizione annuale della manifestazione, ed è formato a cura del Istituto fondatore o associato a cui il Comitato di Gestione ha assegnato la cura dell evento. ISTITUTI PARTECIPANTI iscrivendosi alle gare, beneficiano del supporto della Rete ma non partecipano alle decisioni gestionali o tecniche. La partecipazione alla gara nazionale li rende idonei per aderire alla Rete. Diversamente serve il parere del Comitato Tecnico. 4
5
Benfatti Andrea Corciulo Mattia Dalle Pezze Davide Marchesini Enrico Masili Andrea marconivr partecipa alla gara di Rescue A I.T.I.S G.Marconi Classe 4Bi 6
CAP. 1 - DATI GENERALI Il team marconivr che partecipa quest anno alla ROBOCUP JR. di Riva del Garda è composto da: -Benfatti Andrea -Corciulo Mattia -Dalle Pezze Davide -Marchesini Enrico -Masili Andrea I componenti della squadra frequentano l istituto di istruzione statale Guglielmo Marconi di Verona. I docenti responsabili del progetto sono i Professori Nadia Dallago e Paolo Tomelleri con la collaborazione di Lorenzo De Carli. ISTITUTO GUGLIELMO MARCONI L Istituto Tecnico Industriale Statale G.Marconi di Verona è da molti anni un punto di riferimento per l istruzione tecnica nel territorio di Verona e provincia. Grazie alla sua costante evoluzione è una delle più importanti realtà scolastiche presenti oggi sul territorio veneto. L Istituto, inoltre, ha tra i suoi obiettivi principali quello di valorizzare le capacità dei propri studenti partecipando a competizioni e concorsi nazionali e raggiungendo spesso risultati eccellenti soprattutto nell ambito del proprio indirizzo (Olimpiadi di informatica, Gara Abacus, Macchina di Turing). 7
8
CAP. 2 - DATI DI CONTESTO E MOTIVAZIONE L I.T.I.S G.Marconi partecipa per la prima volta alla Robocup Jr. Italia. Escludendo piccoli interessi personali di alcuni studenti per quanto riguarda la robotica, l istituto non ha mai affrontato argomenti di questo genere. L idea è nata per caso quando una nostra docente disse scherzando che quest anno visto tutto quello che già avevamo da fare, potevamo fare anche la Robocup. Inizialmente la cosa fu presa sul ridere ma in seguito grazie all interessamento e l insistenza del gruppo partecipante si è deciso di provare. Da sottolineare il fatto che il nostro carattere da informatici ci ha portato a concepire e realizzare un robot autocostruito senza avere nessuna conoscenza di base e senza utilizzare kit pronti come ad esempio quelli LEGO. Dopo aver scelto tutti i componenti necessari allo sviluppo del progetto ci siamo quindi trovati a dover costruire e programmare questo nostro robot con la passione e la dedizione che degli informatici possono avere per un qualcosa di nuovo mai utilizzato prima. Quindi come dei pazzi con il poco tempo che ci era rimasto dall arrivo dei componenti (gli ultimi arrivati il 10 aprile) ci siamo buttati su questo nuovo progetto che, speriamo possa continuare nei prossimi anni grazie anche alla partecipazione di un alunno di 3 che appassionato anche lui dagli svariati utilizzi di un Arduino, ha deciso di seguirci per poi poter istruire i futuri robocuppisti del Marconi. 9
10
CAP. 3 NOME E STRUTTURA DEL ROBOT Dopo alcune riflessioni abbiamo deciso di chiamare il robot Efesto, il dio Greco della tecnologia e dell ingegneria. Nella sua fucina, che a seconda delle varie leggende era situata in diversi posti tra Grecia e Italia, Efesto costruiva automi in metallo per aiutarlo nei suoi lavori. Il dio greco era un fabbro e oltre agli automi costruiva armature, edifici, statue. Inoltre si dice che a seguito della caduta dal monte Olimpo Efesto era malforme e brutto, cosa che rispecchia in parte l aspetto del nostro robot. Nonostante il pochissimo tempo a disposizione per la realizzazione del progetto, il gruppo fin da subito ha deciso di adottare una soluzione autocostruita in quanto da veri informatici un kit Lego o simile non avrebbe soddisfatto la nostra voglia di fare. Efesto è costituito da 3 sensori Sharp per il rilevamento di ostacoli in fronte e ai lati del robot. Due motori dc sono responsabili del moto di Efesto; infine abbiamo modificato una pinza prefabbricata per poter facilmente recuperare la vittima. Quest ultima viene mossa da due servo motori (uno per il sollevamento del braccio e l altro per l apertura e chiusura della pinza). Per poter seguire la linea guida abbiamo deciso di acquistare dei sensori di colore a striscia, in modo da facilitare la permanenza del robot sul tracciato. Inoltre sono state appositamente scelte ruote di piccole dimensioni ma con una forte aderenza su vari materiali. Il tutto è stato montato su un plate set ( piastra bucherellata) ed è gestito da un microcontrollore Arduino Mega. Uno dei principali problemi iniziali essendo dei novellini in questo ambito, è stata la scelta dell alimentazione in quanto un pacco pile da 2400mA non forniva abbastanza potenza per poter gestire la chiusura e il sollevamento della pinza e il contemporaneo moto di Efesto. Difatti in presenza di una salita formata da materiale liscio (come la salita presente nel tracciato costruito per prova), i due dc non riuscivano a portare in cima alla rampa Efesto. 11
12
CAP. 4 MECCANICA Vista l inesperienza in questo settore, il primo passo è stato quello di analizzare il funzionamento dei vari componenti e testarli singolarmente. Da qui siamo passati a montare la base principale per Efesto utilizzando un plate bucherellato. Il collegamento dei motori è stato realizzato tramite degli appositi sostegni (in figura) nella parte inferiore della plate. Nella parte inferiore di Efesto è stata montata una sfera, in modo da sostenere il robot su tre piedi e, avendo così solo due ruote, lo spostamento e i vari movimenti del robot avvengono in maniera semplificata. Dopo aver collocato la scheda Arduino, siamo passati alla realizzazione del secondo piano, dove sono state posizionate le batterie. Dettaglio plate, sfera d appoggio e sostegni per motore 13
Infine dopo aver montato ruote, motori e sensori, abbiamo analizzato la pinza; pensavamo che quella acquistata sarebbe stata pronta per l uso ma abbiamo notato che i bracci che servivano a prendere la lattina non erano adatti a quel compito. Abbiamo quindi modificato i due bracci costruendone di nuovi. Pinza prima e dopo la modifica Per facilitare il controllo dei motori e gestire meglio le curve abbiamo adottato un motor shield per la scheda Arduino. 14
CAP. 5 UNITÀ DI CONTROLLO Arduino Mega 2560 è una scheda basata sul microcontrollore ATmega2560. La scheda Arduino è dotata di 54 pin di input/output digitali (14 dei quali possono essere usati come segnali PWM), 16 input analogic, un connettore USB, un jack per l'alimentazione, un connettore per la programmazione ed un pulsantino per il reset della scheda. La scheda inoltre fornisce tutto ciò che è necessario per supportare il funzionamento del microcontrollore. Per cominciare ad utilizzare un Arduino Mega 2560 è necessario connettere la scheda ad un PC tramite un cavo USB oppure alimentare la scheda tramite un adattatore AC-to-DC o tramite una batteria. La scheda Arduino Mega 2560 è compatibile con molte shield progettate per le altre versioni di Arduino, difatti la maggior parte di queste schede hanno larghezza e posizionamento dei pin di input/output uguali. Un Arduino Mega 2560 15
Caratteristiche della scheda Microcontrollore: ATmega2560 Tensione operativa: 5V Input Voltage: (consigliata) 7-12V Input Voltage: (limiti) 6-20V Pin di I/O Digitali: 54 (14 dei quali forniscono in uscita segnali PWM) Pin di Input Analogici: 16 Flash Memory: 256KB (dei quali 8KB utilizzati dal bootloader) SRAM: 8KB EEPROM: 4KB 16
CAP. 6 SENSORI Per il rilevamento di eventuali ostacoli e l individuazione della vittima abbiamo deciso di usare dei sensori della Sharp. Si tratta di sensori di prossimità a infrarossi che forniscono un output analogico che varia da 3.1V a 0.3V e che corrisponde a una distanza che varia da 3cm a 40cm. Dettaglio sensore Sharp Le due lenti che si notano in figura hanno scopi diversi. La prima emette un raggio di luce infrarossa che andrà a scontrarsi con eventuali oggetti. La seconda invece è un rilevatore di luce infrarossa per cui quando la luce andrà a scontrarsi con un oggetto, tramite gli output dell Arduino Mega 2560 siamo in grado di sapere quanto dista. 17
Dettaglio sensore in AutoCAD 18
CAP. 7 ATTUATORI Gli attuatori utilizzati per il movimento di Efesto sono dei motori dc di lunghezza 9.27mm. L albero in uscita corrisponde per forma e dimensioni alle ruote utilizzate per cui non sono state necessarie modifiche. Questo tipo di motori è simile a quello usato sulle mini 4wd e lavora a condizioni di temperatura e umidità standard ( -10,+60 C ) Dettaglio motore Caratteristiche dei motori dc Rapporto di trasmissione 100:1 120rpm 6V 30mA 6V 19
Dettaglio motori AutoCAD Gli attuatori utilizzati per il funzionamento della pinza, invece, sono dei servo motori a basso costo che forniscono però elevate prestazioni. A differenza dei motori dc che funzionano fornendo una velocità da 0 a 255 e la direzione, i servo motori funzionano a rotazione, serve cioè fornire al motore l angolo di rotazione. Dettaglio servo motore Caratteristiche dei servo motori Angolo di rotazione 180 Alimentazione 4.6V-6V Velocità di rotazione 0.20 sec/60 gradi (a 4.8V) Output 2.8kg/cm (a 4.8V) 20
CAP. 8 AMBIENTE DI SVILUPPO Per programmare una scheda Arduino Mega e necessario utilizzare Arduino Ide, un ambiente di sviluppo che consente di scrivere codice, compilarlo e caricarlo direttamente su scheda. Il linguaggio utilizzato e simile al C con in aggiunta qualche istruzione per il controllo dei vari componenti. L ultima versione del software, quella utilizzata per il progetto, è la 1.0 che però non presenta evidenti migliorie rispetto alle versioni precedenti. Dettaglio interfaccia Ide 21
CAP. 9 IL PROGRAMMA SOFTWARE Il software è strutturato in subroutine. Nel main denominato come loop vengono richiamate le due routine principali responsabili del movimento di Efesto e del recupero vittima. A loro volta queste due routine principali richiamano nel loro corso numerose subroutine che servono a strutturare meglio il codice. Di seguito il codice descritto nelle sue parti e commentato nelle righe di codice fondamentali. In questa prima porzione di codice vengono incluse le librerie necessarie all'uso di alcune funzioni di Arduino e vengono definiti i pin utilizzati. #include <QTRSensors.h> #include <DistanceGP2Y0A21YK.h> #define color1 52 #define color2 50 #define color3 48 #define color4 46 #define color5 44 #define color6 42 // definizione dei pin dei motori #define mtr_sx 11 #define mtr_dx 3 //motore dx //motore sx #define dir_sx 13 #define dir_dx 12 22
#define mtrsx 11 #define mtrdx 3 #define dirsx 13 #define dirdx 12 #define armpin 14 #define pinpin 15 // definizione dei pin a cui sono collegati i sensori di linea #define leftfar 0 #define leftcenter 1 #define leftnear 2 #define rightnear 3 #define rightcenter 4 #define rightfar 5 #define NUM_SENSORS 6 #define TIMEOUT 2500 #define EMITTER_PIN QTR_NO_EMITTER_PIN Qui vengono definiti i parametri di configurazione del robot quali velocità massima, minima e aimili; inoltre vengono definite le variabili che verranno utilizzate nel corso del programma. //definizione dei parametri di configurazione del robot #define vel_max 250 // velocità da 0 a 255. #define vel_parz 200 #define vel_correzione 50 // #define soglia 200 // soglia di riconoscimento bianco/nero (0-1000) // dichiarazione variabili globali 23
int leftcenterreading; int leftnearreading; int leftfarreading; int rightcenterreading; int rightnearreading; int rightfarreading; Il sensore di colore è caratterizzato da sei sensori per la lettura dei valori, per questo viene inizializzato un vettore che conterrà i codici dei colori letti dal sensore. //int sensorecoloreid; int valoricolore[6]; Vengono definite le ultime variabili e i servo motori per la pinza. DistanceGP2Y0A21YK Front_up; DistanceGP2Y0A21YK Front_down; DistanceGP2Y0A21YK Left; DistanceGP2Y0A21YK Right; Servo Arm; Servo Pinza; int state; QTRSensorsRC qtrrc((unsigned char[]) { color1, color2, color3, color4, color5, color6,num_sensors, TIMEOUT, EMITTER_PIN); unsigned int sensorvalues[num_sensors]; 24
Nella routine setup il robot legge tramite sensore i colori presenti, in modo da calibrare in maniera semplice Efesto. void setup() { Serial.begin(9600); pinmode(mtr_sx, OUTPUT); pinmode(mtr_dx, OUTPUT); pinmode(dir_sx, OUTPUT); pinmode(dir_dx, OUTPUT); Serial.println("calibrazione in corso..."); for (int i = 0; i < 400; i++){ qtrrc.calibrate(); Serial.println("calibrato."); La routine loop è quella che il robot andrà ad eseguire; vengono richiamate delle subroutine fatte appositamente per seguire la linea e per il recupero vittima. void loop(){ SeguiLinea(); Lattina(); 25
La prossima porzione di codice serve a seguire la linea trovando il valore massimo letto dai sensori, una volta individuato quale sensore ha letto il valore massimo, possiamo dedurre che in quella direzione ci sarà il nastro nero e che quindi Efesto dovrà spostarsi in quella direzione grazie alle routine CorreggiD/S. void SeguiLinea() { if (Front_up.getDistanceCentimeter()<10) Ostacolo(); int IDSensore = elabvalori(); if(idsensore!=-1){ if(idsensore==0 IDSensore==1) Cavanti(); else if(idsensore == 2) CcorreggiS(); else if(idsensore == 3) CcorreggiD(); else if(idsensore == 4) CgiraS(); else if(idsensore == 5) CgiraD(); else{ Cavanti(); int elabvalori() { 26
unsigned int position = qtrrc.readline(sensorvalues); valoricolore[0] = sensorvalues[leftnear]; valoricolore[1] = sensorvalues[rightnear]; valoricolore[2] = sensorvalues[leftcenter]; valoricolore[3] = sensorvalues[rightcenter]; valoricolore[4] valoricolore[5] = sensorvalues[leftfar]; = sensorvalues[rightfar]; int sensorecoloreid = valmaggiore(valoricolore); if(valoricolore[sensorecoloreid]>soglia) return sensorecoloreid; else return -1; int valmaggiore(int vettore[]) { int maggiore = vettore[0]; int indice = 0; for(int i = 1; i<6; i++){ maggiore = max(maggiore,vettore[i]); if(maggiore == vettore[i]) indice = i; return indice; void Cavanti(){ 27
digitalwrite(dir_sx, HIGH); digitalwrite(dir_dx, HIGH); analogwrite(mtr_sx, vel_max); analogwrite(mtr_dx, vel_max); void CcorreggiS(){ digitalwrite(dir_sx, HIGH); digitalwrite(dir_dx, HIGH); analogwrite(mtr_sx, vel_parz); analogwrite(mtr_dx, vel_correzione); void CcorreggiD(){ digitalwrite(dir_sx, HIGH); digitalwrite(dir_dx, HIGH); analogwrite(mtr_sx, vel_correzione); analogwrite(mtr_dx, vel_parz); void CgiraS(){ digitalwrite(dir_sx, HIGH); digitalwrite(dir_dx, LOW); analogwrite(mtr_sx, vel_max); analogwrite(mtr_dx, vel_correzione); 28
void CgiraD(){ digitalwrite(dir_sx, LOW); digitalwrite(dir_dx, HIGH); analogwrite(mtr_sx, vel_correzione); analogwrite(mtr_dx, vel_max); void Cfermo(){ digitalwrite(dir_sx, HIGH); digitalwrite(dir_dx, HIGH); analogwrite(mtr_sx, 0); analogwrite(mtr_dx, 0); int dist(char x){ if (x == 'l'){ return Left.getDistanceCentimeter(); if (x == 'u'){ return Front_up.getDistanceCentimeter(); if (x == 'd'){ return 50; // return Front_down.getDistanceCentimeter(); if (x == 'r'){ return Right.getDistanceCentimeter(); 29
boolean simile(int x, int y){ int tmp = x-y; if (abs(tmp) <4) return true; else return false; void msinistra(){ analogwrite(mtrsx, 150); analogwrite(mtrdx, 150); digitalwrite(dirdx, 1); digitalwrite(dirsx, 0); void mdestra(){ analogwrite(mtrsx, 150); analogwrite(mtrdx, 150); digitalwrite(dirdx, 0); digitalwrite(dirsx, 1); void mavanti(){ analogwrite(mtrsx, 150); analogwrite(mtrdx, 150); digitalwrite(dirdx, 1); digitalwrite(dirsx, 1); 30
void mbrake(){ analogwrite(mtrsx, 0); analogwrite(mtrdx, 0); digitalwrite(dirdx, 1); digitalwrite(dirsx, 1); void alza(){ void apri(){ Pinza.write(0); void chiudi(){ Pinza.write(0); In quest'altro setup vengono definiti i pin usati dalla pinza. void setup() { pinmode(dirdx,output); pinmode(dirsx,output); pinmode(mtrdx,output); pinmode(mtrsx,output); Front_up.begin(A5); Front_down.begin(); Left.begin(A4); 31
Right.begin(); Arm.attach(armPin); Pinza.attach(pinPin); Questa subroutine è responsabile del rilevamento e del recupero della vittima (lattina). void lattina() { delay(5000); mavanti(); int stato = 0; if (stato == 0) { int cont, distlx,distrx,distfr, state; while (state!=-1){ while((simile(dist('l'), dist('r'))) && state == 0){ //Se sono simili, vuol dire che sono in centro e che non c'è nulla di strano ai lati mavanti(); state = 1; mbrake(); //se sono qua ho trovato qualcosa if (simile(dist('l'),dist('r'))){ //invece no, i sensori si sono inventati tutto. state = 0; //ok, dove? if (dist('l')<dist('r') && state == 1){ //è a Sinistra boolean trovato = false; sensori, quello sbalzo è la lattina. //allora giro a sinistra fino a che non trovo uno sbalzo dei while (!trovato){ 32
int a,b,count; a=dist('u'); msinistra(); b=dist('u'); if (!simile(a,b) && state == 1){ // ho trovato il primo pezzo di lattina... state = 2; count = 0; msinistra(); while(state == 2){ //... cerco il prossimo e misuro dove sta count++; a=dist('u'); delay(5); b=dist('u'); if (!simile(a,b) && state == 2){ //ho trovato la fine della lattina, yay for me! state = 3; if (state == 3){ //ora devo tornare indietro di metà count! alza(); apri(); mdestra(); for (int i = 0; i<count/2; i++){ //torno a metà di count delay(5); 33
mbrake(); a=dist('u'); if (a > 10){ // son troppo distante, devo avvicinarmi per prenderla while (dist('u') > 3){ mavanti(); mbrake(); chiudi(); alza(); //presa! yay! else if (dist('l')>dist('r') && state == 1){ //è a Destra La routine Ostacolo individua eventuali ostacoli ingombranti da dover aggirare e compie l'operazione di aggiramento. void Ostacolo(){ int d1=0; int d2=0; while(front_up.getdistancecentimeter()>8){ 34
avanti(); sxasse(); delay(900); fermo(); while(1){ while(right.getdistancecentimeter()<20){ avantipiano(); while(right.getdistancecentimeter()>20){ sinistra(); delay(700); void avanti(){ digitalwrite(mtrsx, 1); digitalwrite(mtrdx, 1); analogwrite(dirdx, 200); analogwrite(dirsx,200); void indietro(){ digitalwrite(mtrdx, 0); digitalwrite(mtrsx, 0); analogwrite(dirdx, 200); analogwrite(dirsx, 200); 35
void destra(){ digitalwrite(mtrdx, 1); digitalwrite(mtrsx, 1); analogwrite(dirdx, 10); analogwrite(dirsx, 255); void sinistra(){ digitalwrite(mtrdx, 1); digitalwrite(mtrsx, 1); analogwrite(dirdx, 255); analogwrite(dirsx, 10); void sxasse(){ digitalwrite(mtrdx, 1); digitalwrite(mtrsx, 0); analogwrite(dirdx, 200); analogwrite(dirsx, 200); void fermo(){ digitalwrite(mtrdx, 1); digitalwrite(mtrsx, 1); analogwrite(dirdx, 0); analogwrite(dirsx,0); 36
void avantipiano(){ digitalwrite(mtrdx, 1); digitalwrite(mtrsx, 1); analogwrite(dirdx, 120); analogwrite(dirsx, 120); 37
CAP. 10 SORGENTE DI ALIMENTAZIONE Per alimentare Efesto sono state utilizzate due batterie. La prima è costituita da un pacchetto di 4 pile ricaricabili che alimentano tutti i motori e i sensori presenti sul robot (2700 ma). La seconda è costituita da una pila da 9V che serve per alimentare la scheda. Dettaglio batterie usate per l alimentazione 38
APPENDICE In questo breve intervento la squadra vuole infine ringraziare i docenti responsabili del progetto che si sono sempre resi disponibili anche in orario extra-scolastico, il professor Tomelleri Paolo per aver ordinato e conservato tutti i pezzi, la professoressa Dallago Nadia per essere sempre stata disponibile a qualsiasi orario e per averci concesso ore di lezione per poter completare il progetto, ed infine il professore De Carli Lorenzo per la costruzione del percorso. 39
INDICE P. 3 - INTRODUZIONE P. 7 CAP. 1 DATI GENERALI P. 9 CAP. 2 DATI DI CONTESTO E MOTIVAZIONE P. 11 CAP. 3 NOME E STRUTTURA DEL ROBOT P. 13 CAP. 4 MECCANICA P. 14 CAP. 5 UNITA DI CONTROLLO P. 17 CAP. 6 I SENSORI P. 19 CAP. 7 GLI ATTUATORI P. 21 CAP. 8 AMBIENTE DI SVILUPPO P. 22 CAP. 9 IL PROGRAMMA SOFTWARE P. 38 CAP. 10 SORGENTE DI ALIMENTAZIONE P. 39 APPENDICE 40
41