Download - Programació del robot Pololu 3PI
Programació del robot Pololu 3PI
PROGRAMACIÓ DEL ROBOT POLOLU 3PI
ÀLEX IZQUIERDO RODRÍGUEZADRIÀ CALVET GONZÀLEZ
2on BATXILLERAT CIENTÍFIC-TECNOLÒGICCURS 2011-2012
TREBALL DE RECERCA
1
Programació del robot Pololu 3PI
ÍNDEX1. Introducció..............................................................................................................................42. El robot....................................................................................................................................6
2.1 Característiques.................................................................................................................73. Elements del robot..................................................................................................................8
3.1 Motors...............................................................................................................................83.2 Sensors..............................................................................................................................93.3 ATPmega328p.................................................................................................................11
3.3.1 Característiques........................................................................................................113.3.2 Connexió dels PIN’s.................................................................................................12
3.4 Bateries............................................................................................................................133.5 Rodes...............................................................................................................................153.6 LCD.................................................................................................................................153.7 Indicadors Led.................................................................................................................163.8 Altaveu............................................................................................................................163.9 Botons.............................................................................................................................173.10 Sistema d'estabilització.................................................................................................18
4. Entorn de programació..........................................................................................................194.1 Programa principal..........................................................................................................194.2 Tokens.............................................................................................................................194.3 Paraules clau...................................................................................................................204.4 Identificadors..................................................................................................................214.5 Operadors........................................................................................................................224.6 Separadors.......................................................................................................................224.7 Comentaris......................................................................................................................224.8 Sentencies de control de flux..........................................................................................23
4.8.1 sentència IF - ELSE.................................................................................................234.8.2 sentència “Switch”...................................................................................................244.8.3 Bucles.......................................................................................................................244.8.4 sentència “While”....................................................................................................254.8.5 sentència “Do...while”.............................................................................................254.8.7 sentència “Continue”................................................................................................264.8.8 sentència “goto”.......................................................................................................26
5. Programari i eines utilitzades................................................................................................275.1 AVR STUDIO 4..............................................................................................................275.2 Cable USB.......................................................................................................................275.3 Llibreries de programació...............................................................................................285.4 Programador AVR ISP de 6 pins connectors...................................................................28
6. Instal·lació del programari....................................................................................................296.1 Creació d'un projecte amb AVR Studio...........................................................................296.2 Compil·lació i programació d'un projecte.......................................................................30
7. Creació de menús..................................................................................................................328. Seguidor de línies..................................................................................................................35
8.1 Pantalla principal.............................................................................................................358.2 Calibració de sensors......................................................................................................37
2
Programació del robot Pololu 3PI
8.3 Funció dels motors..........................................................................................................388.3.1 Assaig del primer circuit..........................................................................................398.3.2 Segona prova de circuit............................................................................................39
8.4 Creació variable “comptador”.........................................................................................419. Resolució d’un laberint ........................................................................................................44
9.1 Resolució directa del laberint..........................................................................................489.1.1. sentència path..........................................................................................................489.1.2. Exemple de memòria “path”...................................................................................49
10. Tancament...........................................................................................................................5011. Conclusions.........................................................................................................................5212. Fonts d'informació..............................................................................................................5513. Agraïments..........................................................................................................................57
3
Programació del robot Pololu 3PI
1. Introducció
A l’hora de seleccionar el nostre treball de recerca, vàrem escollir aquest
treball de robòtica ja que suposaria una gran millora en els nostres
coneixements a l’àrea de tecnologia. La robòtica, és una de les branques
principals de la tecnologia, i per això, els dos membres del grup hem triat
aquest tema, ja que ens sembla que realitzar aquesta tasca serà molt útil
per al nostres estudis. La robòtica, és un camp difícil per començar, i per
això, assistirem a un curs de la Universitat Politècnica de Catalunya (UPC)
a Terrassa, on ens donaran unes lliçons bàsiques per ajudar-nos a
afrontar aquest treball.
Per a aquest objectiu, vam treballar amb un robot anomenat “Pololu 3pi”,
un robot capaç de realitzar diferents funcions, com per exemple, utilitzar
els seus sensors per el seguiment d’una línia. Aquest robot va ser
proposat per els instructors del curs de l’UPC, ja que és bastant senzill de
programar i ideal per a usuaris amb poca experiència com nosaltres. El
treball pràctic consistirà bàsicament en la creació d'un menú inicial per al
robot, amb les funcions bàsiques que ja porta el robot (Mesura de la
càrrega de la bateria, un potenciòmetre, etc.), i afegir-li diferents
funcions, com per exemple, la del seguidor de línies, la resolució d'un
laberint, etc). Per a la creació d'aquests programes, començarem des
d'uns exemples que venien amb el programari del robot, que ens serviran
com a base en la programació.
El dos estudiants que vam fer aquest treball cursem el Batxillerat
Tecnològic, i creiem que la programació del robot i la assistència al curs
d’estiu de l’UPC, ens ajudaran molt a l’hora de iniciar-nos en aquest món.
Per exemple, les matèries que vam donar a la UPC la setmana que vàrem
4
Programació del robot Pololu 3PI
estar allà són assignatures impartides al primer curs de qualsevol
enginyeria. La robòtica és molt important actualment, ja que la utilització
de robots és molt usual al món actual, com per exemple, la utilització de
robots per a la indústria (cadenes de muntatge).
Un altre dels motius pels quals hem escollit aquest tema pel nostre Treball
de Recerca és per continuar la línia de treballs que hem realitzat durant
tota l’ESO, ja que al nostre institut hem realitzat tant la programació, com
la construcció i el disseny de alguns robots diferents al que utilitzarem
durant aquest treball, com per exemple, el robot seguidor de línies o el
robot Lego Mindstorm que vàrem utilitzar el curs anterior, al treball de
recerca de 4art de la ESO.
Aquest nou robot ens va suposar un repte, ja que era més complex i llarg
que tots el robots que havíem fet anteriorment, però finalment vam
aconseguir ensortir-nos.
5
Programació del robot Pololu 3PI
2. El robotEl Pololu 3pi és un petit robot autònom de gran rendiment, dissenyat per
competicions de seguiment de línia i resolució de laberints. està controlat
per un microcontrolador anomenat
ATmega328p amb 32 kBytes de memòria
flash per a carregar el programa que farà el
robot, i també 2 kBytes de memòria RAM per
a carregar variables temporals, i connectats a
aquest una sèrie de perifèrics que són: una
pantalla LCD de 8x2 caràcters per a mostrar
missatges a gust del usuari, un timbre de
petites dimensions, tres polsadors, LED’s, 2 motors reductors que li
permeten arribar a una velocitat de 1 m/s, etc. I tot això en un xassís de
9,7 cm de diàmetre. Per una altra banda, el Pololu 3pi es programa
mitjançant llenguatge C, utilitzant un programa gratuït anomenat AVR
Studio 4.
6
Imatge 1: El robot Pololu 3pi
Programació del robot Pololu 3PI
2.1 CaracterístiquesAquestes són les característiques físiques i tècniques del robot que
programarem. Aquestes dades són essencials per a la seva correcta
programació i utilització. Una vegada programat el robot, podrem veure
aquestes dades a la pantalla LED, com per exemple el voltatge. Aquestes
són les característiques principals:
• Microcontrolador: ATmega328
• Diàmetre del xassís: 9,7cm
• Divers dels motors:TB6612FNG
• Motors: 2 (1 per a cada roda)
• Interfases I/O disponibles para el usuari: 21
• Voltatge mínim: 3 Vcc
• Voltatge màxim: 7 Vcc
• Freqüència PWM màxima: 80 kHz
7
Programació del robot Pololu 3PI
3. Elements del robotA continuació explicarem detalladament les parts principals del robot amb
el qual treballarem i programarem per aquest treball de recerca. Aquestes
són les parts més importants:
– Motors
– Sensors
– Microcontrolador Atmega328p.
– Bateries
– Rodes
– LCD
– Indicadors led
– Altaveu
– Botons
– Sistema d'estabilització
3.1 MotorsEl Pololu 3pi incorpora 2 motors de tipus DC (Corrent Continua). Aquests
motors de corrent continua arriben fins a diversos milers de revolucions
per minut (rpm), per el qual un dispositiu
d’engranatges permet reduir aquestes revolucions
i augmentar la força de gir. El motors DC tenen
també la possibilitat de poder modificar la direcció
de gir a partir del anomenats ponts H. Els ponts H
és construeixen mitjançant transistors que
realitzant la funció de interruptors, en el cas del
3pi s’utilitzen ponts per als dos motors en el 3pi
mitjançant el chip TB6612FNG. Per una altra banda els motors del Pololu
3pi ofereixen un control de la velocitat a partir de les sortides PWM
8
Imatge 2: Motor encarregat d’una de les rodes del robot.
Programació del robot Pololu 3PI
(Modulació de la grandària del puls) del microcontrolador, és a dir, que
podràs marcar a la velocitat que vagin el motors en cada instant.
El Pololu 3pi té motors independents a cadascun dels costats, per això, es
crea un mètode de conducció anomenat conducció diferencial, però per
poder girar mitjançant aquest mètode és necessari fer girar el motors a
diferents velocitats.
3.2 SensorsEl Pololu 3pi té una sèrie de sensors, els quals permeten guiar el
moviment del robot, ja sigui dreta esquerre davant o enrere.
El robot obliga al sensor a llegir i a retornar la lectura estimada entre el
robot i la línia, en un valor entre 0-4000. Si el valor és 0 això indica que el
està al sensor 0, si el valor és 1000 això indica que el sensor utilitzat és el
2, i així successivament amb el altres. Si ens endinsem en com funcionen
els sensors en trobem amb tres possibilitats:
9
Imatge 3. Valors mostrats pels sensors de reflexió.
Programació del robot Pololu 3PI
• 0-1000: Si el robot marca un valor entre 0 i 1000, vol dir que el
robot està lluny del costat dret de la línia i per això girarà cap a
l’esquerra de manera que per fer-ho aquest ajustarà el motor dret a
100 i el esquerra a 255.
• 1000-3000: Si el robot marca un valor entre 1000 i 2000 vol dir que
el robot està centrat en la línia, i per això aquest ajustarà els motors
a velocitat 100, per a que aquest segueixi recte.
• 3000-4000: Si el robot marca un valor entre 3000 i 4000 significarà
que aquest està lluny del costat esquerre de la línia, i per això girarà
cap a la dreta mitjançant l’ajustament del motor dret a 0 i el motor
esquerre a 100.
10
Imatge 4: Esquema dels sensors dels sensors de reflexió presents al robot.
Programació del robot Pololu 3PI
3.3 ATPmega328pEl microcontrolador que s'incorpora dintre de
el Pololu 3pi és el ATmega328P, és un
microcontrolador d'alt rendiment i de baix
consum. Aquest microcontrolador és el cor
del Pololu 3pi i conté una sèrie de pins que
es poden configurar com entrades/sortides
digitals o analògiques.
3.3.1 CaracterístiquesAquestes són les característiques principals del microcontrolador del
nostre robot, encarregat de totes les funcions i de la memòria.
• 131 Instruccions
• Fins 20 MIPS rendiment a 20MHz
• Pin Count: 32
• Max pines I / O: 23
• SPI: 2
• UART: 1
• ADC: 8 canals, 10 bits de resolució
• Comparadors analògics: 1
• Flash (Kbytes): 32
• EEPROM (Kbytes): 1
• SRAM (Kbytes): 2
• Rang de temperatures: -40 a 85 ° C
11
Imatge 5: Microcontrolador ATmega328P
Programació del robot Pololu 3PI
3.3.2 Connexió dels PIN’sA continuació, veurem la destinació i funció de tots el Pin del robot Pololu
3Pi. Aquestes dades són molt importants ja que a l'hora de connectar
altres elements externs al nostre robot, caldrà saber on hem de
connectar-lo pel seu correcte funcionament. En total són 32 pins:
número del Pin
Code Lloc on és connecten
PIN1 PD3 (OC2B/INT1)
Drivers del motor i motor
PIN2 PD4 (XCK/T0) LCDPIN3 GND MassaPIN4 VCC Font 5VPIN5 GNDPIN6 VCC Font 5VPIN7 PB6
(XTAL1/TOSC1)Oscil·lador
PIN8 PB7 (XTAL2/TOSC2)
Oscil·lador
PIN9 PD5 (OCOB/T1) Drivers del motor i motorPIN10 PD6
(OCOA/AIW0)Drivers del motor i motor
PIN11 PD7 (AIN1) LCD/LEDPIN12 PB0 (CCK0/ICP1) LCDPIN13 PB1 (0C1A) LCDPIN14 PB3 (SS/0C1B) Buzzer (brunzidor)PIN15 PB3
(MOSI/0C2A)Drivers del motor / Connexió de Programació
PIN16 PB4 (MIS0) Connexió de ProgramacióPIN17 PB5 (SCK) Connexió de ProgramacióPIN18 AVCC Font 9,25 VPIN19 ADC6 Voltatge de la bateria, circuit de
deteccióPIN20 AREF Font 9,25 VPIN21 GNDPIN22 ADC7PIN23 PC0 (ADC0) Control de sensors reflectants i IR
LEDPIN24 PC1 (ADC1) Control de sensors reflectants i IR
LED
12
Programació del robot Pololu 3PI
PIN25 PC2 (ADC2) Control de sensors reflectants i IR LED
PIN26 PC3 (ADC3) Control de sensors reflectants i IR LED
PIN27 PC4 (ADC4/SDA) Control de sensors reflectants i IR LED
PIN28 PC5 (ADC5/SCL) Alimentació sensors i r/led.PIN29 PCS (RESET) Botó d’apagar / Connexió de
Programació / Drivers del motorPIN30 PD0 (RXD) Comunicació en sèriePIN31 PD1 (TXD) Comunicació en sèriePIN32 PD2 (INTO) LCD
Taula 1. número, nom i funció dels 32 pins del Pololu 3pi.
3.4 BateriesCom qualsevol sistema electrònic, el nostre robot ‘’Pololu 3pi’’ requereix
d'una alimentació, en aquest cas la alimentació és fa mitjançant 4 piles de
1,2 V de tipus AA, que donen la potència al sistema.
Aquestes treballen de manera que el voltatge de la
bateria disminueix, però els components elèctrics
utilitzats precisen d'un voltatge controlat, gràcies a un
component anomenat regulador de voltatge.
D’aquests reguladors hi han dos tipus:
• Lineals: Aquests utilitzen un circuit de
retroalimentació simple per variar la quantitat d’energia que passa a
través de com i quan es descarrega. El regulador lineal produeix una
disminució del valor de entrada a un valor determinat de sortida i el
sobrant de potencial és perd.
• Switching: Aquest tipus de reguladors alternen la tensió on/off a
freqüència generalment alta, i filtrant el valor de sortida, això
produeix un gran valor de estabilitat de voltatge, a més a més,
també poden convertir i regular voltatges baixos i convertir-los en
13
Imatge 6: Bateries de 1'2 V.
Programació del robot Pololu 3PI
alts. El component principal del regulador switching està en el
inductor que és el que emmagatzema l’energia i la va alliberant
suaument, en el 3pi el inductor és el chip que es troba a prop de la
bola marcat com ‘100’.
Al Pololu 3pi, el voltatge de 4x AAA piles pot variar entre 3,5 i 5,5 volts
gràcies al regulador de voltatge a 5V. S’utilitza el regulador switching per
elevar el voltatge a 9,25 V (Vboost) i reguladors lineals per a obtenir 5V
(VCC). Vboos s’utilitza per als motors i el leds sensors IR en línia, mentre
que el VCC és per al microcontrolador i les senyals digitals. Utilitzant
aquest mètode obtenim tres avantatges que no tenen altres robots que
són:
• El voltatge alt es reserva per als motors
• Mentre s'està regulant, el motors treballen a la mateixa velocitat,
sempre i quan les bateries estiguin entre 3,5 i 5,5 volts.
• El cinc LED IR connectats en sèrie a 9,25 V consumeixen menys
quantitat d’energia.
Imatge 7: Diagrama del funcionament de la bateria del robot Pololu 3pi.
14
Programació del robot Pololu 3PI
El punt important d’aquest sistema d’energia és que les bateries no
s’esgoten progressivament com passa al majoria de robots, sinó que al
Pololu 3pi funcionarà al màxim rendiment fins que és pari en algun
moment.
3.5 RodesLes rodes són el components que permeten que el robot és pugui moure.
En el cas del robot les rodes tenen un radi de
0,67 inch. Quan igualem el motor amb les rodes
arribem a la conclusió que en el Pololu 3pi, 30
voltes de motor són 1 de la roda. Les rodes
poden arribar a una velocitat de 700 rpm i el
seu consum mínim és de 60mA a un màxim de
540 mA.
Nombre de metres que recorre en 1 volta: 700 rpm x 2π/60 = 73,30
rad/s
Nombre de metres per minut: 73,30 rad/s x 60s = 4.398 rad/m
3.6 LCDEl LCD que porta com a component el Pololu 3pi és de 8x2 caràcters (2
columnes de 8 caràcters cadascuna), en la qual es
pot visualitzar totes les opcions que pot arribar a
proposar-nos el nostre robot. La pantalla LCD del
robot Pololu 3PI està connectada en sèrie. En el
cas que vulguis obtenir una pantalla més gran, per
poder posar més caràcters, es fàcilment
substituïble.
15
Imatge 8. Rodes laterals del robot.
Imatge 9. Pantalla LCD
Programació del robot Pololu 3PI
3.7 Indicadors LedEls indicadors Led són uns components que estan situats a la part
posterior de la placa del robot, els quals
estan connectats amb els sensors i segons el
que aquests perceben fan la seva funció que
és emetre llum, de color verd o vermell en
aquest cas. També tenim 2 petits leds en el
component de connexió del robot amb
l’ordinador, aquest s’encenen per mostrar-nos si el robot està connectat
o no a l'ordinador.
3.8 Altaveu
El Pololu 3pi també porta integrat un altaveu o brunzidor,
mitjançant el qual és pot configurar el robot amb algun
programa amb el qual aquest emeti sons.
16
Imatge 10. Led vermell
Imatge 11. Altaveu del robot Pololu 3pi
Programació del robot Pololu 3PI
3.9 BotonsEl Pololu 3pi porta una sèrie de botons que li permeten anar pel menú
d’opcions que tingui el robot, i també s’utilitzen per activar i escollir el
programa que vols que faci el robot. Per altra banda també porta els
botons d'encendre o apagar el robot o el de resetejar el sistema.
17
Imatge 12. Esquema dels botons presents al xassís del robot
Programació del robot Pololu 3PI
3.10 Sistema d'estabilitzacióA les primeres proves del nostre robot, vàrem detectar de que al disposar
de dues rodes al laterals i una roda boja a la part posterior, el robot no
anava estable, i donava cops cap endavant ja que no disposava de cap
element que mantingues estable el nostre robot. Per tant, vàrem decidir
soldar un LED a la part davantera del robot (davant de les piles), fet que
va solucionar el problema.
Imatge 13. Posició del Led encarregat de estabilitzar el robot, la roda boja i la roda principal.
18
Programació del robot Pololu 3PI
4. Entorn de programacióPer a la programació del nostre robot Pololu 3pi, el més adequat és la
utilització de la programació en C, el llenguatge essencial per a la
programació. Aquest entorn de programació és el més utilitzat a l’història
de la informàtica, ja que ofereix una eina senzilla i molt útil. Molts dels
jocs, sistemes i programes els quals disposem actualment han estat
creats gràcies a aquest entorn de programació.
4.1 Programa principalA la programació, qualsevol projecte ha de contenir un programa principal
que s’encarrega d’iniciar el programa i combinar les diferents subrutines
segons el que l’hem indicat. Per a indicar-li al nostre compilador on és el
nostre programa principal, posem la funció “main” i utilitzarem les claus
({}) per a agrupar les diferents sentencies del programa principal.
4.2 TokensEls tokens són els components sintàctics emprats pel programador.
S’encarreguen d'indicar al programador les funcions que ha de dur a
terme (anar a una subrutina, tornar a començar el programa, anar a una
determinada línia del programa, etc..). Dins dels tokens, podem distingir
sis classes: paraules clau, identificadors, constants, cadenes de caràcters,
operadors i separadors. El compilador només “entén” les expressions que
li són pròpies, i per tant, qualsevol caràcter que no és propi del programa,
19
Programació del robot Pololu 3PI
podrà malmetre tot el programa. Els comentaris, i els sagnats del principi
de cada línia són ignorats pel programador.
#include <pololu/3pi.h>void initialize{
unsigned int counter; // Usat como un temporizadorunsigned int sensors[5]; // Un vector para guardar el estado dels sensors//Aquest codi es el primer que s'ha d'utilitzar per iniciar els sensors de reflexiópololu_3pi_init(2000);// Mostrar la tensió de la bateria fins que es prem el botó B
while(!button_is_pressed(BUTTON_B)){
int bat = read_battery_millivolts();clear();print_long(bat);print("mV");lcd_goto_xy(0,1);print("Apretar B");delay_ms(100);
}
4.3 Paraules clauEn el llenguatge C, hi ha una sèrie de paraules que no és poden utilitzar
com a nom d’una funció, ja que són emprats universalment per a
comunicar-li al programador un altre tipus de tasca concreta. Aquest
llenguatge de programació, al ser molt senzill i concret, consta de poques
paraules clau. A continuació, veiem les més importants a l’hora de
programar el nostre robot:
delay_ms(xxxx): Indicació al programador de que esperi un número
determinat de milisegons.
Switch: Serveix per evitar llargues sentencies de “if-else”.
return: Indiquem al programador que ha de tornar al principi de la
rutina.
20
Programació del robot Pololu 3PI
goto: Indiquem al programador que ha d’anar a un punt específic del
programa.
if: Indiquem al programador que si és compleix una condició, ha de fer
una tasca determinada.
if else: Indiquem al programador que si no és compleix aquesta condició,
faci un altre tasca determinada.
while: Indiquem al programador que ha de realitzar una tasca al mateix
moment que un altre.
Path: sentència encarregada d'enregistrar els moviments del robot a la
memòria.
4.4 IdentificadorsLa funció dels identificadors és la de anomenar amb una única paraula
una funció, variable o una part del contingut del nostre programa, amb
l’objectiu de fer un programa més senzill i menys extens. L’Identificador
no pot contenir caràcters aliens al llenguatge del nostre programador
(sobretots símbols: &,$,@...) o espais en blanc. Els identificadors són
molt útils ja que ens ajuden a agrupar una funció llarga en una única
paraula, i ens pot ajudar molt a l’hora d’identificar una funció o rutina i de
corregir un programa extens.
21
int main ( )unsigned int posición=read_line (sensors, IR_EMITTERS_ON);
if posició=4000 or posició=0{ Set_motors (20,-20) delay_ms(1000) set_motors (-20,20)}
Programació del robot Pololu 3PI
4.5 OperadorsEls operadors són signes especials encarregats de realitzar operacions
entre determinades variables del nostre programa.
4.6 SeparadorsEls separadors són els encarregats d’ajudar al compilador a
descompondre cadascun dels tokens en l’ordre correcte. A més, els
separadors ofereixen una millor il·legibilitat del programa. Els espais en
blanc, els tabuladors i els caràcters a un altre línia, són exemples dels
separadors més utilitzats.
4.7 ComentarisEls comentaris són notes fetes per l’autor que es mantenen fora del
programa i serveixen per a poder realitzar explicacions sense malmetre ni
canviar el programa original, ja que el programador ometrà directament
aquesta informació. Normalment, els comentaris s’utilitzen per tractar
d’entendre millor la finalitat o funció de cada token. Per a indicar al
programa un comentari, s’utilitzaran els següents caràcters, (//) o (/*)
per indicar-li el començament del comentari, o (\\) i (* \) per indicar el
final.
22
#include <pololu/3pi.h>void initialize{
//Aquest codi es fa el primer per iniciar els sensors de reflexió.pololu_3pi_init(2000);// Mostrar la tensió de la bateria fins que es premi el botó B
while(!button_is_pressed(BUTTON_B)){
int bat = read_battery_millivolts();//Esperarem que es deixi de premer el boto B per fer la calibració//La autocalibració realitza un gir a la dreta del robot i despres cap a l'esquerra.for(counter=0;counter<80;counter++)
Programació del robot Pololu 3PI
4.8 Sentencies de control de fluxOriginalment, el programador executa les seqüències ordenadament, és a
dir, començant per la primera i acabant per l’última. El llenguatge de
programació en C, compta amb algunes sentencies que s’encarreguen de
canviar aquest ordre, com per exemple, les sentencies IF, i ELSE, que ja
hem començat a explicar anteriorment.
4.8.1 sentència IF - ELSEAquesta sentència s’encarrega d’executar o no una sentència en el cas de
que es compleixi una condició determinada. Si aquesta condició no es
compleix, el programador automàticament executa la sentència que va
darrere del “else”. A continuació en veiem un exemple:
En aquest programa, si la variable “counter”, que és un temporitzador, és
més petit que 20 o més gran o igual que 60, els motors es posaran en
velocitat 40,-40 respectivament, és a dir, farà un gir cap a la dreta. En
canvi, si aquesta condició no es compleix i aquest temporitzador no té els
23
#include <pololu/3pi.h>void initialize{
unsigned int counter; // Usat com un temporizadorunsigned int sensors[5]; // Un vector per guardar el estat dels sensors
{if(counter < 20 || counter >= 60)set_motors(40,-40) ;elseset_motors(-40,40) ;// Guarda els valors dels sensorscalibrate_line_sensors(IR_EMITTERS_ON) ;delay_ms(20);
}
}
Programació del robot Pololu 3PI
valors indicats, el programador directament accionarà els motors a -40,40
respectivament, és a dir, que farà un dir cap a l’esquerra.
4.8.2 sentència “Switch”La sentència switch té una funció semblant a la
de la sentència IF – ELSE. En aquest cas, el
programador analitza la condició i realitzarà les
tasques assignades per aquest valors i els
següents. és a dir, en el exemple que veiem a
continuació, si el valor de la condició coincideix
amb la expressió número 2, és realitzaran els
tokens de 2,3,4... Per indicar-li al programador
les sentencies que entren dins del switch,
posarem totes aquestes sentencies entre els
les claus ({) i (}).
4.8.3 BuclesA més de les sentencies de condició, al llenguatge C trobem unes
sentencies capaces de repetir un nombre determinat de vegades la
mateixa sentència. Aquestes sentencies són els bucles, i els més utilitzats
són el do...while, for i el while.
24
Imatge 14. Exemple d’us de la sentència “switch”
Programació del robot Pololu 3PI
4.8.4 sentència “While”La sentència “while” indica al programador que ha de repetir una mateixa
sentència sempre i quan és compleixi una condició, és a dir, quan aquesta
condició deixi de ser complida, aquesta sentència deixarà de ser
utilitzada. Aquí en tenim un exemple:
Durant el temps que el botó B estigui polsat, el programador llegirà les
sentencies que hi ha entre les claus (llegir la bateria, netejar i escriure a
la pantalla,etc...) indefinidament, però en el moment que el botó B deixi
de estar polsat, aquestes sentencies deixaran de ser llegides pel
programador.
4.8.5 sentència “Do...while”Aquesta sentència és molt semblant a la anterior, però amb la diferencia
de que el token que posem entre el “do” i el “while” serà realitzat al
finalitzar el bucle, i no mentre aquest bucle és manté actiu.
4.8.6 sentència “Break”Aquesta sentència és utilitzada per interrompre la lectura d’una sentència
per el programador.
25
while(!button_is_pressed(BUTTON_B)) {
int bat = read_battery_millivolts();clear();print_long(bat);print("mV");lcd_goto_xy(0,1);print("Apretar B");delay_ms(100);
}
Programació del robot Pololu 3PI
4.8.7 sentència “Continue”La sentència “continue” s’encarrega de que el programa comenci el
següent cicle del bucle encara que no hagi arribat fins al final d’aquest.
4.8.8 sentència “goto”Aquesta sentència indica al programador que ha de saltar directament cap
a un altre lloc del programa o un altre subrutina, estalviant-se les
sentencies que hi han a continuació i anant directament a la part del
programa que li hem indicat.
26
Programació del robot Pololu 3PI
5. Programari i eines utilitzadesSeguidament, explicarem totes les eines físiques i informàtiques
(programari) que és necessari per a la correcta programació del Pololu
3PI. Encara que algunes d'aquestes eines no són imprescindibles (les
llibreries de programació, per exemple), són essencials per a fer-ho el més
còmode i senzill possible.
5.1 AVR STUDIO 4
La programació en C és el mètode de programació més utilitzat a la
informàtica i altres camps de la tecnologia,
però per poder programar bé necessitarem
l’ajuda d’un programador, un programa
d’ordinador que s’encarrega de facilitar la tasca
de trobar els errors al codi, passa el programa
al ordinador, compilar,etc...
Com a programador hem utilitzat el programa
“AVR Studio 4”; un programa senzill, intuïtiu i
gratuït recomanat per els professors de la UPC.
Amb aquest programa, bàsicament realitzarem les tasques de compilació
(recerca d’errors al codi abans de passar-ho al robot) i la de transmissió
d’informació al robot (mitjançant un cable USB, el programador
traspassarà la informació del nostre ordinador al microcontrolador del
Pololu 3pi).
5.2 Cable USBCable típic utilitzat a la informàtica, és l’encarregat de fer arribar la
informació creada del programador al nostre robot. El seu nom complet és
Universal Serial Bus, i normalment és emprada per la connexió de
diferents aparells perifèrics a la nostra computadora. El tipus necessari
27
Imatge 15. Logo del programador que utilitzarem, l’AVR Studio 4.
Programació del robot Pololu 3PI
per la seva connexió era un Cable USB A to mini-B cable, que és el tipus
d'entrada que té el programador AVR ISP, explicat a continuació.
5.3 Llibreries de programacióLes llibreries de programació, una de les eines més utilitzades a la
programació, són un conjunt de funcions creades per programadors
experts amb la intenció de facilitar la programació a altres usuaris.
Aquestes sentencies ja construïdes, ens faciliten molt
la tasca de la programació del robot, ja que consten
d’unes extenses funcions i variables des de el
començament, que hauríem de crear manualment.
Un exemple d’això és la sentència “print”, que ens
ajuda a afegir-li text a la pantalla LED del nostre
robot. Aquesta sentència és inclosa a la llibreria de
programació que nosaltres vàrem utilitzar, i ens va
estalviar la creació de nombroses variables que ens haguessin ocupat
massa espai dintre del nostre programa.
5.4 Programador AVR ISP de 6 pins connectorsFa possible la comunicació entre l’ordinador i el microcontrolador del
nostre robot, ATmega328P. Aquest programador és de 6 pins ja que són
necessaris per connectar-los amb el
microcontrolador del robot, i un port USB que el
connectarà amb l’ordinador o el dispositiu que
utilitzem per programar el robot. Aquest element
és imprescindible ja que garanteix que la
informació que fem al nostre ordinador pugui
passar-se al robot. Té dues llums (vermella i
verda) que ens indiquen el seu estat.
28
Imatge 16. Logo de Winrar, programa utilitzat per agrupar les llibreries i poder difondre-les per Internet.
Imatge 17. Programador AVR ISP amb 6 pins.
Programació del robot Pololu 3PI
6. Instal·lació del programariPer instal·lar el programari necessari per la programació del nostre robot,
cal seguir les instruccions següents:
1. Instal·lar AVR Studio (AvrStudio4Setup.exe)
2. Instal·lar el Service Pack 1 de AVR Studio (AVRStudio4.18SP1.exe)
3. Instal·lar el Service Pack 2 de AVR Studio (AVRStudio4.18SP2.exe)
4. Instal·lar WinAVR (WinAVR-20090313-install.exe)
5. Extraure el fitxer libpololu-avr y fer doble clic en make-install.
6.1 Creació d'un projecte amb AVR StudioPer començar, obrim el programa AVR Studio 4, que prèviament hem
instal·lat al nostre ordinador, i per crear un projecte, seleccionem “Project
Wizard” a la pestanya “Project”, que podem trobar-la al menú de la
cantonada superior esquerra. Seguidament, seleccionarem New Project.
A la pantalla que ens sortirà a continuació, escollim l'opció AVR GCC i a
“Project name” li posem el nom que nosaltres vulguem, i que servirà per
identificar-lo al nostre ordinador. A continuació, seleccionem AVR
Simulator 2, i el nostre tipus de microcontrolador, en el nostre cas
Atmega328p.
Imatge 18. Selecció de Plataforma i microcontrolador per a la programació.
29
Programació del robot Pololu 3PI
Ara podem donar-li a “Finish” i ja podrem introduir el codi que vulguem.
6.2 Compil·lació i programació d'un projecteUna vegada hem acabat de construir el nostre codi, seleccionarem el botó
del menú superior “Build Active Configuration” o simplement polsarem el
botó F7, per compilar-lo i que el nostre programador detecti els errors al
programa. Al quadre de text de la part inferior de la pantalla ens indicara
el número de errors i alertes (warnings).
Imatge 19. Esquema dels botons per a compil·lar i per programar el nostre codi.
30
Programació del robot Pololu 3PI
Després, li donarem al botó “CON”, anomenat “Display the connect dialog”
i seleccionarem el programador “AVRISP” o “STK500” i al port,
seleccionarem “auto”, perquè ho faci automàticament.
Finalment, seleccionem el botó “AVR”, “Connect to the selected AVR
Programmer”, i després de seleccionar el arxiu corresponent (.hex) al
nostre programa, seleccionarem “Program” i és carregarà el programa al
nostre robot.
Imatge 20. Programació del robot
31
Programació del robot Pololu 3PI
7. Creació de menús
Per a la combinació de diferents programes dins del robot, utilitzarem un
menú principal per a organitzar les diferents subrutines. Dins d’aquest
menú, disposarem de diferents opcions, com per exemple, per iniciar el
seguidor, per a comprovar els LED’s,etc...
Per començar, tenim que col·locar les diferents opcions del menú
seguidament dels missatges introductoris que hem posat al principi del
nostre programa.
Com veiem, primer hem de crear una nova constant, que serà la paraula
que ens dirigirà a la subrutina dins del menú. Aquí, podem veure com la
primera opció que veiem al nostre menú serà la de “menu_bat_test”, i al
menú, el seu nom serà “Bateria”. Així, quan vulguem posar la subrutina
de la opció “Bateria”, caldrà posar “void bat_test”, per indicar al
programador que relacionem aquesta subrutina amb l’opció del menú.
32
const char menu_bat_test[] PROGMEM = "Bateria";const char menu_led_test[] PROGMEM = "LEDs";const char menu_lcd_test[] PROGMEM = "LCD";const char menu_ir_test[] PROGMEM = "Sensors";const char menu_motor_test[] PROGMEM = "Motors";const char menu_music_test[] PROGMEM = "Música";const char menu_pot_test[] PROGMEM = "Trimpot";const char menu_time_test[] PROGMEM = "Crono";const char menu_seguidor[] PROGMEM = "Seguidor";const char menu_turbo_seguidor[] PROGMEM = "S.Ràpid";const char menu_seguidor_PID[] PROGMEM = "S.Segur";const char menu_encierro[] PROGMEM = "Tancament";const char menu_maze[] PROGMEM = "Laberint";
Programació del robot Pololu 3PI
Aquí podem veure les diferents subrutines enllaçades amb la seva opció al
menú:
Finalment, hem de indicar-li el programador les opcions que volem que
surtin a la pantalla i el seu ordre. Ho farem amb aquestes funcions:
I finalment, com ja hem vist abans, posem la subrutina segons l’ordre
que hem posat abans amb la funció que hem vist
33
void bat_test();void led_test();void lcd_test();void ir_test();void motor_test();void music_test();void time_test();void pot_test();void seguidor();void turbo_seguidor();void seguidor_PID();void encierro()
void (*function)();const function main_menu_functions[] = { bat_test, led_test, pot_test, ir_test, motor_test, music_test, time_test, seguidor, turbo_seguidor, seguidor_PID, encierro, maze};const char *main_menu_options[] = { menu_bat_test, menu_led_test, menu_pot_test, menu_ir_test, menu_motor_test, menu_music_test, menu_time_test, menu_seguidor, menu_turbo_seguidor, menu_seguidor_PID, menu_encierro, menu_maze};const char main_menu_length = sizeof(main_menu_options)/sizeof(main_menu_options[0]);
Programació del robot Pololu 3PI
34
void ir_test(){ unsigned int sensors[5]; // una serie de valors del sensor
if(button_is_pressed(BUTTON_C)) read_line_sensors(sensors, IR_EMITTERS_OFF); else read_line_sensors(sensors,IR_EMITTERS_ON);
unsigned char i;
for(i=0;i<5;i++) { // Inicia la serie de caracters utilitzats pel grafic. Usant l'espai,
// farem una copia extra del caracter, i el caracter 255 (una caixa negra),nosaltres tenim
// 10 caracters en serie. // La variable C té valors d'1 a 9, des de que el valor esta en el rang de 0 a 2000,
// i el 2000/201 es 9 amb una integral matematica. char c = bar_graph_characters[sensors[i]/201];
print_character(c); // Mostra el "bargraph" caracters.
}
// Mostra un indicador de si el IR esta encés o apagat. if(button_is_pressed(BUTTON_C)) print("IR-"); else print(" C");
delay_ms(100);}
Programació del robot Pololu 3PI
8. Seguidor de líniesAmb aquest programa, el nostre robot Pololu tindrà la funció de seguir
una línia de color negre sobre un fons de color blanc. Per a detectar
aquesta línia, el robot utilitzarà els seus sensors de reflexió per a detectar
el color negre. Gràcies al programa que li ficarem al robot, els motors,
s’accionaran quan els sensors detectin la línia. Quan un dels dos sensors
que porta el nostre robot detecti que no hi ha la línia negra, tombarà cap
al costat contrari en busca de la línia negra. Quan no trobi la línia, el robot
seguirà un recorregut en zig-zag fins que torni a trobar-ne la línia, i
llavors tornarà al seu recorregut inicial.
Gràcies a les llibreries de programació i diferents eines que ens
proporciona el subministrador, podem partir el nostre programa a través
d’un dels exemples que trobem dins de la carpeta “Software” – “libpololu”
– “examples”, i seleccionem el programador del nostre robot, en el nostre
cas “Atmega 328p”. En aquesta carpeta seleccionem el exemple que
volem, en aquest cas “3pi-linefollower” i l’obrim amb el programa “AVR
Studio”. Malgrat això, tractarem de explicar la programació del robot des
de zero.
8.1 Pantalla principalComencem creant dos identificadors, un utilitzat com a temporitzador, on
és calcularà el temps transcorregut, i un
altre que guardarà l’estat dels sensor.
Després farem una lectura de la tensió
que passa pel nostre robot amb la
sentència “read_battery_millivolts” i
farem que ens la indiqui a la pantalla
LED. A la línia inferior, escriurem “Pulsar
35
Imatge 21. Pantalla LED indicant la tensió del robot.
Programació del robot Pololu 3PI
B” per indicar a l’usuari que ha polsar el botó per a posar en marxa el
robot.
Aquest és el programa sencer:
36
void initialize(){unsigned int counter; // Usat com un temporizadorunsigned int sensors[5]; // Un vector per guardar el estat de los sensors//Aquest codi es el primer en executar-se, ja que serveix per iniciar els sensors.pololu_3pi_init(2000);// Mostrar la tensió de la bateria mentre no es premi el botó Bwhile(!button_is_pressed(BUTTON_B)) {
int bat = read_battery_millivolts();clear();print_long(bat);print("mV");lcd_goto_xy(0,1);print("Apretar B");delay_ms(100);
}//Esperem a que es deixi de polsar el botó B// par començar la cal·libració dels sensorswait_for_button_release(BUTTON_B);delay_ms(1000);
}
// Auto-calibració: un gir a la dreta i un altre a l'esquerra mentre s'ajusten// els sensors.for(counter=0;counter<80;counter++){
if(counter < 20 || counter >= 60)set_motors(40,-40);
elseset_motors(-40,40);
// Esta funcion graba un set de lectures del sensor i mantenia// els valors maxims i minis trobats. El// IR_EMITTERS_ON significa que si el IR Led es troba// girat durant la calibració, que es usualment el que// volem.
calibrate_line_sensors(IR_EMITTERS_ON);
// El nostre comptador comença a 80, per tant, el temps total serà// 80*20 = 1600 ms.delay_ms(20);
}set_motors(0,0);
Programació del robot Pololu 3PI
8.2 Calibració de sensorsAbans de posar en marxa el robot, cal fer una calibració del sensors de
reflexió per garantir el seu correcte funcionament. Per a realitzar aquest
procés, afegirem a sota del codi utilitzat per la pantalla principal aquest
codi:
El primer que farà just després de prémer el botó B serà fer un gir cap a
l’esquerra i un altre cap a la dreta, amb l’objectiu de que els sensors de
reflexió vegin si hi ha un línia o no. Una vegada acabat aquest procés,
tindrem que polsar-li un altra vegada al mateix botó per que avanci i els
sensors facin la seva funció amb normalitat. A la pantalla LED, el robot
ens indicarà numèricament si detecta la línia negra amb els seus sensors.
37
Programació del robot Pololu 3PI
8.3 Funció dels motorsAquestes sentencies ens permetran ajustar el sentit de gir i la velocitat
del motor, i per tant, de les dues rodes del nostre robot. La sentència
principal és diu “set_motors” i a continuació, posarem entre parèntesis la
velocitat de gir que volem per cada motor, l’esquerra i el dret,
respectivament. La velocitat escollida serà 40, ja que es una velocitat
adequada per tal que el robot no és surti de la línia del circuit, cosa que
passaria si la velocitat fos major. Després, creem l’identificador “posición”
que s’encarregarà de fer la lectura dels sensors i de emmagatzemar les
dades.
Per tant, quan els sensors de reflexió indiquin “1000” o inferior, és a dir,
que la línia només és detectada pels sensors de l’esquerra, la roda
esquerra anirà cap endarrere (velocitat de -40) i la dreta cap endavant,
fent un gir cap a l’esquerra.
38
int main (){
unsigned int sensors [5]initialize() ;while (1){
unsigned int posición=read_line(sensors,IR_EMMITERS_ON);if (posició<1000) set_motors(-100,100) ;if (posició<3000 & read_line>1000) set_motors(100,100) ;if (posició>3000) set_motors (100,-100)
}}
Programació del robot Pololu 3PI
Si els sensors detecten que la línia és entre 1000 i 3000, és a dir, que la
línia és detectada per tots els sensors de reflexió del robot, aquest
seguirà una línia recta.
Finalment, si els sensors detecten la línia major que 3000, el robot
necessitarà un gir cap a la dreta, i per tant, la roda esquerra anirà cap
endavant i la roda dreta en sentit contrari, per aconseguir el gir del robot.
8.3.1 Assaig del primer circuitDesprés de programar el nostre robot,
ha arribat l’hora de provar-ho. Farem
servir un circuit amb una única línia
recta.
Per a que el nostre robot pugui
funcionar correctament per aquest
circuit, només caldrà programar els
sensors i els motors del robot, ja que al
ser una tasca senzilla no caldrà fer-hi
més.
8.3.2 Segona prova de circuitDesprés de comprovar que la
programació del robot per al primer
circuit hagi estat la correcta i funcioni,
prepararem el nostre robot per a
aconseguir que pugui funcionar per el
circuit 2. Aquest circuit, com podem
veure a l’imatge, està caracteritzat per
la seva línia discontinuïtat.
39
Imatge 23. Imatge del robot amb el circuit 2, que presenta una línia discontinua al principi.
Imatge 22. Realització d’una de les proves del robot Pololu 3pi amb el circuit inicial.
Programació del robot Pololu 3PI
Per a aconseguir això, haurem de programar el robot per que quan no
trobi línia per cap dels seus sensors de reflexió, avanci en una trajectòria
de zig-zag fins a trobar novament la línia, i llavors, retornar la seva
trajectòria.
Com a base, utilitzarem el programa que hem creat al principi, i
mitjançant uns petits retocs, intentarem aconseguir el nostre objectiu. El
programa inicial és el següent:
40
include <pololu/3pi.h>void initialize(){
unsigned int counter; // Usat com un temporitzadorunsigned int sensors[5]; // Un vector per guardar el estat dels sensors//Aquest codi ha de ser executat el primer per iniciar els sensors de reflexió.pololu_3pi_init(2000);// Mostrar la tensió de la bateria mentre no es pulsi el botó B
while(!button_is_pressed(BUTTON_B)){
int bat = read_battery_millivolts();clear();print_long(bat);print("mV");lcd_goto_xy(0,1);print("Apretar B");delay_ms(100);
}//Quan es deixi de polsar el botó B començara la calibració dels sensors.
wait_for_button_release(BUTTON_B);delay_ms(1000);//La autocalibració fará un gir a dretes i un altre cap a l'esquerra.for(counter=0;counter<80;counter++){
if(counter < 20 || counter >= 60)set_motors(40,-40);elseset_motors(-40,40);//Guarda els valors dels sensorscalibrate_line_sensors(IR_EMITTERS_ON);delay_ms(20);
}
Programació del robot Pololu 3PI
8.4 Creació variable “comptador”Abans de que el nostre robot comenci una trajectòria en forma de zig-zag
per cercar la línia, deixarem que durant uns pocs segons vagi recte. Això
ens permetrà, en cas de que els sensors no funcionin massa bé, que el
robot no és desvií massa ràpid de la trajectòria, i pugui trobar-la
posteriorment. Per això, utilitzarem una variable a la que anomenarem
“comptador”, i serà l’encarregada de “dir-li” al robot, quan ha de deixar
de anar en línia recta per a desviar-se i començar una trajectòria en zig-
zag.
41
set_motors(0,0);while(!button_is_pressed(BUTTON_B)){
// Llegeix el valor dels sensors de reflexió.unsigned int posició = read_line(sensors,IR_EMITTERS_ON);clear();print_long(posició);lcd_goto_xy(0,1);delay_ms(100);
}
wait_for_button_release(BUTTON_B);clear();print("Go!");
}
int main(){
unsigned int sensors[5];initialize();int comptador=0;while(1)
unsigned int posición=read_line(sensors,IR_EMMITERS_ON);if (posició<1000) set_motors(-100,100) ;if (posició<3000 & read_line>1000) set_motors(100,100) ;if (posició>3000) set_motors (100,-100)
}}
Programació del robot Pololu 3PI
Com veiem al nostre programa, al principi de tot hem creat la variable
anomenada “comptador” amb la funció “unsigned int counter”. Aquesta
variable, s’encarrega de comptar el temps en intervals de mig segon, i
quan arribi a 6 (3 segons), indicar-li al robot que ha de canviar de
variable. Per a això, utilitzarem la sentència “IF”. Si els sensor ens indica
que no troba la línia (4000), i el comptador és menor a 6, seguirà una
trajectòria recta. Si aquest comptador no arriba a 6, seguirà les altres
sentencies, però si arriba, interromprà aquesta funció (break) i anirà a la
següent part del programa:
42
//Si no detecta linia i la variable “comptador” està a 0//seguir recte durant mig segon en busca de la linia
if (posición==4000 && comptador==0){for (comptador=0;comptador<6;comptador++)
{ time_reset() ; while(get_ms()<250) set_motors(10,10) ; posició=read_line(snsors,IR_EMMITERS_ON) ;{
if (posició<4000){ comptador=6 Break;}
}
//Si no detecta linea i l'ha intentat trobar//Gira a l'esquerra 500 milisegons i va cap endavant 500 milisegons.if (posición==4000 && comptador>=6)
{time_reset() ;while(get_ms()<500)set_motors(-10,10) ;time_reset () ;while(get_ms()<500)set_motors(10,10) ;}
Programació del robot Pololu 3PI
Si els sensors de reflexió no troben línia i el comptador és major a 6 (han
passat més de 3 segons des que no és troba línia), es tornarà a iniciar el
compte (time_reset), i cada mig segons (500 milisegons), el robot anirà
cap a un costat i l’altre, amb les ordres que li hem donat al motors:
- set_motors (-10,10): el motor esquerra va en sentit contrari i el
motor dret va cap endavant, i per tant, el robot gira cap a
l’esquerra.
- set_motors (10,-10): el motor esquerra va cap endavant i el motor
dret va en sentit contrari, i per tant, el robot gira cap a la dreta.
Ara només cal carregar el nostre programa al robot, i utilitzar el circuit 2
per a provar si el nou programa funciona correctament.
Imatge 24.Robot Pololu 3PI provant el seguidor de línia discontinua al circuit 2.
43
Programació del robot Pololu 3PI
9. Resolució d’un laberint Per a incloure la funció de resoldre un laberint, utilitzarem un altre dels
exemples de programa que ens proporciona les llibreries de programació.
Cal tenir en compte que aquests programes estan ideats com si fossin
programes principals, i si volem incloure'l a dins del nostre menú, caldrà
fer-li algunes modificacions.
La resolució d'un laberint tindrà dues parts: la primera, serà quan el robot
miri totes les possibilitats que tingui per resoldre el laberint, i intenti anar
per tots els recorreguts possibles fins a trobar el final. A les interseccions,
s'havia de decidir cap a quin cantó girarà sempre, i per això, sempre que
hi hagi dos camins possibles, anirà cap al de l'esquerra. Mentre fa aquesta
part, el robot emmagatzemarà les vegades que ha girat, que ha anat
recta, la direcció en la que ha anat...
La segona part, consistira en que el nostre robot resolgui un altre vegada
el laberint, però de manera que vagi pel camí més curt, és a dir, sense
tenir que passar per tots els recorreguts possibles fins a trobar el camí.
Aixo és possible gràcies a la informació que ha guardat de la primera
resolució del laberint. Això, ho explicarem més detalladament al següent
apartat.
Per utilitzar aquest exemple, ens demana que li hem d'afegir al
programador dues llibreries diferents, anomenades “follow-segment.h” i
“turn.h”. Per a afegir-les, anirem al menú de l'esquerra, i a “Source Files”,
clickarem a “Add Existing Source File(s)” i ens obrirà una finestra per
seleccionar la ubicació dels dos arxius.
44
Programació del robot Pololu 3PI
Imatge 25. Inclusió de noves llibreries al nostre programa.
A continuació, buscarem la sentència on creem la funció “path” dins del
programa del laberint, i la canviem de lloc, per posar-la al principi de tot,
on creàvem els menús:
45
const char menu_bat_test[] PROGMEM = "Bateria";const char menu_led_test[] PROGMEM = "LEDs";const char menu_lcd_test[] PROGMEM = "LCD";const char menu_ir_test[] PROGMEM = "Sensors";const char menu_motor_test[] PROGMEM = "Motors";const char menu_music_test[] PROGMEM = "Música";const char menu_pot_test[] PROGMEM = "Trimpot";const char menu_time_test[] PROGMEM = "Crono";const char menu_seguidor[] PROGMEM = "Seguidor";const char menu_turbo_seguidor[] PROGMEM = "S.Ràpid";const char menu_seguidor_PID[] PROGMEM = "S.Segur";const char menu_encierro[] PROGMEM = "Tancament";const char menu_maze_solve[] PROGMEM = "Laberint";
char path[100] = "";unsigned char path_length = 0; // the length of the path
Programació del robot Pololu 3PI
Al principi del programa, copiarem la calibració de sensors feta al
programa “seguidor de línies”, ja que per a resoldre el laberint el robot
necessitarà saber la seva posició davant la línia negra.
46
{clear();print(path);
if(path_length > 8){
lcd_goto_xy(0,1);print(path+8);
}}char select_turn(unsigned char found_left, unsigned char found_straight, unsigned char found_right){
if(found_left)return 'L';
else if(found_straight)return 'S';
else if(found_right)return 'R';
elsereturn 'B';
}void simplify_path(){
if(path_length < 3 || path[path_length-2] != 'B')return;
int total_angle = 0;int i;for(i=1;i<=3;i++){
switch(path[path_length-i])
Programació del robot Pololu 3PI
Seguidament, posarem fora de la subrutina les sentencies que tinguin
relació amb la funció “path”, creada anteriorment:
47
total_angle = total_angle % 360;
// Canvia el tot camí per un sol girswitch(total_angle){case 0:
path[path_length - 3] = 'S';break;
case 90:path[path_length - 3] = 'R';break;
case 180:path[path_length - 3] = 'B';break;
case 270:path[path_length - 3] = 'L';break;
}
// The path is now two steps shorter.path_length -= 2;
}
{case 'R':
total_angle += 90;break;
case 'L':total_angle += 270;break;
case 'B':total_angle += 180;break;
}
Programació del robot Pololu 3PI
Finalment, canviarem els textos que apareixeran a la pantalla LED del
nostre robot, com hem fet nosaltres:
9.1 Resolució directa del laberintUna vegada el nostre robot ha completat totalment el laberint, aquest
tindrà la capacitat de tornar-lo a fer sense cometre cap error en la seva
trajectòria.
9.1.1. sentència pathLa sentència path és l'encarregada d'emmagatzemar la informació que
pren el robot al resoldre el laberint per a que a la següent vegada ho faci
pel camí més curt.
48
while(!button_is_pressed(BUTTON_B)){
if(get_ms() % 2000 < 1000){
clear();print("Meta!");lcd_goto_xy(0,1);print("Pulsa B");
}else
display_path();delay_ms(30);
Programació del robot Pololu 3PI
9.1.2. Exemple de memòria “path”
Imatge 26. Esquema de l'emmagatzemament de dades del robot Pololu 3PI.
Com hem explicat abans, el nostre robot, en cas de tenir dos camins,
sempre optarà primer per el camí de l'esquerra. En aquest circuit, el robot
comença amb una “S”, ja que va cap endavant (el camí de l'esquerra).
Seguidament, arriba a un punt final, i té que donar la volta, és a dir, una
“U”. Ara el codi guardat és “SU” després, només té un camí, ja que l'altre
ja l'havia fet i era incorrecte, i per tant, substitueix el “SUL” per una “R”,
que era el camí que havia de haver fet des de el principi. Després, a l'altre
intersecció, provarà el camí de l'esquerra, el central, i quan arribi al camí
correcte, el de la dreta, esborrarà les dades dels altres camins, i el podi
serà “RU”.
Quan el robot torni a fer el camí, seguirà el camí “RUS”, i per tant, anirà
pel camí més curt sense tenir que passar per les altres alternatives.
49
Programació del robot Pololu 3PI
10. TancamentA continuació, intentarem atorgar-li un altre funció al nostre robot, que
serà la de mantenir-se dins d'una zona delimitada per línies al voltant, que
mai podrà travessar.
D'aquesta funció que farà el nostre robot no hem trobat cap exemple útil,
però al ser un programa molt semblant al creat per el seguidor de línies,
agafarem aquest programa com a base del que crearem a aquest apartat.
El primer que farà el robot serà calibrar els sensors, igual que quan resol
un laberint o segueix la línia:
50
//Esperem a que deixi d'apretar B// per començar la calibració dels sensorswait_for_button_release(BUTTON_B);delay_ms(1000);//La autocalibració realitza un gir a la dreta del robot i després//cap a l'esquerrafor(counter=0;counter<80;counter++)
{ if(counter < 20 || counter >= 60) set_motors(40,-40); else set_motors(-40,40); //Guarda els valors dels sensors calibrate_line_sensors(IR_EMITTERS_ON); delay_ms(20);}
set_motors(0,0);while(!button_is_pressed(BUTTON_B)
{ // Llegeix el valor dels sensors de reflexió. unsigned int posició = read_line(sensors,IR_EMITTERS_ON); clear(); print_long(posició); lcd_goto_xy(0,1); delay_ms(100);}
Programació del robot Pololu 3PI
Seguidament, agafem el programa principal del seguidor de línies, i
únicament hem de modificar els valors dels motors segons la seva
situació. En aquest cas, el robot quan no trobi línia seguira cap endavant,
i quan la trobi davant donara la volta o girarà cap a un costat en el cas de
que trobi la línia amb un dels seus sensors laterals. El programa quedaria
aixi:
Ara, l'únic que hem de fer és suprimir la sentència següent, que és
ineccesaria pel “tancament”:
51
while(1){
unsigned int posició = read_line(sensors,IR_EMITTERS_ON);if(posició>500 && posició<2000){
set_motors(0,100);
// Només per estetica, indiquem als led's la seva funció.left_led(0);right_led(1);
}else if(posició>2000 && posició<3000){
set_motors(75,0);left_led(1);right_led(0);delay_ms(1000);set_motors(100,100);
}else if (posició>3000 && posició<4000){
set_motors(100,0);left_led(1);right_led(0);
}
//Si els 5 sensors del davant marquen linia negra s'atura o fora zona blanca: seguretat.if (sensors[1]>600 && sensors[2]>600 && sensors[3]>600 && sensors[4]>600){set_motors(0,0);}
Programació del robot Pololu 3PI
11. Conclusions
Quan els dos membres del grup vam prendre la decisió de escollir aquest
tema per al treball de recerca, vam coincidir en que ho faríem per el
nostre interès comú en el camp de la tecnologia, i especialment, la
robòtica. Ja havíem fet uns altres robots molts més senzills (Lego
Mindstorm, altres tipus de seguidors de línia...), i aquests robots van
despertar el nostre interès en la programació de robots.
Durant la realització d’aquest treball hem gaudit molt i après moltes coses
sobre el mòn de la tecnologia. La nostra formació per aquest treball de
recerca va començar a la UPC on vam iniciar-nos en la programació
d’aquesta sèrie de robot o altres aparells, va ser un curset d’una setmana
en la qual vam realitzar diferents pràctiques de programació de robots
amb llenguatge C i els professors de la UPC ens van ensenyar una base
per poder començar a programar en llenguatge C. El fet de fer aquest
curset va ser una experiència molt satisfactòria ja que vam iniciar-nos en
aquest món i gràcies això la realització del nostre projecte va ser molt
més fàcil. Conèixer alguns professors de la universitat i tractar matèries
que és cursen a l'UPC (la programació en llenguatge C és una matèria
ensenyada a 1er de quasi totes les Enginyeries), va ser una experiència
molt útil.
Després de realitzar aquest curset a l'estiu, vam començar el nostre
treball de recerca, i el primer problema que ens va parèixer va ser la
instal·lació dels programes i aplicacions adients a l’ordinador per poder
modificar i programar el robot, amb l’ajuda dels nostres tutors vam
aconseguir solucionar aquest problema i vam començar amb la recopilació
de informació sobre el robot i les seves formes de programació. Podem dir
52
Programació del robot Pololu 3PI
que el fet de buscar informació ha estat una mica complicat ja que la
informació era escassa i la que podíem trobar la trobàvem en anglès i
l'havíem de traduir, però finalment hem pogut aconseguir tot el necessari
per a la realització d'aquest treball. Més endavant vam començar amb la
programació del robot, i aquí va aparèixer un altre problema ja que
aquesta era molt complicada i dificultosa, per aquest motiu el nostre tutor
ens va donar un exemple o model perquè nosaltres poguéssim tenir una
base per poder anar modificant i provant coses en el robot. L'ajuda del
nostre tutor del treball de recerca va ser essencial, ja que ens va ajudar
amb multituds d'errors i dificultats que ens oferia el programador i el
llenguatge de programació en general.
Després de fer la programació del seguidor de línies, que era una tasca
que vam fer durant el curset d'estiu a l'UPC, ens van plantejar realitzar
altres funcions per al nostre robot, com per exemple, la creació de
diferents menús o la compra i instal·lació d'uns altres sensors (de
proximitat) que ens oferirien noves possibilitats de programació
(esquivament d'obstacles, etc.), però finalment ens vam decidir per
realitzar un menú principal on agrupar totes les funcions que pot fer el
nostre robot. Les funcions principals eren la de Seguidor de línia (el robot
gràcies al seu sensor de reflexió segueix una línia negra sobre fons blanc
sense sortir-se d'ella), el laberint (consisteix en que el robot trobi la
sortida d'un laberint format per línies negres, cercant totes les opcions
possibles per sortir d'ell, i emmagatzemant la informació perquè a la
següent vegada que faci el mateix recorregut aconsegueixi fer-ho pel
camí més curt/ràpid) i el Tancament, que consisteix en una línia negra
tancada formant una zona de la que el nostre robot no podrà sortir mai.
Respecte el treball escrit, no hem tingut masses problemes a l'hora de
realitzar-lo, encara que creiem que la limitació de 50 pagines màxim per
53
Programació del robot Pololu 3PI
treball és massa prohibitiva i ens ha demanat una reducció d'informació
que hauria beneficiat els continguts del nostre treball escrit.
Finalment, podem dir que aquest treball, encara que ha estat molt difícil a
l'hora de realitzar la part pràctica i la recerca d'informació, ens ha servit
molt de cara al futur, i ens ha ensenyat que amb esforç i ganes és poden
solucionar els problemes que poden aparèixer al principi d'un treball
d'aquestes característiques.
54
Programació del robot Pololu 3PI
12. Fonts d'informacióAquestes són les eines físiques i digitals que hem utilitzat com a font
d'informació a l'hora de realitzar el nostre treball de recerca:
Pagina web oficial de Pololu
Informació general del robot, i enllaços a altres fonts d’informació.
http://www.pololu.com/
Manual d’Usuari Pololu 3pi (PDF)
Informació sobre components i funcionament general del robot.
http://www.pololu.com/file/0J137/Pololu3piRobotGuiaUsuario.pdf
PDF UPC – Projecte de Robòtica
Cinc PDF creats per professors de la UPC (Néstor Berbel, Jose Luis Medina
i Antoni Salvador) pel Curs de robòtica i automatització 2010, al qual vam
assistir aquest juliol.
1.1.- Hardware i software del robot
1.2.- Llenguatge C
1.3.- Llenguatge C II
1.4.- Seguidor de línies
1.5.- Projecte final
Informació concreta sobre la programació en llenguatge C, incloses
algunes pràctiques per a practicar la programació amb el robot. Per altre
banda, també hi han explicacions sobre la creació del programa “seguidor
de línies” i explicació dels elements del robot, instal·lació del programari i
de les eines utilitzades per la programació.
55
Programació del robot Pololu 3PI
Wikibooks “Programació en C”
Informació general sobre aquest àmbit de programació.
http://és.wikibooks.org/wiki/Programaci%C3%B3n_en_C
56
Programació del robot Pololu 3PI
13. Agraïments
Fernando Hernàndezés el nostre tutor del treball de recerca, i sempre li agrairem la seva dedicació per a ajudar-nos, sobretot a la part final del treball, quan sacrificava temps lliure per resoldre'ns dubtes, corregir-nos errors a la programació, i revisar la realització de la part escrita.
Néstor Berbelés el professor que ens va impartir el curset de programació a l'UPC aquest estiu, i durant aquesta setmana, ens van ajudar moltíssim les seves explicacions sobre el llenguatge de programació en C, i a aplicar-lo pràcticament al funcionament del nostre robot.
57