Programació del robot Pololu 3PI by Institut Torre del Palau

Programació del robot Pololu 3PI

PROGRAMACIÓ DEL ROBOT POLOLU 3PI

ÀLEX IZQUIERDO RODRÍGUEZ ADRIÀ CALVET GONZÀLEZ 2on BATXILLERAT CIENTÍFIC-TECNOLÒGIC CURS 2011-2012 TREBALL DE RECERCA 1

Programació del robot Pololu 3PI

ÍNDEX 1. Introducció..............................................................................................................................4 2. El robot....................................................................................................................................6 2.1 Característiques.................................................................................................................7 3. Elements del robot..................................................................................................................8 3.1 Motors...............................................................................................................................8 3.2 Sensors..............................................................................................................................9 3.3 ATPmega328p.................................................................................................................11 3.3.1 Característiques........................................................................................................11 3.3.2 Connexió dels PIN’s.................................................................................................12 3.4 Bateries............................................................................................................................13 3.5 Rodes...............................................................................................................................15 3.6 LCD.................................................................................................................................15 3.7 Indicadors Led.................................................................................................................16 3.8 Altaveu............................................................................................................................16 3.9 Botons.............................................................................................................................17 3.10 Sistema d'estabilització.................................................................................................18 4. Entorn de programació..........................................................................................................19 4.1 Programa principal..........................................................................................................19 4.2 Tokens.............................................................................................................................19 4.3 Paraules clau...................................................................................................................20 4.4 Identificadors..................................................................................................................21 4.5 Operadors........................................................................................................................22 4.6 Separadors.......................................................................................................................22 4.7 Comentaris......................................................................................................................22 4.8 Sentencies de control de flux..........................................................................................23 4.8.1 sentència IF - ELSE.................................................................................................23 4.8.2 sentència “Switch”...................................................................................................24 4.8.3 Bucles.......................................................................................................................24 4.8.4 sentència “While”....................................................................................................25 4.8.5 sentència “Do...while”.............................................................................................25 4.8.7 sentència “Continue”................................................................................................26 4.8.8 sentència “goto”.......................................................................................................26 5. Programari i eines utilitzades................................................................................................27 5.1 AVR STUDIO 4..............................................................................................................27 5.2 Cable USB.......................................................................................................................27 5.3 Llibreries de programació...............................................................................................28 5.4 Programador AVR ISP de 6 pins connectors...................................................................28 6. Instal·lació del programari....................................................................................................29 6.1 Creació d'un projecte amb AVR Studio...........................................................................29 6.2 Compil·lació i programació d'un projecte.......................................................................30 7. Creació de menús..................................................................................................................32 8. Seguidor de línies..................................................................................................................35 8.1 Pantalla principal.............................................................................................................35 8.2 Calibració de sensors......................................................................................................37 2

Programació del robot Pololu 3PI 8.3 Funció dels motors..........................................................................................................38 8.3.1 Assaig del primer circuit..........................................................................................39 8.3.2 Segona prova de circuit............................................................................................39 8.4 Creació variable “comptador”.........................................................................................41 9. Resolució d’un laberint ........................................................................................................44 9.1 Resolució directa del laberint..........................................................................................48 9.1.1. sentència path..........................................................................................................48 9.1.2. Exemple de memòria “path”...................................................................................49 10. Tancament...........................................................................................................................50 11. Conclusions.........................................................................................................................52 12. Fonts d'informació..............................................................................................................55 13. Agraïments..........................................................................................................................57

Programació del robot Pololu 3PI

1. Introducció A l’hora de seleccionar el nostre treball de recerca, vàrem escollir aquest treball de robòtica ja que suposaria una gran millora en els nostres coneixements a l’àrea de tecnologia. La robòtica, és una de les branques principals de la tecnologia, i per això, els dos membres del grup hem triat aquest tema, ja que ens sembla que realitzar aquesta tasca serà molt útil per al nostres estudis. La robòtica, és un camp difícil per començar, i per això, assistirem a un curs de la Universitat Politècnica de Catalunya (UPC) a Terrassa, on ens donaran unes lliçons bàsiques per ajudar-nos a afrontar aquest treball. Per a aquest objectiu, vam treballar amb un robot anomenat “Pololu 3pi”, un robot capaç de realitzar diferents funcions, com per exemple, utilitzar els seus sensors per el seguiment d’una línia. Aquest robot va ser proposat per els instructors del curs de l’UPC, ja que és bastant senzill de programar i ideal per a usuaris amb poca experiència com nosaltres. El treball pràctic consistirà bàsicament en la creació d'un menú inicial per al robot, amb les funcions bàsiques que ja porta el robot (Mesura de la càrrega de la bateria, un potenciòmetre, etc.), i afegir-li diferents funcions, com per exemple, la del seguidor de línies, la resolució d'un laberint, etc). Per a la creació d'aquests programes, començarem des d'uns exemples que venien amb el programari del robot, que ens serviran com a base en la programació. El dos estudiants que vam fer aquest treball cursem el Batxillerat Tecnològic, i creiem que la programació del robot i la assistència al curs d’estiu de l’UPC, ens ajudaran molt a l’hora de iniciar-nos en aquest món. Per exemple, les matèries que vam donar a la UPC la setmana que vàrem

Programació del robot Pololu 3PI estar allà són assignatures impartides al primer curs de qualsevol enginyeria. La robòtica és molt important actualment, ja que la utilització de robots és molt usual al món actual, com per exemple, la utilització de robots per a la indústria (cadenes de muntatge). Un altre dels motius pels quals hem escollit aquest tema pel nostre Treball de Recerca és per continuar la línia de treballs que hem realitzat durant tota l’ESO, ja que al nostre institut hem realitzat tant la programació, com la construcció i el disseny de alguns robots diferents al que utilitzarem durant aquest treball, com per exemple, el robot seguidor de línies o el robot Lego Mindstorm que vàrem utilitzar el curs anterior, al treball de recerca de 4art de la ESO. Aquest nou robot ens va suposar un repte, ja que era més complex i llarg que tots el robots que havíem fet anteriorment, però finalment vam aconseguir ensortir-nos.

Programació del robot Pololu 3PI

2. El robot El Pololu 3pi és un petit robot autònom de gran rendiment, dissenyat per competicions de seguiment de línia i resolució de laberints. està controlat per

microcontrolador

anomenat

ATmega328p amb 32 kBytes de memòria flash per a carregar el programa que farà el robot, i també 2 kBytes de memòria RAM per a carregar variables temporals, i connectats a aquest una sèrie de perifèrics que són: una pantalla LCD de 8x2 caràcters per a mostrar missatges a gust del usuari, un timbre de

Imatge 1: El robot Pololu 3pi

petites dimensions, tres polsadors, LED’s, 2 motors reductors que li permeten arribar a una velocitat de 1 m/s, etc. I tot això en un xassís de 9,7 cm de diàmetre. Per una altra banda, el Pololu 3pi es programa mitjançant llenguatge C, utilitzant un programa gratuït anomenat AVR Studio 4.

Programació del robot Pololu 3PI

2.1 Característiques Aquestes són les característiques físiques i tècniques del robot que programarem. Aquestes dades són essencials per a la seva correcta programació i utilització. Una vegada programat el robot, podrem veure aquestes dades a la pantalla LED, com per exemple el voltatge. Aquestes són les característiques principals: •

Microcontrolador: ATmega328

•

Diàmetre del xassís: 9,7cm

•

Divers dels motors:TB6612FNG

•

Motors: 2 (1 per a cada roda)

•

Interfases I/O disponibles para el usuari: 21

•

Voltatge mínim: 3 Vcc

•

Voltatge màxim: 7 Vcc

•

Freqüència PWM màxima: 80 kHz

Programació del robot Pololu 3PI

3. Elements del robot A continuació explicarem detalladament les parts principals del robot amb el qual treballarem i programarem per aquest treball de recerca. Aquestes són les parts més importants: – Motors – Sensors – Microcontrolador Atmega328p. – Bateries – Rodes – LCD – Indicadors led – Altaveu – Botons – Sistema d'estabilització

3.1 Motors El Pololu 3pi incorpora 2 motors de tipus DC (Corrent Continua). Aquests motors de corrent continua arriben fins a diversos milers de revolucions per

minut

(rpm),

per

qual

dispositiu

d’engranatges permet reduir aquestes revolucions i augmentar la força de gir. El motors DC tenen també la possibilitat de poder modificar la direcció de gir a partir del anomenats ponts H. Els ponts H Imatge 2: Motor encarregat d’una de les rodes del robot.

és

construeixen

mitjançant

transistors

que

realitzant la funció de interruptors, en el cas del 3pi s’utilitzen ponts per als dos motors en el 3pi

mitjançant el chip TB6612FNG. Per una altra banda els motors del Pololu 3pi ofereixen un control de la velocitat a partir de les sortides PWM

Programació del robot Pololu 3PI (Modulació de la grandària del puls) del microcontrolador, és a dir, que podràs marcar a la velocitat que vagin el motors en cada instant. El Pololu 3pi té motors independents a cadascun dels costats, per això, es crea un mètode de conducció anomenat conducció diferencial, però per poder girar mitjançant aquest mètode és necessari fer girar el motors a diferents velocitats.

3.2 Sensors El Pololu 3pi té una sèrie de sensors, els quals permeten guiar el moviment del robot, ja sigui dreta esquerre davant o enrere. El robot obliga al sensor a llegir i a retornar la lectura estimada entre el robot i la línia, en un valor entre 0-4000. Si el valor és 0 això indica que el està al sensor 0, si el valor és 1000 això indica que el sensor utilitzat és el 2, i així successivament amb el altres. Si ens endinsem en com funcionen els sensors en trobem amb tres possibilitats:

Imatge 3. Valors mostrats pels sensors de reflexió.

Programació del robot Pololu 3PI

• 0-1000: Si el robot marca un valor entre 0 i 1000, vol dir que el robot està lluny del costat dret de la línia i per això girarà cap a l’esquerra de manera que per fer-ho aquest ajustarà el motor dret a 100 i el esquerra a 255. • 1000-3000: Si el robot marca un valor entre 1000 i 2000 vol dir que el robot està centrat en la línia, i per això aquest ajustarà els motors a velocitat 100, per a que aquest segueixi recte. • 3000-4000: Si el robot marca un valor entre 3000 i 4000 significarà que aquest està lluny del costat esquerre de la línia, i per això girarà cap a la dreta mitjançant l’ajustament del motor dret a 0 i el motor esquerre a 100.

Imatge 4: Esquema dels sensors dels sensors de reflexió presents al robot.

Programació del robot Pololu 3PI

3.3 ATPmega328p El microcontrolador que s'incorpora dintre de el Pololu 3pi és el ATmega328P, és un microcontrolador d'alt rendiment i de baix consum. Aquest microcontrolador és el cor del Pololu 3pi i conté una sèrie de pins que es poden configurar com entrades/sortides digitals o analògiques.

Imatge 5: Microcontrolador ATmega328P

3.3.1 Característiques Aquestes són les característiques principals del microcontrolador del nostre robot, encarregat de totes les funcions i de la memòria. •

131 Instruccions

•

Fins 20 MIPS rendiment a 20MHz

•

Pin Count: 32

•

Max pines I / O: 23

•

SPI: 2

•

UART: 1

•

ADC: 8 canals, 10 bits de resolució

•

Comparadors analògics: 1

•

Flash (Kbytes): 32

•

EEPROM (Kbytes): 1

•

SRAM (Kbytes): 2

•

Rang de temperatures: -40 a 85 ° C

Programació del robot Pololu 3PI

3.3.2 Connexió dels PIN’s A continuació, veurem la destinació i funció de tots el Pin del robot Pololu 3Pi. Aquestes dades són molt importants ja que a l'hora de connectar altres elements externs al nostre robot, caldrà saber on hem de connectar-lo pel seu correcte funcionament. En total són 32 pins: número Pin PIN1

del Code

PIN16 PIN17 PIN18 PIN19

PD3 (OC2B/INT1) PD4 (XCK/T0) GND VCC GND VCC PB6 (XTAL1/TOSC1) PB7 (XTAL2/TOSC2) PD5 (OCOB/T1) PD6 (OCOA/AIW0) PD7 (AIN1) PB0 (CCK0/ICP1) PB1 (0C1A) PB3 (SS/0C1B) PB3 (MOSI/0C2A) PB4 (MIS0) PB5 (SCK) AVCC ADC6

PIN20 PIN21 PIN22 PIN23

AREF GND ADC7 PC0 (ADC0)

PIN24

PC1 (ADC1)

PIN2 PIN3 PIN4 PIN5 PIN6 PIN7 PIN8 PIN9 PIN10 PIN11 PIN12 PIN13 PIN14 PIN15

Lloc on és connecten Drivers del motor i motor LCD Massa Font 5V Font 5V Oscil·lador Oscil·lador Drivers del motor i motor Drivers del motor i motor LCD/LED LCD LCD Buzzer (brunzidor) Drivers del motor / Connexió de Programació Connexió de Programació Connexió de Programació Font 9,25 V Voltatge de la bateria, circuit de detecció Font 9,25 V

Control de sensors reflectants i IR LED Control de sensors reflectants i IR LED 12

Programació del robot Pololu 3PI PIN25

PC2 (ADC2)

PIN26

PC3 (ADC3)

PIN27

PC4 (ADC4/SDA)

PIN28 PIN29

PC5 (ADC5/SCL) PCS (RESET)

PIN30 PIN31 PIN32

PD0 (RXD) PD1 (TXD) PD2 (INTO)

Control de sensors reflectants i IR LED Control de sensors reflectants i IR LED Control de sensors reflectants i IR LED Alimentació sensors i r/led. Botó d’apagar / Connexió de Programació / Drivers del motor Comunicació en sèrie Comunicació en sèrie LCD

Taula 1. número, nom i funció dels 32 pins del Pololu 3pi.

3.4 Bateries Com qualsevol sistema electrònic, el nostre robot ‘’Pololu 3pi’’ requereix d'una alimentació, en aquest cas la alimentació és fa mitjançant 4 piles de 1,2 V de tipus AA, que donen la potència al sistema. Aquestes treballen de manera que el voltatge de la bateria disminueix, però els components elèctrics utilitzats precisen d'un voltatge controlat, gràcies a un component

anomenat

regulador

voltatge. Imatge 1'2 V.

D’aquests reguladors hi han dos tipus: • Lineals:

Aquests

utilitzen

circuit

Bateries

retroalimentació simple per variar la quantitat d’energia que passa a través de com i quan es descarrega. El regulador lineal produeix una disminució del valor de entrada a un valor determinat de sortida i el sobrant de potencial és perd. • Switching: Aquest tipus de reguladors alternen la tensió on/off a freqüència generalment alta, i filtrant el valor de sortida, això produeix un gran valor de estabilitat de voltatge, a més a més, també poden convertir i regular voltatges baixos i convertir-los en

Programació del robot Pololu 3PI alts. El component principal del regulador switching

està en el

inductor que és el que emmagatzema l’energia i la va alliberant suaument, en el 3pi el inductor és el chip que es troba a prop de la bola marcat com ‘100’.

Al Pololu 3pi, el voltatge de 4x AAA piles pot variar entre 3,5 i 5,5 volts gràcies al regulador de voltatge a 5V. S’utilitza el regulador switching per elevar el voltatge a 9,25 V (Vboost) i reguladors lineals per a obtenir 5V (VCC). Vboos s’utilitza per als motors i el leds sensors IR en línia, mentre que el VCC és per al microcontrolador i les senyals digitals. Utilitzant aquest mètode obtenim tres avantatges que no tenen altres robots que són: • El voltatge alt es reserva per als motors • Mentre s'està regulant, el motors treballen a la mateixa velocitat, sempre i quan les bateries estiguin entre 3,5 i 5,5 volts. • El cinc LED IR connectats en sèrie a 9,25 V consumeixen menys quantitat d’energia.

Imatge 7: Diagrama del funcionament de la bateria del robot Pololu 3pi.

Programació del robot Pololu 3PI El punt important d’aquest sistema d’energia és que les bateries no s’esgoten progressivament com passa al majoria de robots, sinó que al Pololu 3pi funcionarà al màxim rendiment fins que és pari en algun moment.

3.5 Rodes Les rodes són el components que permeten que el robot és pugui moure. En el cas del robot les rodes tenen un radi de 0,67 inch. Quan igualem el motor amb les rodes arribem a la conclusió que en el Pololu 3pi, 30 voltes de motor són 1 de la roda. Les rodes poden arribar a una velocitat de 700 rpm i el seu consum mínim és de 60mA a un màxim de

Imatge 8. Rodes laterals del robot.

540 mA. Nombre de metres que recorre en 1 volta: 700 rpm x 2π/60 = 73,30 rad/s Nombre de metres per minut: 73,30 rad/s x 60s = 4.398 rad/m

3.6 LCD El LCD que porta com a component el Pololu 3pi és de 8x2 caràcters (2 columnes de 8 caràcters cadascuna), en la qual es pot visualitzar totes les opcions que pot arribar a proposar-nos el nostre robot. La pantalla LCD del robot Pololu 3PI

està connectada en sèrie. En el

cas que vulguis obtenir una pantalla més gran, per poder

posar

més

caràcters,

fàcilment

Imatge 9. Pantalla LCD

substituïble.

Programació del robot Pololu 3PI

3.7 Indicadors Led Els indicadors Led són uns components que posterior de la placa del

estan situats a la part

robot, els quals

estan connectats amb els sensors i segons el que aquests perceben fan la seva funció que és emetre llum, de color verd o vermell en aquest cas. També tenim 2 petits leds en el component

connexió

del

robot

amb

Imatge 10. Led vermell

l’ordinador, aquest s’encenen per mostrar-nos si el robot està connectat o no a l'ordinador.

3.8 Altaveu El Pololu 3pi també porta integrat un altaveu o brunzidor, mitjançant el qual és pot configurar el robot amb algun programa amb el qual aquest emeti sons. Imatge 11. Altaveu del robot Pololu 3pi

Programació del robot Pololu 3PI

3.9 Botons El Pololu 3pi porta una sèrie de botons que li permeten anar pel menú d’opcions que tingui el robot, i també s’utilitzen per activar i escollir el programa que vols que faci el robot. Per altra banda també porta els botons d'encendre o apagar el robot o el de resetejar el sistema.

Imatge 12. Esquema dels botons presents al xassís del robot

Programació del robot Pololu 3PI

3.10 Sistema d'estabilització A les primeres proves del nostre robot, vàrem detectar de que al disposar de dues rodes al laterals i una roda boja a la part posterior, el robot no anava estable, i donava cops cap endavant ja que no disposava de cap element que mantingues estable el nostre robot. Per tant, vàrem decidir soldar un LED a la part davantera del robot (davant de les piles), fet que va solucionar el problema.

Imatge 13. Posició del Led encarregat de estabilitzar el robot, la roda boja i la roda principal.

Programació del robot Pololu 3PI

4. Entorn de programació Per a la programació del nostre robot Pololu 3pi, el més adequat és la utilització de la programació en C, el llenguatge essencial per a la programació. Aquest entorn de programació és el més utilitzat a l’història de la informàtica, ja que ofereix una eina senzilla i molt útil. Molts dels jocs, sistemes i programes els quals disposem actualment han estat creats gràcies a aquest entorn de programació.

4.1 Programa principal A la programació, qualsevol projecte ha de contenir un programa principal que s’encarrega d’iniciar el programa i combinar les diferents subrutines segons el que l’hem indicat. Per a indicar-li al nostre compilador on és el nostre programa principal, posem la funció “main” i utilitzarem les claus ({}) per a agrupar les diferents sentencies del programa principal.

4.2 Tokens Els tokens són els components sintàctics emprats pel programador. S’encarreguen d'indicar al programador les funcions que ha de dur a terme (anar a una subrutina, tornar a començar el programa, anar a una determinada línia del programa, etc..). Dins dels tokens, podem distingir sis classes: paraules clau, identificadors, constants, cadenes de caràcters, operadors i separadors. El compilador només “entén” les expressions que li són pròpies, i per tant, qualsevol caràcter que no és propi del programa,

Programació del robot Pololu 3PI podrà malmetre tot el programa. Els comentaris, i els sagnats del principi de cada línia són ignorats pel programador. #include <pololu/3pi.h> void initialize { unsigned int counter; // Usat como un temporizador unsigned int sensors[5]; // Un vector para guardar el estado dels sensors //Aquest codi es el primer que s'ha d'utilitzar per iniciar els sensors de reflexió pololu_3pi_init(2000); // Mostrar la tensió de la bateria fins que es prem el botó B while(!button_is_pressed(BUTTON_B)) { int bat = read_battery_millivolts(); clear(); print_long(bat); print("mV"); lcd_goto_xy(0,1); print("Apretar B"); delay_ms(100); }

4.3 Paraules clau En el llenguatge C, hi ha una sèrie de paraules que no és poden utilitzar com a nom d’una funció, ja que són emprats universalment per a comunicar-li al programador un altre tipus de tasca concreta. Aquest llenguatge de programació, al ser molt senzill i concret, consta de poques paraules clau. A continuació, veiem les més importants a l’hora de programar el nostre robot: delay_ms(xxxx): Indicació al programador de que esperi un número determinat de milisegons. Switch: Serveix per evitar llargues sentencies de “if-else”. return: Indiquem al programador que ha de tornar al principi de la rutina.

Programació del robot Pololu 3PI goto: Indiquem al programador que ha d’anar a un punt específic del programa. if: Indiquem al programador que si és compleix una condició, ha de fer una tasca determinada. if else: Indiquem al programador que si no és compleix aquesta condició, faci un altre tasca determinada. while: Indiquem al programador que ha de realitzar una tasca al mateix moment que un altre. Path: sentència encarregada d'enregistrar els moviments del robot a la memòria.

4.4 Identificadors La funció dels identificadors és la de anomenar amb una única paraula una funció, variable o una part del contingut del nostre programa, amb l’objectiu de fer un programa més senzill i menys extens. L’Identificador no pot contenir caràcters aliens al llenguatge del nostre programador (sobretots símbols: &,$,@...) o espais en blanc. Els identificadors són molt útils ja que ens ajuden a agrupar una funció llarga en una única paraula, i ens pot ajudar molt a l’hora d’identificar una funció o rutina i de corregir un programa extens. int main ( ) unsigned int posición=read_line (sensors, IR_EMITTERS_ON); if posició=4000 or posició=0 { Set_motors (20,-20) delay_ms(1000) set_motors (-20,20) }

Programació del robot Pololu 3PI

4.5 Operadors Els operadors són signes especials encarregats de realitzar operacions entre determinades variables del nostre programa.

4.6 Separadors Els

separadors

són

els

encarregats

d’ajudar

compilador

descompondre cadascun dels tokens en l’ordre correcte. A més, els separadors ofereixen una millor il·legibilitat del programa. Els espais en blanc, els tabuladors i els caràcters a un altre línia, són exemples dels separadors més utilitzats.

4.7 Comentaris Els comentaris són notes fetes per l’autor que es mantenen fora del programa i serveixen per a poder realitzar explicacions sense malmetre ni canviar el programa original, ja que el programador ometrà directament aquesta informació. Normalment, els comentaris s’utilitzen per tractar d’entendre millor la finalitat o funció de cada token. Per a indicar al programa un comentari, s’utilitzaran els següents caràcters, (//) o (/*) per indicar-li el començament del comentari, o (\\) i (* \) per indicar el final. #include <pololu/3pi.h> void initialize { //Aquest codi es fa el primer per iniciar els sensors de reflexió. pololu_3pi_init(2000); // Mostrar la tensió de la bateria fins que es premi el botó B while(!button_is_pressed(BUTTON_B)) { int bat = read_battery_millivolts(); //Esperarem que es deixi de premer el boto B per fer la calibració //La autocalibració realitza un gir a la dreta del robot i despres cap a l'esquerra. for(counter=0;counter<80;counter++)

Programació del robot Pololu 3PI

4.8 Sentencies de control de flux Originalment, el programador executa les seqüències ordenadament, és a dir, començant per la primera i acabant per l’última. El llenguatge de programació en C, compta amb algunes sentencies que s’encarreguen de canviar aquest ordre, com per exemple, les sentencies IF, i ELSE, que ja hem començat a explicar anteriorment.

4.8.1 sentència IF - ELSE Aquesta sentència s’encarrega d’executar o no una sentència en el cas de que es compleixi una condició determinada. Si aquesta condició no es compleix, el programador automàticament executa la sentència que va darrere del “else”. A continuació en veiem un exemple: #include <pololu/3pi.h> void initialize { unsigned int counter; // Usat com un temporizador unsigned int sensors[5]; // Un vector per guardar el estat dels sensors { if(counter < 20 || counter >= 60) set_motors(40,-40) ; else set_motors(-40,40) ; // Guarda els valors dels sensors calibrate_line_sensors(IR_EMITTERS_ON) ; delay_ms(20); } }

En aquest programa, si la variable “counter”, que és un temporitzador, és més petit que 20 o més gran o igual que 60, els motors es posaran en velocitat 40,-40 respectivament, és a dir, farà un gir cap a la dreta. En canvi, si aquesta condició no es compleix i aquest temporitzador no té els

Programació del robot Pololu 3PI valors indicats, el programador directament accionarà els motors a -40,40 respectivament, és a dir, que farà un dir cap a l’esquerra.

4.8.2 sentència “Switch” La sentència switch té una funció semblant a la de la sentència IF – ELSE. En aquest cas, el programador analitza la condició i realitzarà les tasques assignades per aquest valors i els següents. és a dir, en el exemple que veiem a continuació, si el valor de la condició coincideix amb la expressió número 2, és realitzaran els tokens de 2,3,4... Per indicar-li al programador les sentencies que entren dins del switch, posarem totes aquestes sentencies entre els les claus ({) i (}).

Imatge 14. Exemple d’us de la sentència “switch”

4.8.3 Bucles A més de les sentencies de condició, al llenguatge C trobem unes sentencies capaces de repetir un nombre determinat de vegades la mateixa sentència. Aquestes sentencies són els bucles, i els més utilitzats són el do...while, for i el while.

Programació del robot Pololu 3PI

4.8.4 sentència “While” La sentència “while” indica al programador que ha de repetir una mateixa sentència sempre i quan és compleixi una condició, és a dir, quan aquesta condició deixi de ser complida, aquesta sentència deixarà de ser utilitzada. Aquí en tenim un exemple: while(!button_is_pressed(BUTTON_B)) { int bat = read_battery_millivolts(); clear(); print_long(bat); print("mV"); lcd_goto_xy(0,1); print("Apretar B"); delay_ms(100); } Durant el temps que el botó B estigui polsat, el programador llegirà les sentencies que hi ha entre les claus (llegir la bateria, netejar i escriure a la pantalla,etc...) indefinidament, però en el moment que el botó B deixi de estar polsat, aquestes sentencies deixaran de ser llegides pel programador.

4.8.5 sentència “Do...while” Aquesta sentència és molt semblant a la anterior, però amb la diferencia de que el token que posem entre el “do” i el “while” serà realitzat al finalitzar el bucle, i no mentre aquest bucle és manté actiu.

4.8.6 sentència “Break” Aquesta sentència és utilitzada per interrompre la lectura d’una sentència per el programador.

Programació del robot Pololu 3PI

4.8.7 sentència “Continue” La sentència “continue” s’encarrega de que el programa comenci el següent cicle del bucle encara que no hagi arribat fins al final d’aquest.

4.8.8 sentència “goto” Aquesta sentència indica al programador que ha de saltar directament cap a un altre lloc del programa o un altre subrutina, estalviant-se les sentencies que hi han a continuació i anant directament a la part del programa que li hem indicat.

Programació del robot Pololu 3PI

5. Programari i eines utilitzades Seguidament,

explicarem

totes

les

eines

físiques

informàtiques

(programari) que és necessari per a la correcta programació del Pololu 3PI. Encara que algunes d'aquestes eines no són imprescindibles (les llibreries de programació, per exemple), són essencials per a fer-ho el més còmode i senzill possible.

5.1 AVR STUDIO 4 La programació en C és el mètode de programació més utilitzat a la informàtica i altres camps de la tecnologia, però per poder programar bé necessitarem l’ajuda

d’un

programador,

programa

d’ordinador que s’encarrega de facilitar la tasca de trobar els errors al codi, passa el programa al ordinador, compilar,etc... Com a programador hem utilitzat el programa “AVR Studio 4”; un programa senzill, intuïtiu i gratuït recomanat per els professors de la UPC.

Imatge 15. Logo del programador que utilitzarem, l’AVR Studio 4.

Amb aquest programa, bàsicament realitzarem les tasques de compilació (recerca d’errors al codi abans de passar-ho al robot) i la de transmissió d’informació

robot

(mitjançant

cable

USB,

programador

traspassarà la informació del nostre ordinador al microcontrolador del Pololu 3pi).

5.2 Cable USB Cable típic utilitzat a la informàtica, és l’encarregat de fer arribar la informació creada del programador al nostre robot. El seu nom complet és Universal Serial Bus, i normalment és emprada per la connexió de diferents aparells perifèrics a la nostra computadora. El tipus necessari 27

Programació del robot Pololu 3PI per la seva connexió era un Cable USB A to mini-B cable, que és el tipus d'entrada que té el programador AVR ISP, explicat a continuació.

5.3 Llibreries de programació Les llibreries de programació, una de les eines més utilitzades a la programació, són un conjunt de funcions creades per programadors experts amb la intenció de facilitar la programació a altres usuaris. Aquestes sentencies ja construïdes, ens faciliten molt la tasca de la programació del robot, ja que consten d’unes extenses funcions i variables des de el començament, que hauríem de crear manualment. Un exemple d’això és la sentència “print”, que ens ajuda a afegir-li text a la pantalla LED del nostre robot. Aquesta sentència és inclosa a la llibreria de programació que nosaltres vàrem utilitzar, i ens va

Imatge 16. Logo de Winrar, programa utilitzat per agrupar les llibreries i poder difondre-les per Internet.

estalviar la creació de nombroses variables que ens haguessin ocupat massa espai dintre del nostre programa.

5.4 Programador AVR ISP de 6 pins connectors Fa possible la comunicació entre l’ordinador i el microcontrolador del nostre robot, ATmega328P. Aquest programador és de 6 pins ja que són necessaris

per

connectar-los

amb

microcontrolador del robot, i un port USB que el connectarà amb l’ordinador o el dispositiu que utilitzem per programar el robot. Aquest element és

imprescindible

que

garanteix

que

informació que fem al nostre ordinador pugui passar-se al robot. Té dues llums (vermella i

Imatge 17. Programador AVR ISP amb 6 pins.

verda) que ens indiquen el seu estat. 28

Programació del robot Pololu 3PI

6. Instal·lació del programari Per instal·lar el programari necessari per la programació del nostre robot, cal seguir les instruccions següents: 1. Instal·lar AVR Studio (AvrStudio4Setup.exe) 2. Instal·lar el Service Pack 1 de AVR Studio (AVRStudio4.18SP1.exe) 3. Instal·lar el Service Pack 2 de AVR Studio (AVRStudio4.18SP2.exe) 4. Instal·lar WinAVR (WinAVR-20090313-install.exe) 5. Extraure el fitxer libpololu-avr y fer doble clic en make-install.

6.1 Creació d'un projecte amb AVR Studio Per començar, obrim el programa AVR Studio 4, que prèviament hem instal·lat al nostre ordinador, i per crear un projecte, seleccionem “Project Wizard” a la pestanya “Project”, que podem trobar-la al menú de la cantonada superior esquerra. Seguidament, seleccionarem New Project. A la pantalla que ens sortirà a continuació, escollim l'opció AVR GCC i a “Project name” li posem el nom que nosaltres vulguem, i que servirà per identificar-lo

nostre

ordinador.

continuació,

seleccionem

AVR

Simulator 2, i el nostre tipus de microcontrolador, en el nostre cas Atmega328p.

Imatge 18. Selecció de Plataforma i microcontrolador per a la programació.

Programació del robot Pololu 3PI Ara podem donar-li a “Finish” i ja podrem introduir el codi que vulguem.

6.2 Compil·lació i programació d'un projecte Una vegada hem acabat de construir el nostre codi, seleccionarem el botó del menú superior “Build Active Configuration” o simplement polsarem el botó F7, per compilar-lo i que el nostre programador detecti els errors al programa. Al quadre de text de la part inferior de la pantalla ens indicara el número de errors i alertes (warnings).

Imatge 19. Esquema dels botons per a compil·lar i per programar el nostre codi.

Programació del robot Pololu 3PI Després, li donarem al botó “CON”, anomenat “Display the connect dialog” i

seleccionarem

programador

“AVRISP”

“STK500”

port,

seleccionarem “auto”, perquè ho faci automàticament. Finalment, seleccionem el botó “AVR”, “Connect to the selected AVR Programmer”, i després de seleccionar el arxiu corresponent (.hex) al nostre programa, seleccionarem “Program” i és carregarà el programa al nostre robot.

Imatge 20. Programació del robot

Programació del robot Pololu 3PI

7. Creació de menús Per a la combinació de diferents programes dins del robot, utilitzarem un menú principal per a organitzar les diferents subrutines. Dins d’aquest menú, disposarem de diferents opcions, com per exemple, per iniciar el seguidor, per a comprovar els LED’s,etc... Per començar, tenim que col·locar les diferents opcions del menú seguidament dels missatges introductoris que hem posat al principi del nostre programa. const char menu_bat_test[] PROGMEM = "Bateria"; const char menu_led_test[] PROGMEM = "LEDs"; const char menu_lcd_test[] PROGMEM = "LCD"; const char menu_ir_test[] PROGMEM = "Sensors"; const char menu_motor_test[] PROGMEM = "Motors"; const char menu_music_test[] PROGMEM = "Música"; const char menu_pot_test[] PROGMEM = "Trimpot"; const char menu_time_test[] PROGMEM = "Crono"; const char menu_seguidor[] PROGMEM = "Seguidor"; const char menu_turbo_seguidor[] PROGMEM = "S.Ràpid"; const char menu_seguidor_PID[] PROGMEM = "S.Segur"; const char menu_encierro[] PROGMEM = "Tancament"; const char menu_maze[] PROGMEM = "Laberint"; Com veiem, primer hem de crear una nova constant, que serà la paraula que ens dirigirà a la subrutina dins del menú. Aquí, podem veure com la primera opció que veiem al nostre menú serà la de “menu_bat_test”, i al menú, el seu nom serà “Bateria”. Així, quan vulguem posar la subrutina de la opció “Bateria”, caldrà posar “void bat_test”, per indicar al programador que relacionem aquesta subrutina amb l’opció del menú.

Programació del robot Pololu 3PI

Aquí podem veure les diferents subrutines enllaçades amb la seva opció al menú: void bat_test(); void led_test(); void lcd_test(); void ir_test(); void motor_test(); void music_test(); void time_test(); void pot_test(); void seguidor(); void turbo_seguidor(); void seguidor_PID(); void encierro() Finalment, hem de indicar-li el programador les opcions que volem que surtin a la pantalla i el seu ordre. Ho farem amb aquestes funcions: void (*function)(); const function main_menu_functions[] = { bat_test, led_test, pot_test, ir_test, motor_test, music_test, time_test, seguidor, turbo_seguidor, seguidor_PID, encierro, maze}; const char *main_menu_options[] = { menu_bat_test, menu_led_test, menu_pot_test, menu_ir_test, menu_motor_test, menu_music_test, menu_time_test, menu_seguidor, menu_turbo_seguidor, menu_seguidor_PID, menu_encierro, menu_maze}; const char main_menu_length = sizeof(main_menu_options)/sizeof(main_menu_options[0]);

I finalment, com ja hem vist abans, posem la subrutina segons l’ordre que hem posat abans amb la funció que hem vist

ProgramaciĂł del robot Pololu 3PI void ir_test() { unsigned int sensors[5]; // una serie de valors del sensor if(button_is_pressed(BUTTON_C)) read_line_sensors(sensors, IR_EMITTERS_OFF); else read_line_sensors(sensors,IR_EMITTERS_ON); unsigned char i; for(i=0;i<5;i++) { // Inicia la serie de caracters utilitzats pel grafic. Usant l'espai, // farem una copia extra del caracter, i el caracter 255 (una caixa negra),nosaltres tenim // 10 caracters en serie. // La variable C tĂŠ valors d'1 a 9, des de que el valor esta en el rang de 0 a 2000, // i el 2000/201 es 9 amb una integral matematica. char c = bar_graph_characters[sensors[i]/201]; print_character(c); // Mostra el "bargraph" caracters. } // Mostra un indicador de si el IR esta encĂŠs o apagat. if(button_is_pressed(BUTTON_C)) print("IR-"); else print(" C"); delay_ms(100); }

Programació del robot Pololu 3PI

8. Seguidor de línies Amb aquest programa, el nostre robot Pololu tindrà la funció de seguir una línia de color negre sobre un fons de color blanc. Per a detectar aquesta línia, el robot utilitzarà els seus sensors de reflexió per a detectar el color negre. Gràcies al programa que li ficarem al robot, els motors, s’accionaran quan els sensors detectin la línia. Quan un dels dos sensors que porta el nostre robot detecti que no hi ha la línia negra, tombarà cap al costat contrari en busca de la línia negra. Quan no trobi la línia, el robot seguirà un recorregut en zig-zag fins que torni a trobar-ne la línia, i llavors tornarà al seu recorregut inicial. Gràcies a les llibreries de programació i diferents eines que ens proporciona el subministrador, podem partir el nostre programa a través d’un dels exemples que trobem dins de la carpeta “Software” – “libpololu” – “examples”, i seleccionem el programador del nostre robot, en el nostre cas “Atmega 328p”. En aquesta carpeta seleccionem el exemple que volem, en aquest cas “3pi-linefollower” i l’obrim amb el programa “AVR Studio”. Malgrat això, tractarem de explicar la programació del robot des de zero.

8.1 Pantalla principal Comencem creant dos identificadors, un utilitzat com a temporitzador, on és calcularà el temps transcorregut, i un altre que guardarà l’estat dels sensor. Després farem una lectura de la tensió que

passa

sentència

pel

nostre

robot

amb

“read_battery_millivolts”

farem que ens la indiqui a la pantalla LED. A la línia inferior, escriurem “Pulsar

Imatge 21. Pantalla LED indicant la tensió del robot.

Programació del robot Pololu 3PI B” per indicar a l’usuari que ha polsar el botó per a posar en marxa el robot. Aquest és el programa sencer: void initialize() { unsigned int counter; // Usat com un temporizador unsigned int sensors[5]; // Un vector per guardar el estat de los sensors //Aquest codi es el primer en executar-se, ja que serveix per iniciar els sensors. pololu_3pi_init(2000); // Mostrar la tensió de la bateria mentre no es premi el botó B while(!button_is_pressed(BUTTON_B)) { int bat = read_battery_millivolts(); clear(); print_long(bat); print("mV"); lcd_goto_xy(0,1); print("Apretar B"); delay_ms(100); } //Esperem a que es deixi de polsar el botó B // par començar la cal·libració dels sensors wait_for_button_release(BUTTON_B); delay_ms(1000); }

Programació del robot Pololu 3PI

8.2 Calibració de sensors Abans de posar en marxa el robot, cal fer una calibració del sensors de reflexió per garantir el seu correcte funcionament. Per a realitzar aquest procés, afegirem a sota del codi utilitzat per la pantalla principal aquest codi: // Auto-calibració: un gir a la dreta i un altre a l'esquerra mentre s'ajusten // els sensors. for(counter=0;counter<80;counter++) { if(counter < 20 || counter >= 60) set_motors(40,-40); else set_motors(-40,40); // Esta funcion graba un set de lectures del sensor i mantenia // els valors maxims i minis trobats. El // IR_EMITTERS_ON significa que si el IR Led es troba // girat durant la calibració, que es usualment el que // volem. calibrate_line_sensors(IR_EMITTERS_ON); // El nostre comptador comença a 80, per tant, el temps total serà // 80*20 = 1600 ms. delay_ms(20); } set_motors(0,0);

El primer que farà just després de prémer el botó B serà fer un gir cap a l’esquerra i un altre cap a la dreta, amb l’objectiu de que els sensors de reflexió vegin si hi ha un línia o no. Una vegada acabat aquest procés, tindrem que polsar-li un altra vegada al mateix botó per que avanci i els sensors facin la seva funció amb normalitat. A la pantalla LED, el robot ens indicarà numèricament si detecta la línia negra amb els seus sensors.

Programació del robot Pololu 3PI

8.3 Funció dels motors Aquestes sentencies ens permetran ajustar el sentit de gir i la velocitat del motor, i per tant, de les dues rodes del nostre robot. La sentència principal és diu “set_motors” i a continuació, posarem entre parèntesis la velocitat de gir que volem per cada motor, l’esquerra i el dret, respectivament. La velocitat escollida serà 40, ja que es una velocitat adequada per tal que el robot no és surti de la línia del circuit, cosa que passaria si la velocitat fos major. Després, creem l’identificador “posición” que s’encarregarà de fer la lectura dels sensors i de emmagatzemar les dades. int main () { unsigned int sensors [5] initialize() ; while (1) { unsigned int posición=read_line(sensors,IR_EMMITERS_ON); if (posició<1000) set_motors(-100,100) ; if (posició<3000 & read_line>1000) set_motors(100,100) ; if (posició>3000) set_motors (100,-100) } } Per tant, quan els sensors de reflexió indiquin “1000” o inferior, és a dir, que la línia només és detectada pels sensors de l’esquerra, la roda esquerra anirà cap endarrere (velocitat de -40) i la dreta cap endavant, fent un gir cap a l’esquerra.

Programació del robot Pololu 3PI Si els sensors detecten que la línia és entre 1000 i 3000, és a dir, que la línia és detectada per tots els sensors de reflexió del robot, aquest seguirà una línia recta. Finalment, si els sensors detecten la línia major que 3000, el robot necessitarà un gir cap a la dreta, i per tant, la roda esquerra anirà cap endavant i la roda dreta en sentit contrari, per aconseguir el gir del robot.

8.3.1 Assaig del primer circuit Després de programar el nostre robot, ha arribat l’hora de provar-ho. Farem servir un circuit amb una única línia recta. Per

que

funcionar

nostre

correctament

robot

pugui

per

aquest

circuit, només caldrà programar els sensors i els motors del robot, ja que al ser una tasca senzilla no caldrà fer-hi

Imatge 22. Realització d’una de les proves del robot Pololu 3pi amb el circuit inicial.

més.

8.3.2 Segona prova de circuit Després

comprovar

que

programació del robot per al primer circuit hagi estat la correcta i funcioni, prepararem

nostre

robot

per

aconseguir que pugui funcionar per el circuit 2. Aquest circuit, com podem veure a l’imatge, està caracteritzat per la seva línia discontinuïtat.

Imatge 23. Imatge del robot amb el circuit 2, que presenta una línia discontinua al principi.

Programació del robot Pololu 3PI Per a aconseguir això, haurem de programar el robot per que quan no trobi línia per cap dels seus sensors de reflexió, avanci en una trajectòria de zig-zag fins a trobar novament la línia, i llavors, retornar la seva trajectòria. Com a base, utilitzarem el programa que hem creat al principi, i mitjançant uns petits retocs, intentarem aconseguir el nostre objectiu. El programa inicial és el següent: include <pololu/3pi.h> void initialize() { unsigned int counter; // Usat com un temporitzador unsigned int sensors[5]; // Un vector per guardar el estat dels sensors //Aquest codi ha de ser executat el primer per iniciar els sensors de reflexió. pololu_3pi_init(2000); // Mostrar la tensió de la bateria mentre no es pulsi el botó B while(!button_is_pressed(BUTTON_B)) { int bat = read_battery_millivolts(); clear(); print_long(bat); print("mV"); lcd_goto_xy(0,1); print("Apretar B"); delay_ms(100); } //Quan es deixi de polsar el botó B començara la calibració dels sensors. wait_for_button_release(BUTTON_B); delay_ms(1000); //La autocalibració fará un gir a dretes i un altre cap a l'esquerra. for(counter=0;counter<80;counter++) { if(counter < 20 || counter >= 60) set_motors(40,-40); else set_motors(-40,40); //Guarda els valors dels sensors calibrate_line_sensors(IR_EMITTERS_ON); delay_ms(20); }

Programació del robot Pololu 3PI

set_motors(0,0); while(!button_is_pressed(BUTTON_B)) { // Llegeix el valor dels sensors de reflexió. unsigned int posició = read_line(sensors,IR_EMITTERS_ON); clear(); print_long(posició); lcd_goto_xy(0,1); delay_ms(100); } wait_for_button_release(BUTTON_B); clear(); print("Go!"); } int main() { unsigned int sensors[5]; initialize(); int comptador=0; while(1) unsigned int posición=read_line(sensors,IR_EMMITERS_ON); if (posició<1000) set_motors(-100,100) ; if (posició<3000 & read_line>1000) set_motors(100,100) ; if (posició>3000) set_motors (100,-100) } }

8.4 Creació variable “comptador” Abans de que el nostre robot comenci una trajectòria en forma de zig-zag per cercar la línia, deixarem que durant uns pocs segons vagi recte. Això ens permetrà, en cas de que els sensors no funcionin massa bé, que el robot no és desvií massa ràpid de la trajectòria, i pugui trobar-la posteriorment. Per això, utilitzarem una variable a la que anomenarem “comptador”, i serà l’encarregada de “dir-li” al robot, quan ha de deixar de anar en línia recta per a desviar-se i començar una trajectòria en zigzag.

Programació del robot Pololu 3PI

//Si no detecta linia i la variable “comptador” està a 0 //seguir recte durant mig segon en busca de la linia if (posición==4000 && comptador==0) { for (comptador=0;comptador<6;comptador++) { time_reset() ; while(get_ms()<250) set_motors(10,10) ; posició=read_line(snsors,IR_EMMITERS_ON) ; { if (posició<4000) { comptador=6 Break; } } Com veiem al nostre programa, al principi de tot hem creat la variable anomenada “comptador” amb la funció “unsigned int counter”. Aquesta variable, s’encarrega de comptar el temps en intervals de mig segon, i quan arribi a 6 (3 segons), indicar-li al robot que ha de canviar de variable. Per a això, utilitzarem la sentència “IF”. Si els sensor ens indica que no troba la línia (4000), i el comptador és menor a 6, seguirà una trajectòria recta. Si aquest comptador no arriba a 6, seguirà les altres sentencies, però si arriba, interromprà aquesta funció (break) i anirà a la següent part del programa: //Si no detecta linea i l'ha intentat trobar //Gira a l'esquerra 500 milisegons i va cap endavant 500 milisegons. if (posición==4000 && comptador>=6) { time_reset() ; while(get_ms()<500) set_motors(-10,10) ; time_reset () ; while(get_ms()<500) set_motors(10,10) ; } 42

Programació del robot Pololu 3PI Si els sensors de reflexió no troben línia i el comptador és major a 6 (han passat més de 3 segons des que no és troba línia), es tornarà a iniciar el compte (time_reset), i cada mig segons (500 milisegons), el robot anirà cap a un costat i l’altre, amb les ordres que li hem donat al motors:

set_motors (-10,10): el motor esquerra va en sentit contrari i el motor dret va cap endavant, i per tant, el robot gira cap a l’esquerra.

set_motors (10,-10): el motor esquerra va cap endavant i el motor dret va en sentit contrari, i per tant, el robot gira cap a la dreta.

Ara només cal carregar el nostre programa al robot, i utilitzar el circuit 2 per a provar si el nou programa funciona correctament.

Imatge 24.Robot Pololu 3PI provant el seguidor de línia discontinua al circuit 2.

Programació del robot Pololu 3PI

9. Resolució d’un laberint Per a incloure la funció de resoldre un laberint, utilitzarem un altre dels exemples de programa que ens proporciona les llibreries de programació. Cal tenir en compte que aquests programes estan ideats com si fossin programes principals, i si volem incloure'l a dins del nostre menú, caldrà fer-li algunes modificacions. La resolució d'un laberint tindrà dues parts: la primera, serà quan el robot miri totes les possibilitats que tingui per resoldre el laberint, i intenti anar per tots els recorreguts possibles fins a trobar el final. A les interseccions, s'havia de decidir cap a quin cantó girarà sempre, i per això, sempre que hi hagi dos camins possibles, anirà cap al de l'esquerra. Mentre fa aquesta part, el robot emmagatzemarà les vegades que ha girat, que ha anat recta, la direcció en la que ha anat... La segona part, consistira en que el nostre robot resolgui un altre vegada el laberint, però de manera que vagi pel camí més curt, és a dir, sense tenir que passar per tots els recorreguts possibles fins a trobar el camí. Aixo és possible gràcies a la informació que ha guardat de la primera resolució del laberint. Això, ho explicarem més detalladament al següent apartat. Per utilitzar aquest exemple, ens demana que li hem d'afegir al programador dues llibreries diferents, anomenades “follow-segment.h” i “turn.h”. Per a afegir-les, anirem al menú de l'esquerra, i a “Source Files”, clickarem a “Add Existing Source File(s)” i ens obrirà una finestra per seleccionar la ubicació dels dos arxius.

Programació del robot Pololu 3PI

Imatge 25. Inclusió de noves llibreries al nostre programa.

A continuació, buscarem la sentència on creem la funció “path” dins del programa del laberint, i la canviem de lloc, per posar-la al principi de tot, on creàvem els menús: const char menu_bat_test[] PROGMEM = "Bateria"; const char menu_led_test[] PROGMEM = "LEDs"; const char menu_lcd_test[] PROGMEM = "LCD"; const char menu_ir_test[] PROGMEM = "Sensors"; const char menu_motor_test[] PROGMEM = "Motors"; const char menu_music_test[] PROGMEM = "Música"; const char menu_pot_test[] PROGMEM = "Trimpot"; const char menu_time_test[] PROGMEM = "Crono"; const char menu_seguidor[] PROGMEM = "Seguidor"; const char menu_turbo_seguidor[] PROGMEM = "S.Ràpid"; const char menu_seguidor_PID[] PROGMEM = "S.Segur"; const char menu_encierro[] PROGMEM = "Tancament"; const char menu_maze_solve[] PROGMEM = "Laberint"; char path[100] = ""; unsigned char path_length = 0; // the length of the path

Programació del robot Pololu 3PI Al principi del programa, copiarem la calibració de sensors feta al programa “seguidor de línies”, ja que per a resoldre el laberint el robot necessitarà saber la seva posició davant la línia negra. { clear(); print(path); if(path_length > 8) { lcd_goto_xy(0,1); print(path+8); } } char select_turn(unsigned char found_left, unsigned char found_straight, unsigned char found_right) { if(found_left) return 'L'; else if(found_straight) return 'S'; else if(found_right) return 'R'; else return 'B'; } void simplify_path() { if(path_length < 3 || path[path_length-2] != 'B') return; int total_angle = 0; int i; for(i=1;i<=3;i++) { switch(path[path_length-i])

Programació del robot Pololu 3PI

{ case 'R': total_angle += 90; break; case 'L': total_angle += 270; break; case 'B': total_angle += 180; break; }

Seguidament, posarem fora de la subrutina les sentencies que tinguin relació amb la funció “path”, creada anteriorment: total_angle = total_angle % 360; // Canvia el tot camí per un sol gir switch(total_angle) { case 0: path[path_length - 3] = 'S'; break; case 90: path[path_length - 3] = 'R'; break; case 180: path[path_length - 3] = 'B'; break; case 270: path[path_length - 3] = 'L'; break; } // The path is now two steps shorter. path_length -= 2; }

Programació del robot Pololu 3PI Finalment, canviarem els textos que apareixeran a la pantalla LED del nostre robot, com hem fet nosaltres: while(!button_is_pressed(BUTTON_B)) { if(get_ms() % 2000 < 1000) { clear(); print("Meta!"); lcd_goto_xy(0,1); print("Pulsa B"); } else display_path(); delay_ms(30);

9.1 Resolució directa del laberint Una vegada el nostre robot ha completat totalment el laberint, aquest tindrà la capacitat de tornar-lo a fer sense cometre cap error en la seva trajectòria.

9.1.1. sentència path La sentència path és l'encarregada d'emmagatzemar la informació que pren el robot al resoldre el laberint per a que a la següent vegada ho faci pel camí més curt.

Programació del robot Pololu 3PI

9.1.2. Exemple de memòria “path”

Imatge 26. Esquema de l'emmagatzemament de dades del robot Pololu 3PI.

Com hem explicat abans, el nostre robot, en cas de tenir dos camins, sempre optarà primer per el camí de l'esquerra. En aquest circuit, el robot comença amb una “S”, ja que va cap endavant (el camí de l'esquerra). Seguidament, arriba a un punt final, i té que donar la volta, és a dir, una “U”. Ara el codi guardat és “SU” després, només té un camí, ja que l'altre ja l'havia fet i era incorrecte, i per tant, substitueix el “SUL” per una “R”, que era el camí que havia de haver fet des de el principi. Després, a l'altre intersecció, provarà el camí de l'esquerra, el central, i quan arribi al camí correcte, el de la dreta, esborrarà les dades dels altres camins, i el podi serà “RU”. Quan el robot torni a fer el camí, seguirà el camí “RUS”, i per tant, anirà pel camí més curt sense tenir que passar per les altres alternatives.

Programació del robot Pololu 3PI

10. Tancament A continuació, intentarem atorgar-li un altre funció al nostre robot, que serà la de mantenir-se dins d'una zona delimitada per línies al voltant, que mai podrà travessar. D'aquesta funció que farà el nostre robot no hem trobat cap exemple útil, però al ser un programa molt semblant al creat per el seguidor de línies, agafarem aquest programa com a base del que crearem a aquest apartat. El primer que farà el robot serà calibrar els sensors, igual que quan resol un laberint o segueix la línia: //Esperem a que deixi d'apretar B // per començar la calibració dels sensors wait_for_button_release(BUTTON_B); delay_ms(1000); //La autocalibració realitza un gir a la dreta del robot i després //cap a l'esquerra for(counter=0;counter<80;counter++) { if(counter < 20 || counter >= 60) set_motors(40,-40); else set_motors(-40,40); //Guarda els valors dels sensors calibrate_line_sensors(IR_EMITTERS_ON); delay_ms(20); } set_motors(0,0); while(!button_is_pressed(BUTTON_B) { // Llegeix el valor dels sensors de reflexió. unsigned int posició = read_line(sensors,IR_EMITTERS_ON); clear(); print_long(posició); lcd_goto_xy(0,1); delay_ms(100); }

Programació del robot Pololu 3PI Seguidament, agafem el programa principal del seguidor de línies, i únicament hem de modificar els valors dels motors segons la seva situació. En aquest cas, el robot quan no trobi línia seguira cap endavant, i quan la trobi davant donara la volta o girarà cap a un costat en el cas de que trobi la línia amb un dels seus sensors laterals. El programa quedaria aixi: while(1) { unsigned int posició = read_line(sensors,IR_EMITTERS_ON); if(posició>500 && posició<2000) { set_motors(0,100); // Només per estetica, indiquem als led's la seva funció. left_led(0); right_led(1); } else if(posició>2000 && posició<3000) { set_motors(75,0); left_led(1); right_led(0); delay_ms(1000); set_motors(100,100); } else if (posició>3000 && posició<4000) { set_motors(100,0); left_led(1); right_led(0); } Ara, l'únic que hem de fer és suprimir la sentència següent, que és ineccesaria pel “tancament”: //Si els 5 sensors del davant marquen linia negra s'atura o fora zona blanca: seguretat. if (sensors[1]>600 && sensors[2]>600 && sensors[3]>600 && sensors[4]>600) { set_motors(0,0); }

Programació del robot Pololu 3PI

11. Conclusions Quan els dos membres del grup vam prendre la decisió de escollir aquest tema per al treball de recerca, vam coincidir en que ho faríem per el nostre interès comú en el camp de la tecnologia, i especialment, la robòtica. Ja havíem fet uns altres robots molts més senzills (Lego Mindstorm, altres tipus de seguidors de línia...), i aquests robots

van

despertar el nostre interès en la programació de robots. Durant la realització d’aquest treball hem gaudit molt i après moltes coses sobre el mòn de la tecnologia. La nostra formació per aquest treball de recerca va començar a la UPC on vam iniciar-nos en la programació d’aquesta sèrie de robot o altres aparells, va ser un curset d’una setmana en la qual vam realitzar diferents pràctiques de programació de robots amb llenguatge C i els professors de la UPC ens van ensenyar una base per poder començar a programar en llenguatge C. El fet de fer aquest curset va ser una experiència molt satisfactòria ja que vam iniciar-nos en aquest món i gràcies això la realització del nostre projecte va ser molt més fàcil. Conèixer alguns professors de la universitat i tractar matèries que és cursen a l'UPC (la programació en llenguatge C és una matèria ensenyada a 1er de quasi totes les Enginyeries), va ser una experiència molt útil. Després de realitzar aquest curset a l'estiu, vam començar el nostre treball de recerca, i el primer problema que ens va parèixer va ser la instal·lació dels programes i aplicacions adients a l’ordinador per poder modificar i programar el robot, amb l’ajuda dels nostres tutors vam aconseguir solucionar aquest problema i vam començar amb la recopilació de informació sobre el robot i les seves formes de programació. Podem dir 52

Programació del robot Pololu 3PI que el fet de buscar informació ha estat una mica complicat ja que la informació era escassa i la que podíem trobar la trobàvem en anglès i l'havíem de traduir, però finalment hem pogut aconseguir tot el necessari per a la realització d'aquest treball. Més endavant vam començar amb la programació del robot, i aquí va aparèixer un altre problema ja que aquesta era molt complicada i dificultosa, per aquest motiu el nostre tutor ens va donar un exemple o model perquè nosaltres poguéssim tenir una base per poder anar modificant i provant coses en el robot. L'ajuda del nostre tutor del treball de recerca va ser essencial, ja que ens va ajudar amb multituds d'errors i dificultats que ens oferia el programador i el llenguatge de programació en general. Després de fer la programació del seguidor de línies, que era una tasca que vam fer durant el curset d'estiu a l'UPC, ens van plantejar realitzar altres funcions per al nostre robot, com per exemple, la creació de diferents menús o la compra i instal·lació d'uns altres sensors (de proximitat)

que

ens

oferirien

noves

possibilitats

programació

(esquivament d'obstacles, etc.), però finalment ens vam decidir per realitzar un menú principal on agrupar totes les funcions que pot fer el nostre robot. Les funcions principals eren la de Seguidor de línia (el robot gràcies al seu sensor de reflexió segueix una línia negra sobre fons blanc sense sortir-se d'ella), el laberint (consisteix en que el robot trobi la sortida d'un laberint format per línies negres, cercant totes les opcions possibles per sortir d'ell, i emmagatzemant la informació perquè a la següent vegada que faci el mateix recorregut aconsegueixi fer-ho pel camí més curt/ràpid) i el Tancament, que consisteix en una línia negra tancada formant una zona de la que el nostre robot no podrà sortir mai. Respecte el treball escrit, no hem tingut masses problemes a l'hora de realitzar-lo, encara que creiem que la limitació de 50 pagines màxim per 53

Programació del robot Pololu 3PI treball és massa prohibitiva i ens ha demanat una reducció d'informació que hauria beneficiat els continguts del nostre treball escrit. Finalment, podem dir que aquest treball, encara que ha estat molt difícil a l'hora de realitzar la part pràctica i la recerca d'informació, ens ha servit molt de cara al futur, i ens ha ensenyat que amb esforç i ganes és poden solucionar els problemes que poden aparèixer al principi d'un treball d'aquestes característiques.

Programació del robot Pololu 3PI

12. Fonts d'informació Aquestes són les eines físiques i digitals que hem utilitzat com a font d'informació a l'hora de realitzar el nostre treball de recerca: Pagina web oficial de Pololu Informació general del robot, i enllaços a altres fonts d’informació. http://www.pololu.com/ Manual d’Usuari Pololu 3pi (PDF) Informació sobre components i funcionament general del robot. http://www.pololu.com/file/0J137/Pololu3piRobotGuiaUsuario.pdf PDF UPC – Projecte de Robòtica Cinc PDF creats per professors de la UPC (Néstor Berbel, Jose Luis Medina i Antoni Salvador) pel Curs de robòtica i automatització 2010, al qual vam assistir aquest juliol. 1.1.- Hardware i software del robot 1.2.- Llenguatge C 1.3.- Llenguatge C II 1.4.- Seguidor de línies 1.5.- Projecte final Informació concreta sobre la programació en llenguatge C, incloses algunes pràctiques per a practicar la programació amb el robot. Per altre banda, també hi han explicacions sobre la creació del programa “seguidor de línies” i explicació dels elements del robot, instal·lació del programari i de les eines utilitzades per la programació.

Programació del robot Pololu 3PI

Wikibooks “Programació en C” Informació general sobre aquest àmbit de programació. http://és.wikibooks.org/wiki/Programaci%C3%B3n_en_C

Programació del robot Pololu 3PI

13. Agraïments Fernando Hernàndez és el nostre tutor del treball de recerca, i sempre li agrairem la seva dedicació per a ajudar-nos, sobretot a la part final del treball, quan sacrificava temps lliure per resoldre'ns dubtes, corregir-nos errors a la programació, i revisar la realització de la part escrita. Néstor Berbel és el professor que ens va impartir el curset de programació a l'UPC aquest estiu, i durant aquesta setmana, ens van ajudar moltíssim les seves explicacions sobre el llenguatge de programació en C, i a aplicar-lo pràcticament al funcionament del nostre robot.

Programaci贸 del robot Pololu 3PI