LSMaker API documentation v0.0

68
Documentació LS Maker Programació 1 Í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

description

LSMaker API Documentation v. 0.0

Transcript of LSMaker API documentation v0.0

Page 1: LSMaker API documentation v0.0

Documentació LS Maker

Programació

1

Í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

Page 2: LSMaker API documentation v0.0

Documentació LS Maker

Programació

2

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:

Page 3: LSMaker API documentation v0.0

Documentació LS Maker

Programació

3

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:

Page 4: LSMaker API documentation v0.0

Documentació LS Maker

Programació

4

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:

Page 5: LSMaker API documentation v0.0

Documentació LS Maker

Programació

5

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:

Page 6: LSMaker API documentation v0.0

Documentació LS Maker

Programació

6

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:

Page 7: LSMaker API documentation v0.0

Documentació LS Maker

Programació

7

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:

Page 8: LSMaker API documentation v0.0

Documentació LS Maker

Programació

8

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:

Page 9: LSMaker API documentation v0.0

Documentació LS Maker

Programació

9

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.

Page 10: LSMaker API documentation v0.0

Documentació LS Maker

Programació

10

Page 11: LSMaker API documentation v0.0

Documentació LS Maker

Programació

11

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.

Page 12: LSMaker API documentation v0.0

Documentació LS Maker

Programació

12

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

Page 13: LSMaker API documentation v0.0

Documentació LS Maker

Programació

13

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

Page 14: LSMaker API documentation v0.0

Documentació LS Maker

Programació

14

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:

Page 15: LSMaker API documentation v0.0

Documentació LS Maker

Programació

15

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.

Page 16: LSMaker API documentation v0.0

Documentació LS Maker

Programació

16

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 "Programari\LSLoader". 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).

Page 17: LSMaker API documentation v0.0

Documentació LS Maker

Programació

17

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.

Page 18: LSMaker API documentation v0.0

Documentació LS Maker

Programació

18

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

Page 19: LSMaker API documentation v0.0

Documentació LS Maker

Programació

19

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

Page 20: LSMaker API documentation v0.0

Documentació LS Maker

Programació

20

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

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

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.

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

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

Page 21: LSMaker API documentation v0.0

Documentació LS Maker

Programació

21

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

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

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.

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

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

Page 22: LSMaker API documentation v0.0

Documentació LS Maker

Programació

22

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.

Page 23: LSMaker API documentation v0.0

Documentació LS Maker

Programació

23

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

Page 24: LSMaker API documentation v0.0

Documentació LS Maker

Programació

24

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.

Page 25: LSMaker API documentation v0.0

Documentació LS Maker

Programació

25

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.

Retorn No hi ha cap retorn.

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

Page 26: LSMaker API documentation v0.0

Documentació LS Maker

Programació

26

si no se li indica expressament una altra posició.

Arguments No hi ha arguments.

Retorn No hi ha cap retorn.

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.

Arguments No hi ha arguments.

Retorn No hi ha cap retorn.

Exemple Crida a la funció:

LS_LCD_CursorOn();

Page 27: LSMaker API documentation v0.0

Documentació LS Maker

Programació

27

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.

Page 28: LSMaker API documentation v0.0

Documentació LS Maker

Programació

28

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

}

Page 29: LSMaker API documentation v0.0

Documentació LS Maker

Programació

29

}

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.

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.

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

}

LS_LCD_Printf(0, 0, "%s",cad);

Operació int LS_NVOL_Close(int HANDLE);

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

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

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

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

Page 30: LSMaker API documentation v0.0

Documentació LS Maker

Programació

30

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.

Arguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna 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: %d\n”,ed);

Page 31: LSMaker API documentation v0.0

Documentació LS Maker

Programació

31

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: %d\n”,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

Page 32: LSMaker API documentation v0.0

Documentació LS Maker

Programació

32

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.

while(!LS_IO_GpButtonPress()){}

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

Page 33: LSMaker API documentation v0.0

Documentació LS Maker

Programació

33

// hand, la cadena i el nombre de caràcters d‟aquesta(7, 6 de la paraula temps

// + 1 de \n)

LS_NVOL_Write(hand, “Agenda\n”, 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.

h = LS_NVOL_Open(NVOL_STREAM_B, "r");

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

LS_LCD_Printf(0, 0, "%s",cad);

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

LS_SYS_SleepSecs(2);

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

LS_LCD_Printf(0, 0, "%s",cad);

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

Page 34: LSMaker API documentation v0.0

Documentació LS Maker

Programació

34

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

h = LS_NVOL_Open(NVOL_STREAM_B, "r");

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

LS_LCD_Printf(0, 0, "%s",cad);

LS_SYS_SleepSecs(2);

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

Page 35: LSMaker API documentation v0.0

Documentació LS Maker

Programació

35

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_Lineal(1000,100,0,&stop);

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

Page 36: LSMaker API documentation v0.0

Documentació LS Maker

Programació

36

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

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

}else{

// Sinó...

if(LS_MT_IsStop(MT_STOP_1)<=0){

// ...Si el sensor del mig esta sobre blanc, avancem

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

}else{

// Sinó girem a l‟esquerra.

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

}

}

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.

Page 37: LSMaker API documentation v0.0

Documentació LS Maker

Programació

37

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

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

}else{

// Sinó...

if(GetS(MT_STOP_1)==‟B‟){

// ...Si el sensor del mig esta sobre blanc, avancem

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

}else{

// Sinó girem a l‟esquerra.

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

}

}

Page 38: LSMaker API documentation v0.0

Documentació LS Maker

Programació

38

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.

Arguments No hi ha arguments.

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.

Page 39: LSMaker API documentation v0.0

Documentació LS Maker

Programació

39

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

while(!LS_IO_GpButtonPress()){}

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

Page 40: LSMaker API documentation v0.0

Documentació LS Maker

Programació

40

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

LS_LCD_Printf(0, 0, "%s",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

Page 41: LSMaker API documentation v0.0

Documentació LS Maker

Programació

41

directament el caràcter escrit.

Arguments No hi ha arguments.

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.

Arguments No hi ha arguments.

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: %d\n",pend);

Exemple

Exemple amb diferents instruccions de comunicació USB

Page 42: LSMaker API documentation v0.0

Documentació LS Maker

Programació

42

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: %s\n",cad);

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

LS_LCD_Printf(0, 0, "%s",cad);

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

Page 43: LSMaker API documentation v0.0

Documentació LS Maker

Programació

43

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

Arguments No hi ha arguments.

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_SYS_SleepSecs(1);

LS_LCD_Clear();

LS_LCD_Printf(0, 0, "2...");

LS_SYS_SleepSecs(1);

LS_LCD_Clear();

LS_LCD_Printf(0, 0, "1...");

LS_SYS_SleepSecs(1);

LS_LCD_Clear();

LS_LCD_Printf(0, 0, "0...");

LS_SYS_SleepSecs(1);

LS_LCD_Clear();

Page 44: LSMaker API documentation v0.0

Documentació LS Maker

Programació

44

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.

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 però amb esperes de milisegons: LS_LCD_Printf(0, 0, "3...");

LS_SYS_SleepSecs(1000);

LS_LCD_Clear();

LS_LCD_Printf(0, 0, "2...");

LS_SYS_SleepSecs(1000);

LS_LCD_Clear();

LS_LCD_Printf(0, 0, "1...");

LS_SYS_SleepSecs(1000);

LS_LCD_Clear();

LS_LCD_Printf(0, 0, "0...");

LS_SYS_SleepSecs(1000);

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

Retorn No té cap valor de retorn.

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ó

}

LS_IO_SetLedBeat(35);

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.

Arguments No hi ha arguments.

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

Page 45: LSMaker API documentation v0.0

Documentació LS Maker

Programació

45

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.

LS_IO_SetLedBeat(20);

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

Arguments No hi ha arguments.

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.

Arguments No hi ha arguments.

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

Page 46: LSMaker API documentation v0.0

Documentació LS Maker

Programació

46

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.

Arguments No hi ha arguments.

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

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

Page 47: LSMaker API documentation v0.0

Documentació LS Maker

Programació

47

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.

Page 48: LSMaker API documentation v0.0

Documentació LS Maker

Programació

48

Page 49: LSMaker API documentation v0.0

Documentació LS Maker

Programació

49

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.

Page 50: LSMaker API documentation v0.0

Documentació LS Maker

Programació

50

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: LS_MT_SetNivellStopBits(1);

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

Page 51: LSMaker API documentation v0.0

Documentació LS Maker

Programació

51

// 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: LS_MT_SetNivellStopBits(1);

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

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

}

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

Page 52: LSMaker API documentation v0.0

Documentació LS Maker

Programació

52

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

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

}

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

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

}

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

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

}

Page 53: LSMaker API documentation v0.0

Documentació LS Maker

Programació

53

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.

Page 54: LSMaker API documentation v0.0

Documentació LS Maker

Programació

54

Exemple bàsic complert

void exemple_basic(){

// Programa d'exemple que mostra un menú a la consola LCD i l'usuari ha de

// triar una opció sense que calgui prémer enter

int stop,h,freq,i;

char c,c2;

float X,Y,Z;

char cad[100];

// Quan s'ha premut Gp s'esborra la pantalla LCD

LS_LCD_Clear();

// Es mostra al PC el menú d'opcions disponibles

LS_USB_printf("\n\n\n\n\nMenú\n\n");

LS_USB_printf("1.- Dirigir cotxe amb cursors.\n");

LS_USB_printf("2.- Llegir fitxer A i mostrar contingut a pantalla LCD\n");

LS_USB_printf("3.- Llegir fitxer B i mostrar contingut a pantalla LCD\n");

LS_USB_printf("4.- Canviar la freqüència dels Leds\n");

LS_USB_printf("5.- Indicar color sota l'LSMaker\n");

LS_USB_printf("6.- Indicar dades accelerometre\n");

do{

LS_USB_printf("\nTria opcio:");

// Es captura de PC un caràcter per seleccionar l'opció.

c = LS_USB_getc();

// Repetim mentre l'opció sigui incorrecta

}while(c < '1' || c > '6');

switch(c){

case '1':

LS_USB_printf("\n W\n A S D\n\nQ: Sortir");

do{

// Capturem la tecla premuda

c = LS_USB_getc();

// Eliminem els caràcters "encuats" per no tenir

// rebots en el moviment

for(i=0;i<LS_USB_CharAvailable();i++)

c2 = LS_USB_getc();

// en funció de la tecla premuda l'LS es mou d'una

// manera o d'una altra

if(c=='W' || c=='w'){

LS_MT_Lineal(90, 80, 0, &stop);

}else if(c=='S' || c=='s'){

LS_MT_Lineal(90, -80, 0, &stop);

}else if(c=='D' || c=='d'){

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

}else if(c=='A' || c=='a'){

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

}

// Repetim mentre l'usuari no premi 'Q'

}while(c != 'q' && c != 'Q');

break;

case '2':

// S'obre el fitxer en mode lectura

h = LS_NVOL_Open(NVOL_STREAM_A, "r");

// Es llegeix una línia sencera a la variable cad

LlegeixLinia(h,cad);

// Es repeteix mentre no s'arribi al final de fitxer

while(!LS_NVOL_Eof(h)){

LS_LCD_Printf(0, 0, "%s",cad);

// Es fa una espera de 2 segons entre línia i línia per

// poder-la llegir a l'LCD

LS_SYS_SleepSecs(2);

LS_LCD_Clear();

LlegeixLinia(h,cad);

}

Page 55: LSMaker API documentation v0.0

Documentació LS Maker

Programació

55

LS_LCD_Printf(0, 0, "%s",cad);

LS_NVOL_Close(h);

LS_SYS_SleepSecs(2);

break;

case '3':

// S'obre el fitxer en mode lectura

h = LS_NVOL_Open(NVOL_STREAM_B, "r");

// Es llegeix una línia sencera a la variable cad

//(lectura avançada)

LlegeixLinia(h,cad);

// Es repeteix mentre no s'arribi al final de fitxer

while(!LS_NVOL_Eof(h)){

LS_LCD_Printf(0, 0, "%s",cad);

// Es fa una espera de 2 segons entre línia i línia per

// poder-la llegir a l'LCD

LS_SYS_SleepSecs(2);

LS_LCD_Clear();

LlegeixLinia(h,cad);

}

LS_LCD_Printf(0, 0, "%s",cad);

LS_NVOL_Close(h);

LS_SYS_SleepSecs(2);

break;

case '4':

do{

LS_USB_printf("Freqüència? (entre 1 i 40): ");

// Es captura de PC la freqüència en una cadena

LS_USB_gets(cad);

freq = 50;

// Es transforma la cadena a enter

freq = atoi(cad);

}while(freq < 1 || freq > 40);

// S'estableix la freqüència dels Leds a partir

// del valor d'usuari.

LS_IO_SetLedBeat(freq);

break;

case '5':

// S'indica el color de sota els tres sensors a la consola

LS_USB_printf("El color sota l'LS és: 0:%c 1:%c

2:%c\n",GetS(MT_STOP_0),GetS(MT_STOP_1),GetS(MT_STOP_2));

break;

case '6':

// S'indica les dades de l'acceleròmetre a la consola

LS_ACC_GetPosXYZf(&X,&Y,&Z);

LS_USB_printf("Dades accelerometre: X:%f Y:%f Z:%f\n",X,Y,Z);

break;

}

}

Page 56: LSMaker API documentation v0.0

Documentació LS Maker

Programació

56

Funcionament remot L’LSMaker té dues modalitats de treball: Programant directament el seu processador, com s’ha

explicat anteriorment, o mitjançant un control remot que li indiqui permet treballar també

fent ús d’un control remot que li indiqui al robot els moviments que ha de realitzar.

Aquest control remot té tres dispositius d’entrada/configuració:

Interruptor de mode(1): Interruptor que serveix per indicar si el comandament

s’alimentarà mitjançant les piles (posició ACC) o mitjançant l’USB (posició USB).

Entrada USB(2): Entrada per connectar el comandament a l’ordinador mitjançant un

cable USB i poder-lo alimentar (cal tenir l’interruptor de mode en posició USB).

Polsador(3): És el polsador que cal prémer quan es vol fer moure l’LSMaker.

Configuració

El comandament funciona automàticament sobre qualsevol robot? La resposta és no, cada

LSMaker obeeix les ordres del comandament que se li indiqui. Per tant caldrà configurar

l’LSMaker per indicar quin és el comandament al qual ha de fer cas. Per tal d’identificar un

comandament serà necessari fer ús de l’adreça MAC del comandament. Una adreça MAC

(Media Acces Control) és una adreça de 12 dígits (en hexadecimal) única i irrepetible al món,

dels quals els 6 primers dígits serveixen per identificar el fabricant del xip que conté l’adreça i

els últims sis serveixen per identificar cadascuna de les adreces d’aquest fabricant.

Per indicar a l’LSMaker quina és la adreça MAC a la qual ha de fer cas (i, per tant, el

comandament) caldrà 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ó “Connecta”. Allà és on s’haurà

d’indicar l’adreça MAC del control remot al qual l’LSMaker farà cas. En aquest cas només

caldrà indicar els 6 dígits (hexadecimals) d’identificador d’adreça (no de fabricant) en blocs de

dos en dos (tres blocs).

Page 57: LSMaker API documentation v0.0

Documentació LS Maker

Programació

57

L’adreça MAC del comandament remot està indicada en les etiquetes adhesives que venen

amb el maletí de distribució de l’LSMaker. En la imatge anterior s’indica que, en cas de

desconèixer l’adreça del control remot es pot obtenir amb aquell mateix programa,

connectant el control a l’USB i prement ‘M’ seguit d’ENTER. Tot i això, és possible que aquesta

funcionalitat no sempre respongui. Posteriorment s’explicarà com trobar l’adreça MAC del

comandament remot en cas que es desconegui.

Control remot bàsic: Control manual

Per tal de moure un LSMaker mitjançant el control remot simplement cal prémer i mantenir el

polsador i, posteriorment, moure el comandament en la direcció que es vulgui que es mogui

l’LSMaker, agafant el comandament pels costats llargs, de manera que el polsador quedi a la

part superior i “mirant” endavant. Això farà que l’LSMaker realitzi els moviments en la direcció

que s’indiqui movent el control remot.

A més de simplement moure l'LSMaker, el comandament incorpora una altra funcionalitat:

Emmagatzemar la ruta que segueix l'LSMaker, és a dir, guardar un track. Com s'ha vist a

l'apartat 'd' de les operacions bàsiques per programar el robot, es pot guardar el track quan es

programa directament sobre el robot, fent ús de les operacions concretes. En el cas que ocupa

actualment, no cal fer ús de cap operació, el que simplement cal fer és fer apuntar al

comandament avall (el polsador quedant a la part més inferior i el connector USB i

l'interruptor amunt) i prémer el polsador. A partir d'aquell moment, cada segon s'enregistrarà

la posició relativa al moment d'iniciar el track. Per finalitzar l'enregistrament de posicions,

simplement cal tornar a apuntar avall amb el comandament i tornar a prémer el polsador (la

mateixa acció que per iniciar l'enregistrament).

Per obtenir les dades de posició enregistrades cal fer el mateix que es fa quan s'emmagatzema

un track utilitzant les operacions de la API (explicat anteriorment), és a dir, descarregar el

fitxer 'C' mitjançant l'aplicació LSLoader (veure subapartat "Carregar i descarregar els fitxers de

text de l’LSMaker" de l'apartat 'c', operacions de memòria no volàtil).

Un cop comentades les funcionalitats bàsiques del control manual, és necessari mencionar que

cal tenir en compte els següents aspectes:

L’abast del senyal no és infinit: No es pot pretendre moure un LSMaker situat a molta

distància del comandament, ja que el senyal no arribarà al robot.

Page 58: LSMaker API documentation v0.0

Documentació LS Maker

Programació

58

Les trames es poden perdre: És possible que alguns cops l’LSMaker no respongui com

se li ha indicat (que no realitzi el moviment que s’ha fet amb el control, que es mogui

quan ja no s’està prement el polsador, etc.). Aquest fet és degut a que les trames es

poden perdre amb una certa freqüència.

L'acceleròmetre que incorpora el comandament (el que detecta els moviments que es

realitzen i que serveix per ordenar a l'LSMaker que es mogui) no és precís al 100% i pot

ser que reaccioni de manera incorrecta amb canvis de posició bruscos. Per tant,

s'aconsella realitzar els moviments del comandament de manera suau i progressiva.

Page 59: LSMaker API documentation v0.0

Documentació LS Maker

Programació

59

Control remot programat: API remota

Filosofia de funcionament

L’LSMaker disposa d’un altre mode remot diferent del manual: Controlar el robot mitjançant el

comandament però que les ordres que envia aquest les indiqui un programa.

La filosofia de treball en mode remot programat es basa en realitzar un programa en C que

s’executarà a l’ordinador (a diferència de quan es programa amb l’MPLAB i es carrega el

programa .hex a l’LSMaker mitjançant l’LSLoader, que llavors el programa l’executa la CPU del

robot). El que farà el programa serà donar ordres al comandament remot, que haurà d’estar

connectat al PC mitjançant el cable USB. Aquestes ordres que rebrà el comandament les

retransmetrà a l’LSMaker i aquest les executarà. D’aquesta manera, si per exemple el

programa li ha indicat al comandament que vol que el robot avanci, el comandament li

reenviarà l’ordre a l’LSMaker i aquest es mourà endavant.

Així doncs, fent ús del control remot programat, comparat amb programar el robot

directament, obtenim una sèrie d’avantatges, però també alguns inconvenients.

Per una banda, la capacitat de procés s’incrementa moltíssim, ja que el processador de

qualsevol ordinador és cents o mils de cops més ràpid que el processador que incorpora

l’LSMaker, de manera que els càlculs necessaris es poden fer molt més ràpid que si es

volguessin fer programant directament el robot. Per altra banda, es contacta amb el robot

sense cables, de manera que no es té l’inconvenient de la longitud del cable si es vol contactar

amb l’LSMaker. Així doncs, tenim les característiques de moure el robot amb el control però

sense d’haver-ho de fer manualment. A més, al no haver de programar amb l’entorn MPLAB,

es té una flexibilitat de treball més gran, ja que es poden utilitzar entorns de treball més

amigables.

Per altra banda, pel fet de treballar amb ones de ràdio, es perd fiabilitat de comportament de

l’LSMaker, ja que pot ser que hi hagi ordres que es perdin, etc. A més, també apareix

l’inconvenient del retràs que provoca el fet d’haver d’enviar trames de ràdio per donar ordres,

així com d’haver d’esperar una resposta per part del robot. Així doncs, cada ordre donada

genera aproximadament 30 msegs de delay. A més, l’LSMaker no podrà anar més lluny que

una certa distància del comandament remot, ja que si ho fa no rebrà les trames que aquest li

enviï.

Page 60: LSMaker API documentation v0.0

Documentació LS Maker

Programació

60

Aquestes són les característiques que s’obtenen quan es treballa amb el control remot

programat, i caldrà analitzar en cada moment que és el que es necessita per decidir si es

programa per treballar amb mode control remot programat o es programa l’LSMaker

directament (per exemple, si es necessiten realitzar milions de càlculs val més treballar en

mode remot i que els càlculs els realitzi el processador del PC).

Entorn de treball

A fi de treballar en el mode de control remot programat es requereix fer ús d’una llibreria

específica i d’un codi ja programat que no es pot modificar. Per tal de que el seu ús sigui

uniforme, aquest codi s’ha programat i preparat per ser modificat i utilitzant mitjançant

l’entorn de desenvolupament DevCpp.

Es pot disposar del software del DevCpp a l’estudy, a la secció de “material de pràctiques” dins

l’assignatura de programació. Hi ha disponible també un manual d’instal·lació i configuració

d’aquest entorn anomenat “Instal·lació i ús de la llibreria Allegro amb l’entorn Dev-C++ per

Windows”. Caldrà consultar aquell document per configurar correctament l’entorn de

desenvolupament.

Ubicació i modificacions dels projectes – l’entorn DevCpp

Un cop estigui preparat l’entorn de treball, cal considerar un altre element: La distribució i

ubicació dels fitxers font del projecte. Com s’ha pogut veure a l’apartat de “distribució” del

principi d’aquest document, existeix un directori dins de “codi font” que s’anomena

“SOFT_BASE_REMOT_PGM”. Per poder programar l’LSMaker en mode remot programat

existeixen dues opcions:

Modificar el projecte existent al directori “SOFT_BASE_REMOT_PGM”.

Crear una còpia del directori “SOFT_BASE_REMOT_PGM” i posar-la al mateix directori

on estava aquest, és a dir, al mateix nivell que els directoris “LS_API” i

“LS_API_REMOTA”. En aquest cas simplement caldrà copiar el directori indicat i

canviar-li el nom a la carpeta, no als arxius que conté.

Es triï l’opció que es triï, per modificar el projecte caldrà obrir l’arxiu de projecte DevCpp, que

és el fitxer amb extensió ‘.dev’ anomenat “SoftPc.dev”. Fent doble clic s’hauria de carregar

automàticament l’entorn DevCpp i obrir els fitxers font del projecte. En cas que no sigui així

caldrà obrir l’entorn DevCpp i anar al menú “Fitxer – Obre projecte o fitxer” i seleccionar l’arxiu

.dev del projecte que es desitja obrir.

Page 61: LSMaker API documentation v0.0

Documentació LS Maker

Programació

61

Un cop obert el projecte base, a l’entorn es carregaran els fitxers que composen el codi del

projecte. En aquest cas, com es pot veure a la finestra d’arxius de projecte situada a l’esquerra

de l’editor, el projecte que es diu “Project1” conté dos elements: l’arxiu “LS_APIRemota.cpp” i

l’arxiu “SoftPC.cpp”.

Nota: Els arxius del projecte tenen extensió ‘.cpp’ enlloc de la extensió típica del llenguatge C

que és ‘.c’. La extensió ‘.cpp’ s’associa al llenguatge C++, però no hi ha cap problema, tot

funcionarà igual que si fos un arxiu ‘.c’.

Page 62: LSMaker API documentation v0.0

Documentació LS Maker

Programació

62

L’arxiu que caldrà modificar per treballar serà el “SoftPc.cpp”. L’altre arxiu, el

“LS_APIRemota.cpp” no es pot modificar, ja que fer-ho pot provocar que l’LSMaker no

respongui com se li ha demanat o que no funcioni. Per tant, l’únic tros de codi que caldrà

modificar serà el de l’arxiu “SoftPC.cpp”, concretament la part de codi a partir de la línia

condicional “if(retry < MAXINTENTS){” i fins a l'else.

MOLT IMPORTANT: Com es pot comprovar, a les primeres línies de codi hi ha el següent bucle:

while (retry < MAXINTENTS && LS_OpenCom(com) != 0) {

retry++;

printf("Reintent de connexio %d al port COM %d\n",retry,com);

LS_SYS_SleepSecs(1);

}

El que fa aquest bucle és establir la connexió amb el comandament remot. Realitza un màxim

de MAXINTENTS de connexió. En cas que aconsegueixi establir la connexió, executarà el codi de

l’if, en cas que no, el de l’else. Quan el port de comunicacions està establert es poden utilitzar

les operacions de l’LSMaker sense problemes.

Així doncs, el codi base donat permet establir la connexió amb l’LSMaker i, posteriorment, fa

senzilles operacions per realitzar moviments processant el que escriu l’usuari.

Com es pot comprovar, només l’arxiu “SoftPC.cpp” està ubicat al directori

“SOFT_BASE_REMOT_PGM”. L’altre arxiu, l’”LS_APIRemota.cpp” està ubicat al directori

“LS_API_REMOTA” dins de “Codi font”.

Un cop explicada la ubicació i distribució de fitxers, el que caldrà modificar i com, cal

mencionar diferents aspectes de funcionament dels programes que controlen l’LSMaker

mitjançant la API remota:

- Per tal que funcioni el programa realitzat quan s’executi, caldrà tenir el comandament

connectat al PC mitjançant el cable USB i l’interruptor del comandament en posició

USB.

- La funció LS_OpenCom rep com a paràmetre una variable, ‘com’. Caldrà inicialitzar el

valor d’aquesta variable al mateix valor que indica l’LSLoader de COM actiu. És a dir,

per saber a quin valor cal inicialitzar la variable caldrà executar l’LSLoader i mirar quin

port COM diferent de l’1 està habilitat. Per defecte, el valor d’aquesta variable és 3,

que és el port COM típic que assigna el sistema operatiu Windows XP.

IMPORTANT: Quan es comprova el port COM on està ubicat el comandament remot a

l'LSLoader (a fi d'indicar el port a la variable 'com'), aquest NO s'ha de seleccionar,

només cal comprovar-lo. Si es selecciona el port del comandament al menú d'USB i es

deixa l'LSLoader obert el programa que es realitzi no podrà establir la comunicació amb

el comandament, ja que el port de comunicacions USB ja estarà ocupat per l'LSLoader.

- És possible que la connexió no s’aconsegueixi establir en el nombre d’intents

indicats. Aquest fet pot ser provocat perquè el robot està apagat, perquè el

comandament no està en posició USB, perquè no s’ha indicat el port ‘com’

correctament o, simplement, pot no tenir un motiu. En cas que no hi hagi un motiu

aparent, cal seguir intentant-ho fins que s’estableixi la connexió.

Page 63: LSMaker API documentation v0.0

Documentació LS Maker

Programació

63

- Si es desconeix l’adreça MAC del comandament remot, utilitzant el mode de

funcionament remot es pot descobrir. Per fer-ho, cal inserir el següent codi a l’arxiu

“SoftPC.cpp” (es pot posar abans de l’intent de connexió, ja que amb el comandament

remot sempre es podrà comunicar). Un cop s’executi el programa es mostrarà per

pantalla els 6 caràcters (tres blocs de dos caràcters) hexadecimals de la part

identificadora d’adreça MAC.

// Declarar una cadena de 3 posicions sense signe (unsigned)

unsigned char mac[3];

// Capturar la adreça MAC a la cadena mac.

LS_COM_GetShortMAC(mac);

// Mostrar l’adreça, pintant en format hexadecimal (%x) les tres

// caselles de la cadena per mostrar per pantalla la part de

// l’adreça que interessa.

printf("%x %x %x\n",mac[0],mac[1],mac[2]);

Funcionalitats remotes

Les funcionalitats que ofereix l’LSMaker quan es programa en el mode remot són molt similars

a les que s’ofereixen quan es programa directament sobre el processador del robot (les

operacions explicades anteriorment). El funcionament de la majoria d’operacions és el mateix,

tot i que hi ha algunes en que difereix i hi ha d’altres que en el mode remot no es permeten

utilitzar.

De la mateixa manera que s’ha mencionat a l’apartat d’operacions bàsiques de la API,

existeixen altres operacions que es poden usar sobre l’LSMaker però que no s’han mencionat

en aquest document ja que no es veuen necessàries. De la mateixa manera, es poden

consultar les operacions i si permeten treballar en mode remot o no al fitxer “LSApi.h” del

directori “LS_API” dins de Codi font.

A continuació es mencionaran les principals diferències de funcionament de les operacions

quan es treballa en mode remot, les operacions que no s’ofereixen en aquest mode de treball i

les noves operacions.

Operacions obligatòries pel funcionament

Operació void LS_Init();

Explicació De la mateixa manera que programant directament sobre el processador de l’LSMaker, és obligatori realitzar una crida a l’operació “LS_Init”, (en aquest cas per inicialitzar la configuració del comandament) abans de començar a treballar amb les operacions de l'LSMaker.

Arguments No rep arguments.

Retorn No hi ha cap valor de retorn.

Quan es treballa en mode remot apareixen dues noves operacions que són necessàries per

poder treballar fent ús del comandament remot. Si no es fa una crida inicial a LS_OpenCom o

aquesta no funciona correctament, el programa no enviarà les ordres al comandament remot

Page 64: LSMaker API documentation v0.0

Documentació LS Maker

Programació

64

i, per tant, aquest no les podrà reenviar a l'LSMaker. Per aquest motiu és important controlar

que l'operació ha funcionat correctament (utilitzant el valor de retorn).

De la mateixa manera, és important tancar el port de comunicacions obert prèviament amb el

comandament, ja que si no es fa, és possible que en properes execucions la funció

LS_OpenCom no s'executi correctament.

Operació int LS_OpenCom(int Com);

Explicació Operació que estableix la connexió amb el comandament remot, sempre i quan el comandament estigui connectat al port USB indicat al paràmetre COM. És possible que no sempre aconsegueixi establir la connexió al primer intent. En aquests casos, cal reintentar.

Arguments Com: Indica el port de comunicacions (USB) on s’ha connectat el comandament a distància. Per saber aquest valor cal executar l’LSLoader amb el comandament connectat al PC i amb l’interruptor en mode USB. El valor l’indica el menú USB, mirant el port COM habilitat que no és el 1.

Retorn Retorna zero quan s’ha pogut establir la connexió amb el comandament remot, permetent utilitzar-lo a partir d’aquell moment. En cas que no s’hagi pogut establir la connexió es retorna un valor diferent de 0.

Operació int LS_CloseCom(int Com);

Explicació Operació que tanca la connexió amb el comandament remot.

Arguments Com: Indica el port de comunicacions (USB) on s’ha connectat el comandament a distància. Per saber aquest valor cal executar l’LSLoader amb el comandament connectat al PC i amb l’interruptor en mode USB. El valor l’indica el menú USB, mirant el port COM habilitat que no és el 1.

Retorn Retorna zero quan s’ha pogut tancar la connexió amb el comandament remot. En cas que no s’hagi pogut tancar la connexió correctament es retorna un valor diferent de 0.

Operacions amb canvis de comportament

Com s'ha comentat anteriorment, al treballar en mode remot es canvia el comportament

d'algunes operacions de la API. Alguns canvis de comportament són a nivell intern de la API, és

a dir, en la manera com s'implementen les operacions (no afectarà doncs en el moment de

treballar amb elles). D'altres, en canvi, modifiquen el comportament final de l'operació, de

manera que el resultat final no serà el mateix que programant sobre el processador de

l'LSMaker. Les operacions que canvien el seu comportament són les següents:

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

Diferències En el mode remot, aquesta operació fa exactament el mateix que la funció fopen de C, però enlloc de retornar un FILE* retorna un enter (int). Aquest enter serà l'identificador del fitxer, de la mateixa manera que en un programa normal de C ho seria la variable de tipus FILE*.

Page 65: LSMaker API documentation v0.0

Documentació LS Maker

Programació

65

Quan es vulgui llegir un fitxer, aquest haurà d'estar ubicat al mateix directori que l'executable (igual que en C). De la mateixa manera, quan es creï un fitxer (obrint-lo en mode escriptura), aquest es crearà al directori on està l'executable.

S'eliminen les restriccions de nom dels fitxers, podent llegir o escriure fitxers amb qualsevol nom (recordar que programant directament al processador de l'LSMaker els únics noms vàlids són NVOL_STREAM_A i NVOL_STREAM_B).

Operació int LS_NVOL_Close(int HANDLE);

Diferència El funcionament d'aquesta operació és el mateix que programant sobre el processador de l'LSMaker, però en el mode remot, aquesta operació fa exactament el mateix que la funció fclose de C, amb la diferència ja comentada que, enlloc d'haver d'indicar-li un FILE* se li ha de passar un enter que identifiqui al fitxer (el que retorna la funció LS_NVOL_Open).

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

Diferència El funcionament d'aquesta operació és el mateix que programant sobre el processador de l'LSMaker, és a dir, llegeix 'lenght' caràcters del fitxer 'HANDLE' i els guarda a la cadena 'buffer'. La diferència està en que al seu funcionament intern realitza una crida a la funció fread de C, sabent que només s'utilitzarà en fitxers de text i, per tant, sempre indica 'sizeof(char)' com a paràmetre de mida de variable. Concretament es realitza una crida a: fread(buffer, length, sizeof(char), (FILE *) HANDLE);

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

Diferència El funcionament d'aquesta operació és el mateix que programant sobre el processador de l'LSMaker, és a dir, escriu els 'lenght' primers caràcters de la cadena 'buffer' sobre el fitxer 'HANDLE'. La diferència està en que al seu funcionament intern realitza una crida a la funció fwrite de C, sabent que només s'utilitzarà en fitxers de text i, per tant, sempre indica 'sizeof(char)' com a paràmetre de mida de variable. Concretament es realitza una crida a: fwrite(buffer, length, sizeof(char), (FILE *) HANDLE);

Operació int LS_NVOL_Eof(int HANDLE);

Diferència El funcionament d'aquesta operació és el mateix que programant sobre el processador de l'LSMaker (és a dir, retorna 0 mentre no troba el final de fitxer i un valor major que 0 quan el troba) i el seu comportament és exactament el mateix que el de la funció feof de C.

Operació int LS_NVOL_Eof(int HANDLE);

Page 66: LSMaker API documentation v0.0

Documentació LS Maker

Programació

66

Diferència El funcionament d'aquesta operació és el mateix que programant sobre el processador de l'LSMaker (és a dir, retorna 0 mentre no troba el final de fitxer i un valor major que 0 quan el troba) i el seu comportament és exactament el mateix que el de la funció feof de C.

Operació char LS_USB_getc(void);

Diferència Aquesta operació, igual que les de tipus USB que s’indicaran a continuació, tenen un canvi significatiu de comportament, i és que tant l’escriptura per pantalla com la lectura de teclat ja no es fan a la consola LSLoader sinó que es fan a la pròpia pantalla del programa. En aquest cas, doncs, l’operació simularà el comportament de la funció getc de C, la qual captura el caràcter de la tecla que es premi, sense necessitat de prémer enter.

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

Diferència Aquesta operació d’USB, igual que la anterior, veu afectat el seu comportament pel fet que llegeix de la consola del programa en execució i no de la consola de l’LSLoader. L’operació emula a la funció gets de C.

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

Diferència Aquesta operació d’USB, igual que les anteriors, veu afectat el seu comportament pel fet que escriu a la consola del programa en execució i no a la consola de l’LSLoader. L’operació emula a la funció printf de C.

Operacions void LS_SYS_SleepSecs(unsigned int Seconds);

void LS_SYS_SleepMiliSecs(unsigned int MiliSeconds);

Diferència Ambdues operacions mantenen el seu comportament, és a dir, aturen l’execució del programa durant el temps que se li indiqui (en segons o milisegons). La diferència entre el mode remot i el mode “normal”, és que en el primer cas simplement fa una crida a la funció sleep de windows.

Operació void LS_COM_GetShortMAC(unsigned char

MAC[COM_SHORT_MAC_SIZE]);

Diferència Aquesta operació no està inclosa dins de les operacions bàsiques per programar l’LSMaker directament, ja que el seu ús no te tant sentit en aquell cas. En el mode remot, però, és important saber que aquesta operació retorna la part identificadora de l’adreça MAC del comandament a la cadena ‘MAC’. Anteriorment s’ha inclòs un exemple de com s’utilitza aquesta operació. La diferència principal d’aquesta funció amb ella mateixa però quan es treballa sobre el processador és que en aquest últim cas retorna l’adreça MAC de l’LSMaker.

Page 67: LSMaker API documentation v0.0

Documentació LS Maker

Programació

67

Operacions sense canvis de comportament

Les operacions de la API que es mencionaran a continuació no tenen cap canvi de

comportament, és a dir, el que es fa simplement és enviar l’ordre indicada al comandament i

que aquest la reenviï a l’LSMaker. Per tant, tant el funcionament com els paràmetres i el

resultat és el mateix que el que l’especificat a l’apartat d’operacions bàsiques.

Les operacions que no modifiquen el seu comportament són:

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

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

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

void LS_MT_SetNivellStopBits(unsigned char Nivell);

unsigned int LS_MT_GetTimeFromDistance(int Distance, int Speed);

unsigned int LS_MT_GetTimeFromAngle(int Angle, int Speed);

void LS_MT_InitTrack ();

void LS_MT_EndTrack ();

void LS_MT_GetTrack (int *x, int *y);

int LS_MT_IsStop(unsigned int StopBits);

int LS_SYS_OpenTimer (void);

void LS_SYS_ResetTics (unsigned char Timer);

unsigned int LS_SYS_GetTics (unsigned char Timer);

void LS_SYS_CloseTimer (unsigned char Timer);

int LS_IO_GpButtonPress(void);

void LS_IO_SetLedBeat(int Beat);

int LS_SYS_GetBatteryVoltage(void);

int LS_SYS_PowerOff(void);

int LS_ACC_Tap(void);

int LS_ACC_Shake(void);

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

Page 68: LSMaker API documentation v0.0

Documentació LS Maker

Programació

68

Operacions no permeses

Quan es fa ús del mode de treball remot, hi ha algunes operacions de la API que no es permet

utilitzar (no s’ofereixen), de manera que si s’utilitzessin es donaria un error de compilació al no

trobar definides les operacions a la API remota.

Les operacions no permeses en el mode remot són:

void LS_NVOL_ReOpen(int HANDLE);

int LS_NVOL_Size(int HANDLE);

int LS_USB_CharAvailable(void);

void LS_LCD_Clear(void);

void LS_LCD_CursorOn(void);

void LS_LCD_CursorOff(void);

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