LSMaker API documentation v0.0

Documentació LS Maker
Programació

Índex de continguts
Distribució ..................................................................................................................................... 2
Preparació de l’entorn per programar l’LSMaker via USB ............................................................ 2
1.- Instal·lació del compilador: .................................................................................................. 2
2.- Instal·lació de l’entorn de desenvolupament (IDE) “MPLAB”: ............................................. 5
3.- Instal·lació del driver de comunicació .................................................................................. 9
Programar el codi de l'LSMaker amb l'entorn MPLAB ................................................................ 12
Carregar un programa a l'LSMaker amb l'LSLoader .................................................................... 16
Operacions bàsiques per programar l'LSMaker .......................................................................... 19
a) Operacions de motor .......................................................................................................... 19
Calibració dels motors ......................................................................................................... 23
b) Operacions de gestió del display ........................................................................................ 25
c) Operacions de memòria no volàtil – fitxers ........................................................................ 27
Com inserir el contingut d’una variable entera o real dins d’una cadena .......................... 30
Carregar i descarregar els fitxers de text de l’LSMaker ...................................................... 31
Exemples ............................................................................................................................. 32
d) Operacions de track ............................................................................................................ 35
e) Operacions de control de sensors....................................................................................... 36
f) Operacions de sistema – els “timmers”............................................................................... 38
Exemple ............................................................................................................................... 39
g) Operacions de comunicació USB......................................................................................... 40
Exemple ............................................................................................................................... 41
h) Operacions miscel·lànies importants .................................................................................. 43
El control dels sensors ............................................................................................................. 49
Exemple bàsic complert .......................................................................................................... 54
Funcionament remot .................................................................................................................. 56
Configuració ............................................................................................................................ 56
Control remot bàsic: Control manual...................................................................................... 57
Control remot programat: API remota.................................................................................... 59
Filosofia de funcionament ................................................................................................... 59
Entorn de treball ................................................................................................................. 60
Ubicació i modificacions dels projectes – l’entorn DevCpp ................................................ 60
Funcionalitats remotes........................................................................................................ 63

1

Programació

Distribució

A la distribució de l'LSMaker s'hi poden trobar tres directoris
diferents:

Documentació: És on es troba aquest fitxer i d'altres documents de
documentació de l'LSMaker

Codi font: És on hi ha el codi font de l'LSMaker. Dins hi trobem
quatre directoris:

- LS_API: Conté codi necessari pel funcionament de l'LSMaker. NO ES
POT MODIFICAR EL CONTINGUT NI EL NOM DEL DIRECTORI.
- LS_API_REMOTA: Conté codi necessari pel funcionament de
l'LSMaker. NO ES POT MODIFICAR EL CONTINGUT NI EL NOM DEL
DIRECTORI.
- SOFT_BASE_PGM: Conté el workspace (àrea de treball) necessari
per treballar amb l'MPLAB i els fitxers font d'aquest workspace.
Només s'ha de modificar la part indicada del main del fitxer
“TestMain.c”
- SOFT_BASE_REMOT_PGM: Conté el codi base necessari per
programar l’LSMaker en mode remot.

Programari: Conté els quatre conjunts d'aplicacions necessàries per
fer poder programar i carregar l'LSMaker, que són el compilador de
codi, el driver USB per poder connectar el robot al PC via USB,
l'LSLoader, que és el programa per carregar els programes ja
compilats amb el MPLAB a l'LSMaker i el MPLAB, que és l'entorn de
desenvolupament, on escriurem i compilarem el codi.

Preparació de l’entorn per programar l’LSMaker via USB

1.- Instal·lació del compilador:

Executar l’arxiu MPLABCPIC24_v3_24StdEval.exe del directori Compilador, dins de
Programari. Durant el procés d’instal·lació només caldrà dir a tot que si/següent/acceptar:

2

Programació

A la segona pantalla caldrà indicar que acceptem els termes i condicions:

Com s'ha indicat, a totes les pantalles cal prémer que si, acceptar o l'equivalent:

A la selecció d'instal·lació cal triar la completa:

3

Programació

La ubicació de la instal·lació cal deixar la que s'indica per defecte prement Next:

L'instal·lador demanarà si es permet modificar el path del sistema i que modifiqui el registre.
Cal indicar que si:

Ja a la última pantalla de resum només caldrà indicar que Next:

4

Programació

Arribats a aquest punt la instal·lació començarà:

2.- Instal·lació de l’entorn de desenvolupament (IDE) “MPLAB”:

Explorant el cd de MPLAB, haurem d’accedir a la carpeta “MPLAB_IDE_v8.36” i executar
l’arxiu “setup.exe”. Durant el procés d’instal·lació haurem d’indicar, primerament, que
acceptem les condicions de la llicència i, posteriorment, que es farà una instal·lació completa:

5

Programació

A la pantalla de selecció d'ubicació del programa també es deixarà el directori que ve
establert per defecte:

A la següent pantalla caldrà indicar que s'accepten els termes i condicions. Posteriorment es
mostrarà la pantalla de resum, a la qual només caldrà dir que Next:

6

Programació

Arribats a aquest punt, la instal·lació començarà:

Quan la instal·lació finalitzi es demanarà si es vol instal·lar el HI-TECH C. Caldrà indicar que si,
començant d'aquesta manera una nova instal·lació, a la qual també s'haurà d'indicar a tot que
sí, que s'accepten els termes d'ús, deixar el directori d'instal·lació per defecte:

7

Programació

A la següent pantalla cal marcar la casella de "Add to environment path". Un cop es premi
Next es procedirà a l'instal·lació:

Un cop finalitzada l'instal·lació ens preguntarà si es desitja llegir la guia d'inici ràpid. Es pot
desmarcar la casella, ja que no és necessari llegir-la, podent prémer Finish:

8

Programació

La última pantalla del procés d'instal·lació de l'MPLAB ens demanarà si es vol reiniciar el PC. És
aconsellable fer-ho:

Un cop reiniciat el PC, el MPLAB mostrarà una pantalla preguntant quin document es vol
obrir. Simplement serveix per obrir documents de consulta, de manera que es pot tancar
directament la finestra prement la X de la part superior dreta de la pantalla.

3.- Instal·lació del driver de comunicació

Executar l’arxiu “CP210x_VCP_Win_XP_S2K3_Vista_7.exe” del directori DriverUSB. A la
primera pantalla caldrà prémer Next i a la següent indicar que s’accepten els temes i indicar
Next. A la pantalla de sol·licitud d’ubicació podem modificar la ruta o prémer Next. A la última
pantalla només caldrà prémer a Install.

9

Programació

10

Programació

Arribats a aquest punt es donarà lloc a la instal·lació del driver. Quan acabi es demanarà si es
vol realitzar la instal·lació del driver pròpiament dit. Caldrà marcar la casella "Launch the
CP210x VCP Driver Installer" i prémer Finish:

En aquest punt apareixerà una pantalla preguntant si es vol canviar el directori d'instal·lació.
Podem prémer Install directament:

Quan s'hagi premut install apareixerà una pantalla indicant que cal esperar perquè està
realitzant accions. És possible que aquest procés duri bastant i que el sistema operatiu indiqui
que el programa no respon. Cal esperar. Quan finalitzi ens mostrarà una pantalla indicant que
la instal·lació s'ha dut a terme.

11

Programació

Programar el codi de l'LSMaker amb l'entorn MPLAB

Per començar a programar l'LSMaker caldrà obrir l’entorn de desenvolupament (MPLAB IDE).
Un cop dins caldrà anar al menú “File – Open workspace” i es carregarà el workspace del
projecte, anomenat "SoftBase.mcp", ubicat a la carpeta SOFT_BASE_PGM dins del directori
Fonts.

Nota: En cas de voler fer una còpia de seguretat, un nou projecte o quelcom semblant, es pot
realitzar una copia de la carpeta "SOFT_BASE_PGM" sencera i ubicar-la, de manera obligatòria,
al propi directori "Codi font", és a dir, al mateix nivell que el directori “SOFT_BASE_PGM”. Si no
s'ubica en aquest directori, aquesta còpia del projecte no funcionarà perquè no trobarà els
arxius font necessaris.

Un cop obert el workspace és recomanable que es faci una distribució de les finestres de
projecte i de output, així com del codi font. Per fer-ho, simplement haureu d’anar a “View” i
marcar “Project” i “Output”, de manera que us apareguin aquestes dues finestres a l'interior
de l'IDE. Posteriorment, es poden moure aquestes finestres on es vulgui, així com fer doble clic
sobre algun arxiu del projecte (des de la finestra de Project) i veure el codi font d'aquest.

Ara que l’entorn està preparat, es pot començar a programar l’aplicació que es desitgi. Cal
tenir en compte que l’LSMaker necessita codi de configuració apart del que es vulgui afegir.
Per tant, només s’haurà de canviar el codi de la part final del procediment principal (del main).

12

Programació

És aconsellable realitzar una funció amb tot el codi que es vulgui afegir i posar la crida
d’aquesta funció just abans de tancar el bucle “while(1)”. En la següent imatge es pot veure un
exemple de com es crida a la funció LSMain(), on s’inserirà tot el codi que es realitzi.

Com es pot comprovar, el codi base del main conté una crida a la funció Inicialitza i una crida a
l’operació LS_Executiu dins el bucle infinit. Aquestes dues crides són necessàries i
imprescindibles, de manera que sempre hi hauran de ser en qualsevol programa que es
realitzi. La part que es permet programar és la de just després de la crida a l’LS_Executiu. Per
aquest motiu es crea una funció apart, per veure-la com si fos un “main”.

Cal tenir en compte que el codi que hi hagi al procediment LSMain es repetirà infinitament a
causa del bucle infinit, de manera que s’haurà de fer algun tipus de control quan es finalitzi
una execució i abans que comenci la següent. És molt aconsellable que la funció LSMain
comenci amb la següent línia:

while(!LS_IO_GpButtonPress()){}

Posteriorment es veurà amb més detall l’ús de l’operació LS_IO_GpButtonPress(), però el que
fa la línia de codi anterior és, bàsicament, quedar-se en un bucle sense fer res (per això les
claus oberta i tancada juntes) mentre no es premi el botó ‘gp’ de l’LSMaker. D’aquesta
manera, es provoca que el codi posterior no s’executi fins que l’usuari li premi el botó al robot.

Un cop s'hagi programat tot el que es desitgi, caldrà compilar el projecte fent “Project-Build
all” o fent clic al botó corresponent de la barra d’eines (marcat a la següent imatge). També es
pot fer “Project-Make” o donar-li al botó de make de la barra d'eines(marcat a la següent
imatge). En cas de fer "Build all", es compilarà tot el projecte de nou, cosa que comportarà
molt de temps de compilació. En cas de fer un "make", només es compilaran aquells fitxers del
projecte que hagin canviat.

13

Programació

Si la compilació funciona apareixerà el missatge “BUILD SUCCEEDED” a la pantalla de resultats
(output).

Un cop la compilació hagi finalitzat s'haurà generat un nou fitxer que s'anomenarà igual que el
workspace amb l'extensió "hex" (en aquest cas, SoftBase.hex).

Nota 1: Cal vigilar amb els paràmetres de l'MPLAB que es toquin. És aconsellable no canviar
cap configuració d'aquest, ja que pot provocar comportaments inesperats, que es generin
fitxers "hex" incorrectes, etc. Les úniques opcions que es necessiten són les de programar (build
all o make).

Nota 2: En cas que es desitgi programar un mateix workspace en diferents ubicacions (diferents
PCs amb el compilador i l'MPLAB instal·lat), és possible que existeixin conflictes en la ubicació
del compilador. En cas que existeixi un conflicte apareixerà una finestra com la següent:

Aquesta pantalla informa de que actualment hi ha una ubicació del compilador, però que
l'últim cop que es va modificar aquest workspace el compilador estava en una altra ubicació.
En aquest cas caldrà prémer el botó "Use This" superior, el que indica que s'utilitzarà la
ubicació que té el MPLAB actualment. Possiblement aquesta pantalla apareixerà més d'un cop
durant el procés de compilació del workspace, però sempre s'haurà d'indicar el mateix. Si, per
qualsevol motiu, aquest pas es fes de manera incorrecta, caldrà anar a "Project-Select
Language Toolsuite". Allà apareixerà una pantalla com la següent:

14

Programació

Caldrà buscar el "MPLAB C30 C Compiler", fer clic sobre aquesta línia, prémer el botó Browse i
indicar la ubicació del compilador C en l'ordinador actual, tenint en compte que habitualment
aquest error es dona degut com anomenen els diferents operatius als "Archivos de programa".
Així doncs, possiblement només caldrà canviar "Archivos de programa" per "Program files" o "
Program Files (x86)" o equivalents.

15

Programació

Carregar un programa a l'LSMaker amb l'LSLoader

Un cop es disposi del fitxer amb extensió "hex" generat per la compilació amb el MPLAB,
aquest es podrà carregar a l'LSMaker mitjançant l'aplicació " LSLoader.exe", situada al
directori "ProgramariLSLoader". Per fer-ho, caldrà tenir l'LSMaker connectat al PC via el cable
USB.

Nota: L'explicació del programa LSLoader es farà sobre la versió V1.01. En cas de canvi de
versions, l'ús de l'aplicació a l'hora de carregar el fitxer "hex" hauria de ser igual o molt
similar, de manera que el manual no s’hauria de veure molt afectat.

El primer que caldrà connectar l'LSMaker al PC mitjançant el cable USB i activar el robot
prement el polsador 'ON'. Si l'LSMaker no està connectat o actiu, no funcionarà cap
funcionalitat del programa LSLoader. Si s'intenta fer alguna operació com Calibració,
Telecàrrega o d'altres, apareixerà el següent missatge:

Un cop el robot estigui preparat caldrà triar l'USB on tenim connectat l'LSMaker. Per fer-ho
caldrà prémer el menú USB i triar el port COM que aparegui habilitat. Per defecte estarà
seleccionat el port COM1, però el correcte serà l'altre que aparegui habilitat (que no estigui
en gris). El número de port de COM actiu dependrà de cada ordinador (a la figura apareix l'11,
però podria ser algun altre).

16

Programació

Un cop s'hagi seleccionat el port de comunicacions caldrà fer un reset de l'LSMaker, des de
"operacions-reset", fent clic a F6 o fent clic al botó corresponent de la barra d'eines.

Quan s'hagi reiniciat el robot es podrà procedir a carregar el programa. Per fer-ho caldrà anar
a "operacions-telecàrrega" o fer click sobre el botó corresponent de la barra d'eines (indica
carregar programa). Fent això s'obrirà un explorador, on caldrà de triar el fitxer amb extensió
"hex" a carregar, que estarà ubicat a la mateixa carpeta que el workspace que s'ha editat.

Quan s'hagi seleccionat el fitxer amb extensió "hex", ens apareixerà una nova finestra, on
simplement haurem de prémer "Inicia" per carregar el programa a l'LSMaker.

Un cop finalitzat el procés s'haurà carregat el programa a l'LSMaker i aquest l'executarà
automàticament.

17

Programació

Nota: Cal tenir en compte que, com s'ha dit, quan es carrega el programa, l'LSMaker
l'executarà automàticament. Per tant, si el programa que se li ha carregat fa que es mogui
directament, aquest ho farà. Cal vigilar per tant on tenim col·locat l'LSMaker, a fi d'evitar que
cagui d'una taula o accidents semblants. La millor manera d'evitar aquest tipus d'accidents és
fent ús de la funcionalitat "LS_IO_GpButtonPress" (s'explicarà posteriorment).

18

Programació

Operacions bàsiques per programar l'LSMaker
Fins al moment s’ha explicat com instal·lar i configurar l’entorn de desenvolupament i càrrega i
quin serà el tros de codi que es podrà modificar. A continuació s'introduiran les operacions
més importants que tenim disponibles a la API de l'LSMaker per interactuar amb aquest. Una
API (application programming interface) és un conjunt de procediments i funcions (operacions)
que s'ofereixen per treballar sobre un codi de més baix nivell de manera abstracta. Així doncs,
en aquest cas, la API de l’LSMaker serveix per poder ordenar al robot que realitzi certes
accions simplement executant l’operació desitjada, sense haver de programar a baix nivell.

En aquest apartat d’operacions bàsiques s’explicaran les operacions més importants i
necessàries per poder fer ús de l’LSMaker. No obstant, existeixen altres operacions en aquesta
API que no s’explicaran, ja que el seu ús no resulta necessari a nivell bàsic ni mitjà o hi ha
d'altres funcions que fan una tasca molt similar. Tot i això, per conèixer totes les possibilitats
que ofereix la API es pot consultar l'arxiu "LSApi.h", ubicat al directori LS_API, dins de Fonts.
Dins s’hi troben definides totes les capçaleres de totes les funcions existents, ordenades
segons el tipus i amb una petita explicació de cadascuna d'elles.

a) Operacions de motor

Son les operacions que serveixen per fer moure l’LSMaker. A continuació s’explicaran les
funcions principals de l’API per fer moure l’LS en línia recta o girant, funcions per calcular
temps o angles per definir moviments i operacions bàsiques per definir el control dels sensors.

Operació unsigned int LS_MT_Lineal(unsigned int Time, int Speed,
int StopBits, int * StopReasons);

Explicació Aquesta operació serveix per fer moure l’LSMaker en línia recta, ja sigui
endavant o endarrere. No es pot indicar quina és la distància que volem que es
mogui, però si la velocitat i el temps. A més, es pot fer que el moviment s’aturi
abans del temps establert si es compleixen certes condicions que se li indiquin.

Arguments Time: Enter que indica durant quants milisegons es mourà l’LSMaker. Ha de ser
major o igual a 0 (0 indica temps infinit).

Speed: Velocitat a la que es mourà l’LSMaker entre un rang de [-100,100],
essent 100 la velocitat màxima, 0 indica que està parat i els valors negatius
indiquen que el moviment el farà en sentit invers (endarrere).

StopBits: Indica els motius desitjats per fer que el cotxe es pari abans del temps
establert (s’explicarà amb més detall posteriorment, a l’apartat “El control dels
sensors”). Indicant un 0 vol dir que no hi ha cap motiu perquè s’aturi abans del
temps indicat.

StopReasons: És un enter passat per referència que retorna els motius pels
quals el cotxe s’ha aturat abans de temps.

Retorn Es retorna un enter que són el nombre de milisegons que s’ha mogut el cotxe.

Exemples int stop;

LS_MT_Lineal(1000,100,0,&stop);

19

Programació

En aquest cas el cotxe es mourà endavant durant 1000 milisegons (1 segon) a
velocitat màxima, passi el que passi (no hi ha cap motiu per parar). L’últim
argument, el &stop, és una manera d’indicar que passem la variable entera stop
per referència. Simplement es tracta de posar un ‘&’ davant de la variable
entera que volem que es modifiqui.

int parar;

LS_MT_Lineal(10000, -50, MT_STOP_1 | MT_STOP_2, &parar);

En aquest cas, el cotxe es mourà endarrere durant 10 segons a velocitat mitja
(50), tot i que és possible que es pari si es compleix la condició
(SENSOR_C|SENSOR_D).

Operació unsigned int LS_MT_TurnRight(unsigned int Time, int Speed,
unsigned int Radius, int StopBits, int * StopReasons);

Explicació Aquesta operació serveix per fer girar l’LSMaker a la dreta durant un cert temps,
amb una certa velocitat i amb un angle de gir específic. De la mateixa manera
que passava amb l’operació d’avançar, es poden indicar condicions per fer que
el moviment s’aturi abans del temps indicat.

Arguments Time: Enter que indica durant quants milisegons es mourà (girant) l’LSMaker. Ha
de ser major o igual a 0 (0 indica temps infinit).


Radius: Indica el grau d’obertura de la corba que farà el robot. Un valor de 0
indica que l’LSMaker girarà a la dreta sobre ell mateix. Quan major és el valor,
més oberta serà la corba que farà.

StopBits: Indica els motius que desitgem perquè el cotxe es pari abans del
temps establert (s’explicarà amb més detall posteriorment, a l’apartat “El
control dels sensors”). Indicant un 0 vol dir que no hi ha cap motiu perquè
s’aturi abans del temps indicat.

StopReasons: És un enter per referència que retorna els motius pels quals el
cotxe s’ha aturat abans de temps.


Exemple int stop;

LS_MT_TurnRight(1000,60,0,0,&stop);

En aquest cas el cotxe girarà a la dreta sobre si mateix durant 1000 milisegons
(1 segon) a velocitat de 60 (d’un màxim de 100), passi el que passi (no hi ha cap
motiu per parar). L’últim argument, el &stop, és una manera d’indicar que
20

Programació

passem la variable entera stop per referència. Simplement es tracta de posar un
‘&’ davant de la variable entera que volem que es modifiqui.

int parar;

LS_MT_TurnRight(500,-30,10,0,&parar);

En aquest cas, el cotxe girarà a la dreta, marxa enrere, durant mig segon i amb
un grau d’obertura de 10, cosa que vol dir que enlloc de girar sobre si mateix, el
moviment tindrà una component de recte.

Operació unsigned int LS_MT_TurnLeft(unsigned int Time, int Speed, unsigned
int Radius, int StopBits, int * StopReasons);

Explicació Aquesta operació serveix per fer girar l’LSMaker a l’esquerra durant un cert
temps, amb una certa velocitat i amb un angle de gir específic. De la mateixa
manera que passava amb l’operació d’avançar, es poden indicar condicions per
fer que el moviment s’aturi abans del temps indicat.

Arguments Time: Enter que indica durant quants milisegons es mourà (girant) l’LSMaker. Ha
de ser major o igual a 0 (0 indica temps infinit).


Radius: Indica el grau d’obertura de la corba que farà el robot. Un valor de 0
indica que l’LSMaker girarà a la dreta sobre ell mateix. Quan major és el valor,
més oberta serà la corba que farà.

StopBits: Indica els motius que desitgem perquè el cotxe es pari abans del
temps establert (s’explicarà amb més detall posteriorment, a l’apartat “El
control dels sensors”). Indicant un 0 vol dir que no hi ha cap motiu perquè
s’aturi abans del temps indicat.

StopReasons: És un enter per referència que retorna els motius pels quals el
cotxe s’ha aturat abans de temps.


Exemple int stop;

LS_MT_TurnLeft(1000,60,0,0,&stop);

En aquest cas el cotxe girarà a l’esquerre sobre si mateix durant 1000 milisegons
(1 segon) a velocitat de 60 (d’un màxim de 100), passi el que passi (no hi ha cap
motiu per parar). L’últim argument, el &stop, és una manera d’indicar que
passem la variable entera stop per referència. Simplement es tracta de posar un
‘&’ davant de la variable entera que volem que es modifiqui.

int parar;

LS_MT_TurnRight(500,-30,10,0,&parar);

21

Programació

En aquest cas, el cotxe girarà a l’esquerre i marxa enrere, durant mig segon i
amb un grau d’obertura de 10, cosa que vol dir que enlloc de girar sobre si
mateix, el moviment tindrà una component de recte.

Operació void LS_MT_SetNivellStopBits(unsigned char Nivell);

Explicació Aquesta operació canvia el comportament de les condicions d’aturada en les
operacions de moviment de l’LSMaker. Com es veurà en profunditat a l’apartat
“El control dels sensors”, les condicions d’aturada venen inicialment
determinades pel color que detecten els sensors de sota el robot. Amb aquesta
operació el que es fa és invertir el comportament de les condicions.

Arguments Nivell: Enter que serveix per indicar per quin color s’activa la condició d’aturada.
Només té dos possibles valors:

0: Indica que la condició s’activa per blanc, és a dir, que el moviment s’aturarà
quan el sensor indicat a la condició detecti blanc. Pel contrari, si detecta negre,
la condició no s’activarà i, per tant, no aturarà l’execució de l’operació de
moviment abans del temps previst.

1: Estableix el comportament contrari a 0, és a dir, la condició d’aturada
s’activarà quan el sensor concret detecti negre.

Retorn No hi ha valor de retorn.

Exemple El següent codi fa que l’LSMaker avanci en línia recta mentre la condició de
parada (MT_STOP_1) no s’activi. El primer que fa el codi és establir que la
condició s’activi per negre. Per tant, quan es compleixi que MT_STOP_1 veu
negre, el moviment s’aturarà.

LS_MT_SetNivellStopBits(1);
LS_MT_Lineal(0, 70, MT_STOP_1, &stop);

Operació unsigned int LS_MT_GetTimeFromDistance(int Distance,
int Speed);

Explicació Degut a que a l’operació de moviment recte no se li pot indicar la distància que
es desitja que es recorri, només el temps i la velocitat, existeix aquesta operació
que, donada la distància desitjada i la velocitat a la que es farà moure
l’LSMaker, retorna el temps que cal que es mogui.
Aquesta operació, però, perd la seva eficàcia quan el nivell de bateria no està
entre 72 i 71. En cas que no estigui entre aquest marge, es pot produir un error
d’ aproximadament el 10%.

Arguments Distance: És on s’indica la distància en centímetres a recórrer per l’LSMaker
desitjada.

Speed: Indica la velocitat a la que es farà moure l’LSMaker en línia recta a
l’operació LS_MT_Lineal.

22

Programació

Retorn Retorna un enter que indica el temps que caldrà fer moure l’LSMaker per
recórrer la distància indicada movent-se a la velocitat Speed.

Exemple Aquesta operació es pot utilitzar directament dins l’operació de moviment
recte. En l’exemple es pot observar que se li indica a l’LSMaker que avanci un
metre (100 cm) a velocitat 50, sense cap condició d’aturada:
LS_MT_Lineal(LS_MT_GetTimeFromDistance(100,50),50,0,&stop);

Es podria realitzar la mateixa operació capturant el valor de retorn de l’operació
en qüestió i passant-la com a paràmetre:
int t;

t = LS_MT_GetTimeFromDistance(100,50);
LS_MT_Lineal(t,50,0,&stop);

Operació unsigned int LS_MT_GetTimeFromAngle(int Angle, int
Speed);

Explicació Degut a que a les operacions de gir no se’ls pot indicar l’angle en graus que es
desitja girar, sinó l’angle sobre ell mateix, existeix aquesta operació que, donada
l’angle que es desitja girar i la velocitat a la que es farà moure l’LSMaker,
retorna el temps que cal que es mogui.

Només es pot utilitzar aquesta funció correctament si l’angle de gir és menor a
10º.

Aquesta operació perd la seva eficàcia quan el nivell de bateria no està entre 72
i 71. En cas que no estigui entre aquest marge, es pot produir un error d’
aproximadament el 10%.

Arguments Angle: És on s’indica l’angle a girar desitjat per l’LSMaker.

Speed: Indica la velocitat a la que es farà moure l’LSMaker per girar.

Retorn Retorna un enter que indica el temps que caldrà fer moure l’LSMaker per girar
l’angle indicada movent-se a la velocitat Speed.

Exemple Aquesta operació es pot utilitzar directament dins l’operació de girar. En
l’exemple es pot observar que se li indica a l’LSMaker que giri 5º a velocitat 50,
sense cap condició d’aturada:
LS_MT_TurnRight(LS_MT_GetTimeFromAngle(5,50),50,5,0,&parar);

Calibració dels motors

Un cop explicades les operacions de moviment de l’LSMaker, és necessari mencionar que cada
robot és diferent, i que, degut a l’estat de les rodes, de les orugues, dels motors, etc. el
moviment pot diferir entre un robot i un altre. De fet, és possible que intentant moure el robot

23

Programació

recte, aquest tingui una petita desviació i acabi realitzant un petit gir. Per tal d’evitar aquests
comportaments es pot realitzar una calibració dels motors mitjançant l’aplicació LSLoader.

Per tal de calibrar els motors cal connectar l’LSMaker al PC mitjançant el cable USB, executar
l’LSLoader, indicar el port USB on està connectat l’LSMaker (el COM que estigui actiu en el
menú “USB” que no sigui l’1) i, al menú “Operacions”, executar l’opció “Calibració”.

Com indiquen les pròpies operacions de la pantalla de calibració, l’ajust de direcció serveix per
controlar la direcció de l’LSMaker (si el moviment que fa no és recte quan així se li demana) i
l’ajust de tracció serveix per controlar les velocitats dels motors (per poder fer un ús més
precís de les operacions LS_MT_GetTimeFromDistance i
LS_MT_GetTimeFromAngle.

24

Programació

b) Operacions de gestió del display

Les operacions de gestió del display serveixen per controlar la pantalla LCD i mostrar-hi la
informació desitjada. Cal tenir en compte que la freqüència de refresc de la pantalla LCD és
aproximadament de 50 ms, de manera que és aconsellable no “estressar” la pantalla, ja que en
cas contrari no es visualitzarà correctament el contingut.

Operació void LS_LCD_Clear(void);

Explicació Aquesta operació serveix per esborrar tota la informació que aparegui a la
pantalla.

Arguments No hi ha arguments.

Retorn No hi ha cap retorn.

Exemple Crida a l’operació per netejar la pantalla:
LS_LCD_Clear();

Operació void LS_LCD_Printf(int X, int Y, char *fmt, ... );

Explicació Aquesta operació serveix per mostrar per pantalla el que es desitgi, podent
posicionar aquesta informació on es desitgi de la pantalla.

Arguments X: Posició de columna de la pantalla, tenint en compte que la pantalla té 16
posicions començant per la 0 i fins la 15 (0 més a l’esquerra, 15 més a la dreta).

Y: Posició de fila de la pantalla, tenint en compte que la pantalla té 4 posicions
començant per la 0 i fins la 3(0 més amunt, 3 més avall).

fmt: És la informació que es vol pintar per l’LCD. Té la mateixa estructura de
funcionament que un printf normal.


Exemple Mostrar per pantalla el valor de la variable ‘i’ a la cantonada superior esquerre:
int i=2;

LS_LCD_Printf(0,0,”Variable i:%d”,i);

Mostrar per pantalla el valor de la variable ‘i’ (2) en mig de la pantalla:
int i=2;

LS_LCD_Printf(7,1,”%d”,i);

Operació void LS_LCD_CursorOn(void);

Explicació Aquesta operació serveix per indicar que es desitja que es mostri el cursor per
pantalla. El cursor indica quina és la posició on l’LSMaker escriurà el proper cop

25

Programació

si no se li indica expressament una altra posició.



Exemple Crida a la funció:
LS_LCD_CursorOn();

Operació void LS_LCD_CursorOff(void);

Explicació Aquesta operació serveix per indicar que NO es desitja que es mostri el cursor
per pantalla.



Exemple Crida a la funció:
LS_LCD_CursorOn();

26

Programació

c) Operacions de memòria no volàtil – fitxers

L’LSMaker ofereix la possibilitat de treballar amb fitxers de text d’una manera semblant a la
que ofereix el llenguatge C. Concretament ofereix la possibilitat de treballar amb un màxim de
dos fitxers de text, que poden ser carregats a l’LSMaker des de l’ordinador o descarregats a
l’ordinador des de l’LSMaker mitjançant la utilitat LSLoader.

Operació int LS_NVOL_Open(char *Nom, char *Mode);

Explicació Aquesta operació serveix per obrir un fitxer de text i poder treballar
posteriorment amb ell, ja sigui llegint-lo o escrivint-hi.

Arguments Nom: Cal indicar com a nom de fitxer o bé NVOL_STREAM_A o bé
NVOL_STREAM_B. En cas d’indicar un altre nom donarà error.
Mode: És una cadena de caràcters que indica el mode en que es vol obrir el
fitxer. Els seus valors poden ser:

“r”: Indica que es vol obrir el fitxer en mode lectura i, per tant, només es faran
lectures d’aquest, no s’hi escriurà.

“w”: Indica que es vol obrir el fitxer en mode escriptura. En aquest cas, en fer la
obertura, s’eliminarà tot el contingut previ del fitxer que s’obre, permetent
l’escriptura del fitxer des de l’inici d’aquest.

“a”: Indica que es vol obrir el fitxer en mode afegir, és a dir, escriure però sense
esborrar el contingut previ del fitxer. D’aquesta manera, quan s’obre el fitxer en
mode afegir es començarà a escriure a continuació del text que ja hi hagués.

Retorn L’operació retorna un enter identificatiu del fitxer obert, de la mateixa manera
que en C es retorna un FILE*. Cal capturar-lo perquè serà necessari fer-ne ús en
les operacions de lectura, escriptura, tancar, etc.

Operació int LS_NVOL_Write(int HANDLE, char *buffer, unsigned
int length);

Explicació Aquesta operació serveix per escriure en un fitxer que prèviament s’ha obert en
mode escriptura o afegir. Si es fa ús d’aquesta operació amb un fitxer obert en
mode lectura no funcionarà i donarà un error.

Arguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna la
funció Open).

buffer: És la cadena de caràcters que es vol guardar al fitxer. NOMÉS es poden
guardar cadenes de caràcters, de manera que si es volgués guardar al fitxer el
valor d’una variable entera caldrà fer algun pas previ per inserir el valor dins
d’una cadena.

27

Programació

lenght: Ha d’indicar el nombre de caràcters que conté la cadena de caràcters
que es va a escriure al fitxer. Cal tenir en compte que sempre s’ha d’indicar el
nombre exacte de caràcters, per tant, si la cadena està guardada en una
variable es pot fer ús de la funció strlen(char* string), que retorna el
nombre de caràcters d’una cadena. Recordeu doncs d’incloure la llibreria
<string.h>

Retorn Retorna el nombre de caràcters que realment s’han escrit al fitxer, EOF si s’ha
arribat al límit de mida del fitxer o un enter identificat per la constant
NVOL_INVALID_MODE si s’ha intentat escriure en un fitxer obert en mode
lectura.

Operació int LS_NVOL_Read(int HANDLE, char *buffer, unsigned
int length);

Explicació Aquesta operació serveix per llegir la informació que conté un fitxer que
prèviament s’ha obert en mode lectura. Si es fa ús d’aquesta operació amb un
fitxer obert en mode escriptura o afegir no funcionarà i donarà un error.

L’operació començarà a llegir el fitxer des de l’inici i cada nova lectura es farà
des de la posició on es va quedar la última lectura feta fins al moment.

Arguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna
l’operació Open).

buffer: És la cadena de caràcters on es guardarà la informació que es llegeixi del
fitxer.

lenght: Indica el nombre de caràcters que es llegiran del fitxer. Cal tenir en
compte

Retorn Retorna el nombre de caràcters que realment s’han llegit o la constant EOF si
s’ha arribat al final del fitxer amb la lectura. En cas que s’hagi fet una lectura
indicant un handle d’un fitxer obert en mode escriptura o afegir es retornarà la
constant NVOL_INVALID_MODE.

Funció int LS_NVOL_ReadLine(int HANDLE, char *buffer);

Codi int LS_NVOL_ReadLine(int HANDLE, char *buffer){
int i=0;
char aux[5];
for(i=0;buffer[i]!='0' && buffer[i]!='n' && buffer[i]!='r';
i++) buffer[i]= '0';
i=0;
while(LS_NVOL_Read(HANDLE, aux, 1) != EOF){
if(aux[0] == 'n'){
buffer[i] = '0';
return i;
}else{
buffer[i] = aux[0];
i++;
}

28

Programació
}
buffer[i] = '0';
return EOF;
}

Explicació Aquesta funció llegirà una línia sencera del fitxer obert amb el handle que se li
indiqui. Concretament llegirà fins que trobi un ‘n’ o l’EOF.

AQUESTA FUNCIÓ NO ESTÀ INCLOSA DINS DE LA API DE L’LSMAKER. SI ES VOL
FER ÚS CAL COPIAR EL CODI DE LA FUNCIÓ DINS EL CODI DE L’ARXIU DEL MAIN.


buffer: És la cadena de caràcters on es guardarà la informació que es llegeixi del
fitxer.

Retorn Retorna el nombre de caràcters que realment s’han llegit o la constant EOF si
s’ha arribat al final del fitxer amb la lectura. En cas que s’hagi fet una lectura
indicant un handle d’un fitxer obert en mode escriptura o afegir es retornarà la
constant NVOL_INVALID_MODE.

Exemple El codi del següent exemple fa que es llegeixi tot el fitxer fins que s’arribi al final
del fitxer, mostrant cada línia per la pantalla LCD quan es llegeix.

int h;
char cad[MAXC];
h = LS_NVOL_Open(NVOL_STREAM_B, "r");
while(LlegeixLinia(h,cad)!= EOF){
LS_LCD_Printf(0, 0, "%s",cad);
LS_SYS_SleepSecs(1);
while(!LS_IO_GpButtonPress());
LS_LCD_Clear();
}

Operació int LS_NVOL_Close(int HANDLE);

Explicació Aquesta operació serveix per tancar un fitxer que prèviament ha sigut obert en
qualsevol mode.


Retorn El valor de retorn no té rellevància.

Operació int LS_NVOL_Eof(int HANDLE);

Explicació Aquesta operació serveix per comprovar si un fitxer ha arribat al seu final


29

Programació

Retorn Retorna el valor 0 si el fitxer no ha arribat al final. En cas contrari, quan s'arriba
al final, es retorna un valor major que 0.

Operació void LS_NVOL_ReOpen(int HANDLE);

Explicació Aquesta operació serveix per tornar a situar el punter intern de posició del fitxer
al principi d’aquest, és a dir, cridant a aquesta funció es tornarà al principi de tot
el fitxer. Aquesta operació només es pot utilitzar amb fitxers oberts en mode
lectura.

Arguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna la
funció Open), en mode lectura.

Retorn No hi ha retorn.

Operació int LS_NVOL_Size(int HANDLE);

Explicació Aquesta operació informa del nombre de caràcters que conté el fitxer amb
l’identificador que se li passa com a paràmetre.

l’operació Open), en mode lectura.

Retorn Retorna el nombre de caràcters que té el fitxer.

Com inserir el contingut d’una variable entera o real dins d’una cadena

Per treballar amb l’operació LS_NVOL_Write de l’LSMaker, la que permet escriure als
fitxers, sempre serà necessari fer ús de cadenes, ja que les operacions de la API no permeten
escriure valors enters o reals directament al fitxer. Serà necessari doncs “transformar” els
valors d’una variable de qualsevol tipus a una variable cadena. Més concretament, el que es
farà serà inserir el valor de la variable dins d’una cadena. La manera de fer-ho és molt senzilla i
fàcil d’entendre.

Oi que quan es vol mostrar per pantalla tant un text com el valor d’una variable s’utilitza
l’operació printf? Doncs existeix una altra operació que fa el mateix que el printf però que
enlloc de mostrar la informació per pantalla la guarda dins d’una cadena de caràcters que se li
ha d’indicar. Aquesta funció és la sprintf. Anem a veure un exemple pràctic:

Es vol mostrar el text “Edat” seguit del contingut de la variable “ed” per pantalla. Com es faria
això? Senzill, amb l’operació printf:

printf(“Edat: %dn”,ed);

30

Programació

Ara es vol fer el mateix, però enlloc de mostrar la informació per pantalla, la volem guardar en
una cadena de caràcters. Com ho fem? Doncs amb l’operació sprintf, tenint declarada la
variable cadena:

char cad[100];

sprintf(cad,“Edat: %dn”,ed);

D’aquesta manera si, per exemple, la variable ed valia 25, la cadena ‘cad’ contindrà “Edat: 25”.

Carregar i descarregar els fitxers de text de l’LSMaker

Per carregar (guardar fitxers de text del PC a l’LSMaker) o descarregar (guardar els fitxers de
l’LSMaker dins el PC) fitxers, cal utilitzar el programa LSLoader. Un cop estigui obert el
programa i l’LSMaker connectat al PC via USB, caldrà, igual que es fa per carregar un programa,
seleccionar el port USB per comunicar-se amb el robot, que serà aquell que aparegui habilitat i
que no sigui el port 1.

Un cop seleccionat el port caldrà fer un reset del robot seleccionant “Operacions-reset” o fent
clic sobre el botó de la barra d’eines corresponent.

Per descarregar un fitxer a l’ordinador caldrà anar a “Operacions – Baixa el fitxer X”, on X pot
ser A, B o C. També es pot fer clic sobre els botons corresponents de la barra d’eines. Cal tenir
en compte que els fitxers A i B són els que es poden modificar amb les operacions d’escriptura

31

Programació

de fitxer. El fitxer C és on es guardarà la informació de tracking (per això no es pot carregar,
només es pot descarregar).

Un cop seleccionada la opció apareixerà una finestra de navegació de directori, on simplement
caldrà indicar on i amb quin nom volem guardar el fitxer.

Per carregar un fitxer a l’LSMaker (guardar-lo a la seva memòria) caldrà anar a “Operacions –
Puja el fitxer X”, on X pot ser A o B (no es pot carregar un fitxer C de track) o fer clic sobre el
botó corresponent de la barra d’eines.

Un cop seleccionat el fitxer a carregar apareixerà una finestra de navegació de directori, on
simplement caldrà seleccionar el fitxer a carregar.

Exemples

Exemple d’ús de fitxers d’escriptura

El següent exemple mostra un codi que guarda al fitxer A de l’LSMaker (NVOL_STREAM_A)
inicialment la cadena estàtica “Agenda”, fa un salt de línia (n) i, posteriorment,
emmagatzema una cadena de caràcters i un enter procedents d'un array de tipus "Contacte":
typedef struct{
char nom[50];
int telf;
}Contacte;

Contacte con[MAXC];
int i, hand;
char cad[50];

// ...

// S‟obre el fitxer NVOL_STREAM_A en mode escriptura, capturant l‟id a hand.
hand = LS_NVOL_Open(NVOL_STREAM_A, "w");

// Mentre no es premi el botó gp, espera.

// Es guarda al fitxer la cadena “Agenda” i salt de línia, indicant el fitxer

32

Programació
// hand, la cadena i el nombre de caràcters d‟aquesta(7, 6 de la paraula temps
// + 1 de n)
LS_NVOL_Write(hand, “Agendan”, 7);

for(i=0;i<MAXC;i++){
// S‟insereix la cadena i l'enter de cada posició de l'array a la cadena
// cad utilitzant sprintf
sprintf(cad,"%s %d",con[i].nom, con[i].telf);

// Es captura el nombre de caràcters de la cadena cad a n
n = strlen(cad);

// S‟escriu al fitxer el contingut de la cadena cad.
LS_NVOL_Write(hand, cad, n);
}

// Es tanca el fitxer
LS_NVOL_Close(hand);

Exemple d’ús de fitxers de lectura 1

El següent exemple mostra un codi que fa que l’LSMaker llegeixi el contingut del fitxer B
(NVOL_STREAM_B), línia per línia (fent ús de la funció implementada LS_NVOL_ReadLine)
i la mostra per la pantalla LCD cada línia amb dos segons de diferència (fent ús de la funció
LS_SYS_SleepSecs, que bàsicament fa que el codi s’esperi el temps que se li indica. Es
veurà amb més profunditat a l’apartat g).

int h;
char cad[30];

// S‟obre el fitxer B en mode lectura i capturem l‟identificador a h.

// Llegim una línia del fitxer a la cadena cad.
LS_NVOL_ReadLine (h,cad);
// Iterem mentre no trobem el final de fitxer
while(!LS_NVOL_Eof(h)){

// Mostrem per l‟LCD la línia que s‟ha llegit.

// S‟espera dos segons a executar la següent operació

// Llegim una línia del fitxer a la cadena cad.
LS_NVOL_ReadLine (h,cad);

// Es neteja la pantalla
LS_LCD_Clear();
}
// Es mostra la última línia llegida, ja que aquesta haurà retornat EOF i no
// haurà entrat al bucle

// Es tanca el fitxer
LS_NVOL_Close(h);

Exemple d’ús de fitxers de lectura 2

El següent exemple mostra un codi que, inicialment, fa que l’LSMaker mostri per la pantalla
33

Programació

LCD el nombre de caràcters que conté el fitxer B (NVOL_STREAM_B). Posteriorment es llegirà i
mostrarà la informació que conté, de 10 caràcters en 10 caràcters. Això provocarà que si hi ha
un salt de línia el llegeixi també i intenti mostrar-lo a l’LCD, però no farà el salt. Després de fer
tota la lectura, enlloc de tancar el fitxer es “reiniciarà”, és a dir, es posarà el punter a l’inici del
fitxer.

int h;
char cad[100];

// S‟obre el fitxer B en mode lectura

// Es mostra a la pantalla LCD l‟enter que indica el nombre de caràcters de B
LS_LCD_Printf(0, 0, "%d", LS_NVOL_Size(int HANDLE));

// Es fa la lectura del fitxer, de 10 caràcters en 10 caràcters
while(LS_NVOL_Read(h, cad, 10) != EOF){
LS_LCD_Clear();
//while(!LS_IO_GpButtonPress());
}

// Es posiciona el punter al principi del fitxer per si després s‟ha de tornar
a fer la lectura.
LS_NVOL_ReOpen(h);

34

Programació

d) Operacions de track

L’LSMaker disposa d’operacions per fer un seguiment i control de la ruta que s’ha seguit. Són
les funcions de tracking, les quals serveixen per inicialitzar la posició inicial de l’LS, que sempre
serà la (0,0), emmagatzemar una posició, capturar la posició actual o finalitzar
l’emmagatzemament. Cal tenir en compte que la precisió de les dades que s’emmagatzemen
no és exacta i que hi pot haver un cert grau d’error.

Les dades posicionals que s’enregistrin es guardaran automàticament al fitxer
‘NVOL_STREAM_C’ de l’LSMaker, i es podrà disposar d’aquest tant des de les operacions de
gestió de fitxers com des de l’LSLoader.

Operació void LS_MT_InitTrack ();
Explicació Aquesta operació inicia l’enregistrament de posicions. A partir del moment en
que s’executa es guardarà la posició de l’LSMaker relativa a la posició inicial (on
s’ha executat l’operació LS_MT_InitTrack.
Arguments No té arguments.
Retorn No té un valor de retorn.

Operació void LS_MT_EndTrack ();
Explicació Aquesta operació serveix per finalitzar l’enregistrament de les posicions de
l’LSMaker, de manera que es pugui disposar del fitxer de trajectòries (fitxer
NVOL_STREAM_C) i treballar amb ell.
Arguments No té arguments.
Retorn No té un valor de retorn.

Operació void LS_MT_GetTrack (int *x, int *y);
Explicació Aquesta operació serveix per indicar la posició actual de l’LSMaker. Fent-ne ús
es captura la posició (x,y) relatives a la posició d’inici del robot
Arguments *x: Variable per referència x: Emmagatzema al paràmetre per referència ‘x’ el
valor de la component ‘x’ de la posició actual del robot.
*y: Variable per referència y: Emmagatzema al paràmetre per referència ‘y’ el
valor de la component ‘y’ de la posició actual del robot.
Retorn No hi ha un valor de retorn de la funció; Els valors necessaris s’emmagatzemen
als paràmetres passats per referència.

Exemple d’ús del track
int i,x,y,stop;

LS_LCD_Printf(0,0,”Init track”);
//S‟inicialitza l‟enregistrament de posicions
LS_MT_InitTrack();
for(i=0;i<3;i++){
//Es mou l‟LSMaker endavant i a la dreta
LS_MT_TurnRight(500,-30,10,0,&stop);
//Es captura la posició x i y per mostrar-les per pantalla
LS_MT_GetTrack (&x,&y);
LS_LCD_Printf(0,0,”Pos: %d %d”,x,y);
}
LS_MT_EndTrack();

35

Programació

e) Operacions de control de sensors

L’LSMaker disposa (o pot disposar), a la seva part inferior, d’una placa que té 3 sensors de
color que detecten blanc o negre. El sensor de la esquerra s’identifica amb el codi
‘MT_STOP_0’, el del mig amb ‘MT_STOP_1’ i el de la dreta amb ‘MT_STOP_2’. Es veurà una
explicació molt més detallada dels sensors un cop finalitzada l’explicació de les operacions de
l’LSMaker. En aquest apartat bàsicament s’expliquen les operacions per conèixer els valors que
“veuen” els sensors.

Operació int LS_MT_IsStop(unsigned int StopBits);

Explicació Operació que informa de l’estat dels sensors en l’actualitat (si estan sobre color
blanc o negre).

Arguments StopBits: És on s’indica el sensor que es vol consultar. Si volem consultar el
sensor esquerre valdrà ‘MT_STOP_0’, el del mig ‘MT_STOP_1’ i el de la dreta
‘MT_STOP_2’. Posteriorment s’explicarà el funcionament dels sensors, les
màscares i les condicions de parada de les operacions de motor amb més
profunditat.

Retorn Retorna un valor positiu si el sensor ‘MT_STOP_’i està sobre color negre. En cas
d’estar sobre color blanc retornarà un 0 o valor negatiu.

Exemple El següent codi farà que el cotxe giri a la dreta, a l’esquerra o vagi recte en
funció del que detectin els sensors. Concretament, si tots els sensors detecten
color negre, el cotxe girarà a la dreta. En cas contrari, si el sensor del mig
detecta blanc (valguin el que valguin els altres), seguirà recte. En cas contrari, el
cotxe girarà a l’esquerra.

if(LS_MT_IsStop(MT_STOP_0)>0 && LS_MT_IsStop(MT_STOP_1)>0
&& LS_MT_IsStop(MT_STOP_2)>0){
//Si tots els sensors negres, girem a la dreta
}else{
// Sinó...
if(LS_MT_IsStop(MT_STOP_1)<=0){
// ...Si el sensor del mig esta sobre blanc, avancem
}else{
// Sinó girem a l‟esquerra.
}
}

Funció char GetS(unsigned int MaskStop);

Codi char GetS(unsigned int MaskStop) {
// Retorna Blanc o Negre segons el que valgui el sensor
if (LS_MT_IsStop(MaskStop)>0) return 'N';
return 'B';
}

Explicació Aquesta funció està creada a partir de l’operació LS_MT_IsStop explicada
anteriorment, i serveix per facilitar la feina a l’hora de comprovar els valors dels
sensors. Indica també el color sobre el que està el sensor indicat.

36

Programació

AQUESTA FUNCIÓ NO ESTÀ INCLOSA DINS DE LA API DE L’LSMAKER. SI ES VOL
FER ÚS CAL COPIAR EL CODI DE LA FUNCIÓ DINS EL CODI DE L’ARXIU DEL MAIN.

Arguments MaskStop: De la mateixa manera com s’ha explicat anteriorment amb la funció
LS_MT_IsStop, aquest paràmetre indica el sensor que es vol comprovar. Si es
vol consultar el sensor esquerre valdrà ‘MT_STOP_0’, el del mig ‘MT_STOP_1’ i
el de la dreta ‘MT_STOP_2’.

Retorn Retorna un caràcter: ‘N’ si el sensor està sobre negre i ‘B’ en cas contrari.

Exemple El següent codi és l’equivalent al codi de l’exemple anterior però fent ús de
l’operació GetS:

if(GetS(MT_STOP_0)==‟N‟ && GetS(MT_STOP_1)==‟N‟ && GetS(MT_STOP_2)==‟N‟){
//Si tots els sensors negres, girem a la dreta
}else{
// Sinó...
if(GetS(MT_STOP_1)==‟B‟){
// ...Si el sensor del mig esta sobre blanc, avancem
}else{
// Sinó girem a l‟esquerra.
}
}

37

Programació

f) Operacions de sistema – els “timmers”

Entre les operacions de sistema trobem unes de molt importants que són les de “timmer”.
Aquestes funcions serveixen per calcular temps transcorreguts, de manera que es pugui fer un
control del temps en el codi de l’LSMaker.

L’LSMaker disposa de diversos timmers, de manera que es pot fer un control de diferents
elements temporals en el mateix moment.

Totes les operacions de timmer s’han d’utilitzar d’una manera “conjunta”, de manera que
l’exemple de les funcions s’indicarà al final de tot de l’explicació de les diferents operacions.

Operació int LS_SYS_OpenTimer (void);

Explicació Aquesta operació serveix per demanar un dels timmers disponibles de
l’LSMaker.


Retorn Aquesta operació retorna un valor enter positiu identificant el timmer que hi ha
disponible. En cas que no hi hagi cap timmer disponible (quan s’hagin gastat
tots) retornarà un valor -1.

Operació void LS_SYS_ResetTics (unsigned char Timer);

Explicació Aquesta operació serveix per resetejar el timmer que tenim disponible. És com
si a un cronòmetre preméssim el botó de reiniciar.

Arguments Cal indicar quin és el timmer al qual se li vol resetejar el temps, que haurà de ser
un que tinguem disponible gràcies a haver executat l’operació
LS_SYS_OpenTimer ().

Retorn No hi ha un valor de retorn.

Operació unsigned int LS_SYS_GetTics (unsigned char Timer);

Explicació Aquesta operació serveix per consular el temps que ha transcorregut en el
timmer disponible des de l’últim cop que es va fer un ResetTics. És
imprescindible que, abans d’executar aquesta operació de consulta de temps,
s’hagi fet algun reset per iniciar el timmer.

Nota: Degut a restriccions de l’LSMaker, els timmers no poden comptar més
enllà de 30 segons. Així doncs, si es volgués comptar més de 30 segons caldrà
fer algun tipus de control del temps, acumular temps en variables, etc.

Arguments Cal indicar com a argument el timmer que volem consultar, que serà un dels
que tinguem disponibles.

Retorn Retorna un enter que indica el nombre de milisegons transcorreguts des de
l’últim cop que es va fer un reset en el timmer indicat.
38

Programació

Operació void LS_SYS_CloseTimer (unsigned char Timer);

Explicació Aquesta operació serveix per finalitzar l’ús del timmer. És important executar-la
quan ja no es necessiti fer ús del timmer o quan finalitzi el codi, ja que el fet de
no alliberar els timmers pot ser motiu de que l’operació LS_SYS_OpenTimer ()
retorni un valor negatiu indicant que no hi ha timmers disponibles.

Arguments Cal indicar com a argument el timmer que volem consultar, que serà un dels
que tinguem disponibles.

Retorn No hi ha un valor de retorn.

Exemple

Exemple d’ús de timmers

El següent exemple mostra un codi que demana un timmer i calcula el temps que es triga fins
que es prem el botó gp de l’LSMaker ( la funció LS_IO_GpButtonPress() s’explicarà a
l’apartat ‘f’, però bàsicament retorna ‘cert’ si s’ha premut el botó gp).
int tim, t;

// Es demana un timmer, guardant el número a „tim‟.
tim = LS_SYS_OpenTimer ();

// Reset del temps del timmer adquirit anteriorment.
LS_SYS_ResetTics (tim);

// Mentre no es premi el botó gp, espera (no fa res).

// Es demana el temps que ha transcorregut des del reset del timmer „tim‟.
t = LS_SYS_GetTics (tim);

// Quan no s‟ha d‟utilitzar més el timmer, l‟alliberem.
LS_SYS_CloseTimer (tim);

// Es mostra el temps transcorregut a la pantalla LCD de l‟LSMaker.
LS_LCD_Printf(0, 0, "Temps %d",t);

39

Programació

g) Operacions de comunicació USB

Les operacions de comunicació USB són aquelles que permeten a l’usuari interactuar amb
l’LSMaker mitjançant el teclat i la pantalla. D’aquesta manera, l’usuari pot enviar missatges en
forma de cadena cap a l’LSMaker perquè aquest els processi. De la mateixa manera, l’LSMaker
podrà enviar missatges cap al PC que es mostraran a la consola de l’LSLoader. Serà la manera
que oferirà l’LSMaker per comunicar-nos amb ell a part del botó ‘gp’.

Operació unsigned int LS_USB_printf(const char *, ...);

Explicació Aquesta operació fa que es mostri un cert missatge a la consola de l’LSLoader
del PC, sempre i quan l’LSMaker estigui connectat al PC via USB.

Arguments Els arguments que rep aquesta operació segueixen el mateix format que els
arguments d’un printf.

Retorn El valor de retorn no és rellevant.

Exemple El següent codi fa que es mostri a la consola de l’LSLoader la cadena constant
“Edat” i, a continuació, el valor de la variable ed:

LS_USB_printf(“Edat: %d”,ed);

Operació unsigned int LS_USB_gets(char *buffer, ...) ;

Explicació Aquesta operació captura tots els caràcters que s’escriuen a la consola de
l’LSMaker fins que es prem enter, sempre i quan l’LSMaker estigui connectat al
PC via USB. L’LSMaker ho captura tot com una cadena de caràcters, contingui el
que contingui, de manera que s’haurà de fer un parcejat d’aquesta si s’escau.

Aquesta operació realitza una espera mentre no hi hagi dades que capturar de
teclat.

Arguments buffer: És una cadena de caràcters que contindrà la informació que es capturi
del teclat.

Retorn El valor de retorn no és rellevant.

Exemple El següent codi captura una frase via USB i la mostra a l’LCD:

char cad[100];

LS_USB_gets(cad);

Operació char LS_USB_getc(void);

Explicació Aquesta operació té una utilitat semblant a la anterior, amb la diferència que
només captura (retorna) un caràcter escrit a la consola de l’LSLoader i, més
important, que no espera a que es premi la tecla ‘enter’, sinó que captura
40

Programació

directament el caràcter escrit.


Retorn Aquesta operació retorna el caràcter que s’ha premut a la consola de
l’LSLoader.

Exemple El següent codi mostra com es captura un caràcter de la consola de l’LSLoader i,
posteriorment, realitza una acció diferent si era una tecla o una altra.

char c;

// Es captura un caràcter escrit per teclat
c = LS_USB_getc();

// En funció del caràcter premut es fa una acció o una altra.
if(c=='W' || c=='w'){
LS_LCD_Printf(0, 0, "Endavant");
}else if(c=='S' || c=='s'){
LS_LCD_Printf(0, 0, "Endarrere");
}else{
LS_LCD_Printf(0, 0, "Altre");
}

Operació int LS_USB_CharAvailable(void);

Explicació Cal tenir en compte que tot el que s’escriu per teclat a la consola de l’LSLoader
quan l’LSMaker està connectat al PC via USB queda pendent de ser llegit. Per
tant, és possible que en certs moments hi hagi caràcters esperant a ser llegits, ja
sigui amb l’operació LS_USB_getc o amb la LS_USB_gets. L’operació
LS_USB_CharAvailable indica el nombre de caràcters pendents de ser llegits.


Retorn Retorna un enter que indica el nombre de caràcters a ser llegits.

Exemple El següent codi d’exemple mostra com es comproven el nombre de caràcters
que hi ha pendents de llegir i ho mostra a la consola de l’LSLoader.
Posteriorment es podrà (o no) fer alguna acció per llegir-los i processar-los.

int pend;

pend = LS_USB_CharAvailable();
LS_USB_printf("nPendents: %dn",pend);

Exemple

Exemple amb diferents instruccions de comunicació USB

41

Programació

El següent codi mostra com, inicialment, l’LSMaker indica al PC que escrigui alguna cosa.
Després captura el que s’ha escrit per teclat, ho mostra a la pantalla LCD i ho retorna al PC
com a confirmació a l’usuari. Posteriorment l’LSMaker s’espera a rebre el caràcter ‘c’ per
continuar la seva execució.

char cad[100];

// Es mostra el missatge a la consola de l’LSLoader.
LS_USB_printf("Escriu alguna cosa!n");

// Es captura la cadena de caràcters que s‟ha escrit a la consola.
LS_USB_gets(cad);

// Es retorna el que s‟ha escrit a la consola.
LS_USB_printf("nHas escrit: %sn",cad);

// Es mostra el missatge per la pantalla LCD de l‟LSMaker

// Mentre el caràcter que es premi per teclat sigui diferent de „c‟, no fa res
while(LS_USB_getc()!='c'){}
LS_USB_printf("nContinua l'execución",cad);
// ...

Es pot veure un exemple de resultat d’aquest codi a la imatge següent (també es mostraria el
missatge “Hola!” a la pantalla LCD).

42

Programació

h) Operacions miscel·lànies importants

En aquest apartat s’expliquen algunes operacions de temàtica variada que és important
conèixer i que poden resultar molt necessàries per fer segons quines tasques amb l’LSMaker.

Operació int LS_IO_GpButtonPress();

Explicació Operació que indica si s’ha premut o no el botó “GpButton” de l’LSMaker. És
molt útil per realitzar programes en els que, per iniciar alguna tasca, calgui
prémer el botó ‘gp’.


Retorn Retorna un valor positiu si s’ha premut el botó GPButton. En cas contrari
retorna 0 o un valor negatiu.

Exemple El següent codi mostrarà per pantalla el text “Prem GP” i, posteriorment,
s’esperarà a que es premi aquest botó. Per fer-ho, com a condició d’un bucle
tenim que mentre no es premi el botó (!LS_IO_GpButtonPress()). Per tant, quan
sortim del bucle voldrà dir que la condició de manteniment ja no és certa i, per
tant, que s’ha premut el botó.

//Fem una espera activa mentre no premin el botó gp.
LS_LCD_Printf(0, 1, "Prem GP");
while (!LS_IO_GpButtonPress()) {
// No fem res, simplement esperem a que es premi el botó
}
LS_LCD_Printf(0, 1, "Has premut GP!");

Operació void LS_SYS_SleepSecs(unsigned int Seconds);

Explicació Aquesta operació serveix per realitzar una espera en el codi de l’LSMaker (a
imatge i semblança del que fa l’operació sleep en C).

Arguments Seconds: Indica el nombre de segons que es vol fer esperar.

Retorn No té cap valor de retorn.

Exemple El següent codi mostra un exemple de com fer un compte enrere a la pantalla
LCD de l’LSMaker:

LS_LCD_Printf(0, 0, "3...");
LS_LCD_Clear();
LS_LCD_Printf(0, 0, "2...");
LS_LCD_Clear();
LS_LCD_Printf(0, 0, "1...");
LS_LCD_Clear();
LS_LCD_Printf(0, 0, "0...");
LS_LCD_Clear();

43

Programació

Operació void LS_SYS_SleepMiliSecs(unsigned int MiliSeconds);

Explicació Aquesta operació serveix per realitzar una espera en el codi de l’LSMaker (a
imatge i semblança del que fa l’operació sleep en C).

Arguments MiliSeconds: Indica el nombre de milisegons que es vol fer esperar.


Exemple El següent codi mostra un exemple de com fer un compte enrere a la pantalla
LCD de l’LSMaker però amb esperes de milisegons:

LS_LCD_Printf(0, 0, "3...");
LS_LCD_Clear();
LS_LCD_Printf(0, 0, "2...");
LS_LCD_Clear();
LS_LCD_Printf(0, 0, "1...");
LS_LCD_Clear();
LS_LCD_Printf(0, 0, "0...");
LS_LCD_Clear();

Operació void LS_IO_SetLedBeat(int Beat);

Explicació Aquesta operació serveix per modificar la freqüència dels leds que incorpora
l'LSMaker als seus costats.

Arguments Beat: Indica la freqüència de pulsació en dècimes d'Hz, on 0 indicarà que els leds
estaran apagats, valors iguals o superiors a 40 indicaran que els leds estaran
permanentment encesos i els valors intermedis faran que hi hagi intermitència
(Exemple: Beat = 20 vol dir 2Hz).


Exemple El següent codi mostra un exemple de com canviar la freqüència dels leds de 20
a 35 quan es prem el botó GP:

//Fem una espera activa mentre no premin el botó Gp.
LS_IO_SetLedBeat(20);
while (!LS_IO_GpButtonPress()) {
// No fem res, simplement esperem a que es premi el botó
}

Operació int LS_SYS_GetBatteryVoltage(void);

Explicació Aquesta operació ens indica la tensió de la bateria. Quan l’LSMaker està
connectat a la xarxa elèctrica, aquesta operació retorna un valor 100.


Retorn Retorna un enter entre 0 i 100 que indica la tensió de la bateria amb un
44

Programació

decimal, essent 0 la tensió mínima (0.0 V) i 100 la màxima (10.0 V).

Exemple El següent codi mostra un exemple de com fer un programa que només faci
certes accions si el nivell de bateria és superior a 5V i que en cas contrari mostri
un error a la pantalla LCD:

//Fem una espera activa mentre no premin el botó Gp.
if(LS_SYS_GetBatteryVoltage() > 50) {
// Accions de moviment, motor en general, ...
}else{
LS_LCD_Printf(0, 0, "No hi ha prou càrrega a la bateria");
}

Operació int LS_ACC_Tap (void);

Explicació Aquesta operació serveix per detectar canvis abruptes però petits en l’LSMaker,
com podria ser un cop no gaire fort. D’aquesta manera podem detectar si
alguna cosa li dona un cop a l’LSMaker. Al contrari, actualment, no es pot, ja
que si l’LSMaker es mou, la pròpia vibració dels motors i de l’oruga de les rodes
fan que sempre s’activi.

Cal tenir en compte que el Tap no és molt precís i pot donar “rebots”, que vol
dir que un petit cop que fa que s’activi el Tap (que retorni cert) provoqui que el
valor sigui cert durant més d’una comprovació.


Retorn Retorna cert (un valor enter positiu) si detecta un Tap. En cas que no el detecti,
retorna fals ( un valor negatiu o 0).

Operació int LS_ACC_Shake(void);

Explicació Aquesta operació té el mateix funcionament que l’operació LS_ACC_Tap però
detecta sacsejades enlloc de petits cops abruptes. Té els mateixos problemes de
funcionament que l’operació anterior en quant a que no es pot usar quan
l’LSMaker es mou i que el cert d’una sacsejada pot aparèixer diversos cops.


Retorn Retorna cert (un valor enter positiu) si detecta un Shake. En cas que no el
detecti, retorna fals ( un valor negatiu o 0).

Exemple de Tap i Shake

45

Programació

Amb el següent codi, l’LSMaker esperarà a rebre un Tap o un Shake. Fins que alguna
d’aquestes dues funcions no retorni cert no sortirà del bucle. Un cop surti s’indicarà el motiu
de sortida a la pantalla LCD.

int exit;

exit = 0;
while(!exit){
if(LS_ACC_Shake()) exit=1;
else if(LS_ACC_Tap()) exit = 2;
}
if(exit==1) LS_LCD_Printf(0, 0, "Shake!");
else LS_LCD_Printf(0, 0, "Tap!");

Funció int LS_SYS_PowerOff(void);

Explicació Aquesta operació serveix per apagar l’alimentació de l’LSMaker (el mateix que
s’aconsegueix prement el botó OFF de la part posterior d’aquest).
Cal tenir en compte que, si s’apaga el robot, el codi es deixarà d’executar
automàticament.


Retorn No hi ha valor de retorn (no te sentit que hi hagi, el robot s’haurà apagat i el
codi es deixarà d’executar).

Exemple El codi següent mostra un exemple d’”estalvi d’energia”, donat que si la bateria
del robot és menor a 50 (5V), s’apaga automàticament:
int bateria;

bateria = LS_SYS_GetBatteryVoltage();
if( bateria < 50 ){
LS_SYS_PowerOff();
}

Funció void LS_ACC_GetPosXYZf(float *X, float *Y, float *Z);

Explicació Aquesta operació ens retorna les dades X, Y i Z de l’acceleròmetre que duu
l’LSMaker. Mitjançant aquesta operació es pot saber com està situat l’LSMaker.
Cal tenir en compte que per executar aquesta operació s’han de passar les
variables de tipus float per referència (simplement posant un ‘&’ davant de la
variable).

Cal tenir en compte també que la precisió de l’acceleròmetre no es gaire bona.
De fet, és possible que certs cops retorni valors superiors a 90 (en mòdul, com
per exemple els valors 91, -92, etc). Cal controlar els valors que retorna i fer els
programes que depenguin de l’acceleròmetre amb una mica de marge (no es
pot intentar ser molt precís).

Arguments X: (punter a real): Indica la inclinació de l’LSMaker seguint l’eix longitudinal de
l’LSMaker, és adir, la recta que equival al costat llarg del rectangle de la placa

46

Programació

base. En posició plana, el valor de la X tendirà a 0. Si la part frontal de l’LSMaker
(on NO hi ha la pantalla LCD) s’eleva, el valor de la X serà negativa, major quan
més inclinat estigui. Pel contrari, si la part frontal descendeix, el valor serà
positiu i, quan més inclinat, major.

Y: (punter a real): Indica la inclinació de l’LSMaker seguint l’eix transversal de
l’LSMaker, és adir, la recta que equival al costat petit del rectangle de la placa
base. En posició plana, el valor de la Y tendirà a 0. Si la part esquerra (on hi ha
la toma d’alimentació) de s’eleva, el valor de la Y serà negativa, major quan més
inclinat estigui. Pel contrari, si la part dreta (on hi ha els polsadors d’on/off/gp)
s’eleva, el valor serà positiu i, quan més inclinat, major.

Z: (punter a real): Indica si l’LSMaker està boca amunt (valors positius) o boca
avall (valors negatius).

Retorn No hi ha valor de retorn, es modifiquen les variables per referència.

Exemple El codi següent mostra un exemple en el que, si l‟LSMaker troba
una inclinació amunt poc pronunciada, accelera. Si la inclinació
és amunt i molt pronunciada, fa marxa enrere. En cas que la
inclinació sigui avall també fa marxa enrere.

float X,Y,Z;

X=0.0; Y=0.0; Z=0.0;
LS_ACC_GetPosXYZf(&X,&Y,&Z);
if(X > 5){
// Si s‟inclina avall, marxa enrere.
// (es posa 5º per la pèrdua de precisió).
LS_MT_Lineal(90, -80, 0, &stop);
}else if(X < 0 && X > -40){
// Si la inclinació es amunt i poc pronunciada, avança.
LS_MT_Lineal(90, 80, 0, &stop);
}else if(X < -40){
// Si la inclinació es amunt i molt pronunciada, enrere.
LS_MT_Lineal(90, -80, 0, &stop);
}else{
// Si està en pla avança més lent
LS_MT_Lineal(90, 40, 0, &stop);
}

A les imatges que hi ha a continuació es mostra gràficament el comportament
de l’acceleròmetre en funció de les inclinacions en l’eix X i Y.

47

Programació

48

Programació

El control dels sensors

L'LSMaker incorpora, a la part inferior davantera, tres sensors de color (detecten blanc o
negre) que permeten fer un control del moviment del robot. Es pot fer que el cotxe només es
mogui per terrenys blancs o negres, que canviï el comportament si detecta blanc o negre, etc.

Com s'ha vist, existeixen diferents operacions que serveixen per controlar els colors que
detecten els sensors o que poden canviar el comportament en funció del color que es detecta.

Les operacions que poden canviar el comportament en funció del color que es detecta són les
de moviment, concretament la LS_MT_Lineal, la LS_MT_TurnRight i la LS_MT_TurnLeft.
Aquestes poden canviar el comportament (concretament, parar el moviment) mitjançant el
paràmetre StopBits, on s'indicarà la condició de finalització del moviment. Concretament
espera rebre una constant o una condició múltiple de constants concretes. Aquestes constants
són les següents:

 MT_STOP_0: Constant que controla el sensor de l'esquerra de l'LSMaker.
49

Programació

 MT_STOP_1: Constant que controla el sensor central de l'LSMaker.
 MT_STOP_2: Constant que controla el sensor de la dreta de l'LSMaker.

Aquestes constants tenen un valor concret que serveixen per controlar condicions sobre
cadascun dels sensors. El que es busca és que les condicions s’activin quan un sensor
determinat detecti un cert color. Però quan s’activarà? Quan detecti blanc o quan detecti
negre? Doncs això es pot controlar fent ús de la funció LS_MT_SetNivellStopBits.
Amb això s’aconsegueix determinar si es vol que la condició de parada es doni quan un sensor
detecti blanc o negre. Com s’ha explicat a l’apartat d’operacions de motor, si s’estableix un 0 la
condició s’activarà quan el sensor detecti un blanc (es mourà mentre vegi negre). Pel contrari,
si s’estableix un 1, la condició s’activarà quan es detecti negre.

Per veure amb claredat el seu funcionament s'analitzaran diversos exemples:

LS_MT_Lineal(0,100, MT_STOP_1,&stop);

El que fa aquesta operació és fer avançar el robot recte "per sempre" (temps 0 indica temps
infinit), mentre no es compleixi la condició MT_STOP_1. I quan es complirà aquesta condició?
Doncs quan s’activi la condició del sensor central (hem indicat MT_STOP_1, que és la constant
que controla el sensor central). En aquest cas quan s’activarà? Doncs no es pot saber, ja que
no s’ha fet ús de l’operació LS_MT_SetNivellStopBits(), tot i que es pot suposar que
per defecte s’activa amb negre. Per no fer suposicions, donem per fet que abans de l’operació
de moviment recte hi hagi la següent crida, establint que les condicions s’activin per negre:


Dit això per tant, si inicialment l'LSMaker està situat en una superfície que fa que el sensor
central detecti negre, ja no es mourà. Si, pel contrari, el sensor central detecta blanc, el robot
es mourà mentre aquest no detecti color negre.

En cas que el moviment es pari, a la variable entera stop hi haurà el motiu pel qual s'ha aturat
el robot. En aquest cas està clar que el motiu serà segur que el sensor central ha detectat
negre, però en d'altres casos ens pot interessar saber que ha passat. En aquest cas, doncs,
stop tindrà el valor concret MT_STOP_1.

LS_MT_Lineal(0,100, MT_STOP_0| MT_STOP_1| MT_STOP_2,&stop);

El que fa aquesta operació és fer avançar el robot recte "per sempre" (temps 0 indica temps
infinit), mentre no es compleixi la condició (MT_STOP_0| MT_STOP_1| MT_STOP_2). En
aquesta manera de treballar en concret, per fer una condició on volem que es compleixi
alguna subcondició, ho haurem de fer amb l'operador '|', que equival a una 'OR' lògica. Quan
es complirà doncs aquesta condició? Doncs quan algun dels tres sensors de l'LSMaker
detectin color negre (només amb 1 sensor que detecti negre l’operació pararà, i ha de ser
color negre perquè s’ha indicat anteriorment establint el nivell d’stopbits).

Un cop el robot es pari, es pot comprovar per què s'ha aturat el robot gràcies a la variable
stop. Comprovant el seu valor podrem saber quin és el sensor que s'ha activat. Per exemple:

if ( stop == MT_STOP_0 ){
50

Programació
// S'ha aturat perquè el sensor esquerre ha detectat negre.
// ...
}else if ( stop == MT_STOP_1 ){
//S'ha aturat perquè el sensor central ha detectat negre.
// ...
}else ...

}else if( stop == MT_STOP_0 | MT_STOP_1 ){
// S'ha aturat perquè els sensors esquerre i central han detectat negre
// al mateix moment
}

En l’exemple anterior s’ha vist com fer que el robot es mogui mentre tots els sensors vegin el
color actiu (a la que un sensor vegi el color contrari es pararà). Però, com es pot fer que el
robot només es pari quan els tres sensors detectin el color contrari? No es pot fer només amb
una operació de moviment, caldrà pensar alguna forma de combinar-les d’una manera
“elegant”. A continuació es mostra com es fa aquest cas i després s’explicarà perquè funciona:

while(LS_MT_Lineal(0, 70, MT_STOP_0, &stop) || LS_MT_Lineal(0, 70, MT_STOP_1,
&stop) || LS_MT_Lineal(0, 70, MT_STOP_2, &stop)){}

El que està fent el bucle superior, llegint tal i com funciona un bucle és, “mentre la condició de
moviment 1 o la condició 2 o la condició 3 siguin certes fer res”. Que aconseguim amb això?
Doncs el que el codi fa és moure el robot gràcies a la condició de manteniment del bucle. El
que passa és que la condició de manteniment ja fa que el cotxe es mogui recte gràcies a
alguna de les 3 condicions de manteniment del bucle (cal tenir en compte que si una de les
operacions de moviment no s’executa, aquesta retornarà un zero). D’aquesta manera, si, per
exemple, la primera subcondició del bucle retorna 0 voldrà dir que el sensor 0 (el de
l’esquerra) veu el color contrari. Si el sensor central també veu el color contrari, també
retornarà un 0. Si el tercer sensor també veu el color contrari retornarà un altre 0 i, llavors,
com cap de les tres condicions de manteniment del bucle es complirà, es finalitzarà el bucle i,
per tant, l’LSMaker s’aturarà. És a dir, només cal que una de les subcondicions sigui certa (vegi
el color correcte) perquè l’LSMaker es mogui. Així doncs s’aconsegueix el que s’havia
proposat, que el cotxe es mogui sempre fins que els tres sensors detectin el color actiu.

En les operacions de gir el funcionament és exactament el mateix que en les de moviment
recte que s'han utilitzat en els exemples.

Així doncs, és mitjançant les constants la única manera que hi ha de controlar els sensors de
l'LSMaker? No. Es pot controlar també el control del robot mitjançant d'altres funcions o
combinant aquestes funcions amb l'ús de constants en les operacions de moviment.

La alternativa "senzilla" a l'ús de les constants pel control dels sensors és utilitzar la funció
GetS. Recordem que aquesta funció ha de rebre com a paràmetre una constant identificativa
del sensor i retorna un caràcter 'B' si aquest sensor està detectant blanc o 'N' en cas contrari.
Observem com podem realitzar codis "equivalents" als exemples anteriors a continuació:

while(GetS(MT_STOP_1)=='B'){
}

El que fa aquest codi és realitzar petits moviments rectes (de 50 milisegons de durada) de
51

Programació

l'LSMaker mentre el sensor central (MT_STOP_1) detecti blanc. Indicant un 0 a les condicions
d'stop volem dir que el robot no s'ha d'aturar detecti el que detecti. Per tant, vindria a ser
equivalent al primer exemple explicat fent ús de les constants, amb la diferència que no
comprovem el valor del sensor fins que no ha finalitzat l’operació de moviment, que en el cas
de l'exemple són 50 milisegons.

Nota: Tot i que no fem ús de les constants a l'hora d'aturar el moviment, si que és necessari
passar una variable entera per referència (posant un '&' davant) com a últim paràmetre.

El segon exemple feia que el robot es mogués mentre tots els sensors detectessin blanc, és a
dir, a la que un sensor detectés negre el robot aturaria el seu moviment. L'equivalent a aquest
segon exemple fent ús de la funció GetS és el següent:

while (GetS(MT_STOP_0)=='B' && GetS(MT_STOP_1)=='B' && GetS(MT_STOP_2)=='B' ){
}

Quan aquest bucle finalitzi la seva execució voldrà dir que ja no es compleix la condició de
manteniment i, per tant, que no tots els sensors veuen blanc, és a dir, que algun veu negre.
Igual que en el segon exemple explicat abans es podia comprovar el motiu d'aturada, ara
també es pot comprovar utilitzant la pròpia funció GetS:

if ( GetS(MT_STOP_0)=='N'){
// S'ha aturat perquè el sensor esquerre ha detectat negre.
// ...
}else if ( GetS(MT_STOP_1)=='N' ){ S'ha aturat perquè el sensor central ha
detectat negre.
// ...
}else ...

}else if( GetS(MT_STOP_0)=='N' && GetS(MT_STOP_1)=='N' ){
// S'ha aturat perquè els sensors esquerre i central han detectat negre
// al mateix moment
}

El tercer exemple utilitzant les operacions de moviment feia que el cotxe es mogués mentre
els tres sensors veiessin el color correcte. Fent ús de la funció GetS el tema sembla més fàcil
(o més clar de comprendre):

while (GetS(MT_STOP_0)=='B' || GetS(MT_STOP_1)=='B' || GetS(MT_STOP_2)=='B' ){
}

Com veiem, només cal canviar les ‘&&’ de l’exemple anterior per ‘||’, fent que només que
una de les subcondicions sigui certa el cotxe es mantingui en moviment.

Així doncs s'ha vist que és possible realitzar el control del moviment en funció del que veuen
els sensors de diferents maneres. També es pot fer un control de moviment que incorpori les
dues maneres de controlar els sensors, ja sigui a l'hora de comprovar per que s'ha aturat el
robot o de fer que es mogui. Comprovem-ho en el següent exemple:

while (GetS(MT_STOP_0)=='N' && GetS(MT_STOP_1)=='N' && GetS(MT_STOP_2)=='N' ){
}

52

Programació
if(GetS(MT_STOP_0)=='B'){ // El sensor esquerre està sobre blanc
LS_MT_TurnRight(0,60,0, MT_STOP_0,&stop);
}
...

El que fa aquest codi és avançar recte mentre els tres sensors de l'LSMaker vegin negre. Quan
es surti del bucle inicial voldrà dir que hi ha algun sensor que veu blanc. El primer condicional
comprova si és el sensor esquerre el que està en blanc i, en aquest cas, el que fa és fer girar el
robot a la dreta sobre si mateix (angle 0) fins que s'activi la condició MT_STOP_0, que
recordem que serà quan el sensor esquerre detecti negre.

53

LSMaker API documentation v0.0

LSMaker API documentation v0.0

Recommended

Recommended

More Related Content

Similar to LSMaker API documentation v0.0

Similar to LSMaker API documentation v0.0 (20)

LSMaker API documentation v0.0