Pol Bonastre Romera Marc De Tébar i Peralta
I.E.S. TORRE DEL PALAU
PROGRAMACIÓ DEL ROBOT POLOLU 3PI ARDUINO EN LLENGUATGE C
Treball de Recerca 2on de Batxillerat Marc De Tébar i Peralta , Pol Bonastre Romera Treball de Recerca “Pololu 3pi”
Pàgina 0
Pol Bonastre Romera Marc De Tébar i Peralta
Índex del treball 1.
Introducció ...........................................................................................................................4
2.
Robot Pololu 3Pi Arduino .....................................................................................................6
3.
Parts del robot......................................................................................................................7
4.
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
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. 4.4.
Funció main(). .....................................................................................................20
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
Treball de Recerca “Pololu 3pi”
Pàgina 1
Pol Bonastre Romera Marc De Tébar i Peralta 4.5.4.
Operadors relacionals.........................................................................................23
4.5.5.
Operadors lògics .................................................................................................24
4.6.
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.
6.
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. 5.
Control de flux d’execució ..........................................................................................24
Estructura de la programació C. .................................................................................29
Instal·lació del programa AVR Studio 4 ..............................................................................30 5.1.
Passos per crear un projecte ......................................................................................30
5.2.
USB AVR Programmer ................................................................................................33
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
Treball de Recerca “Pololu 3pi”
Pàgina 2
Pol Bonastre Romera Marc De Tébar i Peralta 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.
7.
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
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
Treball de Recerca “Pololu 3pi”
Pàgina 3
Pol Bonastre Romera Marc De Tébar i Peralta
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
Treball de Recerca “Pololu 3pi”
Pàgina 4
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 5
Pol Bonastre Romera Marc De Tébar i Peralta
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
Treball de Recerca “Pololu 3pi”
Pàgina 6
Pol Bonastre Romera Marc De Tébar i Peralta
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
Treball de Recerca “Pololu 3pi”
Pàgina 7
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.3: Part anterior 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.
Treball de Recerca “Pololu 3pi”
Pàgina 8
Pol Bonastre Romera Marc De Tébar i Peralta
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 /
ATMEGA328P-MU
catàlegs de
Nucli del
informació
processador
AVR
Proveïdor
Atmel
Convertidors
Categoria
Circuits integrats
de dades
Programa Mida
32 KB (16K x 16)
Mida del nucli
8-Bit
Temperatura
-40 ° C a 85 ° C
de la memòria Mida de RAM
2K x 8
de
Nombre d'E / S
23
funcionament
Velocitat
20MHz
Connectivitat
Tipus de
Interior
oscil·lador Tipus de
I ² C, SPI, UART / USART
Tensió - Font FLASH
A / D 8x10b
08/01 V a 05/05 V
(Vcc / Vdd)
Programa
Altres noms
ATMEGA328PMU
Memòria
del mateix
ATMEGA328P
EEPROM Mida
1K x 8
processador
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.
Treball de Recerca “Pololu 3pi”
Pàgina 9
Pol Bonastre Romera Marc De Tébar i Peralta
Velocitat del Subministrament Codi de processador de voltatge (V) comanda (MHz) ATmega328PAU 20 1.8 - 5.5 ATmega328PAUR ATmega328PMU ATmega328PMUR ATmega328PPU
“Package” Rang d’operació 32A 32A 32M1-A 32M1-A 28P3
Industrial (-40°C a 85°C)
Fig.4: Processador Atmega 328p
El microprocessador ATMega 328p té 21 entrades i sortides per a l’usuari.
Fig.5: Estructura del processador ATmega 328p
Treball de Recerca “Pololu 3pi”
Pàgina 10
Pol Bonastre Romera Marc De Tébar i Peralta
Taula d’assignació de les sortides i entrades del processador i funcions que poden realitzar: Pin
Funcions
Notes/funcions alternatives
PD0 PD1
free digital I/O free digital I/O
USART input pin (RXD) connectat al LED vermell d’usuari
PD2 PD3 PD4
LCD control RS M2 línia control LCD control E
PD5 PD6 PD7 PB0
M1 línia de control M1 línia de control LCD dades DB7 LCD control R/W
PB1
LCD dades DB4
PB2 PB3
Brunzidor o altaveu M2 línia de control
PB4
LCD dades DB5
interrupció 0 externa (INT0) Timer2 PWM output B (OC2B) USART rellotge extern input/output (XCK) Timer0 comptador extern (T0) Timer0 PWM output B (OC0B) Timer0 PWM output A (OC0A) Connectat al LED verd d’usuari Timer1 input capture (ICP1) divided system clock output (CLK0) Botó d’usuari Timer1 PWM sortida A (OC1A) Timer1 PWM sortida B (OC1B) Timer2 PWM sortida A (OC2A) ISP línia de programació Botó d’usuari
PB5
LCD dades DB6
Botó d’usuari
PC0
QTR-RC sensor reflexió QTR-RC sensor reflexió QTR-RC sensor reflexió
Sensor etiquetat com a PC0
PC1 PC2
PC3 PC4 PC5 ADC6
sensor etiquetat com a PC1
QTR-RC sensor reflexió QTR-RC sensor reflexió Entrada analògica i I/O digital Entrada dedicada analògica
ADC7
Entrada analògica
reset
Botó de RESET
Treball de Recerca “Pololu 3pi”
dedicada
sensor etiquetat com a PC2 (sensor central) sensor etiquetat com a PC3 sensor etiquetat com a PC4 jumpered to sensors’ IR LEDs ADC input channel 5 (ADC5) jumpered to 2/3rds of battery voltage ADC input channel 6 (ADC6) jumpered to user trimmer potentiometer ADC input channel 7 (ADC7) Reinicialitza el robot
Pàgina 11
Pol Bonastre Romera Marc De Tébar i Peralta
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
Treball de Recerca “Pololu 3pi”
Pàgina 12
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Fig.7. TB6612FNG
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. Treball de Recerca “Pololu 3pi”
Pàgina 13
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.8: Gir del robot en funció de la velocitat que s’aplica als motors.
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
Treball de Recerca “Pololu 3pi”
Pàgina 14
Pol Bonastre Romera Marc De Tébar i Peralta
transmetre informació a través d'un canal de comunicacions o per controlar la quantitat d'energia que s'envia a una càrrega.
Fig. 9: Esquema de modulació
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.
Treball de Recerca “Pololu 3pi”
Pàgina 15
Pol Bonastre Romera Marc De Tébar i Peralta
Fig. 10: Sensors Reflexors de llum
Fig. 11: QTR-1RC Sensor Reflexor de llum
A continuació mostrarem un esquema electrònic de connexió dels sensors.
Fig.12: 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. 13: Jumpers
Treball de Recerca “Pololu 3pi”
Pàgina 16
Pol Bonastre Romera Marc De Tébar i Peralta
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
Treball de Recerca “Pololu 3pi”
Pàgina 17
Pol Bonastre Romera Marc De Tébar i Peralta
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
Brunzidor
Esquema dels sensors
Esquema del processador ATmega 328p
Connexió de programació
Esquema del control dels motors
Control dels leds inferiors
Esquema del LCD i polsadors
Control del valor del voltatge de les bateries
Fig.17: Diagrama del robot Treball de Recerca “Pololu 3pi”
Pàgina 18
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 19
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 20
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 21
Pol Bonastre Romera Marc De Tébar i Peralta
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. Treball de Recerca “Pololu 3pi”
Pàgina 22
Pol Bonastre Romera Marc De Tébar i Peralta 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: >
Treball de Recerca “Pololu 3pi”
Pàgina 23
Pol Bonastre Romera Marc De Tébar i Peralta 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:
Treball de Recerca “Pololu 3pi”
Pàgina 24
Pol Bonastre Romera Marc De Tébar i Peralta
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; } ...
Treball de Recerca “Pololu 3pi”
Pàgina 25
Pol Bonastre Romera Marc De Tébar i Peralta
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 }.
Treball de Recerca “Pololu 3pi”
Pàgina 26
Pol Bonastre Romera Marc De Tébar i Peralta
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. Treball de Recerca “Pololu 3pi”
Pàgina 27
Pol Bonastre Romera Marc De Tébar i Peralta 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.
Treball de Recerca “Pololu 3pi”
Pàgina 28
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 29
Pol Bonastre Romera Marc De Tébar i Peralta
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:
Fig.18 Pantalla inicial del programa.
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.
Treball de Recerca “Pololu 3pi”
Pàgina 30
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.19 Pantalla de creació de projecte.
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.20 Pantalla d’elecció del microcontrolador. Treball de Recerca “Pololu 3pi”
Pàgina 31
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.21 Pantalla principal AVRStudio 4 amb el codi
Fig.22 AVRStudio 4 passant el codi al robot
Treball de Recerca “Pololu 3pi”
Pàgina 32
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 33
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.23: USB AVR Programmer
Treball de Recerca “Pololu 3pi”
Pàgina 34
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 35
Pol Bonastre Romera Marc De Tébar i Peralta 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. #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; } 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) /* 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); } }
Treball de Recerca “Pololu 3pi”
Pàgina 36
Pol Bonastre Romera Marc De Tébar i Peralta 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); } }
Treball de Recerca “Pololu 3pi”
Pàgina 37
Pol Bonastre Romera Marc De Tébar i Peralta 6.1.4. Polsadors del robot III.
Modifiquem el programa perquè tingui en compte els 3 polsadors. #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” } }
Treball de Recerca “Pololu 3pi”
Pàgina 38
Pol Bonastre Romera Marc De Tébar i Peralta 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); } }
Treball de Recerca “Pololu 3pi”
Pàgina 39
Pol Bonastre Romera Marc De Tébar i Peralta 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. #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!"); }
Treball de Recerca “Pololu 3pi”
Pàgina 40
Pol Bonastre Romera Marc De Tébar i Peralta 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.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(); } }
Treball de Recerca “Pololu 3pi”
Pàgina 41
Pol Bonastre Romera Marc De Tébar i Peralta 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()); } } }
Treball de Recerca “Pololu 3pi”
Pàgina 42
Pol Bonastre Romera Marc De Tébar i Peralta 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()); } } }
Treball de Recerca “Pololu 3pi”
Pàgina 43
Pol Bonastre Romera Marc De Tébar i Peralta 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.
#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!"); }
Treball de Recerca “Pololu 3pi”
Pàgina 44
Pol Bonastre Romera Marc De Tébar i Peralta 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); } }
Treball de Recerca “Pololu 3pi”
Pàgina 45
Pol Bonastre Romera Marc De Tébar i Peralta 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) {
Treball de Recerca “Pololu 3pi”
Pàgina 46
Pol Bonastre Romera Marc De Tébar i Peralta
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); } } }
Treball de Recerca “Pololu 3pi”
Pàgina 47
Pol Bonastre Romera Marc De Tébar i Peralta 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); } }
Treball de Recerca “Pololu 3pi”
Pàgina 48
Pol Bonastre Romera Marc De Tébar i Peralta
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 dividintse pel total de sensors activats durant la realització o execució del codi de programació.
#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);
Treball de Recerca “Pololu 3pi”
Pàgina 49
Pol Bonastre Romera Marc De Tébar i Peralta 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!");
}
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ó.
Treball de Recerca “Pololu 3pi”
Pàgina 50
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 51
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 52
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 53
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 54
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 55
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 56
Pol Bonastre Romera Marc De Tébar i Peralta
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 Ω.
Fig.24: Placa d’expansió
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. 25: Tires de pins (femella i mascle respectivament)
Treball de Recerca “Pololu 3pi”
Pàgina 57
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.26 : Robot amb la tira de pins femella connectada
Fig.27 : Placa d’expansió amb la tira de pins masculina soldada
Treball de Recerca “Pololu 3pi”
Pàgina 58
Pol Bonastre Romera Marc De Tébar i Peralta
Fig.28 : Soldadura de la tira de pins femella a la placa d’expansió
Pas 2: Connexió de la tira masculina del connector AC
Fig.29 : Connector AC
Pas 4 : Muntatge de la placa d’expansió al robot
Fig.30 : Robot amb la placa connectada
Treball de Recerca “Pololu 3pi”
Pàgina 59
Pol Bonastre Romera Marc De Tébar i Peralta
Pas 5 : Connexió de leds a la part posterior del robot
Fig.31 : Robot amb els leds soldats i connectats
Pas 6 : Connexió dels leds a la placa d’expansió mitjançant les sortides.
Treball de Recerca “Pololu 3pi”
Pàgina 60
Pol Bonastre Romera Marc De Tébar i Peralta
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
PD0
PD1
GND VBST VBAT
ADC6 ADC7
PC5
GND
VCC
PB3
GND
PC6
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.
Fig.32 : Pins per connectar la placa d’expansió, amb les seves corresponents funcions.
Treball de Recerca “Pololu 3pi”
Pàgina 61
Pol Bonastre Romera Marc De Tébar i Peralta
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. 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);}
V1=40 V2=100 V3=150 Temps Temps Temps Temps Temps Temps Temps Temps Temps 1 2 3 1 2 3 1 2 3 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
Treball de Recerca “Pololu 3pi”
Pàgina 62
Pol Bonastre Romera Marc De Tébar i Peralta 6.5.2. Cinc zones
Hem dividit els 5 sensors del robot en 5 zones depenent del valor que obtenen 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. 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);}
V1=40 V2=100 V3=150 Temps Temps Temps Temps Temps Temps Temps Temps Temps 1 2 3 1 2 3 1 2 3 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
Treball de Recerca “Pololu 3pi”
Pàgina 63
Pol Bonastre Romera Marc De Tébar i Peralta 6.5.3. Nou zones
Hem dividit els 5 sensors del robot en 9 zones depenent del valor que obtenen 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. 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);}
Temps 1 6.9
V1=40 Temps 2 7.2
Temps 3 6.7
4.56 s
Treball de Recerca “Pololu 3pi”
Temps 1 3.2 s
V2=100 Temps 2 2.9 s
2.9 s
Temps 3 2.6 s
Temps 1 2.15 s
V3=150 Temps 2 2.28 s
Temps 3 1.91 s
2.11 s
Pàgina 64
Pol Bonastre Romera Marc De Tébar i Peralta 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.
Treball de Recerca “Pololu 3pi”
Pàgina 65
Pol Bonastre Romera Marc De Tébar i Peralta
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); } }
Treball de Recerca “Pololu 3pi”
Pàgina 66
Pol Bonastre Romera Marc De Tébar i Peralta
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); }
&&
}
Treball de Recerca “Pololu 3pi”
Pàgina 67
Pol Bonastre Romera Marc De Tébar i Peralta
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); }
&&
}
Treball de Recerca “Pololu 3pi”
Pàgina 68
Pol Bonastre Romera Marc De Tébar i Peralta
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 } Treball de Recerca “Pololu 3pi”
Pàgina 69
Pol Bonastre Romera Marc De Tébar i Peralta
// 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"); Treball de Recerca “Pololu 3pi”
Pàgina 70
Pol Bonastre Romera Marc De Tébar i Peralta
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); Treball de Recerca “Pololu 3pi”
Pàgina 71
Pol Bonastre Romera Marc De Tébar i Peralta
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(); Treball de Recerca “Pololu 3pi”
Pàgina 72
Pol Bonastre Romera Marc De Tébar i Peralta
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){ Treball de Recerca “Pololu 3pi”
Pàgina 73
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 74
Pol Bonastre Romera Marc De Tébar i Peralta
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
Treball de Recerca “Pololu 3pi”
Pàgina 75
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 76
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 77
Pol Bonastre Romera Marc De Tébar i Peralta
Treball de Recerca “Pololu 3pi”
Pàgina 78
Pol Bonastre Romera Marc De Tébar i Peralta
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)
Treball de Recerca “Pololu 3pi”
Pàgina 79
Pol Bonastre Romera Marc De Tébar i Peralta
Codis utilitzats: inclou tots els codis que hem fet durant el curs de la UPC. “Text en pantalla i funció de leds”
o Prac1.c 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
Treball de Recerca “Pololu 3pi”
Pàgina 80
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 81
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 82
Pol Bonastre Romera Marc De Tébar i Peralta
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.
Treball de Recerca “Pololu 3pi”
Pàgina 83
Pol Bonastre Romera Marc De Tébar i Peralta
10.
Bibliografia
POLOLU. Adreça: http://www.pololu.com/catalog/product/975/ del robot
Pàgina inicial
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
Treball de Recerca “Pololu 3pi”
Pàgina 84