LSMaker API documentation v0.0

657 views

Published on

LSMaker API Documentation v. 0.0

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
657
On SlideShare
0
From Embeds
0
Number of Embeds
6
Actions
Shares
0
Downloads
8
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

LSMaker API documentation v0.0

  1. 1. Documentació LS Maker ProgramacióÍndex de contingutsDistribució ..................................................................................................................................... 2Preparació 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ó .................................................................................. 9Programar el codi de lLSMaker amb lentorn MPLAB ................................................................ 12Carregar un programa a lLSMaker amb lLSLoader .................................................................... 16Operacions bàsiques per programar lLSMaker .......................................................................... 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 .......................................................................................................... 54Funcionament remot .................................................................................................................. 56 Configuració ............................................................................................................................ 56 Control remot bàsic: Control manual...................................................................................... 57 Control remot programat: API remota.................................................................................... 59 Filosofia de funcionament ................................................................................................... 59 Entorn de treball ................................................................................................................. 60 Ubicació i modificacions dels projectes – l’entorn DevCpp ................................................ 60 Funcionalitats remotes........................................................................................................ 63 1
  2. 2. Documentació LS Maker ProgramacióDistribució A la distribució de lLSMaker shi poden trobar tres directoris diferents: Documentació: És on es troba aquest fitxer i daltres documents de documentació de lLSMaker Codi font: És on hi ha el codi font de lLSMaker. Dins hi trobem quatre directoris: - LS_API: Conté codi necessari pel funcionament de lLSMaker. NO ES POT MODIFICAR EL CONTINGUT NI EL NOM DEL DIRECTORI. - LS_API_REMOTA: Conté codi necessari pel funcionament de lLSMaker. NO ES POT MODIFICAR EL CONTINGUT NI EL NOM DEL DIRECTORI. - SOFT_BASE_PGM: Conté el workspace (àrea de treball) necessari per treballar amb lMPLAB i els fitxers font daquest workspace. Només sha 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 daplicacions necessàries per fer poder programar i carregar lLSMaker, que són el compilador de codi, el driver USB per poder connectar el robot al PC via USB, lLSLoader, que és el programa per carregar els programes ja compilats amb el MPLAB a lLSMaker i el MPLAB, que és lentorn de desenvolupament, on escriurem i compilarem el codi.Preparació de l’entorn per programar l’LSMaker via USB1.- Instal·lació del compilador:Executar l’arxiu MPLABCPIC24_v3_24StdEval.exe del directori Compilador, dins deProgramari. Durant el procés d’instal·lació només caldrà dir a tot que si/següent/acceptar: 2
  3. 3. Documentació LS Maker ProgramacióA la segona pantalla caldrà indicar que acceptem els termes i condicions:Com sha indicat, a totes les pantalles cal prémer que si, acceptar o lequivalent:A la selecció dinstal·lació cal triar la completa: 3
  4. 4. Documentació LS Maker ProgramacióLa ubicació de la instal·lació cal deixar la que sindica per defecte prement Next:Linstal·lador demanarà si es permet modificar el path del sistema i que modifiqui el registre.Cal indicar que si:Ja a la última pantalla de resum només caldrà indicar que Next: 4
  5. 5. Documentació LS Maker ProgramacióArribats a aquest punt la instal·lació començarà:2.- Instal·lació de l’entorn de desenvolupament (IDE) “MPLAB”:Explorant el cd de MPLAB, haurem d’accedir a la carpeta “MPLAB_IDE_v8.36” i executarl’arxiu “setup.exe”. Durant el procés d’instal·lació haurem d’indicar, primerament, queacceptem les condicions de la llicència i, posteriorment, que es farà una instal·lació completa: 5
  6. 6. Documentació LS Maker ProgramacióA la pantalla de selecció dubicació del programa també es deixarà el directori que veestablert per defecte:A la següent pantalla caldrà indicar que saccepten els termes i condicions. Posteriorment esmostrarà la pantalla de resum, a la qual només caldrà dir que Next: 6
  7. 7. Documentació LS Maker ProgramacióArribats a aquest punt, la instal·lació començarà:Quan la instal·lació finalitzi es demanarà si es vol instal·lar el HI-TECH C. Caldrà indicar que si,començant daquesta manera una nova instal·lació, a la qual també shaurà dindicar a tot quesí, que saccepten els termes dús, deixar el directori dinstal·lació per defecte: 7
  8. 8. Documentació LS Maker ProgramacióA la següent pantalla cal marcar la casella de "Add to environment path". Un cop es premiNext es procedirà a linstal·lació:Un cop finalitzada linstal·lació ens preguntarà si es desitja llegir la guia dinici ràpid. Es potdesmarcar la casella, ja que no és necessari llegir-la, podent prémer Finish: 8
  9. 9. Documentació LS Maker ProgramacióLa última pantalla del procés dinstal·lació de lMPLAB ens demanarà si es vol reiniciar el PC. Ésaconsellable fer-ho:Un cop reiniciat el PC, el MPLAB mostrarà una pantalla preguntant quin document es volobrir. Simplement serveix per obrir documents de consulta, de manera que es pot tancardirectament 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 laprimera pantalla caldrà prémer Next i a la següent indicar que s’accepten els temes i indicarNext. A la pantalla de sol·licitud d’ubicació podem modificar la ruta o prémer Next. A la últimapantalla només caldrà prémer a Install. 9
  10. 10. Documentació LS MakerProgramació 10
  11. 11. Documentació LS Maker ProgramacióArribats a aquest punt es donarà lloc a la instal·lació del driver. Quan acabi es demanarà si esvol realitzar la instal·lació del driver pròpiament dit. Caldrà marcar la casella "Launch theCP210x VCP Driver Installer" i prémer Finish:En aquest punt apareixerà una pantalla preguntant si es vol canviar el directori dinstal·lació.Podem prémer Install directament:Quan shagi 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 indiquique el programa no respon. Cal esperar. Quan finalitzi ens mostrarà una pantalla indicant quela instal·lació sha dut a terme. 11
  12. 12. Documentació LS Maker ProgramacióProgramar el codi de lLSMaker amb lentorn MPLABPer començar a programar lLSMaker caldrà obrir l’entorn de desenvolupament (MPLAB IDE).Un cop dins caldrà anar al menú “File – Open workspace” i es carregarà el workspace delprojecte, anomenat "SoftBase.mcp", ubicat a la carpeta SOFT_BASE_PGM dins del directoriFonts.Nota: En cas de voler fer una còpia de seguretat, un nou projecte o quelcom semblant, es potrealitzar 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 nosubica en aquest directori, aquesta còpia del projecte no funcionarà perquè no trobarà elsarxius font necessaris.Un cop obert el workspace és recomanable que es faci una distribució de les finestres deprojecte i de output, així com del codi font. Per fer-ho, simplement haureu d’anar a “View” imarcar “Project” i “Output”, de manera que us apareguin aquestes dues finestres a linteriorde lIDE. Posteriorment, es poden moure aquestes finestres on es vulgui, així com fer doble clicsobre algun arxiu del projecte (des de la finestra de Project) i veure el codi font daquest.Ara que l’entorn està preparat, es pot començar a programar l’aplicació que es desitgi. Caltenir en compte que l’LSMaker necessita codi de configuració apart del que es vulgui afegir.Per tant, només s’haurà de canviar el codi de la part final del procediment principal (del main). 12
  13. 13. Documentació LS Maker ProgramacióÉs aconsellable realitzar una funció amb tot el codi que es vulgui afegir i posar la cridad’aquesta funció just abans de tancar el bucle “while(1)”. En la següent imatge es pot veure unexemple 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 al’operació LS_Executiu dins el bucle infinit. Aquestes dues crides són necessàries iimprescindibles, de manera que sempre hi hauran de ser en qualsevol programa que esrealitzi. La part que es permet programar és la de just després de la crida a l’LS_Executiu. Peraquest 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 acausa del bucle infinit, de manera que s’haurà de fer algun tipus de control quan es finalitziuna execució i abans que comenci la següent. És molt aconsellable que la funció LSMaincomenci 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 quefa la línia de codi anterior és, bàsicament, quedar-se en un bucle sense fer res (per això lesclaus oberta i tancada juntes) mentre no es premi el botó ‘gp’ de l’LSMaker. D’aquestamanera, es provoca que el codi posterior no s’executi fins que l’usuari li premi el botó al robot.Un cop shagi programat tot el que es desitgi, caldrà compilar el projecte fent “Project-Buildall” o fent clic al botó corresponent de la barra d’eines (marcat a la següent imatge). També espot fer “Project-Make” o donar-li al botó de make de la barra deines(marcat a la següentimatge). 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 delprojecte que hagin canviat. 13
  14. 14. Documentació LS Maker ProgramacióSi la compilació funciona apareixerà el missatge “BUILD SUCCEEDED” a la pantalla de resultats(output).Un cop la compilació hagi finalitzat shaurà generat un nou fitxer que sanomenarà igual que elworkspace amb lextensió "hex" (en aquest cas, SoftBase.hex).Nota 1: Cal vigilar amb els paràmetres de lMPLAB que es toquin. És aconsellable no canviarcap configuració daquest, ja que pot provocar comportaments inesperats, que es generinfitxers "hex" incorrectes, etc. Les úniques opcions que es necessiten són les de programar (buildall o make).Nota 2: En cas que es desitgi programar un mateix workspace en diferents ubicacions (diferentsPCs amb el compilador i lMPLAB 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ò quelú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 sutilitzarà laubicació que té el MPLAB actualment. Possiblement aquesta pantalla apareixerà més dun copdurant el procés de compilació del workspace, però sempre shaurà dindicar el mateix. Si, perqualsevol motiu, aquest pas es fes de manera incorrecta, caldrà anar a "Project-SelectLanguage Toolsuite". Allà apareixerà una pantalla com la següent: 14
  15. 15. Documentació LS Maker ProgramacióCaldrà buscar el "MPLAB C30 C Compiler", fer clic sobre aquesta línia, prémer el botó Browse iindicar la ubicació del compilador C en lordinador actual, tenint en compte que habitualmentaquest error es dona degut com anomenen els diferents operatius als "Archivos de programa".Així doncs, possiblement només caldrà canviar "Archivos de programa" per "Program files" o "Program Files (x86)" o equivalents. 15
  16. 16. Documentació LS Maker ProgramacióCarregar un programa a lLSMaker amb lLSLoaderUn cop es disposi del fitxer amb extensió "hex" generat per la compilació amb el MPLAB,aquest es podrà carregar a lLSMaker mitjançant laplicació " LSLoader.exe", situada aldirectori "ProgramariLSLoader". Per fer-ho, caldrà tenir lLSMaker connectat al PC via el cableUSB.Nota: Lexplicació del programa LSLoader es farà sobre la versió V1.01. En cas de canvi deversions, lús de laplicació a lhora de carregar el fitxer "hex" hauria de ser igual o moltsimilar, de manera que el manual no s’hauria de veure molt afectat.El primer que caldrà connectar lLSMaker al PC mitjançant el cable USB i activar el robotprement el polsador ON. Si lLSMaker no està connectat o actiu, no funcionarà capfuncionalitat del programa LSLoader. Si sintenta fer alguna operació com Calibració,Telecàrrega o daltres, apareixerà el següent missatge:Un cop el robot estigui preparat caldrà triar lUSB on tenim connectat lLSMaker. Per fer-hocaldrà prémer el menú USB i triar el port COM que aparegui habilitat. Per defecte estaràseleccionat el port COM1, però el correcte serà laltre que aparegui habilitat (que no estiguien gris). El número de port de COM actiu dependrà de cada ordinador (a la figura apareix l11,però podria ser algun altre). 16
  17. 17. Documentació LS Maker ProgramacióUn cop shagi seleccionat el port de comunicacions caldrà fer un reset de lLSMaker, des de"operacions-reset", fent clic a F6 o fent clic al botó corresponent de la barra deines.Quan shagi reiniciat el robot es podrà procedir a carregar el programa. Per fer-ho caldrà anara "operacions-telecàrrega" o fer click sobre el botó corresponent de la barra deines (indicacarregar programa). Fent això sobrirà un explorador, on caldrà de triar el fitxer amb extensió"hex" a carregar, que estarà ubicat a la mateixa carpeta que el workspace que sha editat.Quan shagi seleccionat el fitxer amb extensió "hex", ens apareixerà una nova finestra, onsimplement haurem de prémer "Inicia" per carregar el programa a lLSMaker.Un cop finalitzat el procés shaurà carregat el programa a lLSMaker i aquest lexecutaràautomàticament. 17
  18. 18. Documentació LS Maker ProgramacióNota: Cal tenir en compte que, com sha dit, quan es carrega el programa, lLSMakerlexecutarà automàticament. Per tant, si el programa que se li ha carregat fa que es moguidirectament, aquest ho farà. Cal vigilar per tant on tenim col·locat lLSMaker, a fi devitar quecagui duna taula o accidents semblants. La millor manera devitar aquest tipus daccidents ésfent ús de la funcionalitat "LS_IO_GpButtonPress" (sexplicarà posteriorment). 18
  19. 19. Documentació LS Maker ProgramacióOperacions bàsiques per programar lLSMakerFins al moment s’ha explicat com instal·lar i configurar l’entorn de desenvolupament i càrrega iquin serà el tros de codi que es podrà modificar. A continuació sintroduiran les operacionsmés importants que tenim disponibles a la API de lLSMaker per interactuar amb aquest. UnaAPI (application programming interface) és un conjunt de procediments i funcions (operacions)que sofereixen 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 certesaccions 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 inecessàries per poder fer ús de l’LSMaker. No obstant, existeixen altres operacions en aquestaAPI que no s’explicaran, ja que el seu ús no resulta necessari a nivell bàsic ni mitjà o hi hadaltres funcions que fan una tasca molt similar. Tot i això, per conèixer totes les possibilitatsque ofereix la API es pot consultar larxiu "LSApi.h", ubicat al directori LS_API, dins de Fonts.Dins s’hi troben definides totes les capçaleres de totes les funcions existents, ordenadessegons el tipus i amb una petita explicació de cadascuna delles.a) Operacions de motorSon les operacions que serveixen per fer moure l’LSMaker. A continuació s’explicaran lesfuncions principals de l’API per fer moure l’LS en línia recta o girant, funcions per calculartemps o angles per definir moviments i operacions bàsiques per definir el control dels sensors.Operació unsigned int LS_MT_Lineal(unsigned int Time, int Speed, int StopBits, int * StopReasons);Explicació Aquesta operació serveix per fer moure l’LSMaker en línia recta, ja sigui endavant o endarrere. No es pot indicar quina és la distància que volem que es mogui, però si la velocitat i el temps. A més, es pot fer que el moviment s’aturi abans del temps establert si es compleixen certes condicions que se li indiquin.Arguments Time: Enter que indica durant quants milisegons es mourà l’LSMaker. Ha de ser major o igual a 0 (0 indica temps infinit). Speed: Velocitat a la que es mourà l’LSMaker entre un rang de [-100,100], essent 100 la velocitat màxima, 0 indica que està parat i els valors negatius indiquen que el moviment el farà en sentit invers (endarrere). StopBits: Indica els motius desitjats per fer que el cotxe es pari abans del temps establert (s’explicarà amb més detall posteriorment, a l’apartat “El control dels sensors”). Indicant un 0 vol dir que no hi ha cap motiu perquè s’aturi abans del temps indicat. StopReasons: És un enter passat per referència que retorna els motius pels quals el cotxe s’ha aturat abans de temps.Retorn Es retorna un enter que són el nombre de milisegons que s’ha mogut el cotxe.Exemples int stop; LS_MT_Lineal(1000,100,0,&stop); 19
  20. 20. Documentació LS Maker Programació En aquest cas el cotxe es mourà endavant durant 1000 milisegons (1 segon) a velocitat màxima, passi el que passi (no hi ha cap motiu per parar). L’últim argument, el &stop, és una manera d’indicar que passem la variable entera stop per referència. Simplement es tracta de posar un ‘&’ davant de la variable entera que volem que es modifiqui. int parar; LS_MT_Lineal(10000, -50, MT_STOP_1 | MT_STOP_2, &parar); En aquest cas, el cotxe es mourà endarrere durant 10 segons a velocitat mitja (50), tot i que és possible que es pari si es compleix la condició (SENSOR_C|SENSOR_D).Operació unsigned int LS_MT_TurnRight(unsigned int Time, int Speed, unsigned int Radius, int StopBits, int * StopReasons);Explicació Aquesta operació serveix per fer girar l’LSMaker a la dreta durant un cert temps, amb una certa velocitat i amb un angle de gir específic. De la mateixa manera que passava amb l’operació d’avançar, es poden indicar condicions per fer que el moviment s’aturi abans del temps indicat.Arguments Time: Enter que indica durant quants milisegons es mourà (girant) l’LSMaker. Ha de ser major o igual a 0 (0 indica temps infinit). 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 20
  21. 21. Documentació LS Maker Programació passem la variable entera stop per referència. Simplement es tracta de posar un ‘&’ davant de la variable entera que volem que es modifiqui. int parar; LS_MT_TurnRight(500,-30,10,0,&parar); En aquest cas, el cotxe girarà a la dreta, marxa enrere, durant mig segon i amb un grau d’obertura de 10, cosa que vol dir que enlloc de girar sobre si mateix, el moviment tindrà una component de recte.Operació unsigned int LS_MT_TurnLeft(unsigned int Time, int Speed, unsigned int Radius, int StopBits, int * StopReasons);Explicació Aquesta operació serveix per fer girar l’LSMaker a l’esquerra durant un cert temps, amb una certa velocitat i amb un angle de gir específic. De la mateixa manera que passava amb l’operació d’avançar, es poden indicar condicions per fer que el moviment s’aturi abans del temps indicat.Arguments Time: Enter que indica durant quants milisegons es mourà (girant) l’LSMaker. Ha de ser major o igual a 0 (0 indica temps infinit). Speed: Velocitat a la que es mourà l’LSMaker entre un rang de [-100,100], essent 100 la velocitat màxima, 0 indica que està parat i els valors negatius indiquen que el moviment el farà en sentit invers (endarrere). Radius: Indica el grau d’obertura de la corba que farà el robot. Un valor de 0 indica que l’LSMaker girarà a la dreta sobre ell mateix. Quan major és el valor, més oberta serà la corba que farà. StopBits: Indica els motius que desitgem perquè el cotxe es pari abans del temps establert (s’explicarà amb més detall posteriorment, a l’apartat “El control dels sensors”). Indicant un 0 vol dir que no hi ha cap motiu perquè s’aturi abans del temps indicat. StopReasons: És un enter per referència que retorna els motius pels quals el cotxe s’ha aturat abans de temps.Retorn Es retorna un enter que són el nombre de milisegons que s’ha mogut el cotxe.Exemple int stop; LS_MT_TurnLeft(1000,60,0,0,&stop); En aquest cas el cotxe girarà a l’esquerre sobre si mateix durant 1000 milisegons (1 segon) a velocitat de 60 (d’un màxim de 100), passi el que passi (no hi ha cap motiu per parar). L’últim argument, el &stop, és una manera d’indicar que passem la variable entera stop per referència. Simplement es tracta de posar un ‘&’ davant de la variable entera que volem que es modifiqui. int parar; LS_MT_TurnRight(500,-30,10,0,&parar); 21
  22. 22. Documentació LS Maker Programació En aquest cas, el cotxe girarà a l’esquerre i marxa enrere, durant mig segon i amb un grau d’obertura de 10, cosa que vol dir que enlloc de girar sobre si mateix, el moviment tindrà una component de recte.Operació void LS_MT_SetNivellStopBits(unsigned char Nivell);Explicació Aquesta operació canvia el comportament de les condicions d’aturada en les operacions de moviment de l’LSMaker. Com es veurà en profunditat a l’apartat “El control dels sensors”, les condicions d’aturada venen inicialment determinades pel color que detecten els sensors de sota el robot. Amb aquesta operació el que es fa és invertir el comportament de les condicions.Arguments Nivell: Enter que serveix per indicar per quin color s’activa la condició d’aturada. Només té dos possibles valors: 0: Indica que la condició s’activa per blanc, és a dir, que el moviment s’aturarà quan el sensor indicat a la condició detecti blanc. Pel contrari, si detecta negre, la condició no s’activarà i, per tant, no aturarà l’execució de l’operació de moviment abans del temps previst. 1: Estableix el comportament contrari a 0, és a dir, la condició d’aturada s’activarà quan el sensor concret detecti negre.Retorn No hi ha valor de retorn.Exemple El següent codi fa que l’LSMaker avanci en línia recta mentre la condició de parada (MT_STOP_1) no s’activi. El primer que fa el codi és establir que la condició s’activi per negre. Per tant, quan es compleixi que MT_STOP_1 veu negre, el moviment s’aturarà. LS_MT_SetNivellStopBits(1); LS_MT_Lineal(0, 70, MT_STOP_1, &stop);Operació unsigned int LS_MT_GetTimeFromDistance(int Distance, int Speed);Explicació Degut a que a l’operació de moviment recte no se li pot indicar la distància que es desitja que es recorri, només el temps i la velocitat, existeix aquesta operació que, donada la distància desitjada i la velocitat a la que es farà moure l’LSMaker, retorna el temps que cal que es mogui. Aquesta operació, però, perd la seva eficàcia quan el nivell de bateria no està entre 72 i 71. En cas que no estigui entre aquest marge, es pot produir un error d’ aproximadament el 10%.Arguments Distance: És on s’indica la distància en centímetres a recórrer per l’LSMaker desitjada. Speed: Indica la velocitat a la que es farà moure l’LSMaker en línia recta a l’operació LS_MT_Lineal. 22
  23. 23. Documentació LS Maker ProgramacióRetorn Retorna un enter que indica el temps que caldrà fer moure l’LSMaker per recórrer la distància indicada movent-se a la velocitat Speed.Exemple Aquesta operació es pot utilitzar directament dins l’operació de moviment recte. En l’exemple es pot observar que se li indica a l’LSMaker que avanci un metre (100 cm) a velocitat 50, sense cap condició d’aturada: LS_MT_Lineal(LS_MT_GetTimeFromDistance(100,50),50,0,&stop); Es podria realitzar la mateixa operació capturant el valor de retorn de l’operació en qüestió i passant-la com a paràmetre: int t; t = LS_MT_GetTimeFromDistance(100,50); LS_MT_Lineal(t,50,0,&stop);Operació unsigned int LS_MT_GetTimeFromAngle(int Angle, int Speed);Explicació Degut a que a les operacions de gir no se’ls pot indicar l’angle en graus que es desitja girar, sinó l’angle sobre ell mateix, existeix aquesta operació que, donada l’angle que es desitja girar i la velocitat a la que es farà moure l’LSMaker, retorna el temps que cal que es mogui. Només es pot utilitzar aquesta funció correctament si l’angle de gir és menor a 10º. Aquesta operació perd la seva eficàcia quan el nivell de bateria no està entre 72 i 71. En cas que no estigui entre aquest marge, es pot produir un error d’ aproximadament el 10%.Arguments Angle: És on s’indica l’angle a girar desitjat per l’LSMaker. Speed: Indica la velocitat a la que es farà moure l’LSMaker per girar.Retorn Retorna un enter que indica el temps que caldrà fer moure l’LSMaker per girar l’angle indicada movent-se a la velocitat Speed.Exemple Aquesta operació es pot utilitzar directament dins l’operació de girar. En l’exemple es pot observar que se li indica a l’LSMaker que giri 5º a velocitat 50, sense cap condició d’aturada: LS_MT_TurnRight(LS_MT_GetTimeFromAngle(5,50),50,5,0,&parar);Calibració dels motorsUn cop explicades les operacions de moviment de l’LSMaker, és necessari mencionar que cadarobot és diferent, i que, degut a l’estat de les rodes, de les orugues, dels motors, etc. elmoviment pot diferir entre un robot i un altre. De fet, és possible que intentant moure el robot 23
  24. 24. Documentació LS Maker Programaciórecte, aquest tingui una petita desviació i acabi realitzant un petit gir. Per tal d’evitar aquestscomportaments 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, executarl’LSLoader, indicar el port USB on està connectat l’LSMaker (el COM que estigui actiu en elmenú “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 percontrolar la direcció de l’LSMaker (si el moviment que fa no és recte quan així se li demana) il’ajust de tracció serveix per controlar les velocitats dels motors (per poder fer un ús mésprecís de les operacions LS_MT_GetTimeFromDistance iLS_MT_GetTimeFromAngle. 24
  25. 25. Documentació LS Maker Programaciób) Operacions de gestió del displayLes operacions de gestió del display serveixen per controlar la pantalla LCD i mostrar-hi lainformació desitjada. Cal tenir en compte que la freqüència de refresc de la pantalla LCD ésaproximadament de 50 ms, de manera que és aconsellable no “estressar” la pantalla, ja que encas 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 25
  26. 26. Documentació LS Maker Programació 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(); 26
  27. 27. Documentació LS Maker Programacióc) Operacions de memòria no volàtil – fitxersL’LSMaker ofereix la possibilitat de treballar amb fitxers de text d’una manera semblant a laque ofereix el llenguatge C. Concretament ofereix la possibilitat de treballar amb un màxim dedos fitxers de text, que poden ser carregats a l’LSMaker des de l’ordinador o descarregats al’ordinador des de l’LSMaker mitjançant la utilitat LSLoader.Operació int LS_NVOL_Open(char *Nom, char *Mode);Explicació Aquesta operació serveix per obrir un fitxer de text i poder treballar posteriorment amb ell, ja sigui llegint-lo o escrivint-hi.Arguments Nom: Cal indicar com a nom de fitxer o bé NVOL_STREAM_A o bé NVOL_STREAM_B. En cas d’indicar un altre nom donarà error. Mode: És una cadena de caràcters que indica el mode en que es vol obrir el fitxer. Els seus valors poden ser: “r”: Indica que es vol obrir el fitxer en mode lectura i, per tant, només es faran lectures d’aquest, no s’hi escriurà. “w”: Indica que es vol obrir el fitxer en mode escriptura. En aquest cas, en fer la obertura, s’eliminarà tot el contingut previ del fitxer que s’obre, permetent l’escriptura del fitxer des de l’inici d’aquest. “a”: Indica que es vol obrir el fitxer en mode afegir, és a dir, escriure però sense esborrar el contingut previ del fitxer. D’aquesta manera, quan s’obre el fitxer en mode afegir es començarà a escriure a continuació del text que ja hi hagués.Retorn L’operació retorna un enter identificatiu del fitxer obert, de la mateixa manera que en C es retorna un FILE*. Cal capturar-lo perquè serà necessari fer-ne ús en les operacions de lectura, escriptura, tancar, etc.Operació int LS_NVOL_Write(int HANDLE, char *buffer, unsigned int length);Explicació Aquesta operació serveix per escriure en un fitxer que prèviament s’ha obert en mode escriptura o afegir. Si es fa ús d’aquesta operació amb un fitxer obert en mode lectura no funcionarà i donarà un error.Arguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna la funció Open). buffer: És la cadena de caràcters que es vol guardar al fitxer. NOMÉS es poden guardar cadenes de caràcters, de manera que si es volgués guardar al fitxer el valor d’una variable entera caldrà fer algun pas previ per inserir el valor dins d’una cadena. 27
  28. 28. Documentació LS Maker Programació lenght: Ha d’indicar el nombre de caràcters que conté la cadena de caràcters que es va a escriure al fitxer. Cal tenir en compte que sempre s’ha d’indicar el nombre exacte de caràcters, per tant, si la cadena està guardada en una variable es pot fer ús de la funció strlen(char* string), que retorna el nombre de caràcters d’una cadena. Recordeu doncs d’incloure la llibreria <string.h>Retorn Retorna el nombre de caràcters que realment s’han escrit al fitxer, EOF si s’ha arribat al límit de mida del fitxer o un enter identificat per la constant NVOL_INVALID_MODE si s’ha intentat escriure en un fitxer obert en mode lectura.Operació int LS_NVOL_Read(int HANDLE, char *buffer, unsigned int length);Explicació Aquesta operació serveix per llegir la informació que conté un fitxer que prèviament s’ha obert en mode lectura. Si es fa ús d’aquesta operació amb un fitxer obert en mode escriptura o afegir no funcionarà i donarà un error. L’operació començarà a llegir el fitxer des de l’inici i cada nova lectura es farà des de la posició on es va quedar la última lectura feta fins al moment.Arguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna l’operació Open). buffer: És la cadena de caràcters on es guardarà la informació que es llegeixi del fitxer. lenght: Indica el nombre de caràcters que es llegiran del fitxer. Cal tenir en compteRetorn Retorna el nombre de caràcters que realment s’han llegit o la constant EOF si s’ha arribat al final del fitxer amb la lectura. En cas que s’hagi fet una lectura indicant un handle d’un fitxer obert en mode escriptura o afegir es retornarà la constant NVOL_INVALID_MODE.Funció int LS_NVOL_ReadLine(int HANDLE, char *buffer);Codi int LS_NVOL_ReadLine(int HANDLE, char *buffer){ int i=0; char aux[5]; for(i=0;buffer[i]!=0 && buffer[i]!=n && buffer[i]!=r; i++) buffer[i]= 0; i=0; while(LS_NVOL_Read(HANDLE, aux, 1) != EOF){ if(aux[0] == n){ buffer[i] = 0; return i; }else{ buffer[i] = aux[0]; i++; } 28
  29. 29. Documentació LS Maker Programació } buffer[i] = 0; return EOF; }Explicació Aquesta funció llegirà una línia sencera del fitxer obert amb el handle que se li indiqui. Concretament llegirà fins que trobi un ‘n’ o l’EOF. AQUESTA FUNCIÓ NO ESTÀ INCLOSA DINS DE LA API DE L’LSMAKER. SI ES VOL FER ÚS CAL COPIAR EL CODI DE LA FUNCIÓ DINS EL CODI DE L’ARXIU DEL MAIN.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 finalArguments HANDLE: És l’enter que identifica el fitxer que s’ha obert (el que retorna l’operació Open). 29
  30. 30. Documentació LS Maker ProgramacióRetorn Retorna el valor 0 si el fitxer no ha arribat al final. En cas contrari, quan sarriba 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 cadenaPer treballar amb l’operació LS_NVOL_Write de l’LSMaker, la que permet escriure alsfitxers, sempre serà necessari fer ús de cadenes, ja que les operacions de la API no permetenescriure valors enters o reals directament al fitxer. Serà necessari doncs “transformar” elsvalors d’una variable de qualsevol tipus a una variable cadena. Més concretament, el que esfarà serà inserir el valor de la variable dins d’una cadena. La manera de fer-ho és molt senzilla ifàcil d’entendre.Oi que quan es vol mostrar per pantalla tant un text com el valor d’una variable s’utilitzal’operació printf? Doncs existeix una altra operació que fa el mateix que el printf però queenlloc de mostrar la informació per pantalla la guarda dins d’una cadena de caràcters que se liha 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 fariaaixò? Senzill, amb l’operació printf:printf(“Edat: %dn”,ed); 30
  31. 31. Documentació LS Maker ProgramacióAra es vol fer el mateix, però enlloc de mostrar la informació per pantalla, la volem guardar enuna cadena de caràcters. Com ho fem? Doncs amb l’operació sprintf, tenint declarada lavariable cadena:char cad[100];sprintf(cad,“Edat: %dn”,ed);D’aquesta manera si, per exemple, la variable ed valia 25, la cadena ‘cad’ contindrà “Edat: 25”.Carregar i descarregar els fitxers de text de l’LSMakerPer carregar (guardar fitxers de text del PC a l’LSMaker) o descarregar (guardar els fitxers del’LSMaker dins el PC) fitxers, cal utilitzar el programa LSLoader. Un cop estigui obert elprograma 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 ique no sigui el port 1.Un cop seleccionat el port caldrà fer un reset del robot seleccionant “Operacions-reset” o fentclic 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 potser A, B o C. També es pot fer clic sobre els botons corresponents de la barra d’eines. Cal teniren compte que els fitxers A i B són els que es poden modificar amb les operacions d’escriptura 31
  32. 32. Documentació LS Maker Programacióde fitxer. El fitxer C és on es guardarà la informació de tracking (per això no es pot carregar,només es pot descarregar).Un cop seleccionada la opció apareixerà una finestra de navegació de directori, on simplementcaldrà 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 elbotó corresponent de la barra d’eines.Un cop seleccionat el fitxer a carregar apareixerà una finestra de navegació de directori, onsimplement caldrà seleccionar el fitxer a carregar.ExemplesExemple d’ús de fitxers d’escripturaEl 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 dun 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 32
  33. 33. Documentació LS Maker Programació// hand, la cadena i el nombre de caràcters d‟aquesta(7, 6 de la paraula temps// + 1 de n)LS_NVOL_Write(hand, “Agendan”, 7);for(i=0;i<MAXC;i++){ // S‟insereix la cadena i lenter de cada posició de larray 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 fitxerLS_NVOL_Close(hand);Exemple d’ús de fitxers de lectura 1El 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. Esveurà 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 fitxerwhile(!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 bucleLS_LCD_Printf(0, 0, "%s",cad);// Es tanca el fitxerLS_NVOL_Close(h);Exemple d’ús de fitxers de lectura 2El següent exemple mostra un codi que, inicialment, fa que l’LSMaker mostri per la pantalla 33
  34. 34. Documentació LS Maker ProgramacióLCD el nombre de caràcters que conté el fitxer B (NVOL_STREAM_B). Posteriorment es llegirà imostrarà la informació que conté, de 10 caràcters en 10 caràcters. Això provocarà que si hi haun salt de línia el llegeixi també i intenti mostrar-lo a l’LCD, però no farà el salt. Després de fertota la lectura, enlloc de tancar el fitxer es “reiniciarà”, és a dir, es posarà el punter a l’inici delfitxer.int h;char cad[100];// S‟obre el fitxer B en mode lecturah = LS_NVOL_Open(NVOL_STREAM_B, "r");// Es mostra a la pantalla LCD l‟enter que indica el nombre de caràcters de BLS_LCD_Printf(0, 0, "%d", LS_NVOL_Size(int HANDLE));// Es fa la lectura del fitxer, de 10 caràcters en 10 caràcterswhile(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 tornara fer la lectura.LS_NVOL_ReOpen(h); 34
  35. 35. Documentació LS Maker Programaciód) Operacions de trackL’LSMaker disposa d’operacions per fer un seguiment i control de la ruta que s’ha seguit. Sónles funcions de tracking, les quals serveixen per inicialitzar la posició inicial de l’LS, que sempreserà la (0,0), emmagatzemar una posició, capturar la posició actual o finalitzarl’emmagatzemament. Cal tenir en compte que la precisió de les dades que s’emmagatzemenno é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 degestió 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 robotArguments *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 trackint i,x,y,stop;LS_LCD_Printf(0,0,”Init track”);//S‟inicialitza l‟enregistrament de posicionsLS_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(); 35
  36. 36. Documentació LS Maker Programacióe) Operacions de control de sensorsL’LSMaker disposa (o pot disposar), a la seva part inferior, d’una placa que té 3 sensors decolor 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à unaexplicació molt més detallada dels sensors un cop finalitzada l’explicació de les operacions del’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. 36
  37. 37. Documentació LS Maker Programació AQUESTA FUNCIÓ NO ESTÀ INCLOSA DINS DE LA API DE L’LSMAKER. SI ES VOL FER ÚS CAL COPIAR EL CODI DE LA FUNCIÓ DINS EL CODI DE L’ARXIU DEL MAIN.Arguments MaskStop: De la mateixa manera com s’ha explicat anteriorment amb la funció LS_MT_IsStop, aquest paràmetre indica el sensor que es vol comprovar. Si es vol consultar el sensor esquerre valdrà ‘MT_STOP_0’, el del mig ‘MT_STOP_1’ i el de la dreta ‘MT_STOP_2’.Retorn Retorna un caràcter: ‘N’ si el sensor està sobre negre i ‘B’ en cas contrari.Exemple El següent codi és l’equivalent al codi de l’exemple anterior però fent ús de l’operació GetS: if(GetS(MT_STOP_0)==‟N‟ && GetS(MT_STOP_1)==‟N‟ && GetS(MT_STOP_2)==‟N‟){ //Si tots els sensors negres, girem a la dreta 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); } } 37
  38. 38. Documentació LS Maker Programacióf) Operacions de sistema – els “timmers”Entre les operacions de sistema trobem unes de molt importants que són les de “timmer”.Aquestes funcions serveixen per calcular temps transcorreguts, de manera que es pugui fer uncontrol del temps en el codi de l’LSMaker.L’LSMaker disposa de diversos timmers, de manera que es pot fer un control de diferentselements temporals en el mateix moment.Totes les operacions de timmer s’han d’utilitzar d’una manera “conjunta”, de manera quel’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. 38
  39. 39. Documentació LS Maker ProgramacióOperació void LS_SYS_CloseTimer (unsigned char Timer);Explicació Aquesta operació serveix per finalitzar l’ús del timmer. És important executar-la quan ja no es necessiti fer ús del timmer o quan finalitzi el codi, ja que el fet de no alliberar els timmers pot ser motiu de que l’operació LS_SYS_OpenTimer () retorni un valor negatiu indicant que no hi ha timmers disponibles.Arguments Cal indicar com a argument el timmer que volem consultar, que serà un dels que tinguem disponibles.Retorn No hi ha un valor de retorn.ExempleExemple d’ús de timmersEl següent exemple mostra un codi que demana un timmer i calcula el temps que es triga finsque es prem el botó gp de l’LSMaker ( la funció LS_IO_GpButtonPress() s’explicarà al’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); 39
  40. 40. Documentació LS Maker Programacióg) Operacions de comunicació USBLes operacions de comunicació USB són aquelles que permeten a l’usuari interactuar ambl’LSMaker mitjançant el teclat i la pantalla. D’aquesta manera, l’usuari pot enviar missatges enforma de cadena cap a l’LSMaker perquè aquest els processi. De la mateixa manera, l’LSMakerpodrà enviar missatges cap al PC que es mostraran a la consola de l’LSLoader. Serà la maneraque 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 40
  41. 41. Documentació LS Maker Programació 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: %dn",pend);ExempleExemple amb diferents instruccions de comunicació USB 41
  42. 42. Documentació LS Maker ProgramacióEl següent codi mostra com, inicialment, l’LSMaker indica al PC que escrigui alguna cosa.Després captura el que s’ha escrit per teclat, ho mostra a la pantalla LCD i ho retorna al PCcom a confirmació a l’usuari. Posteriorment l’LSMaker s’espera a rebre el caràcter ‘c’ percontinuar la seva execució.char cad[100];// Es mostra el missatge a la consola de l’LSLoader.LS_USB_printf("Escriu alguna cosa!n");// Es captura la cadena de caràcters que s‟ha escrit a la consola.LS_USB_gets(cad);// Es retorna el que s‟ha escrit a la consola.LS_USB_printf("nHas escrit: %sn",cad);// Es mostra el missatge per la pantalla LCD de l‟LSMakerLS_LCD_Printf(0, 0, "%s",cad);// Mentre el caràcter que es premi per teclat sigui diferent de „c‟, no fa reswhile(LS_USB_getc()!=c){}LS_USB_printf("nContinua lexecución",cad);// ...Es pot veure un exemple de resultat d’aquest codi a la imatge següent (també es mostraria elmissatge “Hola!” a la pantalla LCD). 42
  43. 43. Documentació LS Maker Programacióh) Operacions miscel·lànies importantsEn aquest apartat s’expliquen algunes operacions de temàtica variada que és importantconè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(); 43
  44. 44. Documentació LS Maker ProgramacióOperació void LS_SYS_SleepMiliSecs(unsigned int MiliSeconds);Explicació Aquesta operació serveix per realitzar una espera en el codi de l’LSMaker (a imatge i semblança del que fa l’operació sleep en C).Arguments MiliSeconds: Indica el nombre de milisegons que es vol fer esperar.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 lLSMaker als seus costats.Arguments Beat: Indica la freqüència de pulsació en dècimes dHz, 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 44
  45. 45. Documentació LS Maker Programació decimal, essent 0 la tensió mínima (0.0 V) i 100 la màxima (10.0 V).Exemple El següent codi mostra un exemple de com fer un programa que només faci certes accions si el nivell de bateria és superior a 5V i que en cas contrari mostri un error a la pantalla LCD: //Fem una espera activa mentre no premin el botó Gp. 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 45
  46. 46. Documentació LS Maker ProgramacióAmb el següent codi, l’LSMaker esperarà a rebre un Tap o un Shake. Fins que algunad’aquestes dues funcions no retorni cert no sortirà del bucle. Un cop surti s’indicarà el motiude sortida a la pantalla LCD.int exit;exit = 0;while(!exit){ if(LS_ACC_Shake()) exit=1; else if(LS_ACC_Tap()) exit = 2;}if(exit==1) LS_LCD_Printf(0, 0, "Shake!");else LS_LCD_Printf(0, 0, "Tap!");Funció int LS_SYS_PowerOff(void);Explicació Aquesta operació serveix per apagar l’alimentació de l’LSMaker (el mateix que s’aconsegueix prement el botó OFF de la part posterior d’aquest). Cal tenir en compte que, si s’apaga el robot, el codi es deixarà d’executar automàticament.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 46
  47. 47. Documentació LS Maker Programació base. En posició plana, el valor de la X tendirà a 0. Si la part frontal de l’LSMaker (on NO hi ha la pantalla LCD) s’eleva, el valor de la X serà negativa, major quan més inclinat estigui. Pel contrari, si la part frontal descendeix, el valor serà positiu i, quan més inclinat, major. Y: (punter a real): Indica la inclinació de l’LSMaker seguint l’eix transversal de l’LSMaker, és adir, la recta que equival al costat petit del rectangle de la placa base. En posició plana, el valor de la Y tendirà a 0. Si la part esquerra (on hi ha la toma d’alimentació) de s’eleva, el valor de la Y serà negativa, major quan més inclinat estigui. Pel contrari, si la part dreta (on hi ha els polsadors d’on/off/gp) s’eleva, el valor serà positiu i, quan més inclinat, major. Z: (punter a real): Indica si l’LSMaker està boca amunt (valors positius) o boca avall (valors negatius).Retorn No hi ha valor de retorn, es modifiquen les variables per referència.Exemple El codi següent mostra un exemple en el que, si l‟LSMaker troba una inclinació amunt poc pronunciada, accelera. Si la inclinació és amunt i molt pronunciada, fa marxa enrere. En cas que la inclinació sigui avall també fa marxa enrere. float X,Y,Z; X=0.0; Y=0.0; Z=0.0; LS_ACC_GetPosXYZf(&X,&Y,&Z); if(X > 5){ // Si s‟inclina avall, marxa enrere. // (es posa 5º per la pèrdua de precisió). LS_MT_Lineal(90, -80, 0, &stop); }else if(X < 0 && X > -40){ // Si la inclinació es amunt i poc pronunciada, avança. LS_MT_Lineal(90, 80, 0, &stop); }else if(X < -40){ // Si la inclinació es amunt i molt pronunciada, enrere. LS_MT_Lineal(90, -80, 0, &stop); }else{ // Si està en pla avança més lent LS_MT_Lineal(90, 40, 0, &stop); } A les imatges que hi ha a continuació es mostra gràficament el comportament de l’acceleròmetre en funció de les inclinacions en l’eix X i Y. 47
  48. 48. Documentació LS MakerProgramació 48
  49. 49. Documentació LS Maker ProgramacióEl control dels sensorsLLSMaker incorpora, a la part inferior davantera, tres sensors de color (detecten blanc onegre) que permeten fer un control del moviment del robot. Es pot fer que el cotxe només esmogui per terrenys blancs o negres, que canviï el comportament si detecta blanc o negre, etc.Com sha vist, existeixen diferents operacions que serveixen per controlar els colors quedetecten 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 lesde 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 elparàmetre StopBits, on sindicarà la condició de finalització del moviment. Concretamentespera rebre una constant o una condició múltiple de constants concretes. Aquestes constantssón les següents:  MT_STOP_0: Constant que controla el sensor de lesquerra de lLSMaker. 49
  50. 50. Documentació LS Maker Programació  MT_STOP_1: Constant que controla el sensor central de lLSMaker.  MT_STOP_2: Constant que controla el sensor de la dreta de lLSMaker.Aquestes constants tenen un valor concret que serveixen per controlar condicions sobrecadascun dels sensors. El que es busca és que les condicions s’activin quan un sensordeterminat detecti un cert color. Però quan s’activarà? Quan detecti blanc o quan detectinegre? 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 sensordetecti blanc o negre. Com s’ha explicat a l’apartat d’operacions de motor, si s’estableix un 0 lacondició 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 sanalitzaran 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 tempsinfinit), 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 constantque controla el sensor central). En aquest cas quan s’activarà? Doncs no es pot saber, ja queno s’ha fet ús de l’operació LS_MT_SetNivellStopBits(), tot i que es pot suposar queper 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 lLSMaker està situat en una superfície que fa que el sensorcentral detecti negre, ja no es mourà. Si, pel contrari, el sensor central detecta blanc, el robotes 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 sha aturatel robot. En aquest cas està clar que el motiu serà segur que el sensor central ha detectatnegre, però en daltres 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 tempsinfinit), mentre no es compleixi la condició (MT_STOP_0| MT_STOP_1| MT_STOP_2). Enaquesta manera de treballar en concret, per fer una condició on volem que es compleixialguna subcondició, ho haurem de fer amb loperador |, que equival a una OR lògica. Quanes complirà doncs aquesta condició? Doncs quan algun dels tres sensors de lLSMakerdetectin color negre (només amb 1 sensor que detecti negre l’operació pararà, i ha de sercolor negre perquè s’ha indicat anteriorment establint el nivell d’stopbits).Un cop el robot es pari, es pot comprovar per què sha aturat el robot gràcies a la variablestop. Comprovant el seu valor podrem saber quin és el sensor que sha activat. Per exemple:if ( stop == MT_STOP_0 ){ 50
  51. 51. Documentació LS Maker Programació // Sha aturat perquè el sensor esquerre ha detectat negre. // ...}else if ( stop == MT_STOP_1 ){ //Sha aturat perquè el sensor central ha detectat negre. // ...}else ...}else if( stop == MT_STOP_0 | MT_STOP_1 ){ // Sha 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 elcolor actiu (a la que un sensor vegi el color contrari es pararà). Però, com es pot fer que elrobot només es pari quan els tres sensors detectin el color contrari? No es pot fer només ambuna 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ó demoviment 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. Elque passa és que la condició de manteniment ja fa que el cotxe es mogui recte gràcies aalguna de les 3 condicions de manteniment del bucle (cal tenir en compte que si una de lesoperacions de moviment no s’executa, aquesta retornarà un zero). D’aquesta manera, si, perexemple, la primera subcondició del bucle retorna 0 voldrà dir que el sensor 0 (el del’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 (vegiel color correcte) perquè l’LSMaker es mogui. Així doncs s’aconsegueix el que s’haviaproposat, 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 movimentrecte que shan utilitzat en els exemples.Així doncs, és mitjançant les constants la única manera que hi ha de controlar els sensors delLSMaker? No. Es pot controlar també el control del robot mitjançant daltres funcions ocombinant 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 identificativadel 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 51

×