programació del robot pololu 3pi

Programació del robot Pololu 3PI

PROGRAMACIÓ DEL ROBOT POLOLU 3PI

ÀLEX IZQUIERDO RODRÍGUEZADRIÀ CALVET GONZÀLEZ

2on BATXILLERAT CIENTÍFIC-TECNOLÒGICCURS 2011-2012

TREBALL DE RECERCA

1


ÍNDEX1. Introducció..............................................................................................................................42. El robot....................................................................................................................................6

2.1 Característiques.................................................................................................................73. Elements del robot..................................................................................................................8

3.1 Motors...............................................................................................................................83.2 Sensors..............................................................................................................................93.3 ATPmega328p.................................................................................................................11

3.3.1 Característiques........................................................................................................113.3.2 Connexió dels PIN’s.................................................................................................12

3.4 Bateries............................................................................................................................133.5 Rodes...............................................................................................................................153.6 LCD.................................................................................................................................153.7 Indicadors Led.................................................................................................................163.8 Altaveu............................................................................................................................163.9 Botons.............................................................................................................................173.10 Sistema d'estabilització.................................................................................................18

4. Entorn de programació..........................................................................................................194.1 Programa principal..........................................................................................................194.2 Tokens.............................................................................................................................194.3 Paraules clau...................................................................................................................204.4 Identificadors..................................................................................................................214.5 Operadors........................................................................................................................224.6 Separadors.......................................................................................................................224.7 Comentaris......................................................................................................................224.8 Sentencies de control de flux..........................................................................................23

4.8.1 sentència IF - ELSE.................................................................................................234.8.2 sentència “Switch”...................................................................................................244.8.3 Bucles.......................................................................................................................244.8.4 sentència “While”....................................................................................................254.8.5 sentència “Do...while”.............................................................................................254.8.7 sentència “Continue”................................................................................................264.8.8 sentència “goto”.......................................................................................................26

5. Programari i eines utilitzades................................................................................................275.1 AVR STUDIO 4..............................................................................................................275.2 Cable USB.......................................................................................................................275.3 Llibreries de programació...............................................................................................285.4 Programador AVR ISP de 6 pins connectors...................................................................28

6. Instal·lació del programari....................................................................................................296.1 Creació d'un projecte amb AVR Studio...........................................................................296.2 Compil·lació i programació d'un projecte.......................................................................30

7. Creació de menús..................................................................................................................328. Seguidor de línies..................................................................................................................35

8.1 Pantalla principal.............................................................................................................358.2 Calibració de sensors......................................................................................................37

2


8.3 Funció dels motors..........................................................................................................388.3.1 Assaig del primer circuit..........................................................................................398.3.2 Segona prova de circuit............................................................................................39

8.4 Creació variable “comptador”.........................................................................................419. Resolució d’un laberint ........................................................................................................44

9.1 Resolució directa del laberint..........................................................................................489.1.1. sentència path..........................................................................................................489.1.2. Exemple de memòria “path”...................................................................................49

10. Tancament...........................................................................................................................5011. Conclusions.........................................................................................................................5212. Fonts d'informació..............................................................................................................5513. Agraïments..........................................................................................................................57

3


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

4


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.

5


2. El robotEl 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 un 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

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.

6

Imatge 1: El robot Pololu 3pi


2.1 CaracterístiquesAquestes 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

7


3. Elements del robotA 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 MotorsEl 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 el qual un 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

é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

8

Imatge 2: Motor encarregat d’una de les rodes del robot.


(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 SensorsEl 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:

9

Imatge 3. Valors mostrats pels sensors de reflexió.


• 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.

10

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


3.3 ATPmega328pEl 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.

3.3.1 CaracterístiquesAquestes 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

11

Imatge 5: Microcontrolador ATmega328P


3.3.2 Connexió dels PIN’sA 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 del Pin

Code Lloc on és connecten

PIN1 PD3 (OC2B/INT1)

Drivers del motor i motor

PIN2 PD4 (XCK/T0) LCDPIN3 GND MassaPIN4 VCC Font 5VPIN5 GNDPIN6 VCC Font 5VPIN7 PB6

(XTAL1/TOSC1)Oscil·lador

PIN8 PB7 (XTAL2/TOSC2)

Oscil·lador

PIN9 PD5 (OCOB/T1) Drivers del motor i motorPIN10 PD6

(OCOA/AIW0)Drivers del motor i motor

PIN11 PD7 (AIN1) LCD/LEDPIN12 PB0 (CCK0/ICP1) LCDPIN13 PB1 (0C1A) LCDPIN14 PB3 (SS/0C1B) Buzzer (brunzidor)PIN15 PB3

(MOSI/0C2A)Drivers del motor / Connexió de Programació

PIN16 PB4 (MIS0) Connexió de ProgramacióPIN17 PB5 (SCK) Connexió de ProgramacióPIN18 AVCC Font 9,25 VPIN19 ADC6 Voltatge de la bateria, circuit de

deteccióPIN20 AREF Font 9,25 VPIN21 GNDPIN22 ADC7PIN23 PC0 (ADC0) Control de sensors reflectants i IR

LEDPIN24 PC1 (ADC1) Control de sensors reflectants i IR

LED

12


PIN25 PC2 (ADC2) Control de sensors reflectants i IR LED

PIN26 PC3 (ADC3) Control de sensors reflectants i IR LED

PIN27 PC4 (ADC4/SDA) Control de sensors reflectants i IR LED

PIN28 PC5 (ADC5/SCL) Alimentació sensors i r/led.PIN29 PCS (RESET) Botó d’apagar / Connexió de

Programació / Drivers del motorPIN30 PD0 (RXD) Comunicació en sèriePIN31 PD1 (TXD) Comunicació en sèriePIN32 PD2 (INTO) LCD

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

3.4 BateriesCom 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 de voltatge.

D’aquests reguladors hi han dos tipus:

• Lineals: Aquests utilitzen un circuit de

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

13

Imatge 6: Bateries de 1'2 V.


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.

14


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 RodesLes 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

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 LCDEl 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, es fàcilment

substituïble.

15

Imatge 8. Rodes laterals del robot.

Imatge 9. Pantalla LCD


3.7 Indicadors LedEls indicadors Led són uns components que estan situats a la part

posterior de la placa del 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 de connexió del robot amb

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.

16

Imatge 10. Led vermell

Imatge 11. Altaveu del robot Pololu 3pi


3.9 BotonsEl 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.

17

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


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.

18


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 principalA 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 TokensEls 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,

19


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 temporizadorunsigned 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 clauEn 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.

20


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 IdentificadorsLa 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.

21

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)}


4.5 OperadorsEls operadors són signes especials encarregats de realitzar operacions

entre determinades variables del nostre programa.

4.6 SeparadorsEls separadors són els encarregats d’ajudar al compilador a

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 ComentarisEls 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.

22


//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


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++)


4.8 Sentencies de control de fluxOriginalment, 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 - ELSEAquesta 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:

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

23


unsigned int counter; // Usat com un temporizadorunsigned int sensors[5]; // Un vector per guardar el estat dels sensors

{if(counter < 20 || counter >= 60)set_motors(40,-40) ;elseset_motors(-40,40) ;// Guarda els valors dels sensorscalibrate_line_sensors(IR_EMITTERS_ON) ;delay_ms(20);

}

}


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 (}).

4.8.3 BuclesA 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.

24

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


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:

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.

25

while(!button_is_pressed(BUTTON_B)) {


}


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.

26


5. Programari i eines utilitzadesSeguidament, explicarem totes les eines físiques i 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, un 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.

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ó al robot (mitjançant un cable USB, el programador

traspassarà la informació del nostre ordinador al microcontrolador del

Pololu 3pi).

5.2 Cable USBCable 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

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


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

estalviar la creació de nombroses variables que ens haguessin ocupat

massa espai dintre del nostre programa.

5.4 Programador AVR ISP de 6 pins connectorsFa 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 el

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 ja que garanteix que la

informació que fem al nostre ordinador pugui

passar-se al robot. Té dues llums (vermella i

verda) que ens indiquen el seu estat.

28

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

Imatge 17. Programador AVR ISP amb 6 pins.


6. Instal·lació del programariPer 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 StudioPer 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 al nostre ordinador. A 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ó.

29


Ara podem donar-li a “Finish” i ja podrem introduir el codi que vulguem.

6.2 Compil·lació i programació d'un projecteUna 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.

30


Després, li donarem al botó “CON”, anomenat “Display the connect dialog”

i seleccionarem el programador “AVRISP” o “STK500” i al 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

31


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.

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ú.

32

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";


Aquí podem veure les diferents subrutines enllaçades amb la seva opció al

menú:

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:

I finalment, com ja hem vist abans, posem la subrutina segons l’ordre

que hem posat abans amb la funció que hem vist

33

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()

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]);


34

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);}


8. Seguidor de líniesAmb 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 principalComencem 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 pel nostre robot amb la

sentència “read_battery_millivolts” i

farem que ens la indiqui a la pantalla

LED. A la línia inferior, escriurem “Pulsar

35

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


B” per indicar a l’usuari que ha polsar el botó per a posar en marxa el

robot.

Aquest és el programa sencer:

36

void initialize(){unsigned int counter; // Usat com un temporizadorunsigned 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ó Bwhile(!button_is_pressed(BUTTON_B)) {


}//Esperem a que es deixi de polsar el botó B// par començar la cal·libració dels sensorswait_for_button_release(BUTTON_B);delay_ms(1000);

}

// 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);

elseset_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);


8.2 Calibració de sensorsAbans 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:

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.

37


8.3 Funció dels motorsAquestes 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.

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.

38

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)

}}


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 circuitDesprés de programar el nostre robot,

ha arribat l’hora de provar-ho. Farem

servir un circuit amb una única línia

recta.

Per a que el nostre robot pugui

funcionar correctament 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

més.

8.3.2 Segona prova de circuitDesprés de comprovar que la

programació del robot per al primer

circuit hagi estat la correcta i funcioni,

prepararem el nostre robot per a

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.

39

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

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


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:

40

include <pololu/3pi.h>void initialize(){

unsigned int counter; // Usat com un temporitzadorunsigned 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



}//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);elseset_motors(-40,40);//Guarda els valors dels sensorscalibrate_line_sensors(IR_EMITTERS_ON);delay_ms(20);

}


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 zig-

zag.

41

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)

}}


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:

42

//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;}

}

//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) ;}


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.

43


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.

44


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:

45

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


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.

46

{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';

elsereturn '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])


Seguidament, posarem fora de la subrutina les sentencies que tinguin

relació amb la funció “path”, creada anteriorment:

47

total_angle = total_angle % 360;

// Canvia el tot camí per un sol girswitch(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;

}

{case 'R':

total_angle += 90;break;

case 'L':total_angle += 270;break;

case 'B':total_angle += 180;break;

}


Finalment, canviarem els textos que apareixeran a la pantalla LED del

nostre robot, com hem fet nosaltres:

9.1 Resolució directa del laberintUna 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 pathLa 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.

48


if(get_ms() % 2000 < 1000){

clear();print("Meta!");lcd_goto_xy(0,1);print("Pulsa B");

}else

display_path();delay_ms(30);


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.

49


10. TancamentA 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:

50

//Esperem a que deixi d'apretar B// per començar la calibració dels sensorswait_for_button_release(BUTTON_B);delay_ms(1000);//La autocalibració realitza un gir a la dreta del robot i després//cap a l'esquerrafor(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);}


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:

Ara, l'únic que hem de fer és suprimir la sentència següent, que és

ineccesaria pel “tancament”:

51

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);

}

//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);}


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


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 de 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


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.

54


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ó.

55

http://www.pololu.com/file/0J137/Pololu3piRobotGuiaUsuario.pdf

http://www.pololu.com/


Wikibooks “Programació en C”

Informació general sobre aquest àmbit de programació.

http://és.wikibooks.org/wiki/Programaci%C3%B3n_en_C

56

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C


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.

57


58

programació del robot pololu 3pi

Documents