El logo es un adorable perrito

Es realmente pequeño, unos 9cm de largo y 5,5 de ancho (un poco más grande que arduino) y cuenta con un lector de trajetas microsd (donde metes el SO y lo que tu quieras), un host USB (para enchufarle camáras, teclados, ratones…), un conector RJ45 y un micro USB para conetarlo al PC.

Bien, no me enrrollo más. Todo esto que cuento ya lo han contado cientos de veces en otras páginas así que vamos al tema. Qué hacer cuando sacas el beaglebone de su caja.

Lo primero que se me ocurre es conectarlo al PC por el microUSB y ver que pasa. Tras unos segundos (recuerda que tiene que iniciar el sistema operativo y eso lleva tiempo) el ordenador detectará un dispositivo de almacenamiento masivo mediante el cual podrás acceder a las particiones que tengas excepto la usada por beaglebone. Recuerda que en esa tarjeta de memoria también están los archivos del sistema operativo. Por defecto la tarjeta trae dos particiones, la que he comentado (que es un Angstrom Linux) y una FAT donde trae unos archivos de manual y drivers para windows y mac. En linux no te hará falta instalar nada.

Bien, ya sabemos que el cacharrito funciona, ahora vamos a hacer algo más divertido. Vamos a conectarnos por consola a nuestro beaglebone y a hozar un poco. Por supuesto también podrías enchufarle un monitor y un teclado pero para conectarle un monitor necesitas una shield (que es carilla) o fabricarla tu mismo.

Para nuestra siguiente labor, en Linux tenemos que cargar un módulo a mano ya que no reconoce las uuid (he leído que en futuras versiones esto lo cambiarán). No es grave, lo hacemos con este comando

sudo modprobe ftdi_sio vendor=0x0403 product=0xa6d0

Sería un rollo poner esto siempre así que creamos un fichero llamado /etc/udev/rules.d/73-beaglebone.rules con el siguiente contenido

ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", 
        ATTRS{idVendor}=="0403", ATTRS{idProduct}=="a6d0", 
        DRIVER=="", RUN+="/sbin/modprobe -b ftdi_sio"

ACTION=="add", SUBSYSTEM=="drivers", 
        ENV{DEVPATH}=="/bus/usb-serial/drivers/ftdi_sio", 
        ATTR{new_id}="0403 a6d0"

ACTION=="add", KERNEL=="ttyUSB*", 
	ATTRS{interface}=="BeagleBone", 
        ATTRS{bInterfaceNumber}=="00", 
	SYMLINK+="beaglebone-jtag"

ACTION=="add", KERNEL=="ttyUSB*", 
	ATTRS{interface}=="BeagleBone", 
        ATTRS{bInterfaceNumber}=="01", 
	SYMLINK+="beaglebone-serial"

Ahora cada vez que enchufemos el beaglebone se detectara sin problema. Esto nos creara una interfaz en /dev/ttyUSBX donde X es un numero que depende de los cacharros que tengas conectados. Ahora ya sólo tenemos que conectarnos, para ello uso el comando screen de esta manera:

screen /dev/ttyUSB1 115200

El número 115200 es la velocidad de transmisión (simula un puerto serie). Si todo va bien, veremos algo como la siguiente imagen.

El login por defecto es root y no tiene contraseña. Una vez dentro puedes manejarlo como un Linux cualquiera!

Ya tenemos control absoluto sobre nuestro aparatito. Sí, podríamos escribir programas en C, compilarlos y ejecutarlos (o pyhton o lo que te de la gana, incluso puedes tener tu servidor apache con php y conectarlo a tu LAN por el RJ45) pero vamos a utilizar una herramienta muy interesante que trae que se llama cloud9. Colud9 es un IDE que se ejecuta en un navegador. Está en el beagle bone y desde nuestro navegador accedemos, compilamos y ejecutamos programas. Todo ello sin instalar ningun software en nuestro ordenador y disponible en cualquier momento. Por defecto programaremos con este IDE como si lo haríamos con javascript (la sintaxis) que para quienes los conozcan se llama Node.js.

Como hemos conectado el beagle bone mediante USB, muchos servicios están desativados e incluso el procesador va a menos ciclos (a 500 en vez de 700). El motivo es que el USB no proporciona la energía necesaría. Para tener funcionando a pleno rendimiento tendríamos que usar la entrada de 5V. Pero queremos algo sencillo y que funcione ya así que crearemos una interfaz ethernet a través de USB. Calma, esto ya viene preparado de serie y es muy sencillo de hacer. Tan sólo tienes que desmontar la unidad de almacenamiento (que se llama BONE nosequé) y automáticamente se iniciará eso del ethernet por usb. Ojo, si te pasa como a mi y no se inicia nada después de desmontar la unidad de almacenamiento ejecuta el comando “eject” para forzarlo. En mi caso es “eject /dev/sdh”. En algunas distribuciones no hace falta, yo uso debian y me llevó un motón de tiempo averiguar por qué narices no funcionaba. Recuerda, si no va usas el comando eject y listo.

Ahora hacemos ifconfig y veremos una interfaz de red nueva. En mi caso se llama eth1 y tiene la IP 192.168.7.1. Esa es la IP que el beagle bone ve. Es una maravilla porque ello sólo se encarga de configurar todo. Si queremos conectarnos al beagle usaremos la dirección ip 192.168.7.2 desde nuestro PC. Si por lo que sea (nunca se sabe) ha cogido otra IP lo que tenemos que hacer es conectarnos por serie al beaglebone (como expliqué antes) y con ifconfig ver qué IP ha cogido. Con esta IP podemos hacer SSH al beagle o lo que queramos, la verdad es que es muy divertido. Ya sea por ssh o por serie nos conectamos al beaglebone y ejecutamos el comando “cloud9″. Tras unos segundos veremos el iconito de la nube con un 9 dentro y debajo pone:

“Project root is: /var/lib/cloud9
Point your browser to http://localhost:3000″

Ya está listo. Vamos a nuestro navegador y accedemos a http://192.168.7.2:3000/ Cargará el IDE que además viene con unos ejemplos y en concreto uno llamado blink.js. Con este ejemplo haremos parpadear a un LED. Beagle bone cuenta con un chorro de pines de entrada/salida (Ojo que funcionan a 3.3V no a 5V así que ni se te ocurra conectarlo directamente a un arduino o aparatos que usen 5V. Si estás interesado busca sobre level shifter o pregúntame a mi )

Los bancos de pines se llaman P8 y P9 (está escrito en un lado). Ese ejemplo usa el pin 3 que está en el banco P8 (bone.P8_3). Si te fijas, en las cuatro esquinas de cada banco aparecen unos numeritos (en caso de P8 pone 2,1   46,45). Eso indica el número del pin. Hay un montón de pines diferentes y para usos diferentes y todo eso viene en la documentación oficial. Para encender un LED conectaremos el polo positivo (patita larga) al pin 3 y el negativo al pin 1 o 2 (son de masa, tierra o ground como quieras llamarlo). Ya sólo nos queda darle a “Run” y veremos como se enciende y apaga el LED. Si! Es la cosa más sencilla del mundo pero esto es sólo el principio! A partir de ahora puedes aplicar todos tus conocimientos para crear todo tipo de robots y autómatas!

Por cierto, te recomendaría que apagues el beaglebone antes de desenchufarlo. Si estás habituado al arduino igual tienes la costumbre de desconectar directamente pero recuerda que esto es como tu ordenador., hay que es apagarlo correctamente (con el comando halt por ejemplo) antes de desenchufar. De la misma manera que con tu ordenador normal, si lo desconectas directamente podrías crear incogruencias en el sistema de ficheros o cortar un proceso importante del sistema operativo (de acuerdo, nunca pasa nada pero cuando pasa, pasa)

Por último, una foto con el arduino (si es necesario es hace una comparativa o algo entre ambas máquinas) o si necesitas más detalles o ayuda con el beagle bone tal vez pueda ayudarte.

En mi caso ejecutaré OpenCV en mi robocoche y algun algoritmo más pesado de toma de decisiones (o una red neuronal). Ya os iré contando novedades

Nos vemos!

Edito par añadir un par de enlaces (en inglés).
Documentación oficial: beagleboard.org/static/BONESRM_latest.pdf

Guía oficial: http://www.beagleboard.org/static/beaglebone/a3/README.htm

Entradas relacionadas.

El ruido del disco duro era semejante al de esta maquina mezclando hormigón

El proble ma no eran los archivos en sí mismos ya que mediante buffers que gestiona el propios sistema operativo se consigue un rendimiento excelente, sino por la base de datos mysql. En mi caso, hacía currar a la base de datos de tal manera (con updates, inserts y selects constantes) que el disco duro parecía una hormigonera. Después de estimar el tiempo total de procesamiento en 6 horas pensé que eso le iba a hacer mucha pupa al disco duro duro (además del evidente cuello de botella) y que había que hacer algo. Entonces me dije: “Quiero almacenar los datos en algo que no haga ruido y si es posible que sea rápido” y eso amigos, es precisamente la memoria RAM. Así que vamos al tema.

Lo bueno de usar este método es que no tienes que tocar nada ni de mysql ni de tu programa, ya que para ellos será un dispositivo de almacenamiento estándar. Ahora prepárate un café porque esto va a ser complicado.

            mount -t tmpfs none /media/ramdisk

Ya está, ahora tienes en el directorio /media/ramdisk montada tu memoria RAM. Por supuesto, se reserva sólo una parte ya que el sistema necesita disponer de memoria para funcionar.
En mi caso, copié /var/lib/mysql a /media/ramdisk y luego un enlace simbólico para que mysql accediera a ello sin configurar nada.
Si quieres saber exactamente cuanto espacio tienes puedes usar el comando:

            df -h

Te mostrará algo como esta línea (junto al resto de sistemas de ficheros montados)

            none                  1,7G  384M  1,3G  24% /media/ramdisk

Dispongo de 1,7GigaBytes de almacenamiento en memoria RAM (384 megas usados). Recueda que es muy importante guadar luego esos archivos en tu disco duro porque la memoria RAM no es persistente y todo lo que haya se volatilizará cuando se demonte. En mi caso el tiempo de ejecución del programa paso de unas 6 horas a poco más de 45 minutos, y eso que mi memoria es lenta (667mhz) además de no hacer ningún ruido. Para casos o situaciones concretas este método puede sernos muy útil, incluso he visto casos de un servidor donde hasta los archivos estáticos (css, js, imagenes…) estaban cargados en memoria. Si tenemos en cuenta que en un ordenador todo pasa por la memoria y que el disco duro es con diferencia el dispositivo más lento (y delicado), se pueden obtener tiempos muy buenos en sistemas críticos (ej. una web con millones de visitas). El problema está cuando trabajamos con datos (que pueden cambiar, algo bastante común) y que nunca estarán a salvo hasta que lo volquemos a un disco duro. Para esos casos ya existen las cachés que en el fondo es copiar en memoria aquellas cosas de sólo lectura mientras mientras que los cambios se guardan al momento y posteriormente se actualiza esa caché.

Entradas relacionadas:

1. Borra tus ficheros de manera definitiva Muchos somos conscientes de que borrar un archivo no implica...
2. Eliminar espacio reservado en ext Cuando formateamos una unidad en el sistema de ficheros ext,...

Antes de nada, os pongo un vídeo del resultado.

Click here to view the video on YouTube.

Sí, ese es el menda jugando. ¿Te interesa saber cómo puedes hacerlo? Si es así sigue leyendo, de lo contrario sólo perderás tu tiempo.

Lo primero y antes de nada tengo que decir que mi código del arduino es una vil copia del proyecto Gamecube-N64-Controller. Ese proyecto permite jugar a la nintendo 64 con un mando de la gamecube. De ahí básicamente saqué el protocolo de comunicación y las funciones para “dialogar” con la n64 (que ya es bastante!!).

También tengo que aclarar que jugar con el wiimote es bastante más complicado. El stick del nunchuk es bastante mediocre comparado con el joystick de la nintendo 64 (para mi uno de los mejores que han existido), de ahí mi manqueo a la hora de apuntar a ganondorf con el arco. El segundo motivo es que el juego está preparado para responder a una única pulsación, entonces responderá sólo cuando hayamos terminado el movimiento lo cual implica movimientos “retardados”. Es mucho más rápido pulsar un botón que hacer el gesto del movimiento de la espada.

Ahora voy a explicar más o menos como funciona la cosa. Tenemos un mando de la wii con nunchuk y queremos jugar a la nintendo 64. El primer problema que se nos plantea es que el mando de la n64 va por cable mientras que el wiimote es inalámbrico. Mi solución ha sido usar el ordenador como pasarela: el wiimote se conecta al ordenador por bluetooth y luego el ordenador mediante usb al arduino, quien simula ser un mando de n64. Si quieres hacer algo más profesional siempre puedes usar el módulo bluetooth para arduino y desarrollar una biblioteca de comunicación. Llegados a este punto vemos que necesitamos dos programas, uno para el arduino y otro para el ordenador. Vamos a ello.

Software para arduino

Nuestro arduino va a ser simplemente un enlace sin ningún tipo de lógica. Nosotros le enviamos los datos y directamente se lo sirve a la consola sin nada de procesamiento (en el proyecto de gamecube que mencioné antes, el arduino realiza las operaciones necesarias para convertir los comandos). El motivo es para que sea más práctico, así sólo es necesario modificar le programa de ordenador si queremos hacer cualquier cambio. La función loop del programa arduino se ha reducido bastante, ya que al recibir los datos preparaditos para enviar no tiene que hacer más que eso (recibir datos del ordenador por el puerto serie y tal cual mandarlos a la consola).

Software para ordenador

Utilizo la biblioteca cwiid desde python y en principio es multiplataforma (aunque sólo lo he probado en Linux). Doy por supuesto que tienes un dispositivo bluetooth funcionando y el software de arduino instalado. Este programa python también es sencillo. Lo que hace es conectarse al mando de la wii (usando cwiid), obtener las pulsaciones de botones y mandarlas al arduino. La verdad es que, sabiendo el protocolo del mando es muy sencillo pero llegar a manejar bien un protocolo cerrado de esos es un infierno. Voy a tratar de explicar (sin detalles técnicos) un poco como funciona.

Funcionamiento del mando de nintendo 64

La consola puede mandar 4 tipos de comandos diferentes al mando. Estos son de identificación, de estado, de lectura y de escritura. Los dos últimos, hasta lo que yo se (recordemos que es un protocolo cerrado y vete tu a saber que más cosas hace) es para gestionar el rumble pack (un aparato que hace al mando vibrar). Cuando encendemos la consola, ésta manda el comando de identificación al que los mandos conectados (en nuestro caso el arduino) y éstos deben responder. Si no, la consola nos mostrará un bonito “NO CONTROLLER”. Por último, la consola nos manda el comando de estado cuando necesita saber que botones estamos pulsando. Cuando la consola nos pregunte por el estado nosotros respondemos. Al contrario de lo que mucha gente pueda pensar, no es el mando quien manda información todo el rato a la consola, sino que es la consola quién pregunta al mando todo el rato que botones hay pulsados. Nuestra labor va a ser que cuando la consola pregunte por esa información el arduino se la entregue.

Ahora veamos qué información es la que mandamos. El paquete con toda la información sobre el estado del mando (los botones pulsados) son 4 Bytes. De estos 4 Bytes, los dos primeros expresan el estado de los botones y los dos últimos la posición del joystick. Para el caso de los botones es bien sencillo, bit a 1 boton pulstado y bit a 0 boton no pulsado. De esta manera con 2 Bytes podemos representar 16 botones y como la consola tiene 14 pues incluso son sobran 2 bits. El contenido exacto de los bytes es este:

Byte 1: A, B, Z, Start, PadArriba, PadAbajo, PadIzquierda, PadDerecha

Entonces si tenemos pulsado el botón A, el primer byte será: 1 0 0 0 0 0 0 0, si pulsamos A y Z será: 1 0 1 0 0 0 0 0. Sencillo de entender, verdad?
El segundo byte contiene: 0, 0, BotonL, BotonR, C-Arriba, C-Debajo, C-Izquierda, C-derecha
Como dije antes nos sobran dos bits, que son esos dos primero bits que siempre valen 0.

Por último nos quedan los bytes para el joystick, el byte 3 contiene la posición X y el byte 4 la posición Y. Para representarlo se utiliza un byte con signo más o menos desde -80 a 80. Esto es muy importante ya que cuando mandemos la información en binario hay que tener muy claro lo que mandamos para que todo funcione bien y de manera sencilla (por eso en el programa python, al empaquetar los bytes los primero con con B, unsigned char, y los dos último son b, signed char). Nosotros generaremos ese paquete de 4Bytes y por el puerto serie se lo mandaremos al arduino.

Ya conocemos la teoría así que a programar. Yo he elegido python pero puedes usar el que te de la gana siempre y cuando generes bien esos 4 Bytes. El programa de arduino te servirá igual.

Obtener el código fuente

El código fuente lo he subido a github y por supuesto con licencia GPL. Puedes clonarlo usando esta dirección https://github.com/maxpowel/Wii-N64-Controller
Si ves algun fallo o quieres compartir una configuración de botones (sobretodo es interesante el tema del acelerómetro del wiiomte) te agradecería que me hicieras un pull request

Montaje

Material:

• Arduino (y su cable USB)
• 2 Cablecitos
• Nintendo 64
• Ordenador
• Bluetooth

Supongo que no tendrás problemas para conectar tu arduino y bluetooth a tu PC. El siguiente paso es conectar el cable de tierra de la conexión del mando a un pin de tierra del arduino usando uno de los cablecitos. El otro cable es para unir el pin 8 (puedes usar el pin que quieras, pero en el código uso el 8 ) con el de datos de la consola. El esquema de pines del mando es el siguiente:

1. +3.3V – Alimentación. No lo usamos ya que el arduino tiene su propia alimentación.
2. Datos – Conectado con el pin digital 8
3. GND – Conectado a un pin de tierra de arduino

Nota: Recuerda que este es el esquema del mando y el de la consola quedará espejado (mirando de frente a la consola se usan los dos pines de la derecha). Espero no haberte líado con esto

Como nota, decir que siempre hay que encender primero el arduino antes que la consola ya que de otra manera no detectará ningún mando. Recuerda lo que dije antes de que la consola cuando se enciende “pregunta” a los mandos para ver qué hay conectado.

Para terminar un pequeño vídeo de como tengo montado el tinglao.

Click here to view the video on YouTube.

Entradas relacionadas.

Me he propuesto volver a tener un poquito de continuidad en el blog, cosa que, por supuesto, no conseguiré, pero bueno…

Y dicho esto vamos a lo que vamos, los spinners de Android. Vamos a dejarnos de gilipolleces y vamos al tema, imagino que tendrás instalado el SDK de android, el eclipse, etc, y que hayas hecho algo para el S.O. de google. Si no es así esto te va a interesar más bien poco.

¿Que son los spinners?

Los spinners en Android son los combobox de toda la vida. Spinner significa, según el traductor de google, hilandero. ¿Porque google ha decidido llamarlo así y no combobox como se ha hecho toda la vida? Y yo que sé. Voy a suponer, de nuevo, que has programado para Android y que sabes cómo se hacen las activitys y demás. Si no lo sabes busca por internet que manuales para empezar hay a patadas.

Para rellenar los spinners es un poquillo complejo, al final todo se arregla picando código, pero si quieres hacer algo especifico (como me pasó a mí, de hecho hay cosas que aún no he sabido arreglar) pues tiene su miga.

Vamos a lo básico. Para crear los objetos de los views en android se hace con findViewById.

Spinner prueba = (Spinner) findViewById(R.id.spinner1);

Ya tenemos el objeto de nuestro spinner. Ahora para poblarlo usamos un ArrayAdapter. Voy a comentar tres formas de hacerlo, dos de ellas bastante populares por internet, poblarla desde un archivo xml de arrays y desde la base de datos SQLite de Android, y una no tan popular pero bastante útil (y más compleja). Después de esto comentaré como obtener los datos elegidos por el usuario y porque me gusta más el tercer método para según qué cosas.

Poblando Spinners

Desde arrays.xml

Bien amigos, para esto necesitamos un archivo arrays.xml con los textos que queramos rellenar en el spinner y un par de líneas de código. El archivo arrays.xml, situado en res/values, tiene el siguiente formato.

1
2
3
4
5
6
7
8

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="comidas">
        <item>Salchichas</item>
        <item>Huevos</item>
        <item>Tomates</item>
    </string-array>
</resources>

Bien, una vez que tengamos esto vamos a nuestro activity en java y utilizamos el siguiente código que explicaré después.

1
2
3
4
5
6

//Creamos el adaptador
ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this,R.array.comidas,android.R.layout.simple_spinner_item);
//Añadimos el layout para el menú
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
//Le indicamos al spinner el adaptador a usar
prueba.setAdapter(adapter);

Analicemos línea por línea.

En la primera creamos un ArrayAdapter. Tenemos que indicar entre <> el tipo de objeto que irá dentro del ArrayAdapter para evitar warnings y mejorar la legibilidad del código, en este caso CharSequence.

Este ArrayAdapter lo creamos pasándole como parámetros el contexto, que lo pasamos directamente con this (en otros casos tendrás que hacer un getApplicationContext() ) la referencia a las cadenas de texto que queremos y el layout genérico que proporciona Android para los Spinners.

Con la siguiente línea indicamos el layout, de nuevo genérico de Android, para crear el menú desplegable.

Por último, le añadimos al objeto del spinner el adaptador.

Una vez hecho esto ya tenemos nuestro precioso Spinner listo para entrar al campo a jugar. Vamos a complicarlo un poco más.

Desde SQLite

Android proporciona para nuestro deleite personas una base de datos SQLite. Aquí es posible que tengamos los datos que necesitamos para poblar nuestro Spinner. Vamos a ello.

Me ahorro el explicar cómo crear una base de datos SQLite en android, si necesitáis información sobre cómo manejarla ya sabéis, internet tiene la respuesta, solo diré que está abierta en el objeto baseDatos, que la tabla donde están los datos se llama comidas y la columna con lo que lo vamos a poblar nombres, además de una id.
Vamos con el código.

1
2
3
4
5
6
7
8

//Creamos el cursor
Cursor c = baseDatos.rawQuery("select id AS _id, nombre from comidas", null);
//Creamos el adaptador
SimpleCursorAdapter adapter2 = new SimpleCursorAdapter(this,android.R.layout.simple_spinner_item,c,new String[] {"nombre"},    new int[] {android.R.id.text1}); 
//Añadimos el layout para el menú
adapter2.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
//Le indicamos al spinner el adaptador a usar
prueba.setAdapter(adapter2);

Veamos, con el cursor hacemos un Query a la base de datos. Aquí hay un detalle importante, para que esto funcione necesitamos que la columna del identificador se llame _id, pero, no sé por qué, si la llamas así en la base de datos y luego haces un select normal no funciona, cosas de google (¿un bug?). Con AS funciona estupendamente. El segundo parámetro es para parámetros de selección, como no queremos nada pues le ponemos null.

Vayamos con el adaptador, que tiene tela. Creamos el adaptador en base a un cursor. Los parámetros son el contexto y el layout por defecto, como en el caso anterior, el cursor que hemos creado en la línea anterior, un array de String donde le indicamos que columna es la que tiene que tomar para mostrarlo y de nuevo otro layout por defecto que, sinceramente, no sé muy bien que hace.

Las otras dos líneas son iguales que en el caso del arrays.xml. Así de sencillo, ya tenemos un spinner que nos mostrará los registros de nuestra base de datos. Ahora vamos a complicarlo un poquito más.

Desde un objeto

En ocasiones necesitamos poblar el Spinner con elementos que no están en SQLite o en un array, como puede ser elementos que nos vengan desde una conexión a una base de datos, creados dinámicamente, o lo que sea.

Veamos los ingredientes; un spinner, que ya tenemos, una clase que genere los objetos que queramos, con su toString sobrescrito, unas cuantas líneas similares a las anteriores y sazonar al gusto.

Vamos con la clase de los objetos, que no tiene mucho misterio, pero bueno.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class ObjetosClase{
	int id;
	String nombre;
	//Constructor
	public ObjetosClase(int id, String nombre) {
		super();
		this.id = id;
		this.nombre = nombre;
	}
	@Override
	public String toString() {
		return nombre;
	}
	public int getId() {
		return id;
	}
}

Creo que está claro, no hay que explicarlo. El getId lo usaremos en el siguiente punto, paciencia. Vale, ahora a crear el spinner.

1
2
3
4
5
6
7
8
9
10
11

//Creamos la lista
LinkedList<ObjetosClase> comidas = new LinkedList<ObjetosClase>();
//La poblamos con los ejemplos
comidas.add(new ObjetosClase(1, "Salchichas"));
comidas.add(new ObjetosClase(2, "Huevos"));
comidas.add(new ObjetosClase(3, "Tomate"));
//Creamos el adaptador
ArrayAdapter<ObjetosClase> spinner_adapter = new ArrayAdapter<ObjetosClase>(this, android.R.layout.simple_spinner_item, comidas);
//Añadimos el layout para el menú y se lo damos al spinner
spinner_adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
prueba.setAdapter(spinner_adapter);

Si controlas un poco de java ves que he creado un nuevo LinkedList y he metido ahí los objetos con las 3 comidas que estamos utilizando.

Después he creado el ArrayAdapter como en el primer caso, solo que esta vez lo hemos creado pasándole el LinkedList. Fijaos que en este caso creamos el ArrayAdapter como cualquier objeto, y que en el primer caso utilizábamos el método estático createFromResource.

El resto ya lo conocemos de sobra. Ya tenemos nuestro spinner con nuestros objetos personalizados. Recordad que lo que toma como nombre es lo que está indicado en el toString.

Obteniendo el dato seleccionado

Ahora que ya tenemos nuestro spinner lleno de datos necesitamos conocer que dato elije el usuario. Para ello tenemos que crear un oyente. En este caso vamos a construirlo para el tercer modo de creación, para obtener el id, para el resto sería igual pero sustituyendo en la línea 4 el código, obteniendo el item y haciéndole toString directamente.

1
2
3
4
5
6
7
8
9
10
11

public class MyOnItemSelectedListener implements OnItemSelectedListener {
	public void onItemSelected(AdapterView<?> parent, View view, int pos,long id) {
		if (parent.getId() == R.id.spinner1) {
			alimentoId = ((ObjetosClase) parent.getItemAtPosition(pos)).getId();
		}
		//Podemos hacer varios ifs o un switchs por si tenemos varios spinners.
	}
	public void onNothingSelected(AdapterView<?> parent) {
		// Do nothing.
	}
}

Perfecto, ahora en cuanto un usuario pulse una opción de nuestro spinner se guardará en la variable alimentoId el id de nuestra comida escogida.

Como podéis ver, utilizando nuestros propios objetos es mucho más sencillo recuperar los datos. Podemos crear objetos relativamente grandes, con varios datos, y obtenerlos y tratarlos como queramos en el oyente. Estoy casi seguro que con el primer método también se podría sacar el id (o lo que queramos) de forma muy similar, pero no lo he conseguido.

Bueno hasta aquí el post. Perdonad el largor o longanismo de este, pero seguro que a más de uno le sirve.

Entradas relacionadas.

Simplemente os quería informar de que el próximo sábado imparto una conferencia y posteriomente un taller sobre el estándar de redes sociales Opensocial. El evento se desarrolla dentro de la party Pallantia en red (a la que todavía os podéis apuntar si queréis ) en Palencia. La entrada a la conferencia es libre y también se puede seguir en directo online (desde la web http://www.pallantiaenred.com/).

En el taller se también se hará una demostración de Wixet, un software que soporta gadgets Opensocial desarrollado por el menda lerenda.

La conferencia será para “todos los públicos” dónde el único requisito es interés o curiosidad por opensocial. En cambio, el taller es de carácter técnico y sólo sería recomendable para aquellos con nociones de programación (salvo que quieras aburrirte un buen rato). El taller consistirá básicamente en realizar una aplicación opensocial haciendo un uso básico pero completo del API. La intención del taller es simplemente iniciar a los asistentes a desarrollar aplicaciones Opensocial (muchas veces el primer empujón es muy importante).

Un saludo y a ver si todo sale bien!

Entradas relacionadas.