Aún mejor, tuve la oportunidad de trabajar con una plataforma relativamente nueva llamada ADK (Accessory Development Kit), presentada en el Google I/O 2011 (en Mayo), la cual permite controlar dispositivos externos de hardware mediante un terminal Android. Así pues con esta quimera: Android y Arduino, me divertí bastante durante un par de semanas y en este artículo pretendo documentar un poco lo aprendido. No se trata de un tutorial paso a paso; más bien un punto de partida para los que quieran profundizar en el tema.

Antes que nada, aclaremos algunos conceptos:

• Arduino: es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares [wikipedia]
• Shield: es un complemento para tarjetas Arduino que extienden sus capacidades ofreciendo nuevos servicios, por ejemplo: puertos de red, tarjetas bluetooth, etc.
• ADK Board es una tarjeta Arduino modificada que está preparada para trabajar usando el Open Accessory Protocol. Es básicamente una tarjeta Arduino Mega con un shield USB embebido. Sin embargo, es posible utilizar el ADK con una tarjeta Arduino normal (por ejemplo, la board UNO) y un shield USB.
• El paquete ADK incluye básicamente: el firmware para las tarjetas Arduino, las especificaciones del hardware (recordemos que es Open Hardware) y un programa de ejemplo (un proyecto de Android y el sketch de Arduino), etc.

Pre-requisitos

Por supuesto, debemos contar con un terminal Android. Lo ideal es que sea un tablet corriendo Android Honeycomb. Según este artículo escrito por Dan Noguerol, las siguientes tablets soportan ADK: Motorola XOOM, Acer Iconia A100, ASUS Eee Pad Transfomer TF101 y Samsung Galaxy Tab 10.1. En mi caso, tengo una Acer Iconia A100, que es lo más barato que pude conseguir en Amazon

El soporte oficial para el ADK se encuentra desde la versión Honeycomb de Android, en donde se pueden utilizar las clases del paquete android.hardware.usb. Sin embargo, el equipo de Android proporciona un paquete de compatibilidad, que permite utilizar dichas clases en dispositivos corriendo Android 2.3.4 (Gingerbread) o superior, lo cual quiere decir que no solo funciona en tablets sino también en dispositivos móviles.

Configuración del ADK

No voy a entrar en detalles acerca de cómo configurar el IDE de Arduino y de Android, puesto que eso ya está muy bien detallado en la documentación oficial: Installing the Arduino software and necessary libraries. De hecho, me parece que Alex de BricoGeek lo explica de una manera muy directa y fácil de seguir en su artículo: El ADK de Google en Arduino UNO, que además incluye el esquema de hardware que hay que montar:

Puesto que los de Google y BricoGeek ya documentaron la parte de la configuración, solo voy a aportar un poco de información acerca de un problema que, al parecer, es bastante común al momento de preparar nuestro Android para usar el ADK (asumo de antemano que ya tienen un dispositivo corriendo Gingerbread). Esto puede aparecer al momento de instalar la aplicación:

Este es un mensaje que aparece cuando el dispositivo no tiene instaladas las librerías necesarias para usar el ADK (o no están configuradas correctamente).

Lo primero que debemos constatar en este caso es que el archivo com.android.future.usb.accessory.jar se encuentre en el directorio /system/framework/ del dispositivo. Este es la librería que contiene las clases del ADK. Además, debe existir el archivo android.hardware.usb.accessory.xml en el directorio /etc/permissions/ con el siguiente contenido:

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2011 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<!-- This is the standard feature indicating that the device supports USB accessories. -->
<permissions>
    <feature name="android.hardware.usb.accessory" />
    <library name="com.android.future.usb.accessory"
            file="/system/framework/com.android.future.usb.accessory.jar" />
</permissions>

La solución la leí de hpsaturn, un entusiasta Colombiano de Android y el software libre, que al parecer tuvo este problema hace tiempo.

Más allá del Hola Mundo

El ejemplo incluído en el ADK utiliza prácticamente todos los aspectos de la API (sensores de luz, servo motores, análogos, etc), y luce así:

Sin embargo, creo que es un poco complejo, lo cual hace que difícil de entender para las personas que hasta ahora están comenzando. Como alternativa, me gustaría compartir con ustedes un ejemplo mucho más sencillo en donde básicamente se utiliza el ADK para controlar un brazo Scara desde una tablet. El resultado es el siguiente (ignorar el introito del video; no estaba en mis cabales ese día):

Este ejemplo me parece un poco más práctico y fácil de montar. Lo único que se necesita, obviando el brazo, son 3 servo motores. El código se puede descargar desde este repositorio Git (en el README está el sketch de Arduino).

La idea es bastante simple; desde el tablet se hacen los cálculos de la cinemática inversa (es decir, calcular el ángulo que deben tener los servos a partir del punto en el cual queremos que el brazo ponga la mano). Posteriormente, se envía al Arduino los ángulos calculados y este a su vez actualiza la posición de los servos.

Lo importante aquí, y para concluir esta entrada, es reflexionar un poco sobre la manera tan fácil y rápida con la que se pueden desarrollar aplicaciones de robótica usando las librerías mencionadas. No hace falta ser un gurú de la electrónica ni mucho menos de la programación… la parte difícil ya está hecha, solo queda la parte más divertida: dejar que nuestra imaginación guíe los proyectos.

Espero les sea de ayuda y si tienen dudas o sugerencias no duden en comentar.

¿Cómo empezar?

Existen sitios en Internet que se dedican exclusivamente a eso: servir como puente entre contratistas freelance (programadores, diseñadores, traductores, etc.) y empresas o personas que requieren de dichos servicios. Las más importantes actualmente que recuerdo son: oDesk, elance.com, Freelancer, GetACoder, entre otras. Actualmente trabajo usando oDesk, así que es la herramienta bajo la cual voy a dar mi punto de vista.

Este tipo de empresas son ideales para iniciar en el mundo del freelancing, puesto que no es necesario tener ningún tipo de experiencia previa y hace mucho más fácil la búsqueda de clientes. Antes que nada, ¿cómo funcionan este tipo de empresas? bueno, es básicamente una bolsa de empleo online:

• Usted, como freelance, crea un perfil que es básicamente un Currículum Vitae virtual (tipo LinkedIn).
• Los empleadores publican empleos de diversos tipos (PHP, Java, Android, iPhone, traducciones, etc.)
• Usted puede aplicar a los trabajos que considere apropiados, con lo cual se inicia un proceso de selección.
• Si gana un contrato, se define el modo de pago: por horas o a precio fijo. El precio por horas es contabilizado por un software especial, que básicamente nos monitorea mientras estemos trabajando.
• Se recibe pagos de diversas maneras: una tarjeta débito de Payoneer, consignaciones directas a nuestra cuenta bancaria, Paypal, Moneybookers, etc.

Pros del trabajo como freelance

1. Rentabilidad: sin duda alguna es más rentable que el trabajo convencional. O al menos debe serlo en países latino americanos, en donde el trabajo como programador no es tan bien remunerado como debería ser. No voy a entrar en detalles de mis ganancias pero, para que se haga una idea, desde que trabajo como freelance estoy ganando un 300% más que antes. Además, hay que tener en cuenta que me faltan décadas para ser experto, lo cual quiere decir que cualquier programador novato como yo puede tener ganancias considerables.
2. No necesita ser profesional: al menos en Colombia (supongo que pasa en todas partes), cuando se busca trabajo y no se tiene un título de profesional, los empleadores se aprovechan de esto y pagan lo que les venga en gana. Cualquier excusa es buena para limitar los ingresos del programador (ser aún estudiante, no tener experiencia previa, no tener bonitas piernas, etc.). Este tipo de problemas no existen en empresas como oDesk: lo contratan porque saben que tiene conocimientos y capacidades de hacer el trabajo, y le pagan en base a esto. De hecho, usted decide cuanto le pagan.
3. Menos monotonía: una de las razones por las cuales se pierde el gusto por el trabajo es la monotonía. La rutina se vuelve insoportable, lo cual afecta notablemente la productividad, perdemos el interés por lo que estamos haciendo, etc. Trabajando como freelance, el 90% de los proyectos no duran más de 3 meses, y por ende siempre se están haciendo y aprendiendo cosas nuevas.
4. Trabajar en casa: ¿Tiene que cumplir un horario? ¿Tiene que madrugar? ¿Odia el transporte público? ¿No le gusta bañarse? Pues bien, por esas razones me encanta mi nuevo estilo de vida. Antes dormía cuatro horas diarias, ahora duermo siete o más. Mi oficina queda a un metro de la cama. Cuando estoy aburrido juego con mi perro; cuando estoy cansado duermo en mi cama; y lo más importante: cuando hago mis necesidades fisiológicas voy a mi baño (todo sin despeinarme, vea usted!).
5. Cambio constante de jefes: ¿odia a su jefe? ¿que tal si pudiera cambiar de jefe cada dos meses? la verdad no tengo queja alguna del 80% de los jefes que he tenido, pero no está mal saber que se puede cambiar de jefe cada contrato.
6. La poligamia es legal! Es decir, puede tener tantos proyectos activos como su cuerpo resista. Incluso, si trabaja de manera normal, puede hacer trabajos extras como freelance. Esto va de la mano con la monotonía. Cuando me aburro de un proyecto, simplemente me pongo a trabajar en otro, etc.
7. Las hojas de vida pierden importancia: los Currículum Vitae son sin duda un requisito para cualquier entrevista de trabajo. Es tal su importancia que incluso mientras estamos en la escuela (colegio, para los más afortunados) nos enseñan cómo preparar hojas de vida. La tendencia es a inflar la hoja de vida: entre más estudios tengamos, entre más experiencia laboral, entre más posgrados, etc., mucho mejor. Pues bien, para las personas con poca experiencia, pocos estudios, etc., trabajar como freelance es una gran ventaja ya que el CV pierde bastante peso, y lo que importa es lo que realmente sabes (que es demostrable como hablaré en otro post).

Contras

1. Posible inestabilidad: cuando se trabaja con un contrato normal, se tiene un puesto seguro (o casi). Incluso si no hay mucho (o nada) por hacer, uno sigue recibiendo un sueldo fijo. Por otro lado, trabajar como freelance implica estar constantemente buscando un nuevo proyecto… y en ocasiones pueda que hayan espacios prolongados de tiempo en los cuales no se tenga ningún proyecto activo. Personalmente, lo que más he durado como ‘desempleado’ siendo freelance ha sido 6 días. Nada grave, pero no está demás tenerlo en cuenta.
2. Interacción con otras personas: lo más probable es que tenga que trabajar solo. ¿A quien jugará bromas o le contará esos chistes malos que se sabe? ¿Con quien va a hablar del partido de fútbol del domingo? Interactuar con la gente es algo que, definitivamente hace falta, y es un espacio que la mayoría de los perros no pueden llenar.
3. Trabajar en casa: sí, también tiene sus contras. Es posible distraerse fácilmente: el hijo pidiendo ayuda para una tarea, el perro mordiéndonos los zapatos, la TV, una olla quemándose en la cocina, etc. Lo recomendable en este caso es tener un estudio, con un ambiente propicio para el trabajo y lejos de la mayor cantidad de distracciones posible.
4. Es necesario saber inglés: o al menos en el 98% de los casos. Si no habla y/o escribe inglés de una manera decente, es difícil que consiga nuevos contratos. Tenga en cuenta que la mayoría de los clientes son estadounidenses, ingleses o árabes (que hablan inglés, claro).

Hay aún muchos temas por tratar al respecto, sin embargo no quiero sobrecargar este artículo. Dependiendo de la respuesta que tenga podría publicar en detalle cómo funciona oDesk, además de dar algunos consejos para sacarle el mejor provecho y aclarar más dudas.

Comprimir y descomprimir usando el formato GZIP

Este es un ejemplo básico en donde se comprime y descomprime un archivo:

function descomprimir($origen, $destino) {
  $string = implode("", gzfile($origen));
  $fp = fopen($destino, "w");
  fwrite($fp, $string, strlen($string));
  fclose($fp);
} 

function comprimir($origen, $destino) {
  $fp = fopen($origen, "r");
  $data = fread ($fp, filesize($origen));
  fclose($fp);
  $zp = gzopen($destino, "w9");
  gzwrite($zp, $data);
  gzclose($zp);
}
comprimir("archivo.txt","archivo.gz");
descomprimir("archivo.gz","archivo2.txt");

Esta es una breve descripción de las funciones para Gzip incluidas en Zlib:

• gzclose — Cierra un puntero gz-file
• gzcompress — Comprime una cadena de texto
• gzencode — Crea una cadena de texto comprimida en gzip
• gzeof — Verifica si es el fin del archivo en un puntero gz-file
• gzfile — Lee el contenido de un archivo gzip y lo almacena en un arreglo
• gzgetc — Obtiene el caracter al que apunta un gz-file pointer
• gzgets — Obtiene la linea a la que apunta un gz-file pointer
• gzgetss — Obtiene la linea a la que apunta un gz-file pointer y remueve las etiquetas HTML
• gzinflate — Descomprime una cadena comprimida
• gzopen — Abre un archivo gzip

Comprimir usando el formato Bunzip

Aquí un ejemplo muy básico:

function comprimir_bzip($origen, $destino){
    // abrir el archivo en modo escritura
    $bz = bzopen($destino, "w");
    // escribir el contenido del origen
    bzwrite($bz, file_get_contents($filename));
    // cerrar el archivo
    bzclose($bz);
}

Información adicional y lista de las funciones disponibles: PHP: Bunzip.

Comprimir usando el formato ZIP

En este caso se utilizan la clase ZipArchive:

function comprimir_zip($origen, $destino){
    $zip = new ZipArchive();
    if ($zip->open($destino, ZIPARCHIVE::CREATE)!==TRUE) {
        die("Error al crear el archivo");
    }
    $zip->addFile($origen, "/".basename($origen));
    $zip->close();
}

Verificar la existencia de las librerías

Esta es una manera sencilla de verificar si PHP fue compilado con soporte para estas librerías:

if( class_exists('ZipArchive') )
    echo "ZIP: OK\n";
if( function_exists('bzwrite') )
    echo "Bunzip: OK\n";
if( function_exists('gzwrite') )
    echo "gzip: OK\n";

La idea es más o menos sencilla: una vez que un sistema Android ha iniciado envía una acción broadcast llamada android.intent.action.BOOT_COMPLETED. La idea es crear un BroadcastReceiver que escuche este tipo de acciones e inicie el servicio que deseemos. Así pues, el primer paso es crear una clase que extienda BroadcastReceiver:

public class Recibidor extends BroadcastReceiver{
	@Override
	public void onReceive(Context context, Intent intent) {
		Intent servicio = new Intent();
		servicio.setAction("foo.bar.Servicio");
		context.startService(servicio);
	}
}

Lo interesante aquí es que se ejecuta el método startService enviando como parámetro un Intent cuyo action es “foo.bar.Servicio”, el cual es el servicio que deseamos ejecutar. Dicho servicio es una clase que extiende de Service, y del cual debemos sobrescribir los métodos onCreate y onStart:

public class Servicio extends Service{

	private static final String TAG = "EjemploServicioBoot";

	private Timer timer;

	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}

	@Override
	public void onCreate(){
		super.onCreate();
		Log.d(TAG, "Servicio creado");
		timer = new Timer();
	}

	@Override
	public void onStart(final Intent intent, final int startId){
		super.onStart(intent, startId);
		timer.scheduleAtFixedRate(new TimerTask() {
			@Override
			public void run() {
				Log.i(TAG, "Se ejecuta la tarea");
			}
		}, 0, 15000);
	}
}

En este caso, el servicio realiza una tarea muy simple: imprime en el log del sistema un mensaje. Básicamente tenemos un objeto tipo Timer que ejecutará una tarea; en onCreate simplemente iniciamos el objeto Timer, mientras que en onStart usamos el método scheduleAtFixedRate indicando que ejecutaremos dicha tarea cada 15 segundos.

Por último, debemos registrar en el archivo AndroidManifest.xml el BroadcastReceiver y el servicio:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="foo.bar" android:versionCode="1" android:versionName="1.0">
    <application>
        <service android:name=".Servicio">
        	<intent-filter>
        		<action android:name="foo.bar.Servicio"/>
        	</intent-filter>
        </service>
        <receiver android:name=".Recibidor">
        	<intent-filter>
        		<action android:name="android.intent.action.BOOT_COMPLETED"/>
        	</intent-filter>
        </receiver>
    </application>
    <uses-sdk android:minSdkVersion="3" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
</manifest>

En el manifest podemos ver que añadimos un elemento service dentro de application, para registrar nuestro servicio. Y lo más interesante se ve en las líneas 12 y 17, que es donde indicamos el tipo de mensaje que nuestro recibidor estará esperando antes de ejecutar la tarea e indicamos que la aplicación requiere permisos para conocer cuando el boot del sistema a finalizado.

Descargar código fuente

Sencillamente estupendo! Lo vi en java.no.

Edito: un amable usuario a puesto un comentario con la versión subtitulada: http://www.youtube.com/watch?v=9g1y7f1xjJ0 muchísimas gracias!

Los ejemplos utilizados en los libros pueden ser descargados gratuitamente en el repositorio de Github. Además de esto, Mark es un usuario activo de StackOverflow.com… ¿y qué con eso? Bueno, personalmente me ha resuelto bastantes dudas allí (¿qué mejor que tener un experto dispuesto a solucionarte dudas puntuales?). También se le ve en twitter por si lo quieren seguir

En fin… Mark me ha enviado un cupón que permite subscribirse a su librería virtual por seis meses, y con la cual se puede acceder legalmente a todos sus contenidos. Los libros son actualizados regularmente cada mes o cada que sale una nueva versión del SDK. Además son distribuidos en formato PDF, EPUB o MOBI…

Así que pensé en sortear dicho cupón entre los lectores del blog que quisieran iniciarse en el mundo de Android (o que ya tengan experiencia pero quieran tener una referencia avanzada más directa). La verdad no sé que tanto pueda interesar a los lectores del blog el sorteo, pues no todos los que lo leen están interesados en la programación, pero no puedo dejar de compartir este valioso recurso con ustedes (tener en cuenta además que los libros están en inglés, por supuesto).

Así pues, si está interesado en adquirir estos títulos puede dejar un comentario indicando su interés, y si fuese posible la razón principal por la que desea aprender a desarrollar en esta plataforma (quisiera que el cupón se lo ganara alguien que realmente desea aprender del tema). El sorteo se realizará usando random.org (como habitualmente se hace) el día 2 de Julio (en honor al gran Andrés Escobar… bueno, en realidad es coincidencia pero sí le tenía bastante aprecio).

import android.app.Activity;
import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class TestSonido extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		Button boton = (Button) findViewById(R.id.reproducir);
		boton.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				MediaPlayer mp = MediaPlayer.create(TestSonido.this, R.raw.slayer);
				mp.start();
			}
		});
	}
}

En este caso, R.raw.slayer representa un archivo de audio con nombre “slayer.mp3″ almacenado en la carpeta res/raw y el sonido se reproduce al presionar el botón con id reproducir.

Este es un tip muy útil que permite obtener la dirección IP que tengamos asignada vía una conexión Wireless.

public String getLocalIpAddress() {
    try {
        for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
            NetworkInterface intf = en.nextElement();
            for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                InetAddress inetAddress = enumIpAddr.nextElement();
                if (!inetAddress.isLoopbackAddress())
                    return inetAddress.getHostAddress().toString();
            }
        }
    } catch (SocketException ex) {}
    return null;
}

Existen otras maneras de hacerlo, por ejemplo usando las clases WifiManager y WifiInfo, pero es mucho más confiable el método anterior. Además, este método funciona no solo en *Android*, sino en cualquier proyecto Java.