Disseny d'una màquina tridimensional amb Lego

.

Disseny d’una màquina tridimensional amb Lego I.E.S Torre del Palau Eduard Ametller Navas i Jaume Fernández Navas

2009-2010

ÍNDEX

1. Objectius .............................................................................................................. 2 Objectiu principal ...................................................................................................................... 2 Com s’ha fet............................................................................................................................... 3 Problemes que hem trobat al llarg del treball........................................................................... 5

2. Automatismes ...................................................................................................... 6 Conceptes bàsics........................................................................................................................ 6 Lego Mindstorms com a automatisme.................................................................................... 14

3. Programació per Lego Mindstorms...................................................................... 19 Entorn de programació ........................................................................................................... 19 NXT-G ...................................................................................................................................... 19 El nostre programa .................................................................................................................. 20

4. Programació per Nintendo DS ............................................................................. 21 Conceptes bàsics...................................................................................................................... 21 Programació per la Nintendo DS ............................................................................................. 22

5. Programació per ordinador ................................................................................. 50 6. Conclusió i agraïments ........................................................................................ 52 7. Fonts d’informació .............................................................................................. 53

Treball de recerca

1

1. OBJECTIUS

1. Objectiu principal L’objectiu del nostre treball és aprendre com programar un autòmat. Per aconseguir això em fet l’ús d’una màquina de la marca Lego. Ens van aconsellar aquesta màquina de Lego perquè era senzilla d’utilitzar tenint en compte allò que volíem fer.

Aquest kit portava tot allò que volíem: motors, sensors i el microcontorlador. A més, també estaven incloses moltes peces Lego que vam decidir utilitzar i que ens van estalviar cert treball. Juntament amb l’esmentat s’adjuntava el software de Lego necessari per programar el microcontrolador. Tot això ens va incentivar a adquirir aquest aparell i no un altre.

Una vegada teníem clar quina màquina hauríem d’utilitzar vam fer un cop d’ull en primera persona a aquest aparell en moviment que va ser possible degut a que l’IES Torre Del Palau conta amb un parell d’aquestes màquines. Vam veuré a primer cop d’ull que funcionava plenament bé.

Finalment vam cercar una mica abans d’adquirir-lo. Vam buscar opinions generals trobant una resposta positiva de la gent. Ens vam informar del preu, del lloc on el venien, quins sensors venien, com era la “botiga”, si tenien peces de recanvi, si podríem comprar més accessoris si fos necessari, i una infinitat d’informació necessària abans de desemborsar els diners en aquest projecte.

Finalment arribava la data màxima per decidir quin treball fer. Vam estar rumiant sobre coses per afegir al nostre treball pràctic, sobretot en l’apartat de control de la grua amb altres dispositius, i finalment ens vam decidir per fer un programa per la Nintendo DS amb el qual poguesim controlar la grua.

Treball de recerca

2

2. Com s’ha fet (pas a pas) Primerament ens vam informar amb tota totalitat sobre l’aparell que anàvem a utilitzar. Per això vam fer una cerca de Lego Minstorms. Un cop decidit que aquest era el nostre treball ens vam informar d’on obtenir-lo. Un professor que entenia d’aquest tema ens va indicar com funcionava aproximadament i també on podíem aconseguirlo. Un cop teníem l’adreça ens vam esperar a que terminés el curs que estàvem fent (1º de batxillerat) per posar-nos mà a l’obra. Aquesta botiga es trobava al “centre” de Barcelona. Vam agafar un tren per poder-lo comprar.

Aquesta botiga està situada entre les avingudes de General Mitre i Via Agusta.

Situació de la botiga de Lego Minstorms

Una vegada adquirit, vam començar a donar-li forma al treball. Vam fer croquis de com podríem fer-lo. Vam començar posant-li rodes al brick, fer un carretó...

Quan vam acabar de fer aquests muntatges, vam mesurar els cables per saber aproximadament de la grandària que ho podíem fer. Aquest cables són bastant curts i per tant ens va limitar bastant la grandària. Vam determinar la grandària de l’estructura (feta amb fusta). Vam fer les mesures i la nostra conclusió va ser que no podia ser més gran que la capsa de Lego Mindstorms (38cm x 48cm). L’altura va ser una mica a cop d’ull i vam decidir fer-la a 25cm del terra.

Treball de recerca

3

Fotografia dels components (provisional), amb l’estructura de fusta Vam comprar les fustes a un lloc especialitzat perquè ens ho fecin a mida. Vam demanar “retalls” de fusta que fossin el més lleugers possible, per la posterior comoditat de transport, per eliminar una possible sobrecarrega i perquè l’aparell pogués traslladar-ne les fustes.

Al llarg del treball hem variat la forma dels components per realitzar una millores al moviment d’aquestes peces. Al últim moment hem inclòs unes guies a banda i banda de les rodes perquè el seu moviment fos el màxim de recte i no es desviés al llarg del seu camí.

Per últim vam programar amb el l’entorn que ve inclòs en l’aparell. Com que vam finalitzar aquesta pràctica molt aviat i teníem interès a anar més enllà, hem desenvolupat un comandament a distància a través del bluetooth que te Lego Minstorms. Hem aconseguit que amb la Nintendo DS puguem controlar tot el mecanisme. Fins i tot em treballat en el disseny per a la NDS.

Treball de recerca

4

3. Problemes que hem trobat al llarg del treball El problema que ens ha donat més treball per solucionar-lo ha sigut el pes. Des del principi ja érem conscients que el pes podria ser un dels nostres problemes però fins que no vam ensopegar no sabíem que anava a ser el major problema.

La fusta que va del brick al carretó era massa pesant i entre la fusta i el motor que hauria d’haver, el motor del brick no era capaç de moure’l. Vam d’haver posar la llistó de fusta molt lleuger, suficientment gruixut, perquè pogués cabre una roda i per tant rodi per aquesta fusta horitzontal altre motor que representa el ganxo per agafar coses, en el nostre cas “cubs”.

Altre problema va ser que els motors que té Lego Mindstorms no són gaire potents i per lo tant, enseguida que el motor necessitava fer una mica de força, la fricció imposibilitava el moviment. Per tant, hem anat amb compte d’afegir el mínim pes possible i d’incrementar la fricció de la roda i la fusta. Aquests problemes van suposar una gran inestabilitat a l’aparell, però finalment, amb la incorporació d’unes guies a banda i banda de la roda, s’ha mig solucionat el problema.

Les dificultats a la programació han sigut básicament donades per l’entorn de programació de Mindstorms. Teniem coneixements bàsics de programació en general i de llenguatge C. Vam ser capaços de programar ràpidament l’autòmat però el programa que ve inclòs amb l’aparell era una ruïna. El primer error va ser que a les poques vegades de probar-lo carregava el programa al Mindstorms però no permetia executar-lo des de l’ordinador. Posteriorment, quan intentavem compilar el programa que haviem desenvolupat donava error. El que vam pensar és que l’arxiu on es guardava el programa estava corrupte i efectivament era així de manera que vam haver de copiar-lo manualment en un nou arxiu. Això ens va demorar molt de temps perquè és un programa lent sobretot quan es treballa amb arxius grans. A més, ha donat el cas de que teníem ja guardat el projecte i d’un dia per l’altre aquest projecte tornava a donar l’error o sense voler es canviava un signe ja que el programa selecciona els blocs només passant per sobre d’ells. Això era degut a que passant el cursor per sobre dels signes es canviava sense confirmació i això ens donava molt mals de cap.

Treball de recerca

5

2. AUTOMATISMES

1. Conceptes bàsics 1.1 Què és un automatisme?

L’automatisme industrial té com a objectiu l’ús de sistemes informàtics per controlar màquines o processos de manera que no sigui necessària la presència humana.

1.2 Aplicacions dels automatismes La seva finalitat és realitzar una funció sense la intervenció d’un ésser humà. Encara que sembli increïble, fins les coses més simples i comuns són automatismes. Un exemple seria el mecanisme per encendre l’enllumenat del carrer a la nit.

La seva principal avantatge és que ens ajuda a realitzar treballs llargs o de gran complexitat de manera simple i sense la nostra intervenció. Afegint sensors a l’automatisme podem fer que aquest reconegui les circumstàncies del medi i que actuï segons la situació. En el exemple anterior, introduint un sensor de llum podríem fer que l’enllumenat s’apagués segons si hi ha llum o no en el medi en que es troba (si es de dia o de nit).

Aquestes màquines automatitzades a més de realitzar el treball sense el cansament propi dels éssers humans, encara poden realitzar-lo amb major precisió i rapidesa. Per exemple, en una empresa d’envasament d’aliments una màquina preparada per la tasca pot posar els envasos o els aliments d’una determinada manera i en un determinat lloc per la seva posterior distribució.

1.3 Quins tipus hi ha?

Hi ha 5 tipus d’automatismes: mecànic, electrònic, elèctrics, pneumàtic o hidràulic.

Cal indicar que les màquines automàtiques solen pertànyer a més d’una de les divisions anteriors.

Treball de recerca

6

Mecànic Les màquines mecàniques aprofiten qualsevol tipus d’energia que pugui ser transformada en mecànica. Aquesta la contenen els cossos amb moviment ja sigui rectilini o rotatiu.

Electrònic Es considera una màquina electrònica aquella que funciona amb corrent en forma de petites carregues a baixa tensió. L’element essencial de l’electrònica moderna és el microprocessador.

Gràcies a la màquina electrònica podem realitzar grans càlculs, que els humans som capaços de fer, però amb una despesa molt gran de temps mentre que la màquina els resol ràpidament. Un exemple d’aquest tipus de màquina és l’ordinador o computadora que és capaç de realitzar en l’actualitat molts càlculs per segon. Tot i que inicialment no va ser molt destacable, amb el temps i l’evolució de l’informàtica aquest tipus de màquina ha agafat molt importància en el món de l’emmagatzematge de la informació.

Exemple d’una maquina electrònica.

Elèctric La màquina elèctrica permet transformar energia elèctrica en un altre tipus d’energia, canviar les propietats d’un corrent, emmagatzemar energia elèctrica o

Treball de recerca

7

generar un camp magnètic. Es poden classificar en tres grups segons les seves funcions: generadors, motors i transformadors.

El generador és un dispositiu que transforma l’energia mecànica en energia elèctrica. Consta d’unes bobines que giren en un camp magnètic uniforme. Òbviament s’ha de produir una rotació de les espires perquè es generi corrent.

Dibuix de com funciona un generador elèctric. Quan l’espira talla el camp magnètic és genera un corrent altern.

Els motors transformen l’energia elèctrica en energia mecànica. Utilitzen el mateix sistema que un generador però en sentit oposat. Fem passar per les bobines corrent que genera un camp i són atretes per els imants produint moviment. Al arribar al imant la polaritat es canvia i la bobina es repel·lida.

Els transformadors són dispositius encarregats de variar la intensitat i la tensió segons les nostres preferències. Consta de dos bobinatges i una estructura metàl·lica que passa per dins d’ells i que concentra el camp magnètic. Depenent de les voltes de cada bobina i el corrent d’entrada el corrent de sortida tindrà una intensitat i tensió determinades.

Representació d’un transformador Treball de recerca

8

Pneumàtic Utilitzen l’aire comprimit com a mètode de transmissió d’energia. Durant la compressió hem d’aplicar un treball que recuperem en part a la descompressió.

Aquest sistema segueix la llei de gasos ideals i la relació entre temperatura, pressió i volum. És útil per circumstàncies en les que s’hagi de superar una gran força com per exemple ascensors, muntacàrregues o excavadores.

L’element fonamental perquè funcioni aquest sistema són les vàlvules. Les vàlvules són les encarregades de distribuir el fluid, regular el caudal i regular la pressió.

- Les vàlvules distribuïdores són les encarregades de determinar el recorregut de l’aire de manera que podem posar en marxa una màquina, canviar de direcció d’alguna cosa, etc.

- Les vàlvules que regulen el caudal i pressió com el seu nom indica poden modificar la quantitat d’aire que passa per les vies i el seu grau de força.

Excavadora que a través del sistema de pneumàtica és capaç de doblegar els “braços” pesants d’aquesta maquina excavadora.

Hidràulic Són semblants als pneumàtics però en comptes d’aire utilitzen un fluid líquid, normalment oli. Amb les bombes hidràuliques s’emmagatzema l’energia al fluid que es gestiona posteriorment amb les vàlvules.

Treball de recerca

9

1.4 El sistema de control: Sistema de Control Distribuït (DCS) i Controlador Lògic Programable (PLC) Existeixen principalment dos sistemes de control: El Sistema de Control Distribuït (DCS) funciona principalment per processos analògics. Aquest sistema és capaç de controlar i supervisar milers de variables amb una fiabilitat i seguretat elevada. Aquest sistema permet processar les variables a temps real de manera que es pot efectuar una operació automàtica amb una efectivitat i seguretat absoluta.

A més, aquest sistema permet enllaçar-lo amb els Controladors Lògics Programables (PLC) i la integració d’altres components de fabricants diferents. Amb aquest sistema podem obtenir els rendiments i consums d’allò que volem. Està destinat a plantes, és a dir, per a industries amb diferents processos.

Els principals elements que la composen són: - Unitat de control local (o estació de control de processos): bàsicament emmagatzema els circuits elèctrics (connexions, entrades i sortides, etc). És el lloc on adquireix totes les dades i realitza controls.

- Bus de planta: permeten la transició de dades a alta velocitat entre les estacions i unitats de controls.

- Estació d’operacions: són les pantalles i teclat per on pots variar els processos i poden presentar ajudes per realitzar el canvi mes adient segons la situació.

- Estació d’enginyeria: són els qui permeten la configuració i carga de les dades de l’estació d’operacions.

- Nodes i interfases: estructura per la qual es construït tot i model de software utilitzar.

Treball de recerca

10

Diferents processos controlats amb el sistema DCS, indústria de planta.

El Controlador Lògic Programable (PLC) consta d’un microprocessador i d’una circuiteria electrònica que permet controlar processos industrials a llocs on el medi dificulta o impossibilita la presència humana, és a dir, amb altes temperatures, sorolls, vibracions... La seva mesura considerablement petita juntament amb la fàcil programació i instal·lació fa que sigui un sistema atractiu.

Ha evolucionat molt en els últims temps, cosa que ha augmentat el seu ús. Per aquesta raó són utilitzats en tot tipus de fàbriques industrials. Aquests controladors estan composats principalment per: - Entrades de senyals: recepció de la informació - La unitat central: Està constituït per un processador i memòries de programes.

- Sortides de les senyals: executa la resolució de la unitat central.

Un exemple en el que podem veure aquestes parts és l’accionament d’un motor controlat per aquest sistema. El comandament per accionar-lo representa l’entrada de senyal, que posteriorment és processada per la unitat central que finalment envia l’ordre d’accionar el motor sent aquesta la sortida senyal.

Treball de recerca

11

1.6 Els primers invents amb funció automàtica Quan pensem en un aparell que funciona automàticament, ens imaginem que va ser inventat fa menys de 200 o 300 anys, però no es així. Les primeres màquines automàtiques trobades daten del 270 aC i van ser creades pels grecs i els àrabs. Tot i així hi ha indicis d’alguns controls automàtics des de l’any 2000 aC. És un exemple el rellotge d’aigua creat pel filòsof Ktesibi. Està compost per una aixeta i un dipòsit amb una sortida d’aigua a un recipient mesurador d’aigua. Es col·loca una peça triangular que floti al dipòsit i que quedi sota la sortida d’aigua de l’aixeta. Així s’aconsegueix una flux d’aigua del dipòsit al mesurador constant ja que si augmenta el cabdal de l’aixeta i s’omple massa el dipòsit, l’aixeta es tapa amb la peça que flota. Sabent aquest cabdal constant i la quantitat d’aigua que hi ha al mesurador podem saber quant temps fa que hem iniciat l’automatisme.

En la imatge podem observar com l’aixeta omple el primer dipòsit de manera constant gràcies al flotador.

Un altre exemple és la làmpada d’oli de nivell constant. Utilitzava un mètode semblant i que més tard va utilitzar Heró d’Alexandria per obrir i tancar les portes del temple. S’encenia un foc en l’altar. Això ocasiona que passi aigua al dipòsit que pesava més i això accionava l’obriment de la porta amb una corda. Després només calia apagar el foc perquè tot tornes al seu estat inicia i ocasionava un efecte místic sobre el poble.

Treball de recerca

12

Làmpada d’oli de nivell constant

1.7 Realimentació o no realimentació Quan pensem en el servei que ha de fer construirem la maquina amb realimentació o no. La principal diferència entre realimentació i no realimentació consisteix en: Quan parlem del sistema de realimentació o de llaç tancat, la sortida torna al principi per reajustar a l’opció més adient i aconseguir el resultat que volem, és a dir, que elimina la diferència entre el resultat desitjat i el valor obtingut. Per exemple el regulador de temperatura de la peixera en la qual un sensor ens dona un paràmetre i un actuador modificarà la temperatura per mantenir-la a la temperatura desitjada.

Per altra banda el sistema de no realimentació funciona amb uns paràmetres ja establerts. Les màquines que utilitzen el sistema de no realimentació o de llaç obert són per exemple la rentadora entre altres. La rentadora té uns paràmetres establerts per rentar amb l’objectiu de rentar la roba però si la roba està molt bruta, possiblement no sortirà la roba neta degut a que es un llaç obert. Si fos un llaç tancat la rentadora hauria de tenir un sensor per detectar que la roba continua estan bruta i per tant continuar rentant-la fins que estigui neta.

Treball de recerca

13

Fig.1

En l’esquema de la figura 1 es representa el sistema de llaç tancat o realimentació en la qual un sistema de control detectarà si em arribat als valors desitjar o encara no.

Fig.2 En l’esquema de la figura 2 es representa el sistema de llaç obert o no realimentació en la qual hi ha uns paràmetres ja establerts i sigui quin sigui el resultat final i el resultat desitjat, aquest resultat final no es modificarà per poder obtenir el desitjat.

2. Lego Mindstorms com automatisme 2.1 Tipus d’automatisme En aquest projecte programarem a través de Lego Mindstorms l’anomena’t “pont grua”. Aquest pont grua permet detectar un objecte i transportar-lo a un lloc desitjat.

Els ponts grues consten d’un autòmat essencialment electrònic i mecànic.

Aquesta màquina realitza moviments rectilinis en la qual són controlats per una programació prèviament feta. En la pràctica, aquestes maquines, són útils per la organització dels elements transportat per aquest autòmat.

Treball de recerca

14

En aquesta imatge es pot observar la translació d’un element d’alumini fins l’interior d’una màquina o cambra En el cas d’un pont grua lleuger pot arribar a pesar de 125kg a 2000kg amb una capacitat de càrrega d’una tona. Si es tracta d’un pont grua bicarril té la capacitat de càrrega al voltant de 25 tones. També existeixen ponts encara més robustos que poden arribar a una carrega màxima de 100 tones.

Aquestes màquines reals consten també amb la funció automàtica de la cerca d’objectes en un perímetre determinat per la translació d’aquest objecte fins el lloc desitjat, tal i com s’ha fet en la nostra pràctica. Òbviament, aquestes màquines poden ser controlades a través d’un comandament a distància per la cerca d’objectes manual.

2.2 Fitxa tècnica de Lego Mindstorms El kit de Lego Mindstorms i el seu brick están formats per: - Microcontrolador principal: ARM7 de 32 bits (a 48 MHz), que conté 256 KB de memòria Flash i 64 KB de memòria RAM. - Microcontroladors de sensors: AVR de 8 bits (a 8 MHz), amb 4 KB de memòria Flash i 512 bytes de memòria RAM. - Bluetooth amb SPP (Serial Port Profile), class II Device i amb un abast de 10 metres.

- USB 2.0 (12 Mb/s).

- 7 connectors (3 entrades de motors i 4 de sensors).

Treball de recerca

15

- Display LCD i 4 botons (pantalla LCD amb 4 botons) - Speaker intern (altaveu intern) - Alimentació: 6 piles AA - 3 servomotors - 4 sensors (color, ultrasò, 2 tàctils per la versió 2.0 i 1 tàctil i 1 de so per les altres) El software que Lego Mindstorms proporciona està dirigit per a Windows i MacOS X versió 10.4 o 10.5 encara que hi ha mètodes per poder-lo utilitzar a Linux. El mètode de programació es de llenguatge de programació gràfic. Vol dir que programarem a través d’organigrames.

Aquest llenguatge de programació de Lego Mindstorms

s’anomena NXT-G. Aquest sistema permet en principi una fàcil programació. De fet Lego Mindstorms és considerat adaptable per a nens de més de 10 anys aproximadament.

2.3 Microcontrolador Els microcontroladors són uns diminuts controladors que s’usa pràcticament en qualsevol aparell elèctric. En àmbits generals, aquest dispositiu funciona de tal manera que regula els processos de la maquina en la qual es utilitzat. Aquest dispositiu és similar a una computadora diminuta amb un circuit integrat.

Els components que la composen són : Processador o UCP (Unitat Central de Procés).

Memòria RAM (emmagatzematge efimer però de ràpid accés) Memòria ROM i similars (emmagatzematge perdurable i de lent accés) Línies de Entrades i Sortides (comunicació exterior) Diversos mòduls per controlar perifèrics (temporitzadors, conversadors digital i analògic, etc.).

Inclou un “rellotge” que sincronitza tot el seu funcionament.

En definitiva, emmagatzema els programes i cada cicle del rellotge, executa les instruccions pertinents definides pel programa. La velocitat en la que executa les instruccions és abismal. Poden executar milions de instruccions per segons. En el cas d’un microcontrolador funcionant a 20 MHz pot executar 5 milions d’instruccions per segon.

Treball de recerca

16

Foto real d’un microcontrolador amb les seves potes (pings).

2.4 Servomotor Un servomotor, o també conegut com servo, es un motor amb un gran rendiment de control. Es pot fixar el nombre de gir en graus del seu eix. Això el fa especial, i té un gran ús en robòtica. Aquest motor és capaç de funcionar com a motor de corrent continua encara que tingui la capacitat del servo i manté una força i velocitat optima.

La mesura de la rotació, velocitat... es duu a terme gracies als encoders. Estan formats per elements òptics i el senyal de sortida que generen és digital. Poden ser de dos tipus: incrementals i absoluts.

Els encoders incrementals és un disc que gira juntament amb l’eix del qual es vol mesurar. Els disc compte amb dues ranures A i B que una està més l’exterior i l’altra més a l’interior. En una part hi ha una emissió de llum estàtica produïdes per díodes.

En canvi els encoders absoluts proporcionen una informació molt més concreta i disposa d’un codi de 4 bits. En aquest cas, en comptes de haver dues ranures, hi ha unes franges en blan i negre d’una manera determinada amb una emissió de quatre llums i quatre receptors.

Treball de recerca

17

Imatge real d’un servomotor.

2.5 Sensor El sensor és un dispositiu que transforma magnituds físiques o químiques en variacions de corrent elèctric. Aquests aparells poden donar la informació segons si hi ha o no aquesta magnitud o si hi ha una variació d’aquesta. Per exemple, el sensor de moviment pot detectar si hi ha o no un objecte amb la qual cosa ens donaria una informació de SI i NO i en canvi un sensor de temperatura no ens pot dir si hi ha o no temperatura. En aquest últim cas, marcarem una variable en la qual segons cada paràmetre de la informació farem ús o no d’aquesta. En un exemple pràctic, si en una habitació fa menys de 20 graus, s’engegarà el calefactor i en canvi si fa més de 25 graus s’engegarà l’aire condicionat (i si fa entre 20-25 graus no passarà res).

Alguns sensors són per exemple el de posició lineal o angular, desplaçament i deformació, velocitat lineal i angular, acceleració, pressió, temperatura o tàctil.

Treball de recerca

18

3. PROGRAMACIÓ PER LEGO MINDSTORMS 1. Entorn de programació Lego Mindstorms pot ser programat en molts llenguatges de programació, com per exemple C, C++ o Java. No obstant l’entorn que proveeix Lego amb la compra de l’aparell utilitza el llenguatge NXT-G. Per utilitzar un altre llenguatge hem d’obtenir un altre entorn que ens ho permeti com per exemple BrickOS o LejOS. Alguns d’aquests entorns necessiten un canvi de firmware (software intern) de l’aparell.

2. NXT-G És un llenguatge visual que té com a objectiu ser senzill i adaptable a totes les edats i coneixements. Aquesta és la seva principal avantatge. La desavantatge és que pot ser útil per programes petits però al treballar amb coses grans l’entorn ralentitza molt el seu funcionament.

Per crear una aplicació en aquest llenguatge hem d’iniciar el programa proveït per Lego i que prèviament hem instal·lat. Posteriorment hem de crear un nou arxiu. Se’ns presenta una quadrícula amb el símbol de Lego Mindstorms que representa l’inici del programa. Les barres estil Lego senyalitzen el flux del programa. Sobre aquesta hem de col·locar els blocs amb l’ordre que vulguem per que realitzin la funció en aquest ordre (d’esquerra a dreta).

Aquests blocs són visualment quadrats amb anotacions que defineixen el seu contingut. Realitzen una funció o representen una variable. La funció pot ser de diversos tipus: una operació, el moviment d’un motor, la lectura dels resultats d’un sensor... A més es poden relacionar els blocs a partir de cables.

També hi ha dues estructures que controlen el flux del programa que són l’estructura condicional que bifurca el flux del programa i segueix un camí o un altre depenent de la situació i la l’estructura bucle que repeteix un fragment de codi mentre es compleixi una condició.

Per compilar i carregar al Mindstorms el nostre programa hem de connectar-lo primer per Bluetooth o amb un cable USB. Després hem de seleccionar l’opció de Treball de recerca

19

compilar i carregar al panell d’abaix a la dreta. També es pot executar donant-li a l’opció del centre del mateix panell.

En la següent imatge s’aclareix millor com és l’entorn:

3. El nostre programa Aquest programa ens ha permès fer que el nostre pont grua realitzi tasques automàtiques. Aprofundint en això, el programa funciona de la següent manera.

L’aparell inicia un recorregut per tota l’estructura per tal de trobar un objecte. Al trobar-lo, determina el color, l’enganxa amb l’imant de manera que el porta al lloc estipulat pel seu color. Finalment segueix amb el seu recorregut fins que troba un altre objecte.

Treball de recerca

20

4. PROGRAMACIÓ PER A NINTENDO DS® 1. Conceptes bàsics 1.1 Què és Nintendo DS? La Nintendo DS és una videoconsola portàtil de sèptima generació creada per Nintendo, una empresa japonesa creada al 1889 per Fusajirō Yamauchi. Al principi aquesta empresa es va centrar en la producció d’unes cartes tradicionals japoneses anomenades hanafuda, però més endavant es va decantar per el mercat de les joguines i més tard pel de les videoconsoles.

Va ser llançada a l’any 2004 i des de llavors ha venut aproximadament segons dades de l’empresa 100 milions d’unitats. Cal comentar que aquesta dada té en compte totes les versions. La que hem utilitzat nosaltres és la inicial.

Aquesta està constituïda per dues pantalles TFT/LCD, l’inferior tàctil, de 256X192 píxels. Als costats de la pantalla superior incorpora els altaveus estèreo. Els controls poden ser els botons (A/B/X/Y/R/L/Select/Start), la pantalla tàctil o el micròfon. La bateria té una autonomia de 6 a 10 hores. També té dos lectors de cartutxos, el superior per a videojocs de DS i l’inferior per a videojocs de la predecessora Game Boy Advance. A més la DS permet la connexió Wi-Fi, un sistema d’intercanvi de dades per ones de radio.

Un altre punt important són els processadors, l’ARM7 i l’ARM9 utilitzats també en altres aparells. L’ARM9 és l’encarregat dels gràfics tridimensionals mentre que l’ARM7 només pot desenvolupar gràfics bidimensionals.

Aquestes característiques obren un ventall de possibilitats que juntament amb la seva disponibilitat van fer decantar-nos per la utilització de la Nintendo DS. 1.2 Què són les flash cards?

Per poder executar homebrew, és a dir, software casolà o backups, és a dir, copies de seguretat de videojocs o aplicacions, necessitem una flash card que es un cartutx com els dels videojocs o aplicacions comercials però amb una memòria accessible.

Treball de recerca

21

Per executar, en el cas d’aquest treball, el nostre homebrew simplement s’ha de passar l’arxiu a la memòria de la flash card i seleccionar-lo des de el menú d’aquesta que s’inicia al encendre la consola.

Depenent del tipus de cartutx o cartutxos que utilitzen les flash cards podem dividir-les en dos tipus: les Slot-1 i les Slot-2. Aquestes reben el nom dels ports d’entrada de cartutxos de la consola que utilitzen.

Així, l’Slot-1 agafa el nom del port superior per a videojocs de DS i per tant només utilitza un cartutx semblant als dels videojocs comercials. Alguns exemples són l’R4 o el DSTT. En canvi, l’Slot-2 utilitza dos cartutxos. Un es al port superior que serveix per redireccionar al port inferior i es sol anomenar key. Al port inferior trobem, per tant, el que seria la flash card en si. Aquest mètode es més antic i es feia per aprofitar les flash cards aparegudes per a la predecessora Game Boy Advance. Alguns exemples són l’M3 o l’EZ-Flash V. Una altra classificació les divideix segons la memòria accessible que utilitzen. La flash card pot portar un lector de memòries flash o pot portar una memòria interna al cartutx a la qual s’accedeix connectant-lo directament amb l’ordinador per un lector especial.

La flash card utilitzada per al treball és una Supercard MiniSD que és Slot-2 i utilitza una memòria MiniSD juntament amb el SuperKey al port superior.

2. Programació per la Nintedo DS 2.1 Elements necessaris Per desenvolupar videojocs o aplicacions per a algun aparell necessitem un kit de desenvolupament de software (en anglès Software Development Kit o SDK). Aquests poden ser creats per l’empresa que ha dissenyat l’aparell per després vendre’l o distribuir-lo gratuïtament o pot ser desenvolupat per algú aliè a la companyia. L’oficial s’anomena CodeWarrior™ Development Studio for Nintendo DS i va ser desenvolupat per l’empresa Metrowerks del grup Freescale Semiconductor.

Treball de recerca

22

El que hem utilitzat nosaltres per aquest treball és el DevkitPro, un SDK gratuït que permet fer aplicacions per a moltes videoconsoles, i més concretament hem utilitzat DevkitARM que és la subdivisió destinada a les videoconsoles japoneses Nintendo DS i Game Boy Advance i la sud-coreana GP32. L’avantatge respecte l’oficial és que no és necessari tenir una llicencia de Nintendo per utilitzar-lo però té molts desavantatges com que no permet un accés complet a les possibilitats de les consoles, no té suport tècnic i el programa generat no sembla tan professional.

El DevkitPro conté diversos elements necessaris per a la creació de l’aplicació. Un d’aquest es la llibreria libnds. Les llibreries són fragments de codi que es poden executar des de l’aplicació que crees (o des d’altres llibreries) i que fan tasques com si fossin subprogrames. Aquesta en concret és molt propera al hardware de la DS. Per utilitzar-la s’ha de tenir coneixement de com funciona aquest hardware el que la fa complicada.

Això es pot simplificar

amb unes altres llibreries que aprofiten les libnds,

anomenades PAlib. A més de ser més fàcils d’utilitzar inclouen exemples senzills, emuladors (programes per a ordinador que permeten simular el funcionament d’un altre aparell, en aquest cas la DS) entre d’altres coses. Alguns dels emuladors més coneguts són el iDeaS, el DeSmume i el que hem utilitzat nosaltres per fer alguna proba: el NO$GBA. De totes maneres les PAlib tenen carències com per exemple la tridimensionalitat, en les que hem agut d’utilitzar les libnds.

Un punt molt important és el Makefile, un arxiu inclòs al DevkitPro on es troben totes les regles per compilar el nostre codi font. El codi font és el conjunt d’instruccions donades en un llenguatge de programació determinat per que l’aparell programat faci el que nosaltres desitgem. Aquest codi s’ha de compilar, és a dir, passar d’un llenguatge de programació al llenguatge del sistema (ceros i uns) que pot entendre l’aparell.

Aquest arxiu pot ser llegit per un programa, el qual amb aquestes regles i donant-li el codi font, pot crear l’arxiu executable. Nosaltres hem utilitzat al treball un programa buil.bat inclòs a la llibreria però es podria haver configurat per exemple el Dev-C++ que nosaltres hem utilitzat com editor de text per crear el codi font també per compilar-lo.

Treball de recerca

23

2.2 Llenguatge de programació C 2.2.1 Què és un llenguatge de programació?

Un llenguatge de programació és un llenguatge interpretable per la màquina que volem programar o per un compilador. Aquest compilador és un programa que permet convertir el codi escrit en un llenguatge de programació en un altre que la màquina pot interpretar (normalment llenguatge màquina). Els llenguatges de programació es poden dividir principalment segons dos criteris.

Segons el nivell d’abstracció Aquesta divisió distingeix els llenguatges pel grau d’apropament al hardware en detriment de la facilitat de programació i l’apropament a l’usuari. Normalment com més apropament a l’alt nivell el llenguatge és més entenedor i portable mentre que com més ens allunyem tenim un llenguatge més eficient, ajustat a les possibilitats de l’aparell i de més fàcil o innecessària compilació. · Llenguatge màquina La màquina pot interpretar el codi en llenguatge màquina directament sense compilar. És molt proper al hardware i per tant s’ha de tenir coneixement d’aquest per utilitzar-lo. Es basa en el sistema binari i en el funcionament de la màquina pel que és poc intuïtiu. · Llenguatge de baix nivell Està constituït per el llenguatge assemblador que és proper al llenguatge màquina però que té una certa abstracció. Tot i que encara es difícilment entenedor per l’usuari , té alguns avantatges relacionats amb l’ús acurat de la màquina.

Per executar el nostre programa escrit en aquest llenguatge necessitem un assemblador que és un compilador senzill que permet passar de llenguatge assemblador a llenguatge màquina. · Llenguatge de nivell mig Moltes vegades es sol incloure en l’alt nivell degut a les seves similituds però és cert que els llenguatges de nivell mig tenen certes característiques dels de baix nivell. Sol ser utilitzat per crear sistemes operatius degut a que és més senzill d’utilitzar per Treball de recerca

24

l’usuari que els llenguatges assemblador i màquina però sense perdre massa afinitats amb la màquina. El més important és C. · Llenguatge d’alt nivell Han sigut adequats a l’ésser humà, fent-lo més entenedor i fàcil d’utilitzar però per aconseguir-ho s’ha sacrificat gran part del seu potencial. També permet crear codi vàlid per diferents màquines i fins i tot sistemes operatius. Alguns exemples són C++, C#, Java, Basic, Fortran, Perl, Pascal o Python. · Llenguatges gràfics És el cas de NXT-G, utilitzat a l’entorn de programació de Lego Mindstorm. La programació es basa en blocs i cables gràfics que permeten apropar la programació de l’aparell a qualsevol sector. Malauradament no permet cap més funció apart de les definides per els blocs i cables que són poques. A més és molt lent al compilar i al programar.

Tot i que cada llenguatge gràfic funciona d’una manera determinada, les seves característiques són en major o menor grau les mateixes que les de l’NXT-G. Segons el paradigma de programació Es refereix a l’enfocament del llenguatge de programació. Segons la situació un és més adequat que un altre però tots tenen avantatges i inconvenients. · Imperatiu Ordenen a la màquina el que ha de fer a partir de: - Variables i constants: dades enregistrades en un lloc de memòria de la màquina.

- Tipus de dades: determinen de quin tipus són les variables, és a dir, si la dada enregistrada es un número enter, un caràcter...

- Expressions: són combinacions de variables, constants i operadors.

- Sentencies de control de flux: permet dirigir cap a la direcció volguda el flux del programa escollint un entre dos possibles camins.

El llenguatge màquina i assemblador són imperatius. Altres llenguatges coneguts imperatius són C, BASIC, Pascal, Fortran o Cobol.

Treball de recerca

25

· Orientat a objectes Han heretat característiques dels imperatius. La seva gran característica són els objectes que són entitats amb tres punts fonamentals, l’estat (o característiques de l’entitat), el comportament o mètode (procediments que pot realitzar) i la identitat que el diferencia de la resta d’objectes. Els llenguatges orientats a objectes més representatius són C++, Java, C#, Python (multiparadigma) i JavaScript. · Lògic Com el seu nom indica es fonamenta en la lògica. Sol tenir un alt nivell d’abstracció i és fàcilment comprensible per l’ésser humà. Està relacionat amb el funcional. El llenguatge lògic més important és Prolog. · Funcional Es basa en la utilització de funcions matemàtiques. Està destinat a resoldre problemes complexos a partir de programes curts i simples. Alguns dels llenguatges funcionals més destacables són Haskell, Miranda i Scala.

Tot i que aquesta és la divisió més utilitzada, la frontera entre un paradigma i un altre a vegades és poc definida pel que es parla d’altres agrupacions o de multiparadigma.

2.2.2 Característiques del llenguatge C Com ja hem vist, C és un llenguatge de programació de nivell mig amb paradigma imperatiu orientat a la creació de sistemes operatius (o almenys una gran part d’aquests ja que es fa una base en assemblador).

Les principals avantatges de C són que és eficient i portable tot i ser proper al hardware. La principal desavantatge és que, amb el sorgiment de nous microprocessadors més ràpids, la diferència de l’eficiència amb els llenguatges d’alt nivell no es percep tant pel que es prefereix utilitzar aquest últim tipus de llenguatges ja que faciliten el treball del programador.

Història del llenguatge C El desenvolupament de C es va dur a terme entre 1969 i 1973 als laboratoris Bell de l’empresa AT&T a Nova Jersei (Estats Units). Va ser creat pel físic Dennis MacAlistair

Treball de recerca

26

Ritchie que va col·laborar paral·lelament en la creació del sistema operatiu Unix.

Aquest llenguatge va heretar característiques d’un llenguatge anterior anomenat B que a la seva vegada havia heretat característiques d’altres anteriors.

Després de la seva creació, al final de la dècada dels 70, C es va començar a estendre fins que va desbancar a BASIC com a llenguatge més utilitzat en la programació de microcomputadors. L’èxit del llenguatge va suposar una més ràpida evolució en forma d’estandarditzacions i de llenguatges derivats. Aquests es van fonamentar en la demanda d’un llenguatge semblant a C però amb orientació a objectes com ho van ser C++ i Objective C. C continua sent tema d’actualitat, ja sigui per què segueix sent un dels llenguatges més utilitzats o per què ha generat i es continua treballant en llenguatges fortament influenciats per C o pels seus derivats com per exemple C#, Java o Vala.

2.2.3 Nocions de C Tal i com s’ha explicat anteriorment, per poder executar codi en C es necessita un compilador de C que tradueixi el codi escrit en aquest llenguatge en codi entenedor per la màquina. També s’ha explicat que per compilar el programa de la DS hem utilitzat un ofert per les PAlib. Pel programa de l’ordinador escrit en C++ hem utilitzat el Dev-C++ que compila C i C++.

Així doncs, amb el compilador preparat ja podem iniciar la programació: Estructura principal del programa #include <stdio.h> int main(){ printf(“Això és el cos del programa\n”); system("PAUSE"); return 0;}

Aquest petit exemple mostra les parts fonamentals que tindrà qualsevol programa escrit en C. Comencem amb la directiva que es el text escrit en verd que permet carregar arxius d’inclusió o capçaleres (en anglès header, per això l’arxiu de l’exemple té l’extensió .h). En la compilació en aquesta part el codi de la capçalera s’afegeix al

Treball de recerca

27

nostre codi. Al afegir-la ens permet utilitzar les funcions que conté. En aquest exemple utilitzem la funció printf() de l’stdio.h.

Passem ara a l’“int main()”. Aquesta és la funció principal del programa i per això s’anomena main ja que és el nom anglès de principal. Al acabar la funció main aquesta torna un valor que determina si el programa ha trobat o no un error. El tipus de dada que torna ve determinat pel que hi ha davant de main. En aquest cas és int que significa integer en anglès, número enter en català. Al final del codi trobem “return 0;” que es on acaba el programa ja que ens ha de tornar 0 al no produir-s’hi errors.

La grandària de la funció main està determinada per les claus {}. El que trobem a dins és el cos del programa. Aquí és on trobem la funció printf() que ens permet mostrar per pantalla text o dades. Cal dir que el resultat del programa no mostrarà els accents degut a les estandarditzacions de l’ANSI si no que mostrarà altres lletres o símbols. La línia següent pausa el programa per poder veure els resultats ja que si no es pauses s’executaria a una velocitat imperceptible per l’ésser humà.

Un altre punt important és el símbol “;” que ha d’estar present al final de cada instrucció com a separació, el que permet poder posar més d’una funció a una mateixa línea (entenent com a instrucció una tasca única com per exemple sumar valors a una variable o mostrar dades per pantalla).

Tipus de dades, constants i operadors Variables i tipus de dades Per utilitzar una variable primer l’hem de declarar. Per fer-ho hem d’utilitzar l’estructura: Tipus_de_dada variable; Exemple: unsigned char variable_1=0; Les variables poden estar compostes per lletres (menys la ñ), el símbol “_” i números (mentre no sigui el seu primer caràcter). Tampoc estan permeses les paraules reservades pel llenguatge com són if, else, while, for... Per tant serien incorrectes per exemple les formes “1variable” o “variable/1”. A més, C diferencia entre majúscules i minúscules i per tant no seran la mateixa variable “variable1” i “Variable1”. Això també Treball de recerca

28

repercuteix a la resta del codi i per tant si per exemple en comptes d’escriure printf() en l’apartat anterior escrivíssim Printf() el compilador notificaria un error al codi.

A la declaració sempre s’ha de determinar el tipus de dada que contindrà la variable perquè el compilador li reservi una part de la memòria. Això es fa afegint-hi les inicials en anglès del nom del tipus de dada davant de la variable. Aquestes són les possibilitats: Rang Tipus de dada

Significat

Número de bits enmagatzemable

char

Caràcter

8

-128 a 128

int

Enter

16

-32.767 a 32.767

long

Enter llarg

32

-2,14·109 a 2,14·109

float

Nombre real

32

3,4E-38 a 3,4E38

double

Nombre real llarg

64

1,7E-307 a 1,7E308

Aquestes dades poden canviar depenent de la màquina i el compilador, però són les més usuals i les utilitzades en el treball.

Davant del tipus de dada també es pot afegir un modificador que fa variar el rang.

Els més basics són signed, unsigned, short i long. En el nostre cas les variables són de manera predeterminada signed i short, és a dir, curtes i amb signe. Si afegim unsigned la variable no abastarà els nombres negatius però abastarà el doble de positius i per tant el rang serà igual de gran però desplaçat. En canvi amb long el que aconseguim es que augmenti el rang.

Altres modificadors són el const que torna constant el valor de la variable durant l’execució del programa, l’static, l’auto o l’extern.

Al programar per la DS també es pot determinar el tipus de dada per la forma (signed/unsigned)(nombre de bits). Per exemple s8 (signed de vuit bits), u16 (unsigned de setze bits) , s32...

Quan es defineix una variable també se li pot assignar un valor com es fa a l’exemple. Cal recordar que s’ha d’afegir “;” al final de la instrucció per ser correcte.

Treball de recerca

29

A més, les variables poden ser globals o locals. Si es defineixen fora de les funcions, inclosa main, és global i per tant es poden utilitzar en qualsevol de les funcions. Si es defineixen dintre d’una funció seran locals i només es podran utilitzar en aquella en concret.

Constants Hi ha dues maneres de definir una constant: #define variable1 0 const variable1=0; const int variable1=0; La primera és fent ús del define, afegint-lo juntament amb els include. Segueix l’estructura #define nom_de_la_variable valor. La segona és utilitzant const com a tipus de dada o modificador.

Operadors Hi ha diferents tipus d’operadors, cadascun amb la seva funció: · D’assignació: com el seu nom indica assigna un valor a la variable. És el cas de l’igual a variable1=0; en l’exemple anterior. · Aritmètics: Suma (+ i +=): El codi x=x+3; que suma 3 a la variable és equivalent a x+=3;.

Resta (- i -=): El codi x=x-3; que resta 3 a la variable és equivalent a x-=3;.

Increment (++): Suma 1 a la variable, és a dir, si tenim que x és inicialment sis i trobem el codi x++; x passarà a ser set.

Decrement (--): Resta 1 a la variable, és a dir, si tenim que x és i inicialment sis i trobem el codi x--; x passarà a ser cinc.

Multiplicació (* i *=): En x=x*y; x tindrà el valor de la multiplicació entre x i y i serà equivalent a x*=y; Quocient (/ i /=): En x=x/y; x tindrà el valor del quocient entre x i y i serà equivalent a x/=y.

Residu (% i %=): En x=x%y; x tindrà el valor del residu de la divisió entre x i y i serà equivalent a x%=y.

Treball de recerca

30

Altres: Alguns arxius de capçalera com math.h contenen exponents, funcions trigonomètriques, arrels quadrades... · De comparació: L’operació torna 0 si no es compleix i normalment 1 si es compleix. Aquests són igual que (==), diferent de (!=), major que (>), menor que (<), major o igual que (>=) i menor o igual que (<=). Són utilitzats sobretot a les sentències de control de flux com veurem més endavant. · Lògics: Com els de comparació, els operadors lògics també solen ser utilitzats a les sentències de control de flux. Només són tres: AND (&&), OR (||) i NOT(!). Permeten unir dues o més comparacions.

Hem utilitzat també l’operador sizeof que determina la dimensió en bytes d’una variable. Aquesta classificació no recull tots els grups (com els operadors de bits), sinó que només els dels operadors que hem utilitzat.

Finalment, és important tenir en compte l’ordre en que el programa durà a terme les operacions:

Prioritat ( ) [ ] -> ! ++ -- *(punter) sizeof *(multiplicació) / % +< <= > >= == != && || = += -= *= /=

Treball de recerca

31

Arrays i strings Alguns llenguatges com C++ defineixen les strings o cadenes de caràcters amb el tipus string però C no és el cas ja que utilitza un array de variables char. L’array és un conjunt de variables d’una mateixa classe amb un nom comú. Es solen definir de les següents maneres: Tipus_de_dada nom[dimensió]; Tipus_de_dada nom[] = “Cadena de caràcters”; Tipus_de_dada nom[] = { 'C', 'a', 'd', 'e', 'n', 'a', '\0' }; /*Exemple:*/ char nom[4]; /*Equivalent:*/ char nom0, nom1, nom2, nom3, nom4;

S’ha de tenir en compte que al final de cada cadena trobem “\0” que marca el final de cadena. Per tant la dimensió per exemple de “nom” serà 4 i no 3. En la tercera manera de definir-la cal afegir “\0” per evitar errors.

Structs Les estructures o structs són grups de variables amb una mateixa temàtica. En aquest treball han sigut utilitzades per agrupar la informació que s’ha de guardar en una arxiu. Es defineixen de la següent manera: struct nom_estructura { int variable1; float variable2; … // Variables que volem definir dintre de l’estructura } referent;

L’estructura agafa com a identificador una variable (en aquest cas referent) que permet utilitzar les variables de l’estructura amb la forma referent.variable.

Sentències de control de flux Aquestes sentències determinen el flux del programa, és a dir, el camí que segueix depenent de la situació. Hi ha més, però les que més hem utilitzat són:

Treball de recerca

32

While La seva funció és repetir un fragment de codi mentre es compleixi una condició. Té la forma: while (/*Condició*/) { /* Codi a executar*/} For És similar a while ja que també crea un bucle. La diferència es que for permet operar a la vegada amb una variable. Té la forma: for (/*operació inicial*/;/*condició*/;/*operació repetida*/) { /* Codi a executar*/} //Exemple: for (i=0;i<40;i++) { printf(“For\n”);}

L’operació inicial és l’operació que permet fer for al iniciar el bucle. Cada vegada que s’executa el codi de dins del for (que es repeteix mentre la condició sigui certa) es realitza l’operació repetida.

Al executar el codi d’exemple (amb els archius de capçalera i la funció main) ens mostraria per pantalla una llista de 40 “For”.

If-else A diferència de les anteriors aquesta és condicional. La funció d’if és executar un codi si es compleix una condició. Si després de la sentència if apareix else i la condició no es compleix, s’executa el codi dins d’else. La seva forma és: if (/*condició*/) { /* Codi a executar si es compleix la condició*/} else { /* Codi a executar si no es compleix la condició*/}

Goto L’hem utilitzat molt poc ja que a la majoria dels casos el seu ús dificulta la lectura del codi. Serveix per anar d’un punt del codi a un altre. El punt al que es vol anar es Treball de recerca

33

determina per una etiqueta que s’escriu amb la forma etiqueta1:. Es selecciona l’etiqueta a la qual volem fer el salt amb la forma goto etiqueta1;.

Funcions Tal i com podem declarar la funció main també podem declarar-ne altres tot i que no siguin principals per després utilitzar-les quan ho necessitem des de main. A més existeixen els arguments, que ens permeten introduir valors a la funció.

Les funcions ens permeten acurtar el codi i estructurar-lo millor. Té la forma següent: tipus_de_dada nom_funcio (/*declaració dels arguments*/) { /* Codi a executar*/} tipus_de_dada main(/*declaració dels arguments*/) { /* Codi*/ nom_funcio (/*valor dels arguments*/) ; /* Codi*/}

2.3 Programació La plantilla de PAlib Les llibreries PAlib ofereixen una plantilla d’arxius i carpetes sobre la que realitzar el treball de programació. És important seguir-la per poder introduir al nostre projecte els fons, sprites, sons,etc i perquè el compili correctament.

A la següent imatge trobem la disposició dels arxius i carpetes del nostre programa, una mica més complet que la plantilla per defecte.

Treball de recerca

34

Pasem ara a explicar-ho part per part: - A la carpeta build trobem arxius creats per el compilador durant el procés de compilació. L’utilitza com a llistat d’elements a incloure al treball.

- A la carpeta data és on ficarem els arxius d’imatge i so que volem incloure al treball i que es carregaran al iniciar-lo a la memòria RAM de la consola.

- Com que la RAM principal de la DS és de 4 megabytes s’han creat maneres de tenir cert dinamisme en l’entrada i sortida de dades a la RAM i també d’augmentar aquest límit. Un d’aquests mètodes per augmentar-la és mitjançant PAFS. Per carregar un arxiu mitjançant aquest sistema s’ha d’incloure a la carpeta Files. Més endavant s’explicarà amb més detall.

-A source trobem la part fonamental del projecte, el codi font main.c. A més trobem la carpeta gfx on han d’estar els sprites que volem incloure al programa.

- build.bat és un arxiu executable que gràcies al Makefile compila el codi i compacta els arxius de la plantilla en un sol arxiu executable per la DS o un emulador.

- L’executable clean.bat elimina els arxius acabats en .nds o .gba de la carpeta si n’hi ha.

- logo.bmp és la icona de presentació del programa.

- Els arxius project.vho i project.vhw permeten obrir el projecte amb VisualHam. En aquest cas no han sigut utilitzats.

- PAFS.bat permet incloure a l’arxiu compilat per build.bat recursos amb el sistema PAFS. Entre els processos que realitza un és executar PAFS.exe.

- En la compilació i al aplicar PAFS és generen dos arxius per raons de compatibilitat amb la flash card, un acabat en .nds i un altre en .gba.

A més per iniciar les PAlib al nostre projecte hem d’incloure l’arxiu de capçalera <PA9.h> que també inclou les libnds i posar les funcions PA_Init(); i PA_InitVBL(); a l’inici de la funció main.

Treball de recerca

35

Sortida de dades Text Les següents sentències permeten mostrar text per pantalla: /*Iniciar el text:*/ PA_InitText(/*Pantalla*/,/*Capa de profunditat*/); /*Color del text:*/ PA_SetTextCol(/*Pantalla*/,/*Color R,G,B*/); /*Color del text:*/ PA_SetTextTileCol(/*Pantalla*/,/*Color 0-9*/); /*Mostrar el text...*/ PA_OutputText(/*Pantalla*/ , /* X*/,/* Y*/, “Text”);

La pantalla es selecciona amb els valors 0 (pantalla inferior) i 1 ( pantalla superior).

La capa de profunditat ha de ser entre 0 i 3. La diferència entre PA_SetTextCol(); i PA_SetTextTileCol(); és que el primer canvia el color del text ja escrit i del que s’escriurà i el segon només el color del que s’escriurà a continuació. A PA_OutputText(); X i Y són les coordenades en les que es mostrarà el text.

A vegades es necessari saber quin valor tenen les variables. Per mostrar aquests valors s’ha de fer de la següent manera: int numero=1; char cadena[7]= “Cadena”; PA_OutputText(0, 0, 0, “Numero: %d Cadena: %s”, numero, &cadena);

Les llibreries també permeten canviar la font carregant-la com un sprite i iniciant-la amb PA_InitCustomText(0,0, nomdelafont); sent els primers valors els mateixos que a PA_InitText();.

Entrada de dades Botons Gracies a un grup d’estructures creades per les PAlib és molt fàcil saber l’estat de cada botó. En el següent esquema podem apreciar la jerarquia de les estructures i variables:

Treball de recerca

36

Llavors, per exemple, la variable Pad.Held.A serà 1 quan el botó A estigui polsat i 0 quan no. Cal destacar que per a Pad.Newpress.A la variable serà 1 només fins l’instant següent de polsar-lo tot i que segueixi polsat. El mateix a l’inversa passa amb Pad.Released.A. Stylus Stylus és un altre nom per referir-se al llapis táctil. Aquest apartat més concretament tracta l’estat de la pantalla tàctil. També funciona amb estructures. Més contretament amb la forma Stylus. seguit de Newpress, Released, Held, X o Y. Les primeres funcionen com als botons. X i Y ens donen els valors en coordenades d’on toca l’Stylus a la pantalla.

Reconeixement de l’escriptura Les PAlib tenen un apartat dedicat al reconeixement de l’escriptura que es divideix en dues parts, el reconeixement amb el sistema Graffiti-like i el reconeixement definit pel programador.

El sistema Graffiti-like té una base de dades amb les que compara la nostre escriptura per determinar la lletra de que es tracta. Com que només permet lletres i no es pot variar ens vam decantar per l’altre alternativa.

Abans de explicar com es reconeixen les formes cal explicar com es dibuixa amb la DS: u16 *pal = (u16*)PAL_BG0; pal[1] = PA_RGB(0, 0, 0); PA_16bitDraw(0, 1); /*Funció per dibuixar sobre un fons de 16 bits, també podria ser de 8 bits. El primer valor és la pantalla i el segon el color*/

Treball de recerca

37

Una vegada que ja podem veure el que fem podem passar a preparar la consola perquè ho reconegui. Per fer això primer hem d’introduir les formes que volem que reconegui i assignar-li un valor de la següent manera: PA_UsePAGraffiti(0); // 0 per deshabilitar-ho, 1 per habilitar-ho PA_RecoAddShape(/*Valor*/, /*Forma segons el sistema*/); /*Exemple:*/ PA_RecoAddShape('a', "AAAAAAAAAAAAAAA");

Per saber si la consola ha reconegut una forma hem d’utilitzar PA_CheckLetter();.

Aquesta funció sense arguments torna el valor de la lletra escrita.

Fons PAlib permet la càrrega de fons tant dinàmics com estàtics. El dinàmic es divideix en l’scrolling o desplaçament del fons i en la rotació. Aquests solen ser utilitzats en videojocs però no en aplicacions. Per això hem utilitzat fons estàtic que es pot carregar de tres maneres diferents: EasyBg Per carregar fons per aquest sistema primer s’ha de convertir la imatge que volem utilitzar. Per fer-ho les PAlib ofereixen un convertidor a la carpeta tools anomenat PAGfx. Aquest transforma imatges de fins a 256 colors en codi. #include "gfx/all_gfx.c" #include "gfx/all_gfx.h" PA_EasyBgLoad(/*Pantalla*/,/*Capa del fons 0-3*/,/*Nom del fons*/);

Per mostrar la imatge primer aquesta s’ha d’agregar al treball com veiem al principi i després escriure la funció que la mostra. La imatge convertida ha d’estar a la carpeta source i a la subcarpeta que escollim, en aquest cas i com és normalment, a la carpeta gfx. Com que es poden carregar molts fons hem de determinar la prioritat a partir de les capes. Així amb un número més petit tenim més prioritat.

Jpeg Es pot incloure aquest format d’imatge fàcilment i sense conversió però té certs desavantatges com que ocupa més memòria i que triga molt en carregar.

Treball de recerca

38

#include "jpeg.h" PA_Init16bitBg(/*Pantalla*/, /*Capa de fons 0-3*/); PA_LoadJpeg(/*Pantalla*/,(void*)/*Nom de la imatge sense l’extensió*/);

Amb la primera sentència incloem la imatge. Aquesta ha d’estar en la carpeta data.

Amb la segona iniciem el mode de 16 bit. La tercera mostra l’imatge.

Gif El procediment és molt similar. Són les mateixes funcions adequades a aquest format: #include "gif.h" PA_Init8bitBg(/*Pantalla*/, /*Capa de fons 0-3*/); PA_LoadGif(/*Pantalla*/,(void*)/*Nom de la imatge sense l’extensió*/);

Sprites Mostrar sprites estátics Els sprites són imatges que permeten definir un color com a transparent. Poden ser de 256 colors o de 16 bits. Els més utilitzats són els de 256 colors. A més han de tenir unes dimensions determinades: píxels

8

16

32

64

8 16 32 64

8x8 8x16 8x32

16×8 16×16 16×32

32×8 32×16 32×32 32×64

64×32 64×64

Els sprites de 256 colors també s’han de convertir tal com ho hem fet amb el fons.

En aquest cas a la dreta del programa hem de seleccionar el color que es transparentarà. El programa a més generarà una paleta amb els 256 colors. Per mostrar l’sprite farem el següent: #include "gfx/all_gfx.c" #include "gfx/all_gfx.h" //Carregar la paleta: PA_LoadSpritePal(/*Pantalla*/,/*Número de paleta*/,(void*)/*Nom*/);

Treball de recerca

39

//Mostrar l’sprite: PA_CreateSprite(/*Pantalla*/,/*Número d’sprite*/ ,(void*)/*Nom*/, OBJ_SIZE_/*Dimensions*/, /*Mode 256 colors*/, /*Paleta*/,/*X*/, /*Y*/); El número de paleta és el número de referència que li assignem a la paleta per després poder seleccionar-la al mostrar l’sprite. Les dimensions han de seguir l’estructura de la taula anterior. X i Y defineixen les coordenades en les que es mostrarà l’sprite.

Animació Per crear una animació amb un sprite primer de tot hem de tenir la seqüència de fotogrames que volem que tingui l’animació. Després cal posar els fotogrames un sota l’anterior ordenadament en una sola imatge i convertir-la a codi. Seguidament cal fer els passos de l’apartat anterior i en la funció PA_CreateSprite(); posar la dimensió dels fotogrames. Per últim podem controlar l’animació amb les següents funcions: //Iniciar l’animació: PA_StartSpriteAnim(/*Pantalla*/, /*Sprite*/, /*Primer fotograma*/, /*Últim fotograma*/, /*Fotogrames per segon*/); //Pausar/continuar l’animació: PA_SpriteAnimPause(/*Pantalla*/, /*Sprite*/, /*Pausa 1 Continuar 0*/); //Mostrar un fotograma determinat: PA_SetSpriteAnim(/*Pantalla*/, /*Sprite*/, /*Fotograma*/);

Altres funcions Hi ha molts efectes per aplicar als sprites com transparència, efecte mosaic... però ens quedarem amb el més important:

//Moure l’sprite: PA_SetSpriteXY(/*Pantalla*/, /*Sprite*/,/*X*/, /*Y*/); //Es toca l’sprite en la pantalla tàctil. Torna 1 si és cert: PA_SpriteTouched(/*Sprite*/); //Voltejar l’sprite horitzontalment: PA_SetSpriteHflip(/*Pantalla*/,/*Sprite*/,/*Habilitat o no 0-1*/); //Voltejar l’sprite verticalment: PA_SetSpriteVflip(/*Pantalla*/,/*Sprite*/, /*Habilitat o no 0-1*/);

Treball de recerca

40

FAT FAT és un sistema inclòs a les PAlib que permet l’ús dinàmic de la memòria RAM. Això significa que podem carregar arxius de la targeta de memòria sense haver-los inclòs en la compilació i també eliminar-los posteriorment de la RAM. Per tant, es pot carregar i eliminar arxius de so i imatge a la memòria però també es pot treballar amb arxius .save, és a dir, de guardat de dades. Les diferents implementacions de FAT es tracta en els apartats pròxims.

So La DS és un aparell molt poc potent en el apartat de so. Pot arribar a reproduir MP3 amb dificultat i amb kbps baixos però els formats més utilitzats són mod i raw. En aquest cas utilitzem raw.

Aquest també ha de tenir unes característiques

determinades, més concretament ha de tenir format de 8 bits sense signe a 11025 Hz. Després de ficar l’arxiu de so que volem introduir a la carpeta data escrivim els següents elements al codi: #include "so.h" //Inicia les llibreries de so: AS_Init(AS_MODE_SURROUND | AS_MODE_16CH); //Inicia l’arxiu de so seleccionat: PA_PlaySimpleSound(/*Canal 0-7*/, /*Arxiu de so*/); Com que el so ocupa molt espai i la DS només té 4 megabytes de memòria RAM és millor carregar-lo per FAT i així podem eliminar-lo si ho desitgem quan necessitem espai. Es fa de la següent manera: #include <fat.h> fatInitDefault(); //Inicia el sistema FAT PA_FatInitAllBuffers(); //Crea espai en memòria per carregar arxius PA_FatSetBasePath("Direcció del so a carregar"); //Direcció de la targeta on és el so PA_FatLoadSfx("SFX_1", "so"); //Guarda el so en memòria i li assigna un nom PA_FatPlaySfx("SFX_1"); //Reprodueix el so PA_FatUnloadSfx("SFX_1"); //Elimina el so de la memòria

Treball de recerca

41

Micròfon Per utilitzar el micròfon primer s’ha d’iniciar el sistema de so com a l’apartat anterior. Després hem de definir una cadena on es guardarà el so enregistrat. Per utilitzar el micròfon hem de fer servir: u8 MicData1[/*Temps límit de gravació. Aprox. 10000 per cada segon.*/]; //Per gravar: PA_MicStartRecording(/*Cadena*/, /*Temps de gravació*/); //Per reproduir lo gravat: PA_MicReplay(/*Cadena*/, /*Temps de reproducció*/);

Guardar i carregar dades Quan volem utilitzar una dada en una posterior execució del programa l’hem de guardar en un arxiu .save i a la nova execució carregar-la. Nosaltres hem utilitzat això per guardar l’estat de les opcions del programa perquè continuïn com estaven a les properes execucions fins que es canviï.

Com hem dit abans s’utilitza el sistema FAT i per tant s’ha d’iniciar. També s’ha de recopilar les variables que volem guardar en una estructura. S’utilitza de la següent manera: #include <fat.h> typedef struct {s8 dadaguardar1; s8 dadaguardar2; }nom_estructura; fatInitDefault(); //Per guardar: FILE* save_file = fopen("save_file.save", "wb"); //Obrir l’arxiu de guardat fwrite(&nom_estructura, 1, sizeof(nom_estructura), save_file); //Guardar fclose(save_file); //Tancar l’arxiu de guardat // Per carregar: FILE* save_file = fopen("save_file.save", "rb"); //Obrir l’arxiu de guardat fread(&nom_estructura, 1, sizeof(nom_estructura), save_file); //Carregar fclose(save_file); //Tancar l’arxiu de guardat

El primer argument d’fopen obre l’arxiu on es guardarà o es carregarà. Si no el troba el crea. El segon argument determina perquè s’obre l’arxiu. Al primer fopen wb és per Treball de recerca

42

write binaries, és a dir, per escriure en binari. Al segon és per read binaries, és a dir, per llegir en binari. També podria ser wt i rt que seria en text en comptes de en binari però és més lent. A fread i fwrite els arguments són en ordre el nom de l’estructura que volem guardar/carregar, longitud màxima de les variables que guarda, la dimensió de l’estructura i l’arxiu on es farà l’acció. Finalment amb fclose es tanca l’arxiu obert per l’escriptura o lectura de dades.

PAFS Significa PAlib File System, que en català es tradueix com PAlib sistema d’arxius. És una reminiscència de les primeres versions de les llibreries quan les flash card slot 2 eren les més comunes o inclús les úniques ja que aquest sistema no funciona amb slot 1. El esquema de la següent pàgina ens ajudarà a entendre perquè només funciona amb aquestes flash card entre d’altres coses. Per exemple ens servirà també amb l’apartat de 3D ja que està programat amb les libnds que requereixen, com hem dit abans, tenir coneixements de les característiques internes de la màquina.

En aquest apartat és important fixar-se en 4 caixetins de l’esquema: l’ARM9, l’ARM7, el GBA Card i la Main Memory que són els dos processadors, la memòria de la flash card slot 2 i la memòria interna de la DS. Tenim que tractar també el funcionament de la Game Boy Advance (GBA) per comprendre el sistema, degut a que l’slot 2 estava pensat inicialment per introduir els seus jocs. Aquesta consola no tenia memòria principal si no que els seus jocs portaven una memòria que feia la seva funció. Per això, alguns jocs o aplicacions comercials per la DS utilitzen l’entrada de jocs de GBA com a extensió de memòria.

Com que les flash card slot 2 estaven pensades per executar programes de GBA van haver de crear un sistema per passar l’executable d’una memòria flash extraïble a una memòria interna de la flash card. Així doncs aquesta memòria interna de fins a 32 megabytes es pot aprofitar com a extensió de memòria principal per la DS amb el sistema PAFS.

Treball de recerca

43

Per carregar imatges amb PAFS hem de ficar-les a la carpeta Files controlant l’ordre alfabètic que serà important al escollir la imatge a mostrar. En el codi farem el següent:

Treball de recerca

44

PA_FSInit(); //Iniciar el sistema PAFS // Mostrar imatges (es pot fer el mateix amb els gif i altres formats): PA_LoadJpeg(0, PA_PAFSFile(/*Numero d’arxiu per ordre alfabètic*/)); Una vegada compilat s’ha d’executar el PAFS.bat per adjuntar els arxius per PAFS a l’executable.

3D Les antigues versions de PAlib incorporaven un apartat sobre 3D però degut a la poca capacitat d’aquest el van suprimir. Per tant hem agut d’utilitzar les libnds que a la vegada inclouen part de les OpenGL (llibreries gràfiques obertes).

Les limitacions de la DS són que no pot carregar textures molt grans ni amb molta qualitat ni models amb més de 6114 vèrtexs. Per treballar amb el 3D hem d’iniciar les OpenGL de la següent manera: videoSetMode(MODE_0_3D); //Iniciar el mode 3D vramSetBankA(VRAM_A_TEXTURE); //Reserva memòria visual per a textures glInit(); //Iniciar les OpenGl glEnable(GL_TEXTURE_2D); //Inicia el mode textures glEnable(GL_ANTIALIAS); //Activar l’antialiasing (millora gráfica) glClearColor(0,0,0,31); //Color de fons RGB i activació de l’antialiasing glClearDepth(GL_MAX_DEPTH); //Profunditat de l’espai al màxim glViewport(0,0,255,191); //Coordenades inicials i finals de l’espai on es representarà (en aquest cas pantalla completa) glMatrixMode(GL_PROJECTION); //Carregar matriu de projecció gluPerspective(60, 256.0 / 192.0, 0.1, 100); //Perspectiva glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK); //Opcions de la visualització Els primers inicien el mode 3D, després es situa i configura la càmera i finalment amb l’última sentència es donen certes propietats als models. En aquest cas són posar l’alpha blending a 31 (si augmentem el número es transparentaran les cares) i fer que no es dibuixin les cares que no es veuen.

Cal destacar també la segona funció que permet reservar l’espai A de la memòria visual per a textures. En el esquema de l’apartat sobre PAFS tenim més informació sobre aquests espais de memòria. Per reservar més haurem de canviar les A per B, per C...

Treball de recerca

45

Ara passem a veure les funcions per mostrar un model. Aquestes han d’estar dins d’un while per que es vegi el moviment del model si n’hi ha. Si no, es mostraria una imatge estàtica del model. while (1){ Model3D(); //Funció on tenim les dades del model glMatrixMode(GL_MODELVIEW); //Mostra el model glFlush(0); //Allibera memòria} Per crear un model 3D que puguem introduir al projecte tenim dues possibilitats, escriure en el codi directament o passar un model creat amb un programa d’edició 3D a codi a partir d’un altre programa o d’un script. En el nostre cas vam començar fent una cosa senzilla directament en el codi però posteriorment vam utilitzar un maxscript per a 3d Studio Max. El maxscript és un fragment de codi que compren aquest programa i que fa una certa funció. Es pot passar el model però s’han d’aplicar les textures posteriorment en el codi. Les funcions per definir un model són: Model3D(){ glLoadIdentity(); //Unifica tots els vèrtexs en una sola entitat glTranslatef(0.0f,0.0f,0.0f); //Coordenades de posició X, Y i Z de l’entitat glRotateX(9.0f); //Rota un cert angle el model en l’eix X glRotateY(9.0f); glRotateZ(9.0f); //El mateix a l’eix Y i Z glBegin(GL_TRIANGLES); //Cares del model formades per tres vèrtex glBegin(GL_QUAD); //Cares del model formades per quatre vèrtex glColor3f(0.0f,0.0f,0.0f); //Determina el color de les cares RGB glVertex3v16(-4117,0,-2702); //Determina un vèrtex a les coordenades X, Y i Z glEnd(); //Acaba l’entitat}

Finalment hem de parlar de les textures, és a dir, les imatges aplicades sobre el model per aportar realisme. Aquestes han de tenir format .pcx i estar a la carpeta data. Primer de tot s’han d’incloure i carregar en el treball. #include "textura_pcx.h" char textura[1]; //Definim una cadena que utilitzarem de referència sImage pcx; //Defineix com a imatge pcx loadPCX((u8*)textura_pcx, &pcx); //Carrega la nostre imatge i la guarda a pcx image8to16(&pcx); //Passa la imatge de 8 a 16 bits glGenTextures(1, &textura[0]); //Defineix el número de textures i la referència

Treball de recerca

46

glBindTexture(0, textura[0]); //Activa la textura glTexImage2D(0, 0, GL_RGB, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, TEXGEN_TEXCOORD, pcx.image.data8); //Configura la textura imageDestroy(&pcx); //Acaba el procés eliminant la imatge i deixant la textura El primer valor de glBindTexture es posa per compatibilitat amb OpenGl però a la DS no té cap funció. Al configurar la textura l’important és introduir el tamany correcte en píxels a TEXTURE_SIZE_(píxels), la resta és millor deixar-ho així per la correcta representació de la textura.

Una vegada que tenim carregada la textura hem d’aplicar-la al model. Ho fem amb aquestes dues funcions: glBindTexture(GL_TEXTURE_2D, textura[0]); //Determinar la textura que s’utilitzarà glTexCoord2t16(0,2032); //Coordenades de la textura per els vèrtexs pròxims La primera sentència s’ha de posar a l’inici de la cara o cares que es volen texturitzar escollint la textura que volem utilitzar. La segona sentència s’ha de col·locar abans de cada vèrtex i determinen la representació de la textura.

Connectivitat Podem connectar la DS a l’ordinador, a Internet o a una altre DS a través de la connexió per ones Wi-Fi. En aquest cas parlem de connexió amb l’ordinador. El primer pas és configurar la connexió a un punt d’accés al menú Wi-Fi de la consola. En alguns casos també cal configurar el punt d’accés (per exemple obrir ports utilitzats per la consola o introduir la clau MAC) i l’ordinador (per exemple el firewall programa que controla les connexions de l’ordinador).

També necessitarem crear i executar un programa que es connecti amb la DS (ho veurem més endavant). Una vegada fet això ja podem programar a la DS: #define MYPORT 32123 //Definim una constant amb el port PA_InitWifi(); //Encendre el Wi-Fi PA_ConnectWifiWFC(); //Conectar-se a un punt d’accés configurat PA_InitSocket(&sock, direcció, MYPORT, PA_NORMAL_TCP); //Crear un socket struct sockaddr_in my_addr; //Estructura de guardat de dades de connexió my_addr.sin_family = AF_INET; //Tipus de connexió my_addr.sin_port = htons(MYPORT); //Port de connexió

Treball de recerca

47

my_addr.sin_addr.s_addr = inet_addr(direcció); //Direcció IP connect(sock,(struct sockaddr *)&my_addr, sizeof (struct sockaddr)); //Crea la connexió a partir del socket i les dades emprades Un port és un canal pel qual s’envien i es reben dades. És important ja que el programa de l’ordinador ha de conectar-se pel mateix port que la DS. Un socket és el conjunt de la direcció IP (número que identifica a un aparell en una conexió), el protocol i el port.

Un protocol és un conjunt de regles que segueixen les

computadores per intercambiar informació a una xarxa. D’aquesta manera, quan creem un socket com hem vist abans amb PA_InitSocket definim primer el punter on es guardarà la configuració, després l’IP, el port i per últim el protocol que en aquest cas és TCP. Per enviar o rebre dades ho hem de fer de la forma següent: recv(sock, buffer, 256, 0); //Rebre dades strcpy(buffer, "Nintendo Ds Conectada|"); //Ficar dades al buffer send(sock, buffer, 22, 0); //Enviar dades Per guardar els que ens arriba necessitem una variable que normalment se li posa el nom de buffer. Tant a recv com a send els arguments són el socket, el buffer, les dimensions del buffer i el tipus de transmisió que per la DS millor que sempre sigui nul.

Strcpy serveix com el nom indica (string copy, copia de cadena) per asignar el valor de la cadena que escribim a buffer.

Altres Hi ha moltes funcions que no poden ser classificades en els apartats anteriors. En aquest punt parlarem de les més importants. // Control de la lluentor (no la retroiluminació) PA_SetBrightness(/*Pantalla*/, /*Lluentor -31 a 31*/); // Sincronització de l’execució del programa amb els fotogrames de la pantalla PA_WaitForVBL(); // Eliminar el text de la pantalla PA_ClearTextBg(/*Pantalla*/); PA_Clear16bitBg(/*Pantalla*/); // Eliminar tot el mostrat per pantalla // Apagar o encendre retroiluminació PA_SetScreenLight(/*Pantalla*/, /*1 Encès, 0 Apagat*/); Treball de recerca

48

El nostre programa Tot el que hem vist anteriorment són els conceptes necessaris per la creació de software per la DS. En aquest apartat ens centrarem més concretament en el software creat pel treball. Com a descripció general, es tracta d’un control remot per a Lego Mindstorms.

En aquest treball ens hem marcat com a objectiu assolir un control complet de l’aparell, intentant abastar totes les possibilitats de la màquina. Per això hem incorporat les següents característiques: 1. Connectivitat: Un apartat fonamental degut a que és un control remot.

2. Personalització: Permet escollir entre d’altres coses tema gràfic o idioma (català, castellà o anglès) a més d’incorporar la gravació personalitzada d’algunes veus amb el micròfon.

3. Accessibilitat: Reproducció de veus que permeten guiar-se millor als invidents o a la gent gran. Com es diu en l’apartat anterior es poden personalitzar per millorar la comprensió.

4. Repertori gràfic: Domini de la representació clara i entenedora amb instruccions i gràfics tant bidimensionals com tridimensionals.

Treball de recerca

49

5. PROGRAMACIÓ PER L’ORDINADOR

5.1 Introducció La següent il·lustració esquematitza el funcionament del programa d’ordinador:

Davant l’impossibilitat de connectar la DS directament a Lego Mindstorms degut a que utilitzen tecnologies d’ona diferents hem hagut de crear un servidor a l’ordinador que es connecti amb els dos aparells i transmeti la informació. A l’esquema, el caixetí verd representa els llenguatges de programació utilitzats i al caixetí taronja trobem les llibreries utilitzades a l’ordinador i la relació.

5.2 SolarSockets Aquestes llibreries permeten connectar un client i un servidor, no necessariament han de ser una DS i un ordinador. Com totes les utilitzades al treball, són gratuïtes. El programa s’inicia esperant una connexió. A la primera petició s’executa una funció que permet aquesta connexió.

Una vegada connectat quan es rep alguna dada s’inicia una altre funció que escriu la dada per pantalla i l’envia al Mindstorms.

Treball de recerca

50

5.3 C++ comunication library Permeten controlar al màxim Lego Mindstorms sense necessitat d’executar cap software en aquest. Només funcionen amb aquest aparell. Quan es rep informació a l’ordinador aquest distingeix de que es tracta i encén els motors a la velocitat que pertoca.

Treball de recerca

51

6. CONCLUSIÓ I AGRAÏMENTS Primer de tot hem d’agrair a Josep Dalmau per les seves aportacions, correccions i suport com a tutor. Hem d’agrair també l‘ajuda desinteressada prestada per Fernando a finals del curs passat.

Hem complert satisfactòriament tots els objectius proposats. Inicialment volíem fer simplement la maqueta com a part pràctica. El funcionament era que trobés automàticament els objectes i pogués traslladar-los al lloc desitjat. Això que sembla molt simple i ràpid d’explicar, vam tardar diversos mesos en aconseguir-lo perquè no només s’ha de programar per un lloc perfecte sinó que s’havia de tenir en compte tots els problemes que condicionen l’univers: la seva gravetat, les propietats del materials... A més, hem pogut fer una gran ampliació. Aquesta gran ampliació ha sigut possible gràcies a una gran ganes de fer un molt bon treball i a les ganes de treballar en la cosa que nosaltres volíem i vam elegir a fer.

El treball en grup ha sigut immillorable. Tots dos hem treballat amb les ganes necessàries que requeria el treball. També totes les recomanacions han sigut molt útils. La recomanació més útil sense cap dubte és la d’anar fent el treball a poc a poc però sense parar. El treball que vam fer en tot l’estiu ha sigut culminant per una finalització amb tot detall.

En conclusió final hem aconseguit aprendre a programar un autòmat i la DS, veure els problemes físics a que s’enfronten els aparells com per exemple la gravetat, la sobrecarrega i molt més problemes de disseny, i sense donar-nos compte hem desenvolupat molt els nostres coneixements sobre programació.

Treball de recerca

52

7. FONTS D’INFORMACIÓ Internet: http://es.wikipedia.org/wiki/Automatización_industrial http://es.wikipedia.org/wiki/Sistemas_de_control http://es.wikipedia.org/wiki/Robótica http://www.monografias.com/trabajos-pdf/sistemas-de-control-distribuido/sistemas-decontrol-distribuido.shtml http://www.slideshare.net/ptah_enki/sistemas-de-control-distribuidos http://tv.uvigo.es/uploads/material/Video/1362/ISAD_Tema1.pdf http://redescolar.ilce.edu.mx/redescolar/act_permanentes/historia/histdeltiempo/pasado/tie mpo/p_midien.htm http://www.ikkaro.com/lampara-aceite-bombilla http://www.mecatronica-portal.com/2009/04/129-definicion-de-automatizacion/ http://es.wikipedia.org/wiki/Máquina_eléctrica http://es.wikipedia.org/wiki/Generador_eléctrico http://es.wikipedia.org/wiki/Transformador http://www.sapiensman.com/neumatica/neumatica14.htm http://www.uclm.es/area/aim/AsignaturasWEB/NeumaticaeHidraulicaIndustrial/Materialdida ctico/Transparencias/Microsoft%20Word%20%20EJEMPLOS%20DE%20UTILIZACIÓN%20DE%20LOS%20ELEMENTOS%20DE%20LA%20NEUM ÁTICA.pdf http://www.kalipedia.com/tecnologia/tema/robotica/neumatica.html?x=20070821klpinginf_1 07.Kes http://citywiki.ugr.es/wiki/Máquina_(mecánica) http://www.logismarket.es/puentes-grua/1124748-cp.html http://www.youtube.com/watch?v=fKfKLzMYvtk http://es.wikipedia.org/wiki/Sensor http://www.todorobot.com.ar/documentos/servomotor.pdf http://monasezaelectronics.blogspot.com/2009/02/servomotores.html http://es.wikipedia.org/wiki/Microcontrolador http://www.ucontrol.com.ar/wiki/index.php/Programación_de_microcontroladores_PIC

http://www.nintendo.es/NOE/es_ES/service/la_historia_de_nintendo_9911.html http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=CWNINTENDODS http://www.devkitpro.org/ http://palib.info/Doc/PAlibDoc%20Eng/modules.html http://www.scribd.com/doc/9174723/Paradigmas-de-Programacion http://garota.fismat.umich.mx/mn1/manual/ http://www.cs.cf.ac.uk/Dave/C/CE.html http://www.zator.com/ http://www.carlospes.com/curso_de_lenguaje_c/ http://www.programatium.com/c.htm http://www.pocketgamer.co.uk/r/DS/Nintendo+DS/news.asp?c=2636 Llibres:

Treball de recerca

53