INFORMATICA - SISTEMI

INFORMATICA - SISTEMI ROBOT MOBILE pag /6

Contenuto Introduzione... 3 Analisi... 4 Progetto... 5 Le componenti utilizzate... 5 Il microcontrollore... 5 L'ambiente di sviluppo... 6 I motori... 6 Il circuito per controllo motori... 6 I sensori... 7 La batteria... 8 Schema logico di collegamento delle diverse componenti...8 Assemblaggio... 8 Il software... 9 Piano di lavoro e tempistica... 9 Realizzazione... 0 codice sorgente... 0 Immagini robot... 5 pag 2/6

Introduzione Il progetto che abbiamo realizzato come lavoro per l'esame di stato è un robot mobile dotato di 3 ruote (2 posteriori motrici ed una anteriore liberamente ruotante) che si sposta in un area piana evitando gli ostacoli che gli si presentano davanti. Il robot ha inoltre un interruttore montato sulla parte anteriore che gli permette di accorgersi quando si trova in prossimità di un gradino. In questo modo il robot è in grado di rilevare un gradino o qualsiasi altra situazione che lo farebbe cadere nel vuoto, bloccandosi tempestivamente. Il progetto è stato realizzato da Lorenzo Frangella, Luca Simeone e Matteo Raffaeli della classe 5^A iti come tesi per l'esame di stato anno 2009/0. Nel presente documento vengono presentate le specifiche funzionali, risultato della fase di analisi inizialmente condotta, tutta la documentazione di progetto, il lavoro realizzato, sia per quanto riguarda il software prodotto, allegato nelle sue parti principali, che per quanto attiene alla realizzazione vera e propria, presentata tramite immagini fotografiche. pag 3/6

Analisi Dopo una lettura dei progetti trovati in rete e valutate le nostre disponibilità sia di risorse che di tempo (ed anche le nostre capacità) abbiamo deciso di realizzare un Robot che soddisfi le seguenti specifiche:. il robot dispone di sensori/interruttori per rilevare:.) ostacoli frontali, purchè più alti di 8cm da terra.2) ostacoli anteriori a sx e a dx,.3) mancanza di piano di appoggio anteriore 2. il robot reagisce agli ostacoli in modo da modificare la propria traiettoria il meno possibile ma evitando l'ostacolo. L'obiettivo da raggiungere è quello di un robot che trovandosi in un percorso delimitato lo percorra in modo abbastanza lineare ed eviti di girare in tondo 3. il robot non cade da un piano quando giunge al bordo perpendicolarmente ad esso o al massimo con una inclinazione di +/- 30 gradi rispetto alla perpendicolare. 4. il robot dispone di autonomia di circa due ore con batteria al piombo ricaricabile 5. il robot gestisce il comportamento dei suoi motori come una macchina a stati, basandosi su una tabella degli stati analizzata in classe. Le azioni che effettua sono semplici:. va avanti 2. va indietro 3. si ferma 4. curva leggermente a destra o a sinistra, proseguendo sul percorso 5. curva in modo deciso a destra o sinistra cambiando decisamente traiettoria 6. curva in retromarcia a destra o sinistra per liberarsi da una situazione senza uscita La scelta del comportamento da seguire dipende da ciò che rilevano i sensori e da ciò che avevano rilevato nell'istante precedente. Tutto questo è riassunto nella tabella degli stati che vi proponiamo Tutto il progetto deve essere realizzato con un budget ridotto, al massimo 00 euro, e riciclando i materiali disponibili. pag 4/6

Progetto Le componenti utilizzate Nella descrizione del nostro progetto illustriamo innanzitutto le scelte tecnologiche adottate per il funzionamento del robot mobile. Gli elementi importanti sono: - il microcontrollore; - l'ambiente di sviluppo; - i motori; - il circuito per controllo motori; - i sensori; - la batteria. Il microcontrollore Il robot è gestito da un microcontrollore, cioè, un dispositivo programmabile e integrato in grado di acquisire e gestire delle informazioni di dati provenienti da sorgenti hardware esterne. La capacità di calcolo di questi circuiti è molto limitata e di solito eseguono lo stesso programma (firmware) per tutta la durata del loro funzionamento. Le applicazioni che i microcontrollori possono eseguire sono molteplici: si può andare da sistemi di automazione industriale a controlli per svariati sistemi elettronici, come orologi digitali, termometri, ecc... È utile utilizzare i microcontrollori perché possono essere programmati a seconda delle nostre esigenze. Quando un software viene trasferito in un microcontrollore, si ha il cosiddetto "firmware". Noi utilizziamo il microcontrollore (PIC) della Microchip modello PIC8F4520 per i nostri scopi. Allegato a questa documentazione potete trovare il datasheet del PIC da noi utilizzato, mentre qui di seguito riportiamo un semplice riassunto dei principali piedini del PIC8F4520 e del loro utilizzo nel nostro progetto. pin 5 6 7 porta Vpp RC0 RC RC2 2 23 24 25 RD2 RC4 RC5 RC6 collegamento ICD2 motore SX motore SX motore SX sensore pavimento motore DX motore DX motore DX descrizione pin di programmazione determina senso di rotazione del motore sinistro abilita il motore sinistro determina senso di rotazione del motore sinistro riceve informazioni dal sensore di pavimento determina senso di rotazione del motore destro abilita il motore destro determina senso di rotazione del motore destro pag 5/6

28 29 30 3 32 39 40 RD5 RD6 RD7 Vss Vdd PGC PGD sensore destro sensore centrale sensore sinistro ICD2 ICD2 ICD2 ICD2 riceve informazioni dal sensore infrarosso destro riceve informazioni dal sensore infrarosso centrale riceve informazioni dal sensore infrarosso sinistro pin di programmazione pin di programmazione pin di programmazione pin di programmazione L'ambiente di sviluppo Il PIC8F4520 è stato programmato tramite alcuni strumenti hardware e software appropriati. Lo strumento software utilizzato è il programma MPlab su Windows XP con il quale abbiamo scritto il software per la gestione del robot con il linguaggio C8. La parte hardware utilizzata per trasferire il programma sul PIC è il programmatore ICD 2 della Microchip che è stato collegato tramite porta USB al computer e tramite 5 spinotti alla scheda che ospita il PIC. I pin esatti del PIC che abbiamo collegato al programmatore sono: - pin : Vpp-MCLR tensione di programmazione - pin 32: Vdd alimentazione +5V - pin 3: Vss-GND terminale di massa GND 0V - pin 39: PGC clock di sincronismo - pin 40: PGD dati di programmazione I motori Il nostro robot è composto da una base meccanica realizzata da studenti dell'ipsia, indirizzo meccanica l'anno precedente al nostro. La base è di alluminio e su di essa sono applicate 3 ruote di cui folle e girevole e 2 motrici. Le due ruote motrici sono azionate da motori in continua a spazzole alimentati a 2V. La nostra scelta è caduta su questi motori perché essi hanno una notevole flessibilità di impiego e la loro velocità è facilmente controllabile, soprattutto quando non è richiesta una particolare precisione. I più grandi vantaggi di questi motori sono: il loro elevato rapporto peso/potenza; la loro facilità nella regolazione, sia come velocità che come coppia, soprattutto se non sono richieste prestazioni elevate; la loro elevata coppia di spunto che li rende ideali nella trazione elettrica. Il circuito per controllo motori I 2 motori in corrente continua descritti prima sono controllati da un circuito della ditta Microbot in modo molto semplice. Il circuito appartiene alla categoria dei ponti H ed è studiato apposta per il controllo di due motori in corrente continua tramite un microcontrollore. Avremmo potuto controllare i motori anche in modo più semplice dal punto di vista elettronico con 4 relè ma abbiamo scelto questa alternativa per trovare minori difficoltà nella costruzione del software. Il movimento che i motori dovranno effettuare saranno effettuati seguendo la logica della tabella degli stati che troverete alla fine di questo capitolo. pag 6/6

Questo circuito ci ha aiutato moltissimo nell utilizzo dei motori a corrente continua. Il circuito può essere alimentato da 3 o 30 V. Per azionare ognuno dei 2 motori è necessario seguire una semplice procedura: - settare l ingresso del circuito Enable a per abilitare il motore - settare l ingresso del circuito InputA - settare l ingresso del circuito InputB Gli ingressi InputA e InputB vanno settati a seconda del movimento che si vuole far fare al motore. Qui di seguito si possono vedere i collegamenti fatti con il microcontrollore e la serie di settaggi del circuito per far funzionare i motori in tutti i modi possibili. motore SX uscita pic (pin) 5 - RC0 6 - RC 7 - RC2 colore cavo blu rosso bianco enable 0 inputs input A 0 0 x motore DX ingressi MR00 input B Enable input A uscita pic (pin) 23 - RC4 24 - RC5 25 - RC6 colore cavo blu rosso bianco ingressi MR00 input 2B Enable input 2A uscite motore input B 0 0 x motore fermo motore fermo motore va avanti motore va indietro motore libero non controllato I sensori Per trovare una soluzione valida per fare in modo che il nostro robot evitasse gli ostacoli che gli si presentano davanti abbiamo effettuato numerose ricerche. La soluzione più appropriata ci è sembrata quella di acquistare 3 sensori a luce infrarossa per i seguenti motivi: - meno influenza sul colore e sulla riflettività degli oggetti, grazie al metodo di misurazione a triangolo ottico - si attivano ad una distanza di 5 cm - non è necessario nessun circuito di controllo esterno; gli output possono essere connessi direttamente al microcontrollore - basso costo Questi sensori presentano 3 fili di colore rosso, nero e giallo. Dal filo rosso il sensore viene alimentato. Il filo nero è invece utilizzato per il negativo. Infine il filo giallo è quello che abbiamo collegato al microcontrollore. Il funzionamento di questi sensori è molto semplice: normalmente i sensori non trasmettono corrente sul cavo giallo, ma se il sensore incontra qualche ostacolo (riceve indietro la luce infrarossa inviata precedentemente), il sensore mette l uscita alla stessa tensione a cui viene alimentato facendo capire in questo modo al PIC che è stato incontrato un ostacolo. Tra il filo rosso e quello giallo abbiamo dovuto montare come descritto nel datasheet, una resistenza da 2Kohm. Oltre ai sensori è stato montato sulla parte anteriore del robot un semplice interruttore che durante il funzionamento del robot è normalmente chiuso. Appena il robot si trova in una situazione di pericolo come un gradino l interruttore si apre e il robot si arresta prima di cadere nel vuoto danneggiandosi irreparabilmente. pag 7/6

La batteria La batteria scelta è una semplice batteria della Beghelli da 2 V al piombo. La scelta è ricaduta su questa batteria per la sua versatilità e potenza. Il robot potrebbe anche funzionare con una serie di batterie al litio comunemente usate anche negli elettrodomestici o nei telecomandi. Schema logico di collegamento delle diverse componenti Le varie parti sono così collegate fra loro: Assemblaggio Il robot che quest anno abbiamo realizzato deriva da uno che era già stato costruito una volta dagli studenti dell anno precedete al nostro con comportamenti diversi (rispondeva ad un radiocomando). Il robot è stato ripreso quest anno e sono state apportate le seguenti modifiche meccaniche: - è stata eliminata una ruota girevole per poter rendere il robot più stabile su 3 ruote invece che 4 - è stata cambiata la posizione di ogni componente del robot (ruote motrici, schede PIC + PIC) - sono stati sostituiti i circuiti per la gestione dei motori con un unico circuito più semplice da gestire e più efficace - sono stati aggiunti i sensori ad infrarossi - è stato eliminato il radiocomando perchè non volevamo copiare cose realizzate da altri. - è stata aggiunta una batteria al piombo da 2 V I vari componenti sono stati montati come da disegno: pag 8/6

Il software Il software si basa sulla tabella dei comportamenti qui presentata. Come tutti i programmi C anche questo dispone di una funzione main() da cui partire, che è formata da un ciclo principale che continua ad eseguire le stesse istruzioni a vita. All inizio della funzione (e fuori dal ciclo principale) vengono inizializzate le porte del PIC come input o come output. Il primo controllo che viene fatto nel ciclo principale è quello dell interruttore frontale: se l interruttore è aperto significa che il robot non ha più un appoggio sicuro sulla parte anteriore e deve quindi arrestarsi tempestivamente perché ha incontrato un situazione di pericolo (gradino, bordo, ecc). Se l interruttore invece chiuso il robot non si trova in una situazione di pericolo e può continuare a eseguire le sue istruzioni di movimento basandosi sui sensori ad infrarossi. Il programma controlla i sensori tramite la funzione input_sensori e manda il risultato alla funzione muovi che decide come far muovere il robot in base alla tabella dei comportamenti. Il software tiene anche in memoria lo stato precedente in modo da evitare spiacevoli comportamenti obsoleti del robot. Piano di lavoro e tempistica Abbiamo iniziato il nostro lavoro poco dopo l inizio del secondo quadrimestre ponendoci come obbiettivo quello di riuscire a terminare il progetto per l esame di maturità. Abbiamo suddiviso il lavoro in 3 fasi che sono state tutte effettuate nei tempi previsti: - documentazione e piano di lavoro (in marzo) - assemblaggio robot (aprile e maggio) - realizzazione software e programmazione PICMicro (aprile e maggio) pag 9/6

Realizzazione La documentazione di quanto realizzato è divisa in 2 parti: - codice sorgente (firmware del robot) - immagini robot codice sorgente Codice sorgente (firmware del robot) /* firmware V.0 Controllo robot mobile */ /* Frangella Lorenzo - Simeone Luca - Raffaeli Matteo */ /* per maggiori informazioni : frangella@email.it */ //#include <p8cxxx.h> #include <p8f4520.h> //#include <stdio.h> //#include <ancomp.h> //#include <usart.h> #pragma config OSC = HS//0 Mhz #pragma config WDT = OFF #pragma config PWRT = ON #pragma config LVP = OFF #pragma config PBADEN = OFF // altrimenti porta B partirebbe come ingresso analogico //funzioni di controllo int input_sensori(void); int muovi(int, int); //funzioni di movimento void azionea(void); void azioneb(void); void azionec(void); void azioned(void); void azionee(void); void azionef(void); void azioneg(void); void azioneh(void); void azionei(void); //define stati #define A 0 #define B #define C 2 #define D 3 #define E 4 #define F 5 #define G 6 #define H 7 #define I 8 //funzioni di ritardo void ritardo(void); void ritardolungo(void); //funzione di impostazione delle porte di input e output del pic void imposta_input_output(void); //INIZIO VARIABILI GLOBALI // comportamenti da tenere in ogni cambio di stato int IN[] = {E,E,E,E,E,H,E,E,E; int IN2[] = {A,B,A,B,F,F,F,F,F; int IN3[] = {A,B,A,B,F,F,I,F,F; pag 0/6

int IN4[] = {A,B,A,D,D,B,D,B,B; int IN5[] = {A,B,C,B,C,A,C,A,A; int IN6[] = {A,B,A,B,B,B,B,B,B; int IN7[] = {A,B,A,B,A,A,A,A,A; int stato=e;//variabile per tenere traccia della stato precedente //int interruttore = 0; //FINE VARIABILI GLOBALI //INIZIO funzione MAIN - funzione principale void main (void){ int sensori=;//controlla cosa vogliono fare i sensori /* significato valori possibili: -> IN -> via libera 2 -> IN2 -> ostacolo da tutti i sensori 3 -> IN3 -> ostacolo centrale 4 -> IN4 -> ostacolo a destra 5 -> IN5 -> ostacolo a sinistra 6 -> IN6 -> ostacolo avanti e a destra 7 -> IN7 -> ostacolo avanti e a sinistra */ imposta_input_output(); //abilitiamo circuito di controllo motori PORTCbits.RC=;//enable 6 PORTCbits.RC5=;//enable 24 PORTDbits.RD2=;//porta interruttore //avviamo robot avanti azionee(); //ciclo principale while() { if(portdbits.rd2==0){ sensori = input_sensori(); stato = muovi(sensori, stato); ritardo(); PORTDbits.RD2=;//porta interruttore else{ azioneg(); //FINE funzione MAIN void ritardo(void){ unsigned long int i; for(i=0; i< 500; i++); void ritardolungo(void){ unsigned long int i; for(i=0; i< 30000; i++); //funzione di controllo input dai sensori int input_sensori(void){ /*sensori: PORTDbits.RD7 -> sens sx PORTDbits.RD6 -> sens c PORTDbits.RD5 -> sens dx */ if(portdbits.rd7==0&&portdbits.rd6==0&&portdbits.rd5==0){ return ;//via libera pag /6

if(portdbits.rd7==&&portdbits.rd6==&&portdbits.rd5==){ return 2;//ostacolo da tt i sens if(portdbits.rd7==0&&portdbits.rd6==&&portdbits.rd5==0){ return 3;//ostacolo centrale if(portdbits.rd7==0&&portdbits.rd6==0&&portdbits.rd5==){ return 4;//ostacolo dx if(portdbits.rd7==&&portdbits.rd6==0&&portdbits.rd5==0){ return 5;//ostacolo sx if(portdbits.rd7==0&&portdbits.rd6==&&portdbits.rd5==){ return 6;//ostacolo avanti dx if(portdbits.rd7==&&portdbits.rd6==&&portdbits.rd5==0){ return 7;//ostacolo avanti sx return ; //funzione che decide il prossimo stato del robot int muovi(int sens, int stat){ int old_stato = stat; // serve per ricordare lo stato al tempo precedente /* solamente se da una rilevazione alla successiva lo stato cambia, allora si prende una nuova decisione di movimento, altrimenti si continua il comportamento scelto nel giro precedente */ // parte ) determinare il nuovo stato switch(sens){ case : stat = IN[stat]; case 2: stat = IN2[stat]; case 3: stat = IN3[stat]; case 4: stat = IN4[stat]; case 5: stat = IN5[stat]; case 6: stat = IN6[stat]; case 7: stat = IN7[stat]; /*if(interruttore){ stat = G; */ // parte 2, se lo stato è cambiato, scegliere una nuova azione if (old_stato!= stat) { switch( stat ) { pag 2/6

case 0: azionea() ; case : azioneb() ; case 2: azionec() ; case 3: azioned() ; case 4: azionee() ; case 5: azionef() ; case 6: azioneg() ; case 7: azioneh() ; case 8: azionei() ; return stat; //A - ruota destra void azionea(void){ //motore dx indietro PORTCbits.RC4=; PORTCbits.RC6=0; //motore sx avanti PORTCbits.RC0=0; PORTCbits.RC2=; ritardolungo(); //B - ruota sinistra void azioneb(void){ //motore dx avanti PORTCbits.RC4=0; PORTCbits.RC6=; //motore sx indietro PORTCbits.RC0=; PORTCbits.RC2=0; ritardolungo(); //C - vai a destra void azionec(void){ //motore dx fermo PORTCbits.RC4=; PORTCbits.RC6=; //motore sx avanti PORTCbits.RC0=0; pag 3/6

PORTCbits.RC2=; ritardolungo(); //D - vai a sinistra void azioned(void){ //motore dx avanti PORTCbits.RC4=0; PORTCbits.RC6=; //motore sx fermo PORTCbits.RC0=; PORTCbits.RC2=; ritardolungo(); //E - vai avanti void azionee(void){ //motore dx avanti PORTCbits.RC4=0; PORTCbits.RC6=; //motore sx avanti PORTCbits.RC0=0; PORTCbits.RC2=; //ritardolungo(); //F - vai indietro void azionef(void){ //motore dx indietro PORTCbits.RC4=; PORTCbits.RC6=0; //motore sx indietro PORTCbits.RC0=; PORTCbits.RC2=0; ritardolungo(); ritardolungo(); ritardolungo(); //G - fermo void azioneg(void){ //motore dx fermo PORTCbits.RC4=; PORTCbits.RC6=; //motore sx fermo pag 4/6

Immagini robot Particolare del circuito di controllo motori. Si notano le due coppie di file che vanno ai motori Basetta di connessione dei sensori. Raccoglie i cavi dei sensori e li manda al PIC8F4520 La scheda principale con il PIC8F4520. Si può vedere lo zoccolo ZIF per togliere facilmente il PIC La slitta che protegge il sensore meccanico (interruttore) anteriore pag 5/6

Un sensore ad infrarossi laterale Uno dei motori con la ruota. pag 6/6