LSMaker API documentation v0.0
-
Upload
la-salle -
Category
Technology
-
view
434 -
download
6
description
Transcript of 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
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:
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:
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:
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:
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:
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:
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:
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.
Documentació LS Maker
Programació
10
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.
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).
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.
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:
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.
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).
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.
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).
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);
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, ¶r);
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
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,¶r);
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,¶r);
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.
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,¶r);
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
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.
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
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();
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.
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++;
}
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).
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);
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
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
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
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);
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();
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.
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);
}
}
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.
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);
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
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
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).
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();
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
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
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!");
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.
Documentació LS Maker
Programació
48
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.
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 ){
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
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);
}
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.
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);
}
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;
}
}
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).
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.
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.
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ï.
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.
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’.
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ó.
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
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*.
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);
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.
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);
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, ... );