Programació del robot Pololu 3PI Arduino en llenguatge C

Pol Bonastre Romera Marc De Tébar i Peralta

Treball de Recerca “Pololu 3pi” Pàgina 0

Treball de Recerca 2on de Batxillerat Marc De Tébar i Peralta , Pol Bonastre Romera

I.E.S. TORRE

DEL PALAU

PROGRAMACIÓ DEL ROBOT POLOLU 3PI

ARDUINO EN LLENGUATGE C



Índex del treball 1. Introducció ........................................................................................................................... 4

2. Robot Pololu 3Pi Arduino ..................................................................................................... 6

3. Parts del robot ...................................................................................................................... 7

3.1. Processador Atmega 328p ............................................................................................ 8

3.2. Bateries ...................................................................................................................... 12

3.3. Motors i engranatges ................................................................................................. 13

3.4. Sensors ....................................................................................................................... 15

3.5. Jumpers ...................................................................................................................... 16

3.6. Leds ............................................................................................................................ 17

3.7. Esquema general del robot ........................................................................................ 18

4. Llenguatge C. ...................................................................................................................... 19

4.1. Memòria d’un computador. ....................................................................................... 19

4.1.1. Classificació de la memòria d’un computador. ................................................... 19

4.2. Definició d’un programa informàtic. .......................................................................... 19

4.3. Funció. ........................................................................................................................ 20

4.3.1. Funció main(). ..................................................................................................... 20

4.4. Tokens. ....................................................................................................................... 20

4.4.1. Paraules clau. ...................................................................................................... 20

4.4.2. Identificadors. ..................................................................................................... 21

4.4.3. Constants ............................................................................................................ 21

4.4.4. Operadors. .......................................................................................................... 22

4.4.5. Separadors. ......................................................................................................... 22

4.4.6. Comentaris. ........................................................................................................ 22

4.5. Operadors................................................................................................................... 22

4.5.1. Operadors aritmètics. ......................................................................................... 23

4.5.2. Operadors d’assignació. ..................................................................................... 23

4.5.3. Operadors incrementals ..................................................................................... 23



4.5.4. Operadors relacionals ......................................................................................... 23

4.5.5. Operadors lògics ................................................................................................. 24

4.6. Control de flux d’execució .......................................................................................... 24

4.6.1. Sentència IF ........................................................................................................ 24

4.6.2. Sentència IF - ELSE ............................................................................................. 24

4.6.3. Sentència IF – ELSE Múltiple ............................................................................... 25

4.6.4. Sentència Switch................................................................................................. 26

4.6.5. Sentència IF anidada. .......................................................................................... 26

4.7. Bucles. ........................................................................................................................ 27

4.7.1. Bucle WHILE. ...................................................................................................... 27

4.7.2. Bucle FOR. .......................................................................................................... 28

4.7.3. Bucle DO ... WHILE. ............................................................................................. 28

4.7.4. Sentència Break, continue, Goto. ....................................................................... 28

4.8. Estructura de la programació C. ................................................................................. 29

5. Instal·lació del programa AVR Studio 4 .............................................................................. 30

5.1. Passos per crear un projecte ...................................................................................... 30

5.2. USB AVR Programmer ................................................................................................ 33

6. Proves amb el robot. .......................................................................................................... 35

6.1. Pràctiques realitzades a la UPC. ................................................................................. 35

6.1.1. Text en pantalla i funció de leds. ........................................................................ 36

6.1.2. Polsadors del robot I. .......................................................................................... 36

6.1.3. Polsadors del robot II. ......................................................................................... 37

6.1.4. Polsadors del robot III. ........................................................................................ 38

6.1.5. Funció de leds a partir dels polsadors I. .............................................................. 39

6.1.6. Funció de leds a partir dels polsadors II. ............................................................. 40

6.1.7. Paràmetres del voltatge. .................................................................................... 41

6.1.8. Paràmetres del voltatge II. ................................................................................. 42

6.1.9. Paràmetres del voltatge III. ................................................................................ 43



6.1.10. Cal·libració i seguidor de línia I. .......................................................................... 44

6.1.11. Cal·libració i seguidor de línia II. ......................................................................... 46

6.1.12. Temps de funcionament. .................................................................................... 48

6.2. Cal·libració .................................................................................................................. 49

6.3. Instal·lació de la placa d’expansió .............................................................................. 57

6.3.1. Procés de muntatge ............................................................................................... 57

6.4. Connexions de la placa d’expansió ............................................................................. 61

6.5. Proves de velocitat ..................................................................................................... 62

6.5.1. Tres zones ........................................................................................................... 62

6.5.2. Cinc zones ........................................................................................................... 63

6.5.3. Nou zones ........................................................................................................... 64

6.5.4. Conclusions a partir de les diferents zones......................................................... 65

7. Projecte final ...................................................................................................................... 66

7.1. Codi final. ................................................................................................................... 69

7.2. Circuits emprats en els diferents programes .............................................................. 75

8. Contingut del CD ................................................................................................................ 79

9. Conclusions ........................................................................................................................ 81

10. Bibliografia ......................................................................................................................... 84



1. Introducció

El nostre treball es basa en la programació en llenguatge C del robot Pololu

3Pi, realitzant tres codis de programació. Com a funció addicional mitjançant la

placa d’expansió, amb cinc leds amb resistències, volíem mostrar d’una

manera il·lustrada els valors dels sensors. Els tres programes que hem realitzat

són: l’estancament en el qual el robot no surt d’una àrea definida; el laberint en

el qual mitjançant unes marques addicionals al costat de la línia es desvia per

la banda correcte del circuit; i el seguidor de línia.

Els objectius que ens vam marcar abans de començar el treball eren els

següents:

- Aprendre a programar un robot.

- Conèixer els components del robot.

- Programar el robot perquè pugui realitzar un laberint i seguir una línia.

- Saber el funcionament del programa AVR Studio 4.

Aquest seguit d’objectius han estat assolits al llarg d’aquest any de treball.

Primerament explicarem què és el Pololu 3pi Arduino en sí mateix i les seves

parts constituents principals, que són: el processador, els leds, els senors, els

motors i engranatges i les bateries.

A continuació expliquem el llenguatge que utilitza el robot, en aquest cas, el

llenguatge C, analitzant-ne totes les seves parts, és a dir, des de la memòria

d’un computador i la seva definició, la funció principal i passant pels diferents

tokens , operadors, bucles i sentències que componen el llenguatge i acabant

l’explicació amb la seva estructura.

Després d’això expliquem la instal·lació del programa AVR Studio 4, què és el

que ens permet editar i transferir el codi cap al robot, mitjançant l’USB AVR

Programmer, que és un adaptador de connectivitat entre l’ordinador i el robot.

D’aquesta manera doncs, mostrem com s’empra el programa.

Dit això, mostrem els codis de programa creats durant les pràctiques a la

Universitat Politècnica de Catalunya de Terrassa, en les quals realitzem



diferents funcions com ara mostrar textos en pantalla, fer funcionar els leds, els

polsadors, els motors i fent ús de la cal·libració.

En el proper apartat, expliquem com el robot realitza la cal·libració, mitjançant

una equació matemàtica que permet saber on es troba la línia negra a seguir

en cada moment, també expliquem el codi de cal·libració emprat.

Seguidament expliquem la instal·lació de la placa d’expansió amb el respectiu

procés de muntatge mitjançant fotografies. També expliquem les connexions

addicionals que s’obtenen al instal·lar la placa d’expansió.

Al següent apartat analitzem la velocitat i el temps de realització d’un circuit

canviant les zones i les velocitats per aconseguir un anàlisi previ per al nostre

codi final.

El nostre projecte final consta de tres programes:

Estancament: el robot no pot sortir d’una àrea delimitada per unes línies

negres, tornant enrere al trobar-ne alguna.

Laberint: el robot segueix les indicacions donades al circuit per

aconseguir arribar al final, parant-se a la franja negra.

Seguidor de línia: el robot segueix una línia negra fins a completar un

circuit.

Tots els elements utilitzats al llarg d’aquest treball de recerca els englobem en

un CD, el qual expliquem en l’apartat anomenat “Contingut del CD”, donant

informació de cada arxiu.

Al finalitzar el treball hem realitzat unes conclusions, les quals estan exposades

en el penúltim apartat.

I per finalitzar el nostre treball, hem inclòs una bibliografia de totes les fonts

d’informació utilitzades.



2. Robot Pololu 3Pi Arduino

El robot que utilitzem en aquest treball de recerca és el Pololu 3Pi. Aquest robot

té dos motors metàl·lics, 5 sensors de reflexió, una pantalla de 8x2 caràcters

LCD, un brunzidor i 3 polsadors, tot això connectat al microcontrolador

ATmega328p.

Al següent apartat explicarem les parts que té.

Fig. 1: Robot Pololu 3Pi



3. Parts del robot

A continuació explicarem les principals parts del robot que són: el processador,

les bateries, els motors i engranatges, els sensors i els Leds.

1. Processador: interpreta les instruccions contingudes en els programes i processa les dades.

2. Bateries: subministren voltatge al robot i als seus components. 3. Motors i engranatges: són els dispositius encarregats de permetre el

moviment del robot. 4. Sensors de reflexió: són uns components que permeten detectar si hi ha

línia o no, i en la posició que es troba. 5. Leds: és un dispositiu semiconductor que emet llum.

Fig.2: Part posterior del robot



3.1. Processador Atmega 328p

La Unitat Central de Procés o CPU),o simplement el processador o

microprocessador, és el component del computador i altres dispositius

programables, que interpreta les instruccions contingudes en els programes i

processa les dades.

L’ ATmega328 és essencialment el mateix que el Atmega168 (processador que

portaven els robots anteriors a l’Arduino 3pi), però va proveït del doble de

memòria (32 KB flash, 2 KB RAM, i 1 KB de EEPROM), de manera que el codi

escrit per un pot treballar, amb mínimes modificacions, en el nou ATmega328.

Fig.3: Part anterior del robot



El processador Atmega 328p de 8 bits té una velocitat del processador de 20

MHz, pel seu funcionament necessita o requereix un voltatge d’entre 1.8 – 5.5

V. La freqüència del rellotge és de 8 MHz i posseeix 32 KB de memòria flash de

programa per emmagatzemar el codi (del qual se n’utilitzen 2 KB per

l’arrencada del sistema, és a dir de memòria RAM) i 1KB de memòria EEPROM

(Electrically-Erasable Programmable Read-Only Memory , ROM programable i

esborrable elèctricament) que és un tipus de memòria ROM que pot ser

programada, esborrada i reprogramada elèctricament

Especificacions del processador Atmel 328p:

Tècnic /

catàlegs de

informació

ATMEGA328P-MU

Proveïdor Atmel

Categoria Circuits integrats

Programa Mida

de la memòria

32 KB (16K x 16)

Mida de RAM 2K x 8

Nombre d'E / S 23

Velocitat 20MHz

Tipus de

oscil·lador

Interior

Tipus de

Programa

Memòria

FLASH

EEPROM Mida 1K x 8

Nucli del

processador

AVR

Convertidors

de dades

A / D 8x10b

Mida del nucli 8-Bit

Temperatura

de

funcionament

-40 ° C a 85 ° C

Connectivitat I ² C, SPI, UART /

USART

Tensió - Font

(Vcc / Vdd)

08/01 V a 05/05 V

Altres noms

del mateix

processador

ATMEGA328PMU

ATMEGA328P

L’Atmel AVR Studio proporciona un entorn de desenvolupament còmode que

inclou un conjunt de biblioteques per poder interactuar amb tot el maquinari

integrant del robot.



Velocitat del processador (MHz)

Subministrament de voltatge (V)

Codi de comanda

“Package” Rang d’operació

20

1.8 - 5.5

ATmega328P-AU

ATmega328P-AUR

ATmega328P-MU

ATmega328P-MUR

ATmega328P-PU

32A 32A

32M1-A 32M1-A

28P3

Industrial (-40°C a

85°C)

El microprocessador ATMega 328p té 21 entrades i sortides per a l’usuari.

Fig.4: Processador Atmega 328p

Fig.5: Estructura del processador ATmega 328p



Taula d’assignació de les sortides i entrades del processador i funcions que

poden realitzar:

Pin Funcions Notes/funcions alternatives

PD0 free digital I/O USART input pin (RXD)

PD1 free digital I/O connectat al LED vermell d’usuari

PD2 LCD control RS interrupció 0 externa (INT0)

PD3 M2 línia control Timer2 PWM output B (OC2B)

PD4 LCD control E USART rellotge extern input/output (XCK) Timer0 comptador extern (T0)

PD5 M1 línia de control Timer0 PWM output B (OC0B)

PD6 M1 línia de control Timer0 PWM output A (OC0A)

PD7 LCD dades DB7 Connectat al LED verd d’usuari

PB0 LCD control R/W Timer1 input capture (ICP1) divided system clock output (CLK0)

PB1 LCD dades DB4 Botó d’usuari Timer1 PWM sortida A (OC1A)

PB2 Brunzidor o altaveu Timer1 PWM sortida B (OC1B)

PB3 M2 línia de control Timer2 PWM sortida A (OC2A) ISP línia de programació

PB4 LCD dades DB5 Botó d’usuari

PB5 LCD dades DB6 Botó d’usuari

PC0 QTR-RC sensor reflexió

Sensor etiquetat com a PC0


sensor etiquetat com a PC1


sensor etiquetat com a PC2 (sensor central)





PC5 Entrada analògica i I/O digital

jumpered to sensors’ IR LEDs ADC input channel 5 (ADC5)

ADC6 Entrada dedicada analògica

jumpered to 2/3rds of battery voltage ADC input channel 6 (ADC6)

ADC7 Entrada dedicada analògica

jumpered to user trimmer potentiometer ADC input channel 7 (ADC7)

reset Botó de RESET Reinicialitza el robot



3.2. Bateries

Les bateries que empra el nostre robot, i per tant, l’alimentació que té, està

formada per un conjunt de quatre piles del tipus AAA que proporcionen una

tensió o diferència de potencial d’1,5 volts al robot.

Les bateries contenen uns elements químics que reaccionen al moure electrons

del terminal negatiu cap al positiu. Un dels tipus més coneguts és la pila

alcalina, que està composta de zenc i de magnesi en una solució d’hidròxid

potàssic.

El corrent és la quantitat d'electrons que circulen per segon, i es mesura en

Ampers.

Com a exemple, 1 A equival a 6.1018 electrons circulant per segon, i és el

corrent que necessita un motor per que funcioni a la seva màxima velocitat. Per

a qualsevol bateria en funcionament, el voltatge subministrat es redueix amb l'

temps baixant fins a perdre tota l'energia.

La Figura 3 mostra com la tensió disminueix quan augmenta el corrent que és

lliurada per la bateria. Per exemple,al punt marcat a la Fig 1, es subministra un

corrent de 0,6 A per tant, la tensió o diferència de potencial en els seus borns

serà de 0,9 V, la qual cosa significa que la potència que lliurarà la bateria serà

de 0,54 W.

Fig.6. Tensió subministrada per una bateria AA

o AAA en funció del corrent que subministra



La quantitat d'energia de les bateries està marcada en la mateixa com a

miliampers / hora (MAH). Si utilitzeu al circuit que consumeix 200mA (0,2 A)

durant 3 hores, una bateria de 650 mAh necessitarà una recàrrega

transcorregut aquest temps. Si el circuit és de 5 mAh.

3.3. Motors i engranatges

El motor és una màquina elèctrica que converteix l’energia en tracció. Hi han

dos tipus de motors, però el que utilitza el robot és DC amb escombretes.

Aquest tipus de motor conté imants permanents a l’exterior i bobines

electromagnètiques a l’eix del motor. Les escombretes són unes peces lliscants

que el què fan és subministrar electricitat des d’una part de la bobina a l’altra,

produint, d’aquesta manera diferents pulsacions elèctriques que permeten que

l’eix giri en la mateixa direcció.

TB6612FNG (Toshiba Bi-DC Circuit Integrat monolític de silici) és un

controlador IC del motor de Corrent Contínu de la marca Toshiba, que es troba

localitzat a la port posterior del robot i que té una sortida de transistor LD MOS,

d’estructura, amb baixa resistència. A més a més té dues senyals d'entrada,

IN1 i IN2, que permeten triar quatre maneres de funció com ara CW, CCW,

fre de curta durada, i mode de parada.

Els motors són independents a cada costat, i per tant, es crea un mètode de

conducció anomenat conducció diferencial o conducció de tancs. Per girar

mitjançant aquest mètode s’han de moure els motors a velocitats diferents o si

el que es vol és fer un canvi de direcció completa, un en sentit positiu i l’altre en

negatiu .La diferència de velocitat és la que acabarà determinant si el gir és

més brusc o més suau.

Fig.7. TB6612FNG



La velocitat lliure de rodament d'un petit motor DC és de diversos milers de

revolucions per minut (rpm) molt alta per al desplaçament del motor, de manera

que un dispositiu d'engranatges permet reduir aquestes revolucions i

augmentar el parell, així com la força de rodament. La relació d'engranatges és

de 30 a 1 en el robot "Pololu 3Pi", és a dir per cada 30 voltes del motor, es

produeix una volta de la roda del robot.

Els motors del robot es poden combinar de set maneres diferents:

Motor A Motor B Moviment

Endavant Endavant El robot avança en línia recte

Enrere Enrere El robot retrocedeix en línia recte

Endavant Parat El robot realitza un gir cap a la dreta

Parat Endavant El robot realitza un gir cap a l’esquerra

Endavant Enrere El robot fa una rotació cap a la dreta

Enrere Endavant El robot fa una rotació cap a l’esquerra

La modulació per amplada d'impulsos ( MAP o PWM) d'un senyal o font

d'energia, és una tècnica en la qual es modifica el cicle de treball d'un senyal

periòdic (una ona sinusoïdal o ona quadrada, per exemple), ja sigui per

Fig.8: Gir del robot en funció de la velocitat que

s’aplica als motors.



transmetre informació a través d'un canal de comunicacions o per controlar la

quantitat d'energia que s'envia a una càrrega.

La modulació per amplada d'impulsos és una tècnica utilitzada per regular la

velocitat de gir dels motors elèctrics d'inducció o asíncrons. Manté el parell

motor constant i no suposa un desaprofitament de la energia elèctrica.

Consisteix a canviar l'amplitud d'un senyal, de freqüència fixa, en funció del

símbol a transmetre. Això es pot aconseguir amb un amplificador de guany

variable o seleccionant el senyal d'un banc d'oscil·ladors, s'utilitza tant en

corrent continu com en altern. La modulació per amplada d'impulsos també

s'usa per controlar servomotors, els quals modifiquen la seva posició d'acord a

l'ample de l'impuls enviat cada un cert període que depèn de cada servo motor.

3.4. Sensors

Els sensors de reflexió són una font de llum i un receptor de llum, molt propers

l’un de l’altre i integrats en una mateixa peça. La font de llum que emet un feix

de llum es reflexarà si la superfície és blanca, i d’aquesta manera el receptor de

llum el rebrà. Si la superfície és negra, no es reflexarà la llum.

El model dels sensors que utilitza el robot Pololu 3Pi és QTR-1RC Sensor

Reflexor de llum, que es troben a la part frontal del robot.

Fig. 9: Esquema de modulació



A continuació mostrarem un esquema electrònic de connexió dels sensors.

Els sensors de reflexió es connecten a la unitat central mitjançant l’esquema de

la Figura 8.

3.5. Jumpers

Els jumpers són uns elements que serveixen per interconnectar dos terminals

de manera tempora, sense haver d’efectuar cap operació que requereixi una

eina addicional. Aquesta unió de terminals tanca el circuit elèctric.

Fig.12: Esquema electrònic de connexió dels sensors.

Fig. 11: QTR-1RC Sensor Reflexor de llum

Fig. 10: Sensors Reflexors de llum

Fig. 13: Jumpers



3.6. Leds

El robots disposa de diferents leds (dispositius emissors de llum) situats a la

part inferior de la placa. Dos d’aquests leds es poden configurar i el color de

llum que emeten són el vermell i el verd, respectivament. Els altres dos leds

dels que disposa el robot emeten llum blava i no són programables, és a dir, es

queden encesos durant tot el funcionament del robot.

Un díode LED és un dispositiu semiconductor que emet llum d'espectre reduït

quan se'n polaritza de forma directa la unió PN i és travessat per corrent

elèctric, la coberta té una cara plana que indica el càtode, que a més és més

curt que l'ànode.

Fig.14: Parts del led (Ànode i

càtode)

Fig.16: Taula parts del led

Fig.15: Parts del led



3.7. Esquema general del robot

Aquest és l’esquema simplificat de diagrames del robot Pololu 3Pi, el qual es

pot observar l’estructura de tots els seus components.

Esquema de la part del voltatge

Esquema del processador ATmega 328p

Esquema del LCD i polsadors

Esquema del control dels motors

Esquema dels sensors

Control del valor del voltatge de les bateries

Control dels leds inferiors

Connexió de programació

Brunzidor

Fig.17: Diagrama del robot



4. Llenguatge C.

En aquest apartat farem una explicació de les principals característiques del

llenguatge C.

Es tracta d'un llenguatge feblement tipificat de mig nivell. Disposa de les

estructures típiques dels llenguatges d'alt nivell però, al seu torn, disposa de

construccions del llenguatge que permeten un control a molt baix nivell. Els

compiladors solen oferir extensions al llenguatge que possibiliten barrejar codi

en assemblador amb codi C o accedir directament a memòria o dispositius

perifèrics.

És un llenguatge orientat a la implementació de Sistemes Operatius,

concretament Unix. C és apreciat per l'eficiència del codi que produeix i és el

llenguatge de programació més popular per crear programari de sistemes,

encara que també s'utilitza per crear aplicacions.

4.1. Memòria d’un computador.

La memòria d’un computador està formada per bits que contenen 0 i 1. Un sol

bit té poca utilitat, en canvi un conjunt de bits permet emmagatzemar quasi

qualsevol tipus d’inrofmació.

4.1.1. Classificació de la memòria d’un computador.

Quasi tots els ordinadors, agrupen els bits en conjunts de 8. Aquest conjunt és

anomenat bytes. El conjunt de 1024 bytes és anomenat kbytes, que és la unitat

més utilitzada per mesurar la memòria. El conjunt de 1024 kbytes s’anomena

Mbytes. L’agrupació de 1024 Mbytes és anomenat Gbytes. Podríem trobar

classificacions de bits més altes, però aquestes són les més importants.

4.2. Definició d’un programa informàtic.

Un programa informàtic està format per un conjunt d’instruccions que

s’executen de mode seqüencial, és a dir, una a continuació de l’anterior.

El llenguatge amb el qual nosaltres programem, és més o menys comprensible

per a l’usuari, però no per al processador. Per a que el processador pugui

executar-los fa falta traduir-los al propi llenguatge de la màquina. Aquesta

traducció la fa un programa anomenat compilador.



4.3. Funció.

Els programes acostumen a tenir moltes línies de codi font. A mida que anem

desenvolupant-los, aquests augmenten de tamany, fent-los menys manejables.

Per això existeix la Modulació que ens permet dividir un programa molt gran

en una sèrie de mòduls més petits i manejables, anomenant-los de diverses

maneres: Subprogrames, subrutines, funcions... En el llenguatge C fem us del

concepte función (en el codi C és anomenat function).

4.3.1. Funció main().

El llenguatge C, està format amb una estructura determinada. Dins aquesta

estructura, trobem el programa principal (main) que és on comença la execució

del programa. El main és una funció que està per sobre de totes les altres.

El programa main té la següent estructura:

int main()

{

Sentencia_1

Sentencia_2

…

}

Les claus { i } constitueixen el mode per agrupar sentències, per fer-les que es

comportin com a sentències úniques.

4.4. Tokens.

En el llenguatge C existeixen diferents tipus de components sintàctics o tokens.

4.4.1. Paraules clau.

Com a tots els llenguatges existeixen una sèrie de paraules clau que el usuari

no pot utilitzar com identificadors. Serveixen per indicar al computador que

realitzi unes feines molt determinades.



Auto

Break

Case

Char

Const

Continue

Default

Do

Double

Else

Enum

Extern

Float

For

Goto

If

Int

Long

Register

Retorn

Short

Signed

Sizeof

Static

Typedef

Union

Unsigned

Void

Voletile

While

4.4.2. Identificadors.

Un identificador és un nom amb el qual es fa referència a una funció o a una

variable. Cada llenguatge té les seves pròpies regles. En el llenguatge C, les

regles són les següents:

1. Un identificador es forma amb una seqüència de lletres, ja sigui amb majúscules o

minúscules i dígits.

2. El caràcter subratllat (_) es considera com una lletra més.

3. Un identificador no pot contenir espais en blanc, ni altres caràcter no especificats en

el primer punt.

4. El primer caràcter d’un identificador ha de ser sempre una lletra o un _. No pot ser un

dígit.

5. Existeix distinció entre majúscules i minúscules, per tant, per exemple l’identificardor

temps no serà considerat el mateix que Temps o TEMPS.

6. El llenguatge C permet tenir identificadors de fins a 31 caràcters de longitud.

4.4.3. Constants

Les constants són variables que no canvien de valor, per tant tenen un valor fix.



Trobem diferents tipus de constants:

1. Constants numèriques: formats per valors numèrics.

2. Constants caràcters: qualsevol caràcter tancat entre apòstrofs (‘’)

3. Cadenes de caràcters: un conjunt de lletres i nombres tancats entre cometes (“) també

és un tipus de constant. Exemple: “nombre1”

4. Constants simbòliques: formades per un identificador, amb un valor fix que no es pot

canviar al llarg de l’execució del programa.

4.4.4. Operadors.

Els operadors són signes especials que indiquen operacions a realitzar amb

variables i constants. Existeixen diferents tipus:

Aritmètics: +, -, *, /, %.

D’assignació: =, +=, -=, *=, /=.

Relacionals: ==, <, >, <=, >=, !=.

Lògics: &&, ||, !

...

4.4.5. Separadors.

Els separadors estan formats per espais en blanc, tabulacions, i caràcters de

nova línia. Això ens ajuda a descompondre el programa, per aconseguir una

millor llegibilitat dels programes.

4.4.6. Comentaris.

El llenguatge C ens permet afegir comentaris al nostre codi, per fer explicacions

sobre el programa. El compilador ignora els comentaris, ja que només

serveixen per a l’usuari que programa el codi.

El caràcter /* permet iniciar un comentari a un programa i el */ serveix per

finalitzar el comentari. També podem utilitzar // que ens permetran fer un

comentari sense necessitat de tancar el comentari, ja que només s’aplica a la

mateixa línia.

4.5. Operadors.

Un operador és un caràcter que actua sobre una o més variables per realitzar

una determinada operació amb un determinat resultat. Ara explicarem els

diferents tipus d’operadors.



4.5.1. Operadors aritmètics.

Són els més fàcils d’entendre i d’utilitzar.

Suma: +

Resta: -

Multiplicació: *

Divisió: /

Resto: %

Exemples:

Tenim dos variables $temps i $velocitat, les quals les volem sumar:

$temps+$velocitat

4.5.2. Operadors d’assignació.

Els operadors d’assignació estan atribuïts a una variable, depositen en la zona

de memòria aquesta variable. El més utilitzat és l’operador d’igualtat (=) que

s’utilitza de la següent manera: $nom_variable1 = $nom_variable2

4.5.3. Operadors incrementals

Els operadors incrementals (++, --) són operadors que incrementen o

disminueixen en una unitat el valor de la variable a la qual afecten.

Exemple: a = 2; b = 2 m = a++; // Després d’executar-se m=2 i a=3 n = ++b; // Després d’executar-se n=3 i b=3

4.5.4. Operadors relacionals

Els operadors relacionals ens permeten estudiar si es compleixen o no les

condicions. Si no es compleixen les condicions, ens dóna com a resultat false,

en canvi si es compleix, el resultat que ens dóna és true. Hi ha diferents tipus:

1. Igual que: ==

2. Menor que: <

3. Major que: >



4. Menor o igual que: <=

5. Major o igual que: >=

6. Diferent que: !=

4.5.5. Operadors lògics

Els operadors lògics són operadors que ens permeten combinar els resultats

dels operadors relacionals, comprovant que es compleixin simultàniament

vàries condicions. Els dos operadors lògics són:

L’operador Y (&&)

L’operador O (||)

4.6. Control de flux d’execució

En principi les sentències en C, s’executen seqüencialment (una a continuació

de l’altre). En C això pot ser modificat, utilitzant bifurcacions i bucles.

4.6.1. Sentència IF

Aquesta sentència ens permet executar o no una sentència segons es

compleixi o no una determinada condició.

La seva forma general és:

if (expressio)

{

sentencia_1;

sentencia_2;

}

Si el resultat de l’expressio és verdadera (true) s’executa les sentències, si no,

se salta la sentència.

4.6.2. Sentència IF - ELSE

Aquesta sentència ens permet realitzar una bifurcació executant una part o una

altre del programa segons si es compleix unes certes condicions. La seva

expressió és aquesta:



if (expressio)

{

sentencia_1;

}

else

{

sentencia_2;

}

Si el resultat de l’expressio és verdadera (true) s’executa la sentencia_1, en

canvi si el resultat és fals (false) s’executa la sentencia_2

4.6.3. Sentència IF – ELSE Múltiple

Aquesta sentència ens permet fer una elecció entre varies parts del programa

segons es complexi una entre n condicions.

La seva expressió és aquesta:

if (expressio_1)

{

sentencia_1;

}

else if (expressio_2)

{

sentencia_2;

}

else if (expressio_3)

{

sentencia_3;

}

...



Si l’expressio_1 es compleix s’executarà la sentencia_1, si no es compleix es

passa a la següent part, es verifica l’expressio_2 si es compleix s’executa la

sentencia_2 si no es compleix es passa a verificar la següent, expressio_3 que

si es compleix s’executarà la sentencia_3, i així successivament.

4.6.4. Sentència Switch.

La sentència switch té una funció semblant a la sentència if – else múltiple

explicada en l’apartat anterior, però amb importants diferències. La seva forma

és aquesta:

switch (expressio){

case expressio_cte_1:

sentecia_1;

case expressio_cte_2:

sentencia_2;

...

default:

sentencia;

}

S’avalua expressio i es considera el resultat d’aquesta avaluació. Si coincideix

amb el valor constant d’expressio_cte_1, s’executa la sentencia_1, seguida de

sentencia_2... Si el valor de expressio coincideix amb el valor constant

d’expressio_cte_2, s’executa la sentencia_2 i les següents. Si l’expressio no

coincideix amb cap expressio_cte, aquesta executa el que posem a default.

4.6.5. Sentència IF anidada.

Una sentència if pot estar formada per diversos if dins de la mateixa sentència.

Aquest tipus de sentències s’anomenen sentències anidades, és a dir, una dins

una altre. Per no tenir problemes amb la interpretació del codi, utilitzarem { i }.



if (a >= b) { if (b != 0.0) { c = a/b; } } else { c = 0.0; }

En aquest exemple el podem interpretar de la següent manera: Primer el if

comprova si a és més gran o igual que b, de ser cert (true), es prosseguirà amb

la següent línia, que es comprovarà si b és diferent que 0.0, si aquest és cert

(true) el valor de c serà la divisió entre a i b. De no ser així, si el primer if, dóna

com a resultat false s’executarà el que està al else. En canvi si el primer if és

cert, però el segon és fals (false) el programa no farà res.

4.7. Bucles.

Els bucles són sentències que permeten repetir una sèrie de cops la execució

de les línies del codi. Aquesta repetició pot ser realitzada, ja sigui per un

nombre determinat de cops o quan es compleixi una determinada condició. Els

bucles que veurem a continuació són: while, for i do...while.

4.7.1. Bucle WHILE.

El bucle while ens permet executar repetidament una sentència mentre es

compleixi una determinada condició. Té la següent forma:

while (expressio_de_control) { sentencia; }

Aquest codi ens indica que mentre l’expressio_de_control tingui un valor de 1 o

sigui true executarà la sentencia, en canvi si no es compleix, no executarà la

sentencia.



4.7.2. Bucle FOR.

El bucle for és el bucle més utilitzat en el llenguatge C. La seva forma és la

següent:

for (inicialització; expressio_de_control; actualització) { sentencia; }

El bucle for funciona de la següent manera: Primer inicialitzem (inicialitzacio) la

variable, la qual volem actualitzar, després posem una condició

(expressio_de_control) en que si és true s’executarà la sentència i si és false

no executarà res. Llavors si es compleix (true) també es farà l’actualització de

la variable que hem iniciat en la inicialitzacio. Per exemple l’actualització podria

ser incrementar en 1 la variable iniciada.

4.7.3. Bucle DO ... WHILE.

Aquest bucle funciona com el while però l’avaluació de la condició es fa al final,

per tant el codi s’haurà executat un cop abans de fer la comprovació, en la que

si surt true tornarà a executar-se, en canvi si es false no s’executarà cap cop

més. La seva forma és la següent:

do sentencia; while(expressio_de_control);

4.7.4. Sentència Break, continue, Goto.

La sentència break té la funció d’interrompre l’execució del bucle en el qual

està inclòs, sortint del bucle.

La sentència continue fa que el programa comenci el següent cicle del bucle on

es troba, encara que no hagi arribat al final de la sentència composta.

La sentència goto permet saltar el programa a la sentència on es troba escrita

l’etiqueta que porta el goto.



if (condicio) { goto altre_lloc; sentencia_1; sentencia_2; } altre_lloc: sentencia_3;

4.8. Estructura de la programació C.

El llenguatge C té una estructura determinada, que hem de seguir per tal de

que el programa funcioni. L’estructura és la següent:

#include <pololu/3pi.h> int main() { //Aquí posem el programa principal. }

Primerament trobem el #include que ens serveix per carregar les funcions que

té el processador del robot, en aquest cas pololu/3pi.h.

El int main() com hem explicat anteriorment, és on comença la execució del

programa.



5. Instal·lació del programa AVR Studio 4

Per instal·lar el programa AVR Studio 4 hem de seguir els següents passos:

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. Extreure el fitxer libpololu-avr i fer doble clic en make-install. Doneu-li a l'espai

tantes vegades com us indiqui la pantalla i amb això ja estarà instal·lat el programari

per a la programació del robot.

5.1. Passos per crear un projecte

Per crear un projecte primerament hem d’obrir el programa AVR Studio 4 i ens

apareixerà la següent pantalla:

A continuació, s'anirà al menú Project, i Project Wizard. Haurà d'aparèixer la

pantalla de la Fig. . Es farà clic en el botó New Project.

Fig.18 Pantalla inicial del programa.



S’ha d’escollir, el Project type l'opció AVR GCC; en Project name es

posarà un nom per al projecte, per exemple test, i es farà clic en el botó

Next

En la següent pantalla, s’escollirà AVR Simulator 2 en la meitat esquerra i en

la meitat dreta s’escollirà el microcontrolador, ATmega328P. Una vegada

realitzada aquestes dues accions, es farà clic en Finish.

Fig.19 Pantalla de creació de projecte.

Fig.20 Pantalla d’elecció del microcontrolador.



Fig.21 Pantalla principal AVRStudio 4 amb el codi

Fig.22 AVRStudio 4 passant el codi al robot



5.2. USB AVR Programmer

Un cop realitzat el programa en el AVR Studio 4, necessitem enviar-lo al robot

mitjançant el Pololu USB AVR Programmer, que es connecta al robot

Aquest dispositiu és un programador de controladors AVR-base, com ara el

nostre robot pololu 3pi. El programador emula un AVRISP v2 en un port sèrie

virtual, pel que és compatible amb el programari estàndard de programació

AVR. Dues característiques addicionals ajuden a generar i depurar projectes:

un port sèrie TTL-nivell per a la comunicació d'ús general i un SLO-àmbit

d'aplicació per al monitoratge de senyals i els nivells de tensió.

Borns de funcions:

Port sèrie TTL-nivell:

El programador AVR USB funciona com un adaptador de USB a sèrie, però

amb algunes millores clau. El programador s'instal·la com dos ports COM

virtuals: un per a comunicar-se amb el programari de programació i un per

l'adaptador d'ús general d'USB sèrie. Això significa que es pot canviar sense

problemes entre la programació d'un regulador i la depuració a través del port

TTL de sèrie sense haver d'obrir i tancar el programa de terminal. El

programador també li dóna accés a la regulació d'USB del bus d'energia de 5V

a través del pern VBUS.

SLO-abast:

El SLO-àmbit és un oscil·loscopi que pot mesurar tensions entre 0 i 5 V ~ (el

màxim està limitat per la tensió del bus USB). Aquesta característica pot ajudar

a depurar els seus circuits i el microprogramari per veure el que les tensions

estan fent en diversos nodes.

Utilitza un cable ISP per a la connexió entre el robot i el USB AVR Programmer

i un cable USB 2.0 per a la connexió amb l’ordinador.



Fig.23: USB AVR Programmer



6. Proves amb el robot.

En aquest apartat explicarem els exercicis pràctics fets, la cal·libració i la

instal·lació de la placa d’expansió.

6.1. Pràctiques realitzades a la UPC.

En aquest apartat explicarem els codis de programació que hem utilitzat durant

les pràctiques a la UPC.

Pràctica 1: Text en pantalla i funció de leds. Mostra un text a la pantalla i

s’encenen i apaguen els leds.

Pràctica 2: Polsadors del robot I. Programa amb els diferents polsadors del robot.

Pràctica 2.1: Polsadors del robot II. Programa amb els diferents polsadors del

robot, però d’una altra manera.

Pràctica 2.2: Polsadors del robot III. Programa amb els diferents polsadors del

robot, però d’una altra manera diferent als dos anteriors.

Pràctica 3: Funció de leds a partir dels polsadors I. Programa combinat amb els

polsadors i els leds.

Pràctica 3.1 Funció de leds a partir dels polsadors II. Programa combinat amb els

polsadors i els leds, de manera diferent i més complexa que l’anterior.

Pràctica 4: Paràmetres del voltatge I. Programa que mostra el nivell de voltatge de

les bateries.

Pràctica 4.1: Paràmetres del voltatge II. Programa que mostra el nivell de voltatge

de les bateries més avançat.

Pràctica 4.2: Paràmetres del voltatge III. Programa que mostra el nivell de voltatge

de les bateries, codi més simplificat.

Pràctica 5: Cal·libració i seguidor de línia I. Programa que calibra els sensors i

segueix la línia.

Pràctica 5.2: Cal·libració i seguidor de línia II. Programa que calibra els sensors i

segueix la línia, de diferent manera.

Pràctica 6: Temps de funcionament Programa que mostra el temps de

funcionament a la pantalla.



6.1.1. Text en pantalla i funció de leds.

En aquesta pràctica modifiquem el text que mostra la pantalla del robot i que es

desplaci horitzontalment perquè mostri el text totalment i que s’encenguin i

s’apaguin els leds.

6.1.2. Polsadors del robot I.

El robot mostra a la pantalla “Esperar” i quan premem el botó A canvia el text

per “Puls A”. Quan deixem de prémer durant 1 segon posa “Despul”.

#include <pololu/3pi.h> int main() { while(1) { print(" Hola soy Pololu!"); lcd_scroll(0,17,500); red_led(1); green_led(1); delay_ms(5000); red_led(0); green_led(0); delay_ms(3000); } return 0; }

#include <pololu/3pi.h> int main() { while(1) /* Sempre executarà l’acció */ { clear(); print("Esperar!"); /* A la pantalla posarà “Esperar!” */ unsigned char pulsador = wait_for_button_press(BUTTON_A); /*condició del polsador A*/ clear(); if (pulsador==BUTTON_A) /* Si el polsador A esta premut posarà “puls A” */ print("Puls A"); wait_for_button_release(pulsador); /* Si el deixem de prémer posarà “Despul” durant 1segon */ clear(); print("Despul"); delay_ms(1000); } }



6.1.3. Polsadors del robot II.

En aquesta pràctica hem realitzat unes modificacions, afegint el polsador C.

#include <pololu/3pi.h> int main() { while(1) /* Sempre executarà l’acció */ { clear(); print("Esperar!"); /* A la pantalla posarà “Esperar!” */ unsigned char pulsador = wait_for_button_press(BUTTON_A | BUTTON_C); //condició del botó C i A //Aquesta línia, afegeix el botó c respecte del programa anterior. clear(); if (pulsador==BUTTON_A) /* Si prems el botó A mostra “Puls A” */ print("Puls A"); else /* Si prems el botó C mostra “Puls C” */ print("Puls C"); wait_for_button_release(pulsador); /* Si el deixem de prémer posarà “Despul” durant 1segon */ clear(); print("Despul"); delay_ms(1000); } }



#include <pololu/3pi.h> int main() { while(1) { clear(); print("Esperar!"); /* A la pantalla surt “Esperar!” */ unsigned char pulsador = wait_for_button_press(BUTTON_A | BUTTON_C | BUTTON_B); /* Esperant a que es premi un botó */ clear(); if (pulsador==BUTTON_A) { /* Si premem el botó A surt a la pantalla “Puls A”*/ print("Puls A"); } else if (pulsador==BUTTON_C) //Si premem el botó C surt a la pantalla “Puls C” i s’activa el led vermell { print("Puls C"); red_led(1); green_led(0); } else if (pulsador==BUTTON_B) //Si premem el botó C surt a la pantalla “Puls C” i s’activa el led verd { print("Puls B"); green_led(1); } play("!L16 V8 cdefgab>cbagfedc"); while (is_playing()); // the first few measures of Bach's fugue in D-minor play("!T240 L8 a gafaeada c+adaeafa >aa>bac#ada c#adaeaf4"); wait_for_button_release(pulsador); //Espera a que deixem de prémer qualsevol botó. delay_ms(4000); red_led(0); //Després d’un segon s’apaguen els leds. clear(); print("Despul"); //Surt a la pantalla “Despul” } }

6.1.4. Polsadors del robot III.

Modifiquem el programa perquè tingui en compte els 3 polsadors.



6.1.5. Funció de leds a partir dels polsadors I.

En aquesta pràctica s’encenen i s’apaguen els leds .

#include <pololu/3pi.h> int main() { while(1) { clear(); print("Esperar!"); unsigned char pulsador = wait_for_button_press(BUTTON_A); clear(); if (pulsador==BUTTON_A) // Si premem el botó A mostra “Puls A” { print("Puls A"); do // Mentre el botó és premut s’encendran i s’apagaran els leds { red_led(1); green_led(1); delay_ms(500); red_led(0); green_led(0); delay_ms(500); } while(button_is_pressed(BUTTON_A)); //Comprova si el botó és premut } wait_for_button_release(pulsador); // Esperem a que el botó es deixi de prémer clear(); print("Despul"); delay_ms(1000); red_led(0); green_led(0); } }



#include <pololu/3pi.h> int main() { while(1) { clear(); print("Esperar!"); unsigned char pulsador = wait_for_button_press(BUTTON_A | BUTTON_B | BUTTON_C); // Té en compte els 3 botons clear(); switch(pulsador) //A partir d’aquest punt el codi és diferent, respecte del programa anterior. { case BUTTON_A: //Si premem el botó a s’executa el següent { print("Puls A"); do //Mentre el botó està premut s’encendran i apagaran els leds { red_led(1); green_led(1); delay_ms(500); red_led(0); green_led(0); delay_ms(500); } while(button_is_pressed(BUTTON_A)); //Comprova si està premut break; } case BUTTON_B: // Si premem el botó B s’executa el següent { print("Puls B"); do // Mentre el botó està premut s’encendran i apagaran els LEDS { red_led(1); green_led(1); delay_ms(1000); red_led(0); green_led(0); delay_ms(1000); } while(button_is_pressed(BUTTON_B)); //Comprova si està premut break; case BUTTON_C: // Si premem el botó C s’executa el següent { print("Puls C"); do // Mentre el botó està premut s’encendran i apagaran els LEDS { red_led(1); green_led(1); delay_ms(250); red_led(0); green_led(0); delay_ms(250); } while(button_is_pressed(BUTTON_C)); //Comprova si està premut break; } default: print ("Esperar!"); }

6.1.6. Funció de leds a partir dels polsadors II.

En aquesta pràctica encenem i apaguem leds amb els tres polsadors del robot.



6.1.7. Paràmetres del voltatge.

En aquesta pràctica el robot ens mostra el voltatge de les piles a la pantalla.

#include <pololu/3pi.h> int main() { int bateria; //Canviar de nombre enter a cadena de caràcters char cadena_car[10]; while(1) { print(" Pulse button B for Battery"); lcd_scroll(0,27,200); unsigned char pulsador = wait_for_button_press(BUTTON_B); if (pulsador==BUTTON_B) { clear(); bateria=read_battery_millivolts_3pi(); itoa(bateria,cadena_car,10); //Passa els nombres enters a una cadena de caràcters print(cadena_car); // Que la mostri en pantalla print("mV"); //Introduir unitat delay(5000); if (bateria<5000) { play_frequency(1000,1000,10); while (is_playing()); } } wait_for_button_release(pulsador); clear(); } }

wait_for_button_release(pulsador); // Esperem a que es deixi de prémer qualsevol botó clear(); print("Despul"); delay_ms(1000); red_led(0); green_led(0); } }



6.1.8. Paràmetres del voltatge II.

És una modificació del l’anterior en que si la bateria és inferior a 5 V fa un so.

#include <pololu/3pi.h> int main() { int bateria; //Canviar de nombre enter a cadena de caràcters char cadena_car[10]; while(1) { print(" Pulse button B for Battery"); lcd_scroll(0,27,200); unsigned char pulsador = wait_for_button_press(BUTTON_B); if (pulsador==BUTTON_B) { clear();

// A partir d’aquí el codi té unes certes modificacions respecte de l’anterior // fent girar el robot respecte el seu eix durant 3 segons.

set_m1_speed(100); set_m2_speed(-100); delay_ms(3000); } wait_for_button_release(pulsador); clear(); set_m1_speed(0); set_m2_speed(0); delay_ms(1000); bateria=read_battery_millivolts_3pi(); itoa(bateria,cadena_car,10); //Passa els nombres enters a una cadena de caràcters print(cadena_car); // Que la mostri en pantalla

print("mV"); //Introduir unitat delay(3000); //Durant 3 segons, sino posem temps no apareix en pantalla if (bateria<5000) { play_frequency(1000,1000,10); while (is_playing()); } } }



6.1.9. Paràmetres del voltatge III.

En aquesta pràctica el robot ens mostra d’una manera diferent el voltatge

respecte la pràctica anterior.

#include <pololu/3pi.h> int main() { while(1) { unsigned int bateria = read_battery_millivolts_3pi(); clear(); lcd_goto_xy(0,0);// el codi és diferent a partir d’aquesta línia

//Essent més simplificat i sense moure els motors. print("Bateria"); lcd_goto_xy (0,1); print_long(bateria); // Que mostri els volts que disposa la bateria print("mV"); //Introduir unitat delay(5000); // El temps d’actualització és de 5 segons if (bateria<5000) { play_frequency(1000,1000,10); while (is_playing()); } } }



#include <pololu/3pi.h> void initialize() { unsigned int counter; //Utilitzat com a temporitzador unsigned int sensors[5]; // Un vector per guardar l’estat dels sensors //Aquest codi ha de ser el primer que s’executi per inicialitzar els sensors pololu_3pi_init(2000); //Mostrar la tensió de la bateria mentre no 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); } // Esperar que es deixi de prémer B per començar la cal·libració wait_for_button_release(BUTTON_B); delay_ms(1000); // L’auto cal·libració realitza un gir a la dreta i un altre 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 els valors dels sensors de reflexió unsigned int position = read_line(sensors,IR_EMITTERS_ON); clear(); print_long(position); lcd_goto_xy(0,1); delay_ms(100); } wait_for_button_release(BUTTON_B); clear(); print("Go!"); }

6.1.10. Cal·libració i seguidor de línia I.

En aquesta pràctica es calibren els sensors a l’inici del programa i després,

depenent de la posició de la línia, es mou cap a una posició o una altra.



int main() //Programa principal { unsigned int sensors[5]; // S’inicialitzen les variables initialize(); int contador=0; while(1) { unsigned int posicion=read_line(sensors,IR_EMITTERS_ON); // Els sensors s’encenen clear(); print_long(contador); lcd_goto_xy(0,1); print_long(posicion); if (posicion<1000){ set_motors(-40,40);}

else if (posicion>1000 && posicion<3000){ set_motors(40,40); contador=0;} else if (posicion>3000 && posicion<4000){ set_motors(40,-40);} do{ posicion=read_line(sensors,IR_EMITTERS_ON); if (posicion==4000){ contador++; set_motors(20,20); delay_ms(100);} else break; } while(contador>=5); } }



6.1.11. Cal·libració i seguidor de línia II.

En aquesta pràctica es calibren els sensors a l’inici del programa, depenent del

valor que detecta gira cap a una banda o una altra i si no detecta línia segueix

recte durant 30 segons.

#include <pololu/3pi.h> void initialize() { unsigned int counter; //Utilitzat com a temporitzador unsigned int sensors[5]; // Un vector per guardar l’estat dels sensors //Aquest codi ha de ser el primer que s’executi per inicialitzar els sensors pololu_3pi_init(2000); //Mostrar la tensió de la bateria mentre no 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); } // Esperar que es deixi de prémer B per començar la cal·libració

wait_for_button_release(BUTTON_B); delay_ms(1000); // L’auto cal·libració realitza un gir a la dreta i un altre 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 els valors dels sensors de reflexió unsigned int position = read_line(sensors,IR_EMITTERS_ON); clear(); print_long(position); 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 contador=0; while(1) {



unsigned int posicion=read_line(sensors,IR_EMITTERS_ON); clear(); print_long(contador); lcd_goto_xy(0,1); print_long(posicion); if (posicion<1000) { set_motors(-40,40); // Si posició<1000 girar esquerra } else if (posicion>1000 && posicion<3000) { set_motors(40,40); // Si posició entre 1000 i 3000 //Anar Recte contador=0; } else if (posicion>3000 && posicion<=3999) //Si posició entre 3000 y 4000 girar dreta { set_motors(40,-40); } //Si no detecta línia i variable “contador” està a 0 //Seguir recte durant 30 segons en busca la línia else if (posicion==4000 && contador==0) { for (contador=0;contador<6;contador++) { time_reset(); while(get_ms()<250) set_motors(10,10); posicion=read_line(sensors,IR_EMITTERS_ON); if (posicion<4000) { contador=6; break; } } } //Si no detecta línia i s’ha intentat trobar la línia gira a l’esquerra durant 500 mil·lisegons i segueix recte durant 500 mil·lisegons més else if (posicion==4000 && contador>=6) { time_reset(); //fa un reset al comptador, el posa a 0. (comptador de temps) while(get_ms()<500) // Dóna el temps transcorregut en mil·lisegons i creem una variable set_motors(-10,10); time_reset(); while(get_ms()<500) set_motors(10,10); } } }



6.1.12. Temps de funcionament.

Mostra el temps transcorregut al llarg del circuit a la pantalla.

#include <pololu/3pi.h> int main() { while(1) { unsigned int tiempo = get_ms(); clear(); print_long(tiempo); print("ms"); delay(30); } }



#include <pololu/3pi.h> void initialize() { unsigned int counter; //Utilitzat com a temporitzador unsigned int sensors[5]; // Un vector per guardar l’estat dels sensors //Aquest codi ha de ser el primer que s’executi per inicialitzar els sensors pololu_3pi_init(2000); //Mostrar la tensió de la bateria mentre no 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); } // Esperar que es deixi de prémer B per començar la cal·libració wait_for_button_release(BUTTON_B); delay_ms(1000); // L’auto cal·libració realitza un gir a la dreta i un altre a l’esquerra for(counter=0;counter<80;counter++) { if(counter < 20 || counter >= 60) set_motors(40,-40); else set_motors(-40,40); calibrate_line_sensors(IR_EMITTERS_ON); //Guarda els valors dels sensors delay_ms(20); } set_motors(0,0);

6.2. Cal·libració

Donat als problemes obtinguts amb el codi de cal·libració, vam observar el

valor que marcava el robot en diferents posicions i la vam comparar amb la

lectura teòrica que hauria d’haver mostrat.

El valor teòric es calcula a partir de la següent expressió matemàtica:

∑

El qual llegeix els valors de cada sensor, el qual es multiplica i se suma dividint-

se pel total de sensors activats durant la realització o execució del codi de

programació.



Aquest és el codi de cal·libració dels sensors del robot el qual un cop hem

premut el botó B inicia l’execució dels sensors reflectors i motors per detectar

els valors de la línia. I un cop tornem a prémer el polsador B inicia la següent

instrucció.

while(!button_is_pressed(BUTTON_B)) { // Llegeix els valors dels sensors de reflexió unsigned int position = read_line(sensors,IR_EMITTERS_ON); clear(); print_long(position); lcd_goto_xy(0,1); delay_ms(100); } wait_for_button_release(BUTTON_B); clear(); print("Go!");

}



6.3. Instal·lació de la placa d’expansió

En aquest robot se li poden col·locar dos plaques d’expansió diferents. La placa

que hem utilitzat és la que permet visualitzar la pantalla, per poder indicar la

posició de la línia amb el robot en el mateix moment que s’està movent,

mitjançant la col·locació de leds amb unes resistències de 220 Ω.

6.3.1. Procés de muntatge

Pas 1 : Connexió de a tira de pins a la placa mare (tira de pins femelles) i tira

de pins mascle a la placa d’expansió.

Fig.24: Placa d’expansió

Fig. 25: Tires de pins (femella i mascle respectivament)



Fig.26 : Robot amb la tira de pins femella connectada

Fig.27 : Placa d’expansió amb la tira de pins masculina soldada



Pas 2: Connexió de la tira masculina del connector AC

Pas 4 : Muntatge de la placa d’expansió al robot

Fig.29 : Connector AC

Fig.28 : Soldadura de la tira de pins femella a la placa d’expansió

Fig.30 : Robot amb la placa connectada



Pas 5 : Connexió de leds a la part posterior del robot

Pas 6 : Connexió dels leds a la placa d’expansió mitjançant les sortides.

Fig.31 : Robot amb els leds soldats i connectats



6.4. Connexions de la placa d’expansió

En aquest apartat explicarem les connexions de la placa d’expansió, mitjançant

diferent sortides digitals disponibles a la placa mare.

GND és la presa de terra; PD0 és una sortida digital disponible; PD1 és una

sortida digital disponible; ADC6 és una entrada analògica que s’utilitza pel

sistema de mesura del voltatge, que es pot utilitzar si es treu el jumper

corresponent, on baixa el valor de la bateria 2/3; ADC7 és una entrada

analògica ocupada per un potenciòmetre; PC5 és una entrada analògica que

realitza la funció d’enviar els infrarojos dels sensors reflectors, que es pot

desactivar traient un jumper; VBST que regula el voltatge subministrat als

motors a 9.25V; VBAT que és el voltatge de les bateries; VCC que regula el

voltatge a 5V; PC6 fa la funció de resetejar el robot i PB3 és una sortida digital

que controla els motors.

GND PD0 PD1 ADC6 ADC7 PC5 GND

GND VBST VBAT VCC PC6 PB3 GND

Fig.32 : Pins per connectar la placa d’expansió, amb les

seves corresponents funcions.



6.5. Proves de velocitat

En aquest apartat explicarem amb quines àrees de treball amb els sensors

s’assoleix un millor temps depenen de la velocitat en un mateix recorregut.

A continuació us mostrarem les taules dels valors obtinguts a les proves

realitzades:

6.5.1. Tres zones

Hem dividit els 5 sensors del robot en 3 zones depenent del valor que obtenen

els sensors. Si la posició és més baixa que 1000 el robot gira cap a l’esquerra,

si és més gran que 1000 i més petita que 3000 el robot segueix recte i si és

major de 3000 el robot gira cap a la dreta.

V1=40 V2=100 V3=150

Temps1

Temps2

Temps3

Temps1

Temps2

Temps3

Temps1

Temps2

Temps3

6.9 s 6.9 s 6.9 s 3.6 s 3.3 s 3.8 s 1.87 s 3.23 s 2.19 s

6.9 s 3.56 s 2.43 s

if (posicion<1000){ set_motors(-40,40);} else if (posicion>1000 && posicion<3000){ set_motors(40,40);} else if (posicion>3000){ set_motors(40,-40);}



6.5.2. Cinc zones


els sensors. Si la posició és més baixa que 1000 el robot gira cap a l’esquerra

sobre el mateix, si és més gran que 1000 i més petita que 1500 gira cap a

l’esquerra, si la posició és més gran que 1500 i més petita que 2500 el robot

segueix recte i si és major de 2500 i més petita que 3000 el robot gira cap a la

dreta i si és més gran que 3000 el robot dóna un gir sobre si mateix cap a la

dreta.

V1=40 V2=100 V3=150

Temps1

Temps2

Temps3

Temps1

Temps2

Temps3

Temps1

Temps2

Temps3

7.0 7.1 07.0 5.1 s 3.0 s 2.9 s 2.41 s 3.32 s 1.57 s

7.03 s 3.66 s 2.43 s

if (posicion<1000){ set_motors(-40,40);} else if (posicion>1000 && posicion<1500){ set_motors(0,40);} else if (posicion>1500 && posicion<2500){ set_motors(40,40);} else if (posicion>2500 && posicion<3000){ set_motors(40,0);} else if (posicion>3000){ set_motors(40,-40);}



6.5.3. Nou zones


els sensors. Si la posició és més baixa que 500 el robot gira cap a l’esquerra

sobre el mateix, si és més gran que 500 i més petita que 1000 gira cap a

l’esquerra, si la posició és més gran que 1000 i més petita que 1500 el robot fa

es desvia cap a l’esquerra i si és major de 1500 i més petita que 1800 el robot

es devia una mica menys que en el cas anterior cap a la dreta i si és més gran

que 1800 i més petit que 2200 el robot va recte.

Si la posició és més gran que 2200 i més petita que 2500 el robot es desvia

una mica cap a la dreta, si és més gran que 2500 i més petita que 3000 es

desvia cap a la dreta , si la posició és més gran que 3000 i més petita que 3500

el robot gira cap a la dreta i si és major de 3500 el robot gira cap a la dreta.

V1=40 V2=100 V3=150

Temps1

Temps2

Temps3

Temps1

Temps2

Temps3

Temps1

Temps2

Temps3

6.9 7.2 6.7 3.2 s 2.9 s 2.6 s 2.15 s 2.28 s 1.91 s

4.56 s 2.9 s 2.11 s

if (posicion<500){ set_motors(-40,40);} else if (posicion>500 && posicion<1000){ set_motors(-10, 40);} else if (posicion>1000 && posicion<1500){ set_motors(20,40);} else if (posicion>1500 && posicion<1800){ set_motors(30,40);} else if (posicion>1800 && posicion<2200){ set_motors(40,40);} else if (posicion>2200 && posicion<2500){ set_motors(40,30);} else if (posicion>2500 && posicion<3000){ set_motors(40,20);} else if (posicion>3000 && posicion<3500){ set_motors(40,-10);} else if (posicion>3500){ set_motors(40,-40);}



6.5.4. Conclusions a partir de les diferents zones

A partir dels diferents anàlisis realitzats ens els apartats anteriors, hem arribat a

la conclusió que el robot treballa millor si les zones de lectura dels sensors es

divideixen en nou zones, ja que de mitjana el temps de realització del circuit és

inferior a la resta.

Respecte la velocitat, el millor temps dins de l’anàlisi de funcionament amb nou

zones, és el de 150, ja que obtenim un temps bastant inferior a les altres

velocitats testades.



7. Projecte final

En aquest apartat explicarem el codi final de programació, que inclourà tres

programes, que s’activaran prement un dels 3 polsadors que posseeix.

Al principi de cada programa el robot realitzarà la cal·libració dels sensors.

En el polsador A el robot no sortirà de la zona delimitada per les línies negres,

girant quan en trobi alguna de manera contínua.

if (pulsador==BUTTON_A) { clear(); print("Estancament"); if (posicion==4000) { set_motors(60,60); } else { set_motors(60,-80); } }



En el polsador B el robot haurà de resoldre el laberint proposat fins arribar a la

franja negre, a on s’aturarà.

else if (pulsador==BUTTON_B) { clear(); lcd_goto_xy(0,1); print_long(posicion); if (posicion<500){ set_motors(-40,40);} else if (posicion>500 && posicion<1000){ set_motors(0,40);} else if (posicion>1000 && posicion<1900){ set_motors(20,40);} else if (posicion>1900 && posicion<2100){ set_motors(40,40);} else if (posicion>2100 && posicion<2500){ set_motors(40,20);} else if (posicion>2500 && posicion<3000){ set_motors(40,0);} else if (posicion>3000){ set_motors(40,-40);} if(sensors[0]>200 && sensors[2]>200 && sensors[1]==0){ set_motors(-20,80); } if(sensors[2]>200 && sensors[4]>200){ set_motors(80,-20); } //Si els 5 sensors del davant marquen linia negra s'atura if (sensors[1]>600 && sensors[2]>600 && sensors[3]>600 && sensors[4]>600){ set_motors(0,0); } }



En el polsador C el robot seguirà la línia negre completant el circuit, i al llarg del

recorregut mostra a la pantalla el valor dels sensors.

else if (pulsador==BUTTON_C) { clear(); print("Seguidor"); if (posicion<500){ set_motors(-150,150);} else if (posicion>500 && posicion<1000){ set_motors(-40,150);} else if (posicion>1000 && posicion<1500){ set_motors(75,150);} else if (posicion>1500 && posicion<1800){ set_motors(30,150);} else if (posicion>1800 && posicion<2200){ set_motors(150,150);} else if (posicion>2200 && posicion<2500){ set_motors(150,30);} else if (posicion>2500 && posicion<3000){ set_motors(150,75);} else if (posicion>3000 && posicion<3500){ set_motors(150,-40);} else if (posicion>3500){ set_motors(150,-150);} //Si els 5 sensors del davant marquen linia negra s'atura if (sensors[1]>600 && sensors[2]>600 && sensors[3]>600 && sensors[4]>600){ set_motors(0,0); } }



7.1. Codi final.

En aquest apartat mostrem el codi de programació final el qual realitza tres

programes diferents. Primerament, fa la cal·libració dels sensors i inicia el

programa “estancament” que es basa en fer que el robot no surti d’una àrea

determinada. A continuació el robot inicia el laberint el qual el robot ha de trobar

el final. Per finalitzar el robot inicia el seguidor de línia que es basa en el fet de

realitzar un circuit seguint una línia.

#include <pololu/3pi.h> #include <avr/pgmspace.h> // Les dades per a la generació dels caràcters utilitzats en load_custom_characters // I display_readings. En llegir els nivells de [] a partir de les diverses // Compensacions, podem generar tots els 7 caràcters addicionals necessaris per a un // Gràfic de barres. Això també s'emmagatzema en l'espai del programa. const char levels[] PROGMEM = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111 }; // Aquesta funció carrega els caràcters a la pantalla. // Els utilitzem per fer els 7 nivells del gràfic de barres void load_custom_characters() { lcd_load_custom_character(levels+0,0); // una barra lcd_load_custom_character(levels+1,1); // dos barres lcd_load_custom_character(levels+2,2); // etc... lcd_load_custom_character(levels+3,3); lcd_load_custom_character(levels+4,4); lcd_load_custom_character(levels+5,5); lcd_load_custom_character(levels+6,6); clear(); // the LCD must be cleared for the characters to take effect }



// Aquesta funció posa el valor dels sensors en el gràfic de barres void display_readings(const unsigned int *calibrated_values) { unsigned char i; for(i=0;i<5;i++) { // Inicialitzar la matriu de caràcters que s'utilitzarà per a la

// Gràfic. Ús de l'espai, una còpia addicional de la barra // Caràcter, i el caràcter 255 (un quadre negre complet), obtenim 10 // Caràcters en la matriu.

const char display_characters[10] = {' ',0,0,1,2,3,4,5,6,255}; // La variable c tindrà valors de 0 a 9, ja que

// Calibrar els valors estan en el rang de 0 a 1000, i // 1000/101 de 9 amb les matemàtiques sencer.

char c = display_characters[calibrated_values[i]/101]; // Mostra el gràfic de barres print_character(c); } } // Cal·libració void initialize() { unsigned int counter; unsigned int sensors[5];

// Això s'ha de mencionar al principi del codi 3pi, per establir els // Sensors. Nosaltres fem servir un valor de 2000 per al temps d'espera, // correspon a 2.000 * 0,4 = 0,8 ms en el nostre processador de 20 MHz

pololu_3pi_init(2000); load_custom_characters(); // càrrega de caràcters personalitzats int bat = read_battery_millivolts(); if (bat<5000) { play_frequency(1000,1000,10); while (is_playing()); } // Mostra la bateria i s’espera a que es premi qualsevol botó. while(!button_is_pressed(BUTTON_A | BUTTON_B| BUTTON_C)) { clear(); print_long(bat); print("mV"); lcd_goto_xy(0,1); print("Press B");



delay_ms(100); }

// Sempre s’espera a que es premi el botó i es deixi de prémer, de // manera que 3pi no //Comença a moure's fins que la seva mà està fora d'ella.

wait_for_button_release(BUTTON_A | BUTTON_B| BUTTON_C); delay_ms(1000);

// Auto-cal·libració: gira a la dreta i a l’esquerra mentre es cal·libren els // sensors.

for(counter=0;counter<80;counter++) { if(counter < 20 || counter >= 60) set_motors(40,-40); else set_motors(-40,40)

// Aquesta funció registra una sèrie de lectures dels sensors i // manté // un registre dels valors mínims i màxims trobats. L’ // Argument IR_EMITTERS_ON significa que els LEDs IR es // troben encesos durant la lectura, que és generalment el que // Volem. calibrate_line_sensors(IR_EMITTERS_ON); //Des de que el nostre comptador està a 80el retard total serà de // 80*20 = 1600 ms. delay_ms(20);

} set_motors(0,0); // Mostra els valors de cal·libració com un gràfic while(!button_is_pressed(BUTTON_A | BUTTON_B| BUTTON_C)) { // Lectura dels valors dels sensors i mesura de la posició. unsigned int position = read_line(sensors,IR_EMITTERS_ON); // Mostra la mesura de la posició, que anirà de 0

// (Quan el sensor és més a l'esquerra sobre la línia) i 4000 (quan // El sensor de la dreta és més de la línia) al 3pi, // Amb un gràfic de barres de les lectures del sensor. Això permet // assegurar que el robot està llest per a funcionar.

clear(); print_long(position); lcd_goto_xy(0,1); display_readings(sensors); delay_ms(100); } wait_for_button_release(BUTTON_A | BUTTON_B | BUTTON_C);



clear(); print("Go!"); // Es mostra “Go!” a la pantalla del robot } int main() { unsigned int sensors[5]; initialize(); // Inicialitza el codi de cal·libració unsigned char pulsador = wait_for_button_press(BUTTON_A | BUTTON_B | BUTTON_C); //Esperant a que es premi un botó while (pulsador==BUTTON_A) // Al prémer el botó A s’inicia el següent codi { unsigned int sensors[5]; unsigned int posicion=read_line(sensors,IR_EMITTERS_ON);

// Llegeix els valors dels sensors clear(); // Esborra el text que hi ha en pantalla print(" Estancament"); lcd_scroll(0,12,500); // Desplaça el text en pantalla

// (direcció, nombre de caràcters, temps entre cada lletra) if (posicion==4000) // Si la posició és 4000 (fons blanc) { set_motors(20,20);

// Posa els motors en funcionament en el mateix sentit i el robot va recte. // El 20 és el valor de la velocitat de cada motor.

} else //Si la posició és diferent a 4000 (troba línia negra) { set_motors(60,-40);

// Posa els motors en funcionament en diferent sentit i el robot gira cap a la dreta. // El 60 és el valor de la velocitat del motor esquerra // El -40 és el valor de velocitat del motor dret que va en sentit //contrari

} wait_for_button_release(pulsador);

// Espera a que el botó es deixi de prémer } while (pulsador==BUTTON_B) // Al prémer el botó B s’inicia el següent codi { unsigned int posicion=read_line(sensors,IR_EMITTERS_ON); clear();



lcd_goto_xy(0,1); // Mostra el valor de la posició a la part inferior de la pantalla

print_long(posicion); // Valor de la posició if (posicion<500){ // Si la línia es troba entre el sensor PC0 i PC0+ set_motors(-40,40);}

// El motor esquerra gira endarrere i l’altre cap endavant else if (posicion>500 && posicion<1000){

// Si la línia es troba entre PC0+ i PC1 set_motors(0,40);}

// El motor esquerra para i l’altre gira endavant else if (posicion>1000 && posicion<1900){

// Si la línia es troba entre PC1 i PC2 set_motors(20,40);}

// El motor esquerra gira més lent que el dret else if (posicion>1900 && posicion<2100){ // Si la línia es troba al voltant de PC2 set_motors(40,40);} // El robot va recte else if (posicion>2100 && posicion<2500){

// Si la línia es troba entre PC2 i PC2+ set_motors(40,20);}

// El motor dret gira més lent que l’esquerra

else if (posicion>2500 && posicion<3000){ // Si la línia es troba entre PC2+ i PC3

set_motors(40,0);} // El motor dret para i l’altre gira endavant

else if (posicion>3000){

// Si la línia es troba entre PC3 i PC4 set_motors(40,-40);}

// El motor dret gira endarrere i l’altre cap endavant if(sensors[0]>200 && sensors[2]>200 && sensors[1]==0){

// Si el sensor PC0 i PC2 troben línia, mentre que el PC1 no n’hi troba set_motors(-20,80); // Fa un gir cap a l’esquerra } if(sensors[2]>200 && sensors[4]>200 && sensors[3]==0){

// Si el sensor PC2 i PC4 troben línia, mentre que el PC1 no n’hi troba set_motors(80,-20); // Fa un gir cap a la dreta } //Si els 5 sensors del davant marquen linia negra s'atura if (sensors[1]>600 && sensors[2]>600 && sensors[3]>600 && sensors[4]>600){



set_motors(0,0); } wait_for_button_release(pulsador); } while (pulsador==BUTTON_C) // Al prémer el botó C s’inicia el següent codi { unsigned int posicion=read_line(sensors,IR_EMITTERS_ON); clear(); print(" Seguidor"); lcd_scroll(0,9,500);

// Depenent de la posició de la línia varia la velocitat del motor del robot if (posicion<500){ set_motors(-150,150);} else if (posicion>500 && posicion<1000){ set_motors(-40,150);} else if (posicion>1000 && posicion<1500){ set_motors(75,150);} else if (posicion>1500 && posicion<1800){ set_motors(30,150);} else if (posicion>1800 && posicion<2200){ set_motors(150,150);} else if (posicion>2200 && posicion<2500){ set_motors(150,30);} else if (posicion>2500 && posicion<3000){ set_motors(150,75);} else if (posicion>3000 && posicion<3500){ set_motors(150,-40);} else if (posicion>3500){ // Si la línia es troba entre PC3+ i PC4 set_motors(150,-150);} //Si els 5 sensors del davant marquen linia negra s'atura if (sensors[1]>600 && sensors[2]>600 && sensors[3]>600 && sensors[4]>600){ set_motors(0,0); } } } Aquest codi final inclou tots els programes junts, però nosaltres els anem

posant d’un en un mostrant el procés de transferència de fitxers.



7.2. Circuits emprats en els diferents programes

A continuació incloem els 3 circuits utilitzats com a prova en els diferents programes:

- El primer és el seguidor de línia

- El segon l’estancament

- El tercer el laberint



8. Contingut del CD

El contingut del cd és el següent:

Programari del robot:

o Dins la carpeta AVR Studio hi trobem:

AVRStudio4.exe (software programació)

AVRStudio4.18SP1.exe (actualització)

AVRStudio4.18SP2.exe (actualització)

o Dins la carpeta libpololu-avr hi trobem:

Install.bat (instal·lador de les llibreries del processador)

o WinAVR-20090313-install (compilador C) i

o pgm03a_windows (drivers per al Windows)

Manuals: Inclou totes les pràctiques realitzades a la UPC, el manual del

processador ATMega 328p, les llibreries del processador i la guia

d’usuari del robot.

o atmega328p.pdf : Manual del microprocessador ATMega 328p

(en anglès).

o Avr_library_commands.pdf : llibreries del robot (en anglès).

o Circuit 1/2/3.pdf : circuits de prova realitzats a la UPC.

o Leng_c.pdf: manual de llenguatge C.

o Manual3pi.pdf: guia d’usuari del robot (en anglès).

o Prac 1/2/3/4/5.pdf : Pràctiques realitzades a la UPC

o TB6612FNG.pdf Manual del driver IC per motors duals de corrent

continu (en anglès)



Codis utilitzats: inclou tots els codis que hem fet durant el curs de la

UPC.

o Prac1.c “Text en pantalla i funció de leds”

o Prac2.c “Polsadors del robot I”

o Prac22.c “Polsadors del robot II”

o Prac23.c “Polsadors del robot III”

o Prac3.c “Funció de leds a partir dels polsadors I”

o Prac32-33.c “Funció de leds a partir dels polsadors II”

o Prac34-35.c “Paràmetres del voltatge I”

o Prac36.c “Paràmetres del voltatge II”

o Prac4.c “Paràmetres del voltatge III”

o Prac42.c “Cal·libració i seguidor de línia”

o Prac5.c “Cal·libració i seguidor de línia”

o Prac51.c “Temps de funcionament”

Codi final: Codi de programació final que inclou tots els programes

utilitzats el dia de l’exposició.

o Codifinal.c: programa final

Treball final: inclou la versió final

o Tdrmarcdetebarpolbonastre.pdf



9. Conclusions

Després de finalitzar el nostre treball, i d’enfrontar tots els problemes que

en han anat sorgint durant diferents processos, hem arribat a les següent

conclusions:

Amb la realització d’aquest treball, hem après a programar en llenguatge

C, el qual al principi ens semblava molt difícil ja que no en teníem un

coneixement previ i amb el curs de programació de llenguatge C realitzat a la

Universitat Politècnica de Catalunya de Terrassa durant l’estiu , hem après a

dominar-lo i a utilitzar-lo de manera constant, així com resoldre els diferents

errors que poden sorgir durant el procés de programació d’una manera senzilla

i ràpida.

A més a més, hem aprofundit els nostres coneixements sobre les

principals parts d’un robot, els motors, els leds, la placa base, el

microcontrolador i el seu àmbit de treball, completant els objectius proposats

abans d’iniciar el treball, aquests eren: aprendre a programar un robot i

conèixer els components del robot, els quals s’han assolit satisfactòriament.

Més endavant i un cop iniciat el treball ens vam proposar uns objectius

addicionals que eren: programar el robot perquè pugui realitzar un laberint i

seguir una línia i saber el funcionament del programa AVR Studio 4, que és el

programa que ens permet transferir el codi font al robot.

L’estructura del robot consta de tots els elements distribuïts en una placa

en forma de cercle en la qual els dos motors es troben a la part central exterior

d’aquest, permetent que el robot pugui efectuar un gir sobre si mateix. Aquesta

distribució també s’hagués pogut fer posant els motors a la part iniciar del robot

enlloc del centre fet que suposaria que no pogués realitzar girs sobre si mateix

però que permetria una millor orientació sobre la línia, també hi ha la possibilitat

de que tingui quatre motors de manera que els dos de cada banda vagin

coordinats entre si, que permetria realitzar el gir entre si mateix però alhora

poder-se orientar sobre la línia com en el cas anterior.



Una altra possible millora de l’estructura del robot rau en la

implementació d’una altra esfera de plàstic giratòria a la part frontal del robot

millorant l’estabilitat als canvis de velocitat, als girs i a les frenades.

Un dels problemes freqüents que ens hem trobat està relacionat amb els

sensors, els quals depenent de la puresa del color blanc del fons del circuit,

funcionen amb més o menys precisió, un altre problema relacionat amb els

sensors és el de la il·luminació, ja sigui natural o artificial, que interfereix en la

mesura del valor dels sensors a l’hora de realitzar la mesura.

Relacionat amb les rodes del robot, hem observat que depenent de la

superfície, el robot rellisca sobre aquesta, causant un desplaçament en el seu

moviment i a causa d’aquest fet, no s’orienta de manera correcte a la línia

negra.

Un cop iniciat el treball ens vam proposar instal·lar la placa d’expansió

per ampliar les característiques del robot i així disminuir-ne les limitacions. Al

començar a treballar-hi van sorgir molts conflictes alhora de trobar les sortides

correctes, trobant-nos en què dels 5 leds instal·lats que requereixen 5 sortides

lliures, només n’hi havia 4.

Per aquest fet i per la manca de temps en aquest apartat, nosaltres no

hem pogut realitzar aquesta part del treball, però seria una possible proposta

per aprofundir més en les capacitats del robot utilitzant la placa d’expansió.

Arran de la instal·lació de la placa d’expansió, la pantalla del robot es va

desconfigurar i va quedar inutilitzable, fet que ens va dificultar les

programacions posteriors del robot, degut a que els valors dels sensors no es

mostraven a la pantalla, i per tant, no els podíem saber d’una manera precisa.

En relació qualitat-preu, creiem que el robot és complert i permet

realitzar moltes funcions diferents, sense arribar a superar els 100€ de preu. A

més a més, permet la instal·lació de la placa d’expansió, la qual amplia d’una

manera bastant àmplia les possibilitats.



Ha estat molt positiu el fet de treballar amb aquest robot, ja que hem

pogut realitzar els nostres objectius i, fins i tot ampliar-los. Tot i que té unes

quantes limitacions que es poden pal·liar de certa manera amb la placa

d’expansió, aquest fet no ha suposat un problema per a nosaltres, ja que els

programes realitzats utilitzen tots els components que porta el robot de sèrie.



10. Bibliografia

POLOLU. Adreça: http://www.pololu.com/catalog/product/975/ Pàgina inicial del robot

ATMEGA 328P.

Adreça: http://www.atmel.com/dyn/products/product_card.asp?part_id=4198 Pàgina inicial del robot

UPC.Curs de robòtica i automatització 2010

http://www.pololu.com/catalog/product/975/

http://www.atmel.com/dyn/products/product_card.asp?part_id=4198

Programació del robot Pololu 3PI Arduino en llenguatge C

Documents

Transcript of Programació del robot Pololu 3PI Arduino en llenguatge C