Hace poco tuvimos en mi trabajo la necesidad de sustituir el proceso explorer.exe de un portátil para que sólo mostrase una ventana con 3 opciones y que el usuario no pudiese hacer nada más.

El explorer.exe es un proceso que cuando se ejecuta al principio muestra el escritorio de Windows y en las sucesivas ocasiones muestra el explorador de ficheros.

Se puede sustituir fácilmente accediendo a la entrada del registro HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon y modificando el valor Shell por otro ejecutable.

El ejecutable debe estar normalmente en la ruta C:\Windows y puede ser cualquier programa con interfaz gráfica. El nuestro creaba una ventana que ocupaba todo el monitor, con un logotipo de fondo, sin marco y tenía varios botones para cargar otras aplicaciones, reiniciar y apagar.

Para labores de mantenimiento teníamos un botón que debía poner el escritorio de Windows cuando se pulsaba, y lo lógico era pensar que si desde nuestra aplicación ejecutábamos el fichero explorer.exe se mostraría, pero eso no ocurría y solamente nos aparecía el explorador de ficheros. Al final comprobamos que este comportamiento se debía a que el proceso explorer.exe sólo muestra el escritorio de Windows si se cumplen dos condiciones:

1. Que no exista otro proceso explorer.exe ya ejecutándose.
2. Que en el registro de Windows que he puesto antes esté apuntando a si mismo.

Por ello lo que tendremos que hacer para mostrar el escritorio es cambiar la variable Shell del registro expuesto anteriomente a explorer.exe, ejecutar el fichero C:\Windows\explorer.exe y pasados unos segundos volver a modificar la variable Shell con el nombre de nuestro ejecutable para asegurarnos que en el siguiente arranque se vuelve a cargar nuestro programa.

Con este artículo termino de explicar cómo explotar todas las características de este marco digital. Este artículo lo dividiré en 3 partes debido a su extensión.

La primera parte consiste en explicar cómo usar la librería SDL (Simple Directmedia Layer) para dibujar en la pantalla. Lo bueno de esta librería es que es muy sencilla de usar y te facilita bastante el dibujar gráficos en la pantalla mediante programación.

La segunda parte trata sobre usar las entradas de información del marco. Se va a leer el estado de los 3 botones, del inclinómetro y la cantidad de luz que hay en el ambiente .

La tercera parte la he reservado para las comunicaciones. Dado que el marco tiene bluetooth y una tarjeta de red configurada voy a explicar cómo intercambiar información entre el marco y otros dispositivos.

1- Librería SDL

Antes de empezar a explicar, lo mejor será que ponga un vídeo, después el código fuente, a continuación cómo compilarlo, ejecutarlo y finalmente explicar su funcionamiento.

[VÍDEO]

[CÓDIGO]

#include <stdio.h> 
#include <stdlib.h> 
#include <math.h>
#include <signal.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
volatile char salir = 0;
 
void salida(int sig)
{
	salir = 1;
}
 
int main(void) 
{ 
	SDL_Surface *izquierda;
	SDL_Surface *derecha;
	SDL_Surface *ok;
	SDL_Surface *diamante;
	SDL_Surface *sol;
	SDL_Surface *pantalla; 
 	SDL_Rect destino;
	unsigned char alpha = 0;
	float radianes;
 
	if(SDL_Init(SDL_INIT_VIDEO) != 0) 
	{ 
		printf("No se pudo iniciar SDL: %s\n",SDL_GetError()); 
		exit(1); 
	} 
 
	atexit(SDL_Quit);
 
	pantalla = SDL_SetVideoMode(320, 240, 16, 
		SDL_HWSURFACE | SDL_DOUBLEBUF); 
	if(pantalla == NULL) 
	{ 
	  	printf("No se puede inicializar el modo gráfico: %s\n",
			SDL_GetError()); 
		exit(1); 
	} 
 
	SDL_ShowCursor(SDL_DISABLE); 
 
	izquierda = IMG_Load("izquierda.png");
    	if(izquierda == NULL)
	{ 
		printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
		exit(1); 
	} 
 
	derecha = IMG_Load("derecha.png");
	if(derecha == NULL)
	{ 
        	printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
		exit(1); 
	}
 
	ok = IMG_Load("ok.png");
	if(ok == NULL)
	{ 
        	printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
        	exit(1); 
	}
 
	diamante = IMG_Load("diamante.png");
	if (diamante == NULL)
	{ 
        	printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
        	exit(1); 
    	}
 
	sol = IMG_Load("sol.gif");
	if(sol == NULL)
	{ 
		printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
		exit(1); 
    	} 
 
	signal(SIGINT, salida);
 
	destino.x = 0;
	destino.y = pantalla->h / 2 - izquierda->h / 2; 
	destino.w = izquierda->w; 
	destino.h = izquierda->h; 
	SDL_BlitSurface(izquierda, NULL, pantalla, &destino); 
 
	destino.x = pantalla->w / 2 - ok->w / 2;
	SDL_BlitSurface(ok, NULL, pantalla, &destino); 
 
	destino.x = pantalla->w - derecha->w;
	SDL_BlitSurface(derecha, NULL, pantalla, &destino); 
 
	radianes = 0;
	while(!salir)
	{
		destino.x = 0;
		destino.y = pantalla->h - sol->h;
		SDL_SetAlpha(sol, SDL_SRCALPHA | SDL_RLEACCEL, alpha);
		SDL_BlitSurface(sol, NULL, pantalla, &destino); 
 
		destino.x = pantalla->w / 2 + sin(radianes) * 60 - diamante->w / 2;
		destino.y = pantalla->h / 2 + cos(radianes) * 60 - diamante->h / 2;
		SDL_BlitSurface(diamante, NULL, pantalla, &destino);
 
		SDL_Flip(pantalla);
		SDL_Delay(1);
		SDL_FillRect(pantalla, &destino, 
			SDL_MapRGB(pantalla->format, 0, 0, 0));
		destino.x = 0;
		destino.y = pantalla->h - sol->h;
		SDL_FillRect(pantalla, &destino,
			SDL_MapRGB(pantalla->format, 0, 0, 0));
		radianes += 0.02;
		alpha += 1;
	}
 
	SDL_FreeSurface(izquierda);
	SDL_FreeSurface(derecha);
	SDL_FreeSurface(ok);
	SDL_FreeSurface(diamante);
	SDL_FreeSurface(sol);
	SDL_FreeSurface(pantalla);
 
	printf("\nFin del programa\n");
 
	return 0; 
}

[COMPILACIÓN]

Para compilar el programa, copiad el código fuente y guardarlo en la carpeta minifs con el nombre pruebasdl.c, después desde ese mismo directorio ejecutad el comando:

toolchain/arm-v4t-linux-uclibcgnueabi/bin/arm-v4t-linux-uclibcgnueabi-gcc -I build-df3120/staging/usr/include -L build-df3120/staging/usr/lib -lSDL -lSDL_image -liconv -o pruebasdl pruebasdl.c

[EJECUCIÓN]

Una vez se haya creado el fichero pruebasdl, descargarlo en el marco junto con las siguientes imágenes:

tal y como explicaba en el anterior artículo y ejecutarlo. Si todo ha ido bien veréis lo mismo que en el vídeo. Para salir del programa simplemente pulsar las teclas CONTROL y C simultáneamente.

[EXPLICACIÓN]

Explicaré cómo funciona el programa. Un buen tutorial de SDL en español lo podéis descargar de aquí.

• Se declaran los punteros SDL_Surface, que son los que contendrán las imágenes y el buffer de la pantalla.
• La función SDL_Init se llama con el parámetro SDL_INIT_VIDEO para inicializar la librería SDL internamente.
• La función SDL_GetError devuelve una cadena con el último error ocurrido en la librería SDL.
• La función atexit con el puntero a la función SDL_Quit se llama para que, cuando la aplicación termine, se llame a la función SDL_Quit y libere todos los recursos usados por la librería.
• La función SDL_SetVideoMode se llama para inicializar el buffer de la pantalla con los parámetros de anchura, altura, profundidad de color y que use la memoria de vídeo con la técnica de doble buffer (haciendo un OR de los valores SDL_HWSURFACE y SDL_DOUBLEBUF). Esta función nos devuelve la estructura SDL_Surface de ese buffer de pantalla.
• La función SDL_ShowCursor se llama con el parámetro SDL_DISABLE para ocultar el puntero del ratón en la pantalla.
• La función IMG_Load se llama con la ruta de una imagen como parámetro para cargar la imagen. Esta función nos devuelve la estructura SDL_Surface de la imagen.
• La función signal se llama con el parámetro SIGINT y un puntero a una función para que se capture la pulsación de las teclas CTRL y C. Cuando se pulsen se llamará a la función salida que simplemente cambiará el valor de la variable salir. Esto se usa para poder salir del bucle principal y terminar el programa de una forma limpia.
• La función SDL_BlitSurface se llama con una imagen, un valor nulo, el buffer de la pantalla y una estructura SDL_Rect como parámetros. Esto copia la imagen en el buffer de la pantalla en el lugar indicado por la estructura SDL_Rect.
• La función SDL_SetAlpha se llama con una imagen, con los valores SDL_SRCALPHA y SDL_RLEACCEL y un número como parámetros. Esto modifica la transparencia de una imagen (valor 0 para transparente y valor 255 para opaca). No funciona bien con los PNG, por eso la imagen del sol es un GIF.
• La función SDL_Flip se llama con el parámetro del buffer de pantalla para traspasar todos los pixels del buffer de pantalla a la tarjeta de vídeo y así mostrarlos.
• La función SDL_Delay se llama con un número como parámetro para parar la ejecución del programa durante un tiempo especificado en milisegundos.
• La función SDL_FillRect se llama con el buffer de pantalla, una estructura SDL_Rect y un color como parámetros para que dibuje en la zona determinada por la estructura SDL_Rect un rectángulo con el color especificado. En las animaciones se usa para eliminar el dibujo anterior al que se va a pintar y así dar un efecto de movimiento.
• La función SDL_MapRGB se llama con el formato del buffer de la pantalla y 3 números como parámetros. Sirve para mapear un color RGB al formato del buffer de la pantalla y así adaptarlo a su profundidad de color.
• La función SDL_FreeSurface se llama con una estructura SDL_Rect como parámetro para liberar todos los recursos utilizados por esta.

Con todo esto hemos logrado dibujar en la pantalla imágenes png y gif, además de animar dos de ellas en un bucle (una haciendo círculos gracias a las funciones trigonométricas de seno y coseno y la otra a fundirse mediante transparencia) a la espera de que el usuario pulse la combinación de teclas CTRL+C para salir del programa.

2- Entradas de información

Al igual que antes pongo un vídeo, después el código fuente, a continuación cómo compilarlo, ejecutarlo y finalmente explicar su funcionamiento.

[VÍDEO]

[CÓDIGO]

#include <stdio.h> 
#include <stdlib.h> 
#include <math.h>
#include <signal.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
#define BASE_PUERTOS 0x56000000
#define BASE_ADC 0x58000000
#define PUERTO_F_CONFIGURACION 0x50
#define PUERTO_G_CONFIGURACION 0x60
#define PUERTO_F_DATOS PUERTO_F_CONFIGURACION + 4
#define PUERTO_G_DATOS PUERTO_G_CONFIGURACION + 4
#define ADC_0 0x0C
#define BOTON_I  3
#define BOTON_C  4
#define BOTON_D  2
#define INCLINOMETRO_1  9
#define INCLINOMETRO_2  10
#define CONFIGURA_F 0xFC0F
#define CONFIGURA_G 0xFFC3FFFF
#define CONFIGURA_ADC 0x7FC2
 
typedef struct
{
 char boton_izquierdo;
 char boton_central;
 char boton_derecho;
 char inclinacion;
 unsigned char luminosidad;
}
ENTRADAS;
 
 
volatile char salir = 0;
static volatile void *memoria_puertos;
static volatile void *memoria_adc;
 
void salida(int sig)
{
	salir = 1;
}
 
void inicializa_entradas()
{
	int fd = open("/dev/mem", O_RDWR);
 
        if (fd < 0)
	{
		perror("/dev/mem");
		exit(1);
	}
	memoria_puertos = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, BASE_PUERTOS);
	if (memoria_puertos == MAP_FAILED) 
	{
		perror("mmap puertos");
		exit(1);
	}
 
	memoria_adc = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, BASE_ADC);
	if (memoria_adc == MAP_FAILED) 
	{
		perror("mmap adc");
		exit(1);
	}
 
	uint32_t configuracion = *(uint32_t *) (memoria_puertos + PUERTO_F_CONFIGURACION);
	configuracion &= CONFIGURA_F;
	*(uint32_t *) (memoria_puertos + PUERTO_F_CONFIGURACION) = configuracion;
 
	configuracion = *(uint32_t *) (memoria_puertos + PUERTO_G_CONFIGURACION);
	configuracion &= CONFIGURA_G;
	*(uint32_t *) (memoria_puertos + PUERTO_G_CONFIGURACION) = configuracion;
 
	*(uint32_t *) (memoria_adc) = CONFIGURA_ADC;
	configuracion = *(uint32_t *) (memoria_adc + ADC_0);
 
}
 
void lee_entradas(ENTRADAS *entradas)
{
	uint32_t datos = *(uint32_t *) (memoria_puertos + PUERTO_F_DATOS);
	entradas->boton_derecho = (datos & (int)pow(2, BOTON_D)) >> BOTON_D;
	entradas->boton_izquierdo = (datos & (int)pow(2, BOTON_I)) >> BOTON_I;
	entradas->boton_central = (datos & (int)pow(2, BOTON_C)) >> BOTON_C;
	datos = *(uint32_t *) (memoria_puertos + PUERTO_G_DATOS);
	entradas->inclinacion = ((datos & (int)pow(2, INCLINOMETRO_2)) + (datos & (int)pow(2, INCLINOMETRO_1))) >> INCLINOMETRO_1;
	datos = *(uint32_t *) memoria_adc;
	if(datos & 0x8000)
	{
		datos = *(uint32_t *) (memoria_adc + ADC_0);
		entradas->luminosidad = (datos & 0x3FF) * 255 / 1023;
	}
}
 
int main(void) 
{ 
	SDL_Surface *izquierda;
	SDL_Surface *derecha;
	SDL_Surface *ok;
	SDL_Surface *diamante;
	SDL_Surface *sol;
	SDL_Surface *pantalla;
 	SDL_Rect destino;
	float radianes = 0;
	float destino_radianes;
	float suma_radianes;
	ENTRADAS entradas;
 
	inicializa_entradas();
 
	if(SDL_Init(SDL_INIT_VIDEO) != 0) 
	{ 
		printf("No se pudo iniciar SDL: %s\n",SDL_GetError()); 
		exit(1); 
	} 
 
	atexit(SDL_Quit);
 
	pantalla = SDL_SetVideoMode(320, 240, 16, 
		SDL_HWSURFACE | SDL_DOUBLEBUF); 
	if(pantalla == NULL) 
	{ 
	  	printf("No se puede inicializar el modo gráfico: %s\n",
			SDL_GetError()); 
		exit(1); 
	} 
 
	SDL_ShowCursor(SDL_DISABLE); 
 
	izquierda = IMG_Load("izquierda.png");
    	if(izquierda == NULL)
	{ 
		printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
		exit(1); 
	} 
 
	derecha = IMG_Load("derecha.png");
	if(derecha == NULL)
	{ 
        	printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
		exit(1); 
	}
 
	ok = IMG_Load("ok.png");
	if(ok == NULL)
	{ 
        	printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
        	exit(1); 
	}
 
	diamante = IMG_Load("diamante.png");
	if (diamante == NULL)
	{ 
        	printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
        	exit(1); 
    	}
 
	sol = IMG_Load("sol.gif");
	if(sol == NULL)
	{ 
		printf("No pude cargar gráfico: %s\n", SDL_GetError()); 
		exit(1); 
    	} 
 
	signal(SIGINT, salida);
 
	while(!salir)
	{
		lee_entradas(&entradas);
 
		// dibujamos el boton izquierdo
		destino.x = 0;
		destino.y = pantalla->h / 2 - izquierda->h / 2; 
		destino.w = izquierda->w; 
		destino.h = izquierda->h;
		if(!entradas.boton_izquierdo)
		{
			SDL_BlitSurface(izquierda, NULL, pantalla, &destino);
		}
		else
		{
			SDL_FillRect(pantalla, &destino, SDL_MapRGB(pantalla->format, 0, 0, 0));
		}
		// dibujamos el boton central
		destino.x = pantalla->w / 2 - ok->w / 2;
		if(!entradas.boton_central)
		{
			SDL_BlitSurface(ok, NULL, pantalla, &destino);
		}
		else
		{
			SDL_FillRect(pantalla, &destino, SDL_MapRGB(pantalla->format, 0, 0, 0));
		}
		// dibujamos el boton derecho
		destino.x = pantalla->w - derecha->w;
		if(!entradas.boton_derecho)
		{
			SDL_BlitSurface(derecha, NULL, pantalla, &destino);
		}
		else
		{
			SDL_FillRect(pantalla, &destino, SDL_MapRGB(pantalla->format, 0, 0, 0));
		}
		// dibujamos el sol de luminosidad
		destino.x = 0;
		destino.y = pantalla->h - sol->h;
		SDL_SetAlpha(sol, SDL_SRCALPHA | SDL_RLEACCEL, entradas.luminosidad);
		SDL_BlitSurface(sol, NULL, pantalla, &destino); 
		// dibujamos el diamante de inclinación
		switch(entradas.inclinacion)
		{
			case 1: // izquierda
				destino_radianes = 3 * M_PI / 2;
				suma_radianes = -0.10;
				break;
			case 2: // derecha
				destino_radianes = M_PI_2;
				suma_radianes = 0.10;
				break;
			case 3: // abajo
				if(radianes > M_PI)
				{
					destino_radianes = 2 * M_PI;
					suma_radianes = 0.10;
				}
				else
				{
					destino_radianes = 0;
					suma_radianes = -0.10;
				}
				break;
 
		}
		if((radianes > (destino_radianes + 0.10)) || (radianes < (destino_radianes - 0.10)))
		{
			radianes += suma_radianes;
			if(radianes < 0)
			{
				radianes = 2 * M_PI;
			}
			else if(radianes > (2 * M_PI))
			{
				radianes = 0;
			}
		}
 
		destino.x = pantalla->w / 2 + sin(radianes) * diamante->w - diamante->w / 2;
		destino.y = pantalla->h / 2 + cos(radianes) * diamante->h - diamante->h / 2;
		SDL_BlitSurface(diamante, NULL, pantalla, &destino);
 
		SDL_Flip(pantalla);
		SDL_Delay(1);
		SDL_FillRect(pantalla, &destino, 
			SDL_MapRGB(pantalla->format, 0, 0, 0));
		destino.x = 0;
		destino.y = pantalla->h - sol->h;
		SDL_FillRect(pantalla, &destino,
			SDL_MapRGB(pantalla->format, 0, 0, 0));
	}
 
	SDL_FreeSurface(izquierda);
	SDL_FreeSurface(derecha);
	SDL_FreeSurface(ok);
	SDL_FreeSurface(diamante);
	SDL_FreeSurface(sol);
	SDL_FreeSurface(pantalla);
 
	printf("\nFin del programa\n");
 
	return 0; 
}

[COMPILACIÓN]

Hay que hacer lo mismo que en la COMPILACIÓN del apartado Librería SDL. Sólo que esta vez el fichero de salida se llama pruebaentradas y el del código fuente pruebaentradas.c.

[EJECUCIÓN]

Hay que hacer lo mismo que en la EJECUCIÓN del apartado Librería SDL, incluidas las imágenes si no las tenéis ya. Sólo que esta vez el fichero se llama pruebaentradas.

[EXPLICACIÓN]

En esta ocasión he aprovechado el código del anterior apartado y le he modificado para que responda a eventos. Ahora cada vez que se pulse un botón saldrá en la pantalla el icono correspondiente, se mostrará hacia que lado del marco está la gravedad y cuanta luz llega al sensor trasero.

Me centraré en explicar cómo he recuperado la información de las entradas de las que dispone el marco (botones, inclinómetro y fotoresistencia).

Si os acordáis en el primer artículo explicaba cómo acceder a la memoria del vídeo para escribir los píxeles de la imagen directamente en ella. Aquí lo que vamos a hacer es abrir el fichero /dev/mem ya que desde él podemos acceder a los registros del microprocesador que contienen la información de las entradas y poder configurarlas. Si queréis saber a fondo cómo funciona el microprocesador s3c2412 que gobierna el marco os podéis bajar su datasheet. Las entradas de los botones se pueden leer desde los pines 2, 3 y 4 del puerto F y las del inclinómetro desde los pines 9 y 10 del puerto G, en ambos casos son GPIO y los leeremos mediante polling. El valor de la fotoresistencia se puede leer del pin ADC0 y como indica el nombre es un ADC que leeremos igualmente mediante polling.

En la función inicializa_entradas inicializaremos los registros:

• Con la función open abrimos el fichero /dev/mem como lectura y escritura.
• Con la función mmap abrimos las posición de memoria 0×56000000 para poder acceder desde el espacio de usuario a los registros de configuración y de datos de los puertos GPIO y la posición de memoria 0×58000000 para leer los canales ADC. Estos números se pueden encontrar en las páginas 68 y 69 del datasheet que he puesto antes.
• Para leer los puertos F y G debemos configurarlos antes. Para esto debemos acceder a las direcciones de memoria de configuración del puerto F (GPFCON 0×56000050) y del puerto G (GPGCON 0×56000060) e indicar qué bits serán de lectura. En el puerto F serán los bits 2, 3 y 4 por lo que el valor de configuración para este registro (según las página 275 del datasheet) será xxxxxx000000xxxx, o lo que es lo mismo, para dejar el resto de bits a su valor original y sólo cambiar los 6 bits de los botones hay que hacer una operación AND del valor 0xFC0F. En el puerto G serán los bits 9 y 10 por lo que el valor de configuración para este registro (según la página 276 del datasheet) será xxxxxxxxxx0000xxxxxxxxxxxxxxxxxx, o lo que es lo mismo, para dejar el resto de bits a su valor original y sólo cambiar los 4 bits del inclinómetro hay que hacer una operación AND del valor 0xFFC3FFFF.
• Para leer continuamente el valor del canal 0 del ADC donde se encuentra conectada la fotoresistencia debemos configurar el registro ADCCON situado en la dirección de memoria 0×58000000.  Lo inicializaremos asignándole el valor 0x7FC2 (según la página 420 del datasheet). Finalmente leemos el valor del ADC para activarlo.

En la función lee_entradas leeremos el valor de las entradas y los guardaremos en una estructura llamada ENTRADAS:

• Accedemos a las direcciones de memoria de datos del puerto F (GPFDAT 0×56000054) y G (GPGDAT 0×56000064), extraemos uno por uno los valores de los pines con una operación AND, desplazamos esos valores mediante shifting hasta dejarlos en el primer bit  y los vamos guardando en la variable correspondiente de la estructura. Los botones cuando están libres tienen un valor de 1, pero cuando están pulsados tienen un valor de 0. El botón izquierdo corresponde al pin 3, el botón central corresponde al pin 4 y el botón derecho al pin 2. El inclinómetro tiene un valor de 3 cuando el marco reposa sobre su base , un valor de 2 si reposa sobre el lado derecho y un valor de 1 si reposa sobre el lado izquierdo. No detecta cuando el marco reposa por el lado contrario a la base (que sería un valor de 0).
• Para el ADC0 accedemos a su dirección de memoria de configuración (ADCCON 0×58000000), leemos su valor y comprobamos que el último bit está a 1 para saber si podemos leer el resultado de la conversión o todavía la está haciendo, si está a 1 leemos la dirección de memoria de datos (ADCDAT0 0x5800000C), nos quedamos con los primeros 10 bits y hacemos una conversión a 8 bits para que se pueda usar directamente en la función  SDL_SetAlpha.

Con todo esto hemos modificado el programa del apartado Librería SDL para que ahora sólo represente las imágenes dependiendo del estado de las distintas entradas que componen el marco digital.

3- Comunicaciones

Como en los casos anteriores pongo un vídeo, después el código fuente, a continuación cómo compilarlo, ejecutarlo y finalmente explicar su funcionamiento.

[VÍDEO]

[CÓDIGO]

#include <stdio.h> 
#include <stdlib.h> 
#include <math.h>
#include <signal.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <netdb.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
volatile char salir = 0;
 
void salida(int sig)
{
	salir = 1;
}
 
void carga_imagen(char *cadena)
{
	int conexion, recibidos, reales;
	char cabecera = 0;
	char *puntero;
	char buffer[1024];
	struct addrinfo parametros, *servidores, *coincidencia;
	int rv;
	FILE *fichero;
 
	if((fichero = fopen("texto.png", "wb")) == NULL)
	{
		perror("fichero texto.png");
		return;
	}
 
    	memset(&parametros, 0, sizeof parametros);
    	parametros.ai_family = AF_UNSPEC;
    	parametros.ai_socktype = SOCK_STREAM;
 
	if ((rv = getaddrinfo("sistemasorp.es", "80", &parametros, &servidores)) != 0)
	{
	        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
	        return;
	}
 
	for(coincidencia = servidores; coincidencia != NULL; coincidencia = coincidencia->ai_next)
	{
		if ((conexion = socket(coincidencia->ai_family, coincidencia->ai_socktype,
                coincidencia->ai_protocol)) == -1)
		{
			perror("socket");
			continue;
		}
 
		if (connect(conexion, coincidencia->ai_addr, coincidencia->ai_addrlen) == -1)
		{
		    close(conexion);
		    perror("connect");
		    continue;
		}
 
	        break;
	}
 
	if (coincidencia == NULL)
	{
	        fprintf(stderr, "No se puedo conectar\n");
    	}
 
	freeaddrinfo(servidores);
 
	sprintf(buffer,"GET /blog/imagen.php?cadena=%s HTTP/1.0\r\nHost:www.sistemasorp.es\r\n\r\n", cadena);
	send(conexion, buffer, strlen(buffer), 0);
	while ((recibidos = recv(conexion, buffer, sizeof(buffer), 0)) > 0) 
	{
		puntero = buffer;
		if(!cabecera)
		{
			puntero = strstr(buffer, "\r\n\r\n");
			puntero += 4;
			reales = recibidos - (puntero - buffer);
			recibidos = reales;
			cabecera = 1;
		}
		fwrite(puntero, 1, recibidos, fichero);
	}
 
 
	close(conexion);
	fclose(fichero);
}
 
int main(void) 
{
	char caracter;
	char cadena[100];
	char *puntero = cadena;
	FILE *fichero;
	fd_set lista;
	struct timeval tv;
	SDL_Surface *texto;
	SDL_Surface *pantalla; 
 	SDL_Rect destino;
 
	if(SDL_Init(SDL_INIT_VIDEO) != 0) 
	{ 
		printf("No se pudo iniciar SDL: %s\n",SDL_GetError()); 
		exit(1); 
	} 
 
	atexit(SDL_Quit);
 
	pantalla = SDL_SetVideoMode(320, 240, 16, 
		SDL_HWSURFACE | SDL_DOUBLEBUF); 
	if(pantalla == NULL) 
	{ 
	  	printf("No se puede inicializar el modo gráfico: %s\n",
			SDL_GetError()); 
		exit(1); 
	} 
 
	SDL_ShowCursor(SDL_DISABLE); 
 
	fichero = fopen("/dev/rfcomm0", "r");
 
	if(fichero == NULL)
	{
		perror("NO se pudo abrir /dev/rfcomm0");
		exit(1); 
	}
 
	signal(SIGINT, salida);
 
	destino.x = 0;
	destino.y = 0; 
	destino.w = pantalla->w; 
	destino.h = pantalla->h; 
	SDL_FillRect(pantalla, &destino, 
		SDL_MapRGB(pantalla->format, 255, 255, 255));
	SDL_Flip(pantalla);
	destino.x = 0;
	destino.y = pantalla->h / 2 - 15; 
	destino.w = pantalla->w; 
	destino.h = 30;
 
	memset(cadena, 0, sizeof(cadena));
 
	while(!salir)
	{
 
		fread(&caracter, 1, 1, fichero);
		putchar(caracter);
		if(caracter == ' ')
		{
			caracter = '+';
		}
 
		if(caracter == '\n')
		{
			salir = 1;
		}
		else
		{
			*puntero++ = caracter;
			*puntero = '\0';
			carga_imagen(cadena);
		}
		texto = IMG_Load("texto.png");
		if (texto != NULL)
		{
			SDL_BlitSurface(texto, NULL, pantalla, &destino);
			SDL_Flip(pantalla);
	    	}
	}
 
	fclose(fichero);
	SDL_FreeSurface(pantalla);
 
	printf("\nFin del programa\n");
 
	return 0; 
}

[COMPILACIÓN]

Hay que hacer lo mismo que en la COMPILACIÓN del apartado Librería SDL. Sólo que esta vez el fichero de salida se llama pruebacomunicaciones y el del código fuente pruebacomunicaciones.c.

[EJECUCIÓN]

En el ordenador debéis tener bluetooth ya sea incorporado o mediante un usb y conexión a internet.

En el ordenador activar el ruteo de paquetes tcp/ip para la interfaz de red del marco (ejecutarlo todo como usuario root, en ubuntu con sudo -s)

iptables --table nat --append POSTROUTING --out-interface eth0 -j MASQUERADE
iptables --append FORWARD --in-interface usb0 -j ACCEPT
echo 1 > /proc/sys/net/ipv4/ip_forward

En el marco activar la ruta por defecto de los paquetes tcp/ip

route add default gw 172.16.61.2

En el marco dejar visible a todos el bluetooth y permitir conexiones al marco

hciconfig hci0 piscan

En el marco mostrar la MAC ADDRESS del bluetooth (para saber a donde se debe conectar el ordenador por rfcomm)

hciconfig hci0

En el marco dejar en modo de escucha para rfcomm

rfcomm listen /dev/rfcomm0

En el ordenador conectarse al marco mediante rfcomm

sudo rfcomm connect /dev/rfcomm0 <MAC ADDRESS>

En el ordenador descargarse el programa screen (si no se tenía antes)

sudo apt-get install screen

En el ordenador conectarse al dispositivo rfcomm0 con el programa screen

sudo screen /dev/rfcomm0

En el marco ejecutar el programa

./pruebacomunicaciones

En el ordenador desde el programa screen escribir caracteres. ENTER para hacer salir el programa del marco.

Anotaciones

Tendreis que abrir una consola nueva tanto en el ordenador como en el marco después de ejecutar el comando rfcomm puesto que se queda permanentemente conectado hasta que se pulse CTRL + C.

Para salir del programa screen simplemente pulsad CTRL y A a la vez y después de soltarlos pulsad la tecla K.

[EXPLICACIÓN]

Por un lado se pretende conectar mediante bluetooth al marco usando las utilidades BlueZ mediante RFCOMM. Así conseguimos que desde nuestro ordenador podamos enviarle datos al marco.

Por otro lado pretendemos conectarnos a una página de Internet para recuperar una imagen y mostrarla en el marco.

La unión de ambas cosas es lo que habéis visto en el vídeo. Mientras escribo en el programa screen caracteres, estos se envían al marco mediante bluetooth. Despueś el marco los va concatenando y va llamando a una página web que he hecho a tal efecto para que vaya generando la cadena de texto en una imagen PNG. Esta imagen se la descarga el marco y posteriormente la muestra.

Gracias a las utilidades de BlueZ la conexión bluetooth ya se establece mediante comandos y nosotros nos tenemos que dedicar simplemente a abrir el fichero /dev/rfcomm0 y desde este escribir o leer con las funciones básicas que proporciona C para manejo de ficheros.

Las conexiones a Internet se consiguen mediante programación de sockets y esto nos da mucho juego para poder pedir información (descargar una imagen, llamar a un servicio web, etc.) y luego mostrarla en nuestro marco. En el ejemplo cuando se llama a la función carga_imagen hacemos una conexión http a http://www.sistemasorp.es/blog/imagen.php con la cadena pasada como parámetro y guardamos en el fichero texto.png la imagen PNG que se ha generado. No voy a explicar qué hace cada función de los sockets, pero si os recomiendo leer el mejor manual que hay en internet para saber cómo programarlos: Beej’s Guide to Network Programming.

Y aquí acaban esta serie de artículos esperando que os haya servido de ayuda para que podáis empezar a juguetear con el marco y sacarle muchas utilidades. Me gustaría que si hicieseis algo con el lo pusierais en los comentarios, además de vuestras dudas o lo que sea.

1º artículo

2º artículo

Hace tiempo que mi amigo Roberto quiso actualizar su cámara IP (la cual compró por recomendación mía). El caso es que al actualizar el firmware el proceso falló y la cámara quedó inutilizada. Así han pasado ya muchos meses hasta que hace unos días me encontré con esta página que hablaba de cómo recuperar una cámara Foscam FI8908W cuando el proceso de actualización de firmware ha fallado.

Lo bueno de esta página es que habla de que las cámaras foscam (y la zaapa ciprw es una de ellas con el modelo FI8901W) no mueren del todo, sino que tienen un puerto serie escondido al que se puede acceder y comunicarse con una consola para cargar un firmware. Yo me he comunicado con la cámara con un conversor serie TTL a USB:

La solución ya estaba, sólo tenía que conseguir el firmware de la zaapa (ya que otros no valen) y decirle a mi amigo que me dejase su cámara para arreglársela. Pero no ha sido así de fácil y he tenido que pelearme con varios frentes.

El primero es el servicio técnico de Foscam. En el comentario 101 del anterior enlace un tal David comentaba que Doris de Foscam había sido muy amable y que le había dado los ficheros de recuperación. Yo probé la misma suerte con el servicio técnico de Foscam y esta fué la primera respuesta que obtuve:

Hi,

We do not have a model No. FI8901W camera, could you please double check the model No.?

Es decir, que no saben ni los modelos que han fabricado. Le dije que si existía ese modelo de cámara en su marca y me contesto esto otro:

Hi,

Sorry for my mistake. We have stopped produce this product for a long time. We do not have the firmware now. Sorry for this.

Vamos que no querían ayudarme en nada (David, que suerte tuviste…).

Buscando por Internet unos ficheros de recupercación para la zaapa o para la FOSCAM FI8901W no encontré nada. Pero por suerte encontré esto otro. Una forma de extraer de una cámara que funcionase su firmware a través de la consola serie oculta. El proceso fue pesado: me tuve que bajar el kermit 95 y buscar cómo demonios abrir una consola serie, después esperé un rato largo a que se ejecutara el script, convertir con el jedit una salida en otro fichero y finalmente pasar el convertidor de hexadecimal a binario, el cual tuve que compilar, modificar y compilar de nuevo para que funcionase. Todo esto para que al final no se hubiera decargado correctamente el firmware linux.bin y romfs.img necesarios para reprogramar la cámara estropeada, dando esta errores nada más arrancar.

Parecía que no iba a dar con la solución, pero encontré un programa que te descargaba automáticamente los ficheros necesarios del firmware. Lo ejecuté y parecía que había hecho bien su trabajo, pero pasó lo mismo que en el anterior párrafo aunque esta vez sólo con el fichero linux.bin. Sin embargo gracias a esta otra página descubro que el fichero linux.bin es en realidad un archivo .zip y que lo que había hecho está aplicación es comerse los últimos 168 bytes, asi que leyendo la memoria de  la cámara que funcionaba recuperé esos 168 bytes.

Finalmente seguí paso por paso el proceso de nuevo pero cambiando los comandos fx por estos:

fx 6 romfs.img 0x7F0D0000 0x7F0D0000 -a
fx 7 linux.bin 0x7F020000 0x00008000 -acxz

Para Windows 7 como no existe el Hyperterminal, he usado el Tera Term.

Finalmente la cámara de mi amigo ha dejado de ser un pisapapeles y ha vuelto a funcionar, pudiéndola manejar ahora con Firefox, con su IPhone, etc.

Para evitaros las incomodidades por las que yo he pasado os dejo los enlaces de los ficheros de recuperación de la versión que le instalé a mi amigo y que es la última que proporciona Zaapa:

romfs.img

linux.bin

Embeded Web UI 2.0.0.16.bin

En el anterior artículo explicaba cómo instalar linux en el marco digital Parrot DF3120. En este explicaré cómo generar el toolchain para poder crear programas que funcionen en el marco digital. De paso crearemos una versión de la imagen más moderna para nuestro marco. El artículo original que lo explicaba es este, pero está desfasado y hay que hacer retoques para que funcione bien.

Lo voy a hacer todo desde mi linux Ubuntu 11.10, por lo que es posible que algunas cosas haya que modificarlas si usáis otra distribución.

Lo primero es instalarse usa serie de paquetes que son necesarios para que todo el proceso sea correcto:

sudo apt-get install git-core
sudo apt-get install tig
sudo apt-get install lzop
sudo apt-get install uboot-mkimage
sudo apt-get install libelf-dev
sudo apt-get install libncurses-dev
sudo apt-get install gtk-doc-tools
sudo apt-get install checkinstall
sudo apt-get install e2fsprogs
sudo apt-get install libglib2.0-dev
sudo apt-get install libxml2-dev
sudo apt-get install genext2fs
sudo apt-get install lzma
sudo apt-get install subversion
sudo apt-get install cvs
sudo apt-get install gawk
sudo apt-get install bison
sudo apt-get install flex
sudo apt-get install automake
sudo apt-get install gcc
sudo apt-get install build-essential
sudo apt-get install texinfo
sudo apt-get install curl

Después hay que bajarse minifs con el git:

git clone http://oomz.net/git/minifs.git minifs

A continuación hay que hacer un par de modificaciones:

• Edita el fichero minifs/conf/board/df3120/config_busybox.conf y reemplaza la línea # CONFIG_CHMOD is not set por CONFIG_CHMOD=y
• Edita el fichero minifs/conf/packages/05crosstools.sh y reemplaza la línea hset libtool url “http://ftp.gnu.org/gnu/libtool/libtool-2.4.2.tar.gz” por hset libtool url “http://ftp.gnu.org/gnu/libtool/libtool-2.4.tar.gz”
• Edita el fichero minifs/conf/packages/11graphical.sh y reemplaza la línea hset libpng url “ftp://ftp.simplesystems.org/pub/libpng/png/src/libpng-1.4.8.tar.bz2″ por hset libpng url “ftp://ftp.simplesystems.org/pub/libpng/png/src/libpng-1.4.9.tar.bz2″

Después ya podemos ejecutar el script de la siguiente forma (Puede tardar varios minutos):

cd minifs
export MINIFS_BOARD=df3120
./minifs_build.sh

Ahora vemos que entre otras cosas se han creado dos ficheros en el directorio build-df3120, un .img y un .plt. Pues bien con ellos hay que volver a hacer lo mismo que comentaba en el anterior artículo. Si todo ha ido bien veremos la nueva versión del firmware donde lo más destacado es que aparecen los mensajes de arranque:

Ahora vamos a compilar nuestro primer programa, y cómo no, tenía que ser un Hola Mundo:

#include <stdio.h>
 
void main(void)
{
 printf("Hola Mundo.\n");
}

Copiamos el código que aparece arriba y lo guardamos en un fichero llamado holamundo.c. Después ejecutamos el siguiente comando:

toolchain/arm-v4t-linux-uclibcgnueabi/bin/arm-v4t-linux-uclibcgnueabi-gcc holamundo.c -o holamundo

Esto habrá generado un fichero ejecutable llamado holamundo, pero ¿cómo lo subimos al marco para ejecutarlo?. Pues bien entre otros comandos el marco tiene dos, el tftp y wget para descargar ficheros mediante el protocolo tftp y http respectivamente, por tanto hay que instalar un servidor web o tftpd en nuestra máquina linux.

Servidor web apache:

sudo apt-get install apache2

Servidor tftp: Instrucciones

Si hemos optado por el servidor web sólo hay que copiar el fichero holamundo al directorio /var/www. Si la elección ha sido tftpd entonces hay que copiar el fichero holamundo al directorio que se haya configurado.

Ahora tenemos que descargarlo desde el marco digital. Hacemos un telnet como explicaba en el anterior artículo. En el firmware actual todo el disco está montado como sólo lectura, por lo que tendremos que remontarlo como escritura también de la siguiente forma:

mount / / -o remount,rw

Ahora nos vamos al directorio /tmp y descargamos el programa.

Para tftp el comando sería:

tftp -g -r holamundo <IP DEL SERVIDOR TFTP>

Para wget el comando sería:

wget http://<IP DEL SERVIDOR WEB>/holamundo

Ahora que tenemos el fichero, hay que darle permisos de ejecución y finalmente ejecutarlo:

chmod a+x holamundo
./holamundo

Obtendremos esto:

Ya hemos compilado nuestro primer programa y lo hemos hecho funcionar, pero claro, nos interesa que se pueda dibujar en la pantalla algo para ver cómo se ve en el marco. Lo primero que hay que saber es que la pantalla tiene asignado el dispositivo /dev/fb0 y que lo que tenemos que conseguir es acceder a su memoria para escribir directamente los colores. Esto se consigue de la siguiente forma:

Con la función open abrimos el dispositivo como lectura/escritura:

int g_fb = open("/dev/fb0", O_RDWR);

Con la función ioctl recibimos en una estructura información sobre la pantalla:

struct fb_var_screeninfo var_info;
ioctl(g_fb, FBIOGET_VSCREENINFO, &var_info);

Con la función mmap obtenemos el buffer de la memoria de vídeo para leerlo y escribir en el:

char *buffer = (char *)mmap(0, 153600, PROT_READ|PROT_WRITE, MAP_SHARED, g_fb, 0);

Ahora sólo queda dibujar los bytes en la memoria para que se vean reflejados como pixeles en la pantalla. Al poder representar la pantalla 64k colores estos se codifican a RGB mediante 16 bit con el formato 5-6-5 (rrrrrggggggbbbbb). Así el rojo es 1111100000000000 (0xF800), el verde es 0000011111100000 (0x07E0) y el azul es 0000000000011111 (0x001F). Por tanto cada pixel en la pantalla ocupa 16 bits.

Para probar todo esto he creado un programa que muestra un cuadro verde rebotando por el marco usando la técnica de doble buffer para evitar parpadeos:

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
 
 
char *inicializa(int *cuantos)
{
  char* buffer;
  int g_fb;
  struct fb_var_screeninfo var_info;
 
  g_fb = open("/dev/fb0", O_RDWR);
  if (g_fb == -1)
  {
    printf("No se puede abrir /dev/fb0\n");
    _exit(1);
  }
 
  printf("/dev/fb0 abierto con el handle 0x%x\n", (unsigned)g_fb);
 
  if (ioctl(g_fb, FBIOGET_VSCREENINFO, &var_info))
  {
    printf("No se puede obtener la información variable de la pantalla\n");
    _exit(1);
  }
 
  printf("xres: %d\n", var_info.xres);
  printf("yres: %d\n", var_info.yres);
  printf("bpp: %d\n", var_info.bits_per_pixel);
  *cuantos = var_info.xres * var_info.yres * var_info.bits_per_pixel /8;
 
  printf("El tamaño del buffer de pantalla es de %d bytes\n", *cuantos);
 
  buffer = (char *)mmap(0, *cuantos, PROT_READ|PROT_WRITE, MAP_SHARED, g_fb, 0);
 
  if ((int)buffer == -1) 
  {
    printf("falló mmap().\n"); 
    exit(1);
  }
  printf("Pantalla devuelta\n");
  return buffer;
}
 
void cuadro(int x, int y, short int *buffer, int color)
{
 int anchura;
 int altura;
 short int *puntero;
 
 for(altura = 0; altura < 50; altura++)
 {
  puntero = buffer + ((y + altura) * 320);
  for(anchura = 0; anchura < 50; anchura++)
  {
   *(puntero + x + anchura) = color;
  }
 }
}
 
void main(void)
{
 int indice;
 int cuantos;
 int x = 0;
 int y = 0;
 int suma_x = 1;
 int suma_y = 1;
 
 short int *buffer = (short int *)inicializa(&cuantos);
 short int *ventana = (short int *)malloc(cuantos);
 
 if (ventana == NULL)
 {
  printf("No se puede crear el doble buffer\n");
  _exit(1);
 }
 // fondo negro
 for(indice = 0; indice < (cuantos / 2); indice++)
 {
  buffer[indice] = 0; 
 }
 
 for(;;)
 {
  usleep(10000);
  cuadro(x, y, ventana, 0);
  x += suma_x;
  y += suma_y;
  if(x > 269 || x < 0)
  {
   suma_x *= -1;
   x += suma_x;
  }
  if(y > 189 || y < 0)
  {
   suma_y *= -1;
   y += suma_y;
  }
  cuadro(x, y, ventana, 0x7E0);
  memcpy(buffer, ventana, cuantos);
 }
}

Que ejecutándolo quedaría así:

En un próximo artículo explicaré como acceder a la interfaz con SDL, comunicarse con bluetooth mediante RFCOMM y obtener los valores de los botones traseros y del inclinómetro.

Edición 12/02/2012:

1º artículo

3º artículo

He adquirido el marco digital de fotos Parrot DF3120. Es un marco que por menos de 20€ puede representar fotografías en una pantalla de 320×240 (3.5″). Sus puntos fuertes es que tiene bluetooth para poder subir las imagenes desde, por ejemplo, un móvil y una entrada para tarjetas SD con la misma función.

Este marco ha sido hackeado y se le puede instalar un linux, con las ventajas que ello representa. El objetivo de este primer artículo es mostrar el proceso de instalación de linux y cómo acceder a este de una forma sencilla.

Lo primero es hacer un duplicado de disco del siguiente fichero: minifs-full-ext.img. Esto en linux, siendo root, se consigue con el siguiente comando (disco SD es el nombre que le haya asignado el sistema):

dd if=minifs-full-ext.img of=/dev/<disco SD>

Lo siguiente es actualizar el firmware del marco. Para ello hay que encender el marco sin ninguna tarjeta SD insertada y enchufar el cable usb. Cuando podamos acceder al contenido del disco, crear una carpeta llamada update y dentro de esta copiar el fichero parrotDF3120.plf. Después sacar el usb de forma segura y veremos que aparecen 4 cuadros en la pantalla (uno azul y el resto verde), momento en el cual ya se ha actualizado el firmware.

Ahora tenemos un modo de arranque dual. Por un lado si encendemos el marco sin más veremos su funcionalidad de siempre, es decir, se visualizarán las imágenes que tengamos almacenadas una detrás de otra. Pero si metemos la tarjeta SD y antes de encenderlo pulsamos los botones izquierdo y central de la parte de atrás y, sin soltarlos, encendemos el marco, se arrancará  linux y busybox.

Finalmente para acceder a la consola en el modo linux podemos hacerlo de dos formas (la dificil y la fácil):

La dificil es sacar todos los tornillos para quedarnos con la placa y la pantalla. A continuación soldamos en los agujeros del J4 (la consola serie) los tres pines (1: GND, 2: RX, 3: TX) y nos buscamos un conversor TTL a puerto serie o a usb para poder comunicarnos con el dispositivo usando los siguientes parámetros de conexión: 115200 8,N,1 (recomiendo screen en linux o mac y putty en windows). Esta es la consola serie donde se ven los mensajes de estado del arranque y luego se obtiene una shell donde interactuar con linux:

La fácil es simplemente conectar el cable usb al marco y a nuestro ordenador, lo que nos configurará una conexión ethernet por usb llamada Ethernet Gadget, la cual será una tarjeta de red que debemos configurar con la IP 172.16.61.2 y la máscara de red 255.255.255.0. Si todo ha ido bien y hacemos un ping a la dirección 172.16.61.1 el marco nos debería responder. Finalmente para acceder a una shell sólo hay que hacer un telnet a la IP comentada.

Edición 22/01/2011:
En el marco vienen unos programas para probar la pantalla gráfica. Podeis ejecutar cualquiera de ellos:
/usr/bin/plasma: Una bonita demo sobre el efecto plasma.
/usr/bin/newvox: Un paisaje que si tuvieramos teclado podríamos recorrerlo.

Edición 12/02/2011:

2º artículo

3º artículo

Hacía tiempo que no volvía a escribir sobre la cámara ip Zaapa CIPRW. Escribí dos artículos: Uno sobre la descripción de la cámara en septiembre de 2008 y otro sobre cómo programarla en .NET en Agosto de 2009.

Lo cierto es que desde entonces dejé abandonado el tema y por necesidades he tenido que retomarlo para poder interactuar con ella. Poco tiempo después de escribir el último artículo se publicó en la página de Gadget Victims información sobre un nuevo firmware para las cámaras Foscam FI908W (La de Zaapa es la FI8901W) en septiembre de 2009 donde entre otras cosas se habla de la documentación oficial de FOSCAM para sus cámaras IP. Lo mejor de esto es que en esta documentación hay dos textos que pueden servirnos a los programadores para interactuar definitivamente con la cámara Zaapa y a los usuarios para poder ver sus cámaras en navegadores como Firefox, Chrome, Safari, etc.

Se trata del IPCAM CGI SDK 2.1 y del IPCAM Protocol. El primero es un documento PDF donde se explica cómo haciendo peticiones HTTP se puede descargar la imagen de la cámara y enviar ordenes a esta. El segundo es un documento de Word donde se explica el protocolo de la cámara para comunicarse con ella mediante socket. En este artículo me centraré en el primero por su facilidad de uso.

En el primer documento se explica qué peticiones hay que hacer para interactuar con la cámara. Se trata de acceder a páginas web CGI pasándole normalmente los parámetros mediante el método GET, que es como en realidad nosotros hacemos las llamadas desde un navegador web normalmente.

Antes de empezar a probar hay que cerciorarse de que la cámara Zaapa tiene el último firmware y el último Embeded Web UI. Si en la sección Device Info del panel del administrador son distintos de 11.4.1.40 y 2.0.0.16 respectivamente, hay que actualizar. En la página del producto se pueden descargar pero hay que introducir el número de serie que aparece como código de barras en la parte inferior de la cámara. Una vez que empieza la descarga empieza lo gracioso y es que veremos algo raro en el fichero que descargamos pues no tiene extensión y que no sirve para actualizar ya que no es un .bin. Pues bien el fichero es un archivo .rar por lo que hay que renombrarlo, ponerle esa extensión y ya podemos abrirlo. Dentro de este veremos dos ficheros .bin y aquí esta lo segundo más gracioso ¡¡¡ están al revés !!! Embeded Web UI 11.4.1.40.bin tendría que ser Firmware 11.4.1.40.bin y Firmware 2.0.0.16.bin tendría que ser Embeded Web UI 2.0.0.16.bin. Una vez arreglado ese desaguisado ya podemos actualizarlo desde la sección Upgrade Device Firmware del panel de administrador y actualizar el firmware primero y el Web UI después (en ambos casos se reinicia la cámara).

Hay unos cuantos CGI y lo mejor es leerse la documentación, pero voy a explicar 3 de ellos que me parecen fundamentales:

• El primero de ellos es el snapshot.cgi. Sirve para capturar una imagen estática de la cámara. Si ponemos en un navegador web http://ip de la cámara/snapshot.cgi nos pedirá un usuario y una contraseña. Cuando la hayamos introducido veremos la imagen jpg. Podemos evitar que salga el recuadro que nos pide el usuario y la contraseña simplemente añadiendo los parámetros user y pwd a la url de la siguiente forma http://ip de la cámara/snapshot.cgi?user=usuario&pwd=contraseña para que ya directamente nos muestre la imagen. Tiene otro parámetro llamado next_url para indicar el nombre del fichero pero no lo veo útil.
• El segundo de ellos son en realidad dos: videostream.cgi y videostream.asf. Sirven para mostrar un flujo continuo de imagenes a modo de vídeo. El que tiene extensión .cgi envía imágenes jpg sucesivas (ideal para verlas con una navegador), el que tiene extensión asf envía las imágenes con el formato Advanced Streaming Format (ideal para verlas con el VLC o con el MPlayer). Si ponemos en un navegador web http://ip de la cámara/videostream.cgi?user=usuario&pwd=contraseña podemos ver el flujo continuo de lo que la cámara está enfocando en ese momento. Tiene otro parámetro llamado resolution para indicar con un 8 o un 32 si queremos que la imagen tenga de tamaño 320×240 o 640×480 respectivamente.
• El tecero de ellos es el decoder_control.cgi. Sirve para interactuar con la cámara. Si ponemos en el navegador web http://ip de la cámara/videostream.cgi?user=usuario&pwd=contraseña&command=comando donde comando sea un número que indica qué hacer a la cámara (0 = empezar a mover hacia arriba, 1 = parar de mover hacia arriba, 2 = empezar a mover hacia abajo, etc) veremos como se mueve esta.

Finalmente he creado una página HTML para probar los dos últimos CGIs que he explicado. La página muestra la sucesión de imágenes de la cámara y tiene unos botones que permiten mover la cámara. Para adecuarlo a la vuestra sólo teneis que cambiar en la sección javascript el usuario, la clave y la ruta a vuestra cámara:

<html>
<head>
	<style type="text/css">
		.comando {background-color:#FFFF00; border-radius: 10px; font-family:Arial; font-size:10pt; font-weight:bold; width:70px; text-align:center}
		#imagen {visibility:hidden; width:640px; height:480px;}
		#marco {visibility:hidden;}
	</style>
	<script type="text/javascript">
		var usuario = "usuario";
		var clave = "clave";
		var ruta = "http://192.168.0.12/";
 
		function cargado()
		{
			var imagen = document.getElementById("imagen");
			imagen.src = ruta + "videostream.cgi?user=" + usuario + "&pwd=" + clave + "&resolution=32";
			imagen.style.visibility = "visible";
		}
 
		function empieza_arriba()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=0";
		}
 
		function termina_arriba()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=1";
		}
 
		function empieza_abajo()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=2";
		}
 
		function termina_abajo()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=3";
		}
 
		function empieza_izquierda()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=4";
		}
 
		function termina_izquierda()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=5";
		}
 
		function empieza_derecha()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=6";
		}
 
		function termina_derecha()
		{
			var marco = document.getElementById("marco");
			marco.src = ruta + "decoder_control.cgi?user=" + usuario + "&pwd=" + clave + "&command=7";
		}
 
 
	</script>
</head>
<body onload="cargado()">
<img id="imagen">
<table>
<tr><td>&nbsp;</td><td class="comando" onmousedown="empieza_arriba()" onmouseup="termina_arriba()">Arriba</td><td>&nbsp;</td></tr>
<tr><td class="comando" onmousedown="empieza_izquierda()" onmouseup="termina_izquierda()">Izquierda</td><td>&nbsp;</td><td class="comando" onmousedown="empieza_derecha()" onmouseup="termina_derecha()">Derecha</td></tr>
<tr><td>&nbsp;</td><td class="comando" onmousedown="empieza_abajo()" onmouseup="termina_abajo()">Abajo</td><td>&nbsp;</td></tr>
</table>
<iframe id="marco" src=""></iframe>
</body>
</html>

El funcionamiento es muy sencillo. Una etiqueta img muestra el CGI videostream.cgi. Las celdas de la tabla tienen los eventos onmousedown y onmouseup para detectar cuando se pulsan y cargar en el marco oculto el CGI decoder_control.cgi con la orden correspondiente. Así es como se ve funcionando en un MAC y Safari:

Y de paso pongo otro vídeo de cómo se puede usar esta cámara con un móvil con las múltiples aplicaciones que hay en android market y en app store simplemente eligiendo en estas como marca de cámara la FOSCAM:

Hacía tiempo que no me ponía a mi mismo un reto de programación y el otro día viendo en la tele el programa cifras y letras me animé a hacer una aplicación que resolviese la sección de cifras. Primero me leí las normas y luego empecé a pensar cómo resolver este tipo de problema. Buscando por Internet encontré estos artículos: (uno, dos y tres) donde de 30.965.760 combinaciones posibles entre los 6 números y sus cuatro operaciones se reduce a 488.642 combinaciones. Además me encontré con dos páginas que resuelven el problema on-line: esta y esta (ambas usando la técnica de backtracking).

Como mi objetivo era hacerlo mediante fuerza bruta, la técnica de backtracking me pareció lo mejor para abordar el problema. Se crea un árbol donde cada nodo contendrá los números con los que se operan, la operación que ha generado ese nodo y el resultado de la misma (excepto el primer nodo que sólo contiene el conjunto de números original).

Vamos combinando uno por uno todos los números con todas las operaciones para encontrar el resultado que buscamos. El orden de las operaciones es suma, resta, multiplicación y división. Como esto puede generar una ingente cantidad de cálculos, podemos podar (acotar) el árbol para reducir estos y el tiempo empleado. Esto se consigue eliminando aquellos casos que no deben darse: En la resta que el resultado sea 0, en la división que el divisor sea 1 o que el resto sea distinto de 0 y que en la multiplicación uno de los factores sea 1. Para evitar números negativos en la resta o que el divsor sea mayor que el dividendo ponemos primero el mayor y después el menor en la operación.

A medida que vamos avanzando en la profundidad del árbol, el conjunto de números con los que operar se irá reduciendo ya que cada pareja de números se convertirá en uno por la operación matemática que se les aplique, siendo esto así recursivamente hasta que sólo haya un número, momento en el cual si el resultado no coincide con el esperado, se retrocede un nodo y se continúa con las siguientes combinaciones.

Para entenderlo mejor un gráfico donde dado un conjunto de tres números (1, 2 y 3) debemos operar con ellos hasta que obtengamos 7 como resultado:

En el ejemplo después de buscar varias combinaciones entre sumas y restas (puntos suspensivos en el gráfico) hemos llegado a las combinaciones de multiplicaciones. Existen tres combinaciones de multiplicaciones: Op: 1 * 2 (que no he puesto en el gráfico por simplificarlo), Op: 1 * 3 y Op: 2 * 3.

• En el nodo de la multiplicación de 1 * 3 el resultado (Res:) es 3 y no 7 como andamos buscando por lo que hay que seguir calculando. El conjunto de números de este nodo se ha reducido de Nu: 1, 2, 3 a Nu: 2, 3.
• A continuación hay que crear otro nodo con la suma de los únicos números que quedan: 2 + 3, pero el resultado es 5 con lo que volvemos al nodo anterior.
• Vamos a hacer la resta: 3-2, pero sigue sin servirnos el resultado, por tanto volvemos al nodo anterior.
• Hacemos la multiplicación: 2 * 3, pero seguimos igual, por lo que nos vamos al nodo anterior.
• La división se descarta porque 3 / 2 no dá como resto 0, con lo que no se crea ese nodo y se vuelve al anterior (que en este ejemplo es el principal).
• Continuamos con la creación del nodo de la multiplicación de 2 * 3 donde el resultado (Res:) es 6 y no 7 como andamos buscando por lo que hay que seguir calculando. El conjunto de números de este nodo se ha reducido de Nu: 1, 2, 3 a Nu: 1, 6.
• Hay que crear otro nodo con la suma de los únicos números que quedan: 1 + 6, y como el resultado es 7, que es el que buscábamos, ya no hacemos ninguna operación más y vamos retrocediendo por todo el árbol (que os recuerdo que se ha construido mediante una función recursiva) hasta salir de la función que lo ha generado.

El nivel de profundidad de los árboles depende de la cantidad de números inicial. Si son un conjunto de 3 números la profundidad será de 3 niveles, si es de 6 pues … ya sabeis la respuesta

Como se trata de una estructura de árbol, cada nodo debe tener un puntero al siguiente nodo para trazar un camino desde el nodo inicial hasta el nodo que contiene el resultado que buscamos (en el cual el puntero estará vacío).  Dado que hemos aplicado la técnica de backtracking los nodos que previamente hayamos calculado y no pertenezcan a ese camino desaparecerán porque no nos sirven. Finalmente mediante un bucle recorreremos todos los nodos del camino mostrando por pantalla la operación que lo ha creado hasta el nodo final. Así en el ejemplo quedaría:

3 * 2 = 6
6 + 1 = 7

Sin embargo en el juego de cifras y letras si no se encuentra el número exacto se puntúa el número que más se acerque a este. La problemática aquí es que con el bactracking, si no se encuentra el número exacto, el camino que se habrá generado cuando retorne la función es el de la última operación, que con toda probabilidad no será el camino hacia el número que más se aproxime al original.

En este caso tenemos dos posibles formas de solucionarlo:

• A medida que vamos generando los nodos debemos comparar el resultado con el número que buscamos, si se acerca más que el anterior valor que hayamos comparado guardamos este resultado como el número que más se aproxima al buscado. Después cuando haya salido de la función y no se haya encontrado el exacto, se vuelve a llamar a esta misma pero buscando en esta ocasión el resultado aproximado (ya que tenemos la certeza de que se puede calcular) obteniendo así el camino hasta llegar al que más se acerca.
• El problema de la solución anterior es que tenemos que llamar dos veces a la función que genera el árbol: una para buscar el exacto y otra para buscar el aproximado. Lo ideal es ir guardando un camino alternativo hacia el número aproximado, para que, en caso de no hallar el exacto, recorrer el camino alternativo mediante un bucle para mostrar las operaciones que obtengan el número aproximado. Todo desde la misma llamada a la función. Esto provoca que también se necesite un puntero al nodo anterior.

Aquí dejo el código fuente en C# que pone en práctica todo lo comentado. Se trata de una aplicación de consola donde como parámetros se le pasa todo el conjunto de números separados por espacio y como último número el resultado que se desea averiguar.

Program.cs:

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
 
namespace Cifras
{
    class Program
    {
        static int Main(string[] args)
        {
            // Ncesitamos como mínimo dos números para operar y un resultado
            if (args.Length < 3)
            {
                Console.Write("La sintaxis es " + System.AppDomain.CurrentDomain.FriendlyName + " <número 1>...<número n> <número buscado>");
                return 1;
            }
            Console.Write("Set de números: ");
            ArrayList posibilidades = new ArrayList();
            int indice = 0;
            // Creamos el conjunto de números a partir de la línea de comandos.
            for (; indice < args.Length - 1; indice++)
            {
                Console.Write(args[indice] + " ");
                posibilidades.Add(Int32.Parse(args[indice]));
            }
            int descubre = Int16.Parse(args[indice]);
            Console.WriteLine("\nNúmero buscado: " + descubre + "\n");
            // Creamos el primer nodo del árbol.
            Nodo encuentra = new Nodo(posibilidades, descubre);
            // Creamos un contador
            DateTime hora = DateTime.Now;
            TimeSpan tiempo;
            // Si se ha encontrado el exacto
            if (encuentra.busca() == true)
            {
                tiempo = DateTime.Now - hora;
                Console.WriteLine("Se encontró el exacto.\n");
            }
            // En caso de no encontrarse el exacto
            else
            {
                tiempo = DateTime.Now - hora;
                Console.WriteLine("No se ha encontrado el exacto.\n");
                // Sustituimos el camino original por el camino del aproximado
                encuentra = Nodo.Cercano;
            }
            Console.WriteLine("Número de nodos calculados: " + Nodo.NumeroNodos);
            Console.WriteLine("Tiempo en calcularlo: " + tiempo.TotalMilliseconds + " ms.\n");
            Console.WriteLine("Operaciones:");
            // Recorremos todos los nodos del camino para mostrar las operaciones que se han ido ejecutando.
            while (encuentra.Hijo != null)
            {
                encuentra = encuentra.Hijo;
                Console.WriteLine(encuentra.Valor1 + encuentra.Signo + encuentra.Valor2 + "=" + encuentra.Resultado);
            }
            return 0;
        }
    }
}

Nodo.cs:

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
 
namespace Cifras
{
    class Nodo
    {
        private enum OPERACIONES { SUMA, RESTA, MULTIPLICACION, DIVISION };
        private static int buscado; // El número exacto que debemos encontrar.
        private ArrayList numeros; // El conjunto de números con los que pueden operar los hijos del nodo.
 
        private Nodo padre; // El nodo padre del nodo actual.
 
        private Nodo hijo; // El nodo hijo del nodo actual.
 
        public Nodo Hijo
        {
            get { return hijo; }
        }
 
        private int valor1; // El primer operando.
 
        public int Valor1
        {
            get { return valor1; }
        }
        private int valor2; // El segundo operando.
 
        public int Valor2
        {
            get { return valor2; }
        }
 
        private string signo; // El signo de la operación.
 
        public string Signo
        {
            get { return signo; }
        }
 
        private int resultado; // El resultado de la operación.
 
        public int Resultado
        {
            get { return resultado; }
        }
 
        private static Nodo cercano; // Camino donde se llega al número más aproximado al buscado.
 
        public static Nodo Cercano
        {
            get { return Nodo.cercano; }
        }
 
        private static int aproximado; // Variable que va guardando qué número es el más aproximado.
 
        private static int numeroNodos; // Número total de nodos creados.
 
        public static int NumeroNodos
        {
            get { return Nodo.numeroNodos; }
        }
 
        // Contructor para crear el primer nodo del arbol
        public Nodo(ArrayList numeros, int buscado)
        {
            this.numeros = numeros;
            Nodo.buscado = buscado;
            padre = null;
            hijo = null;
            Nodo.cercano = null;
            Nodo.aproximado = 0;
            Nodo.numeroNodos = 0;
        }
 
        // Constructor para crear los restantes nodos del arbol.
        private Nodo(ArrayList numeros, int valor1, int valor2, int resultado, string signo, Nodo padre)
        {
            this.numeros = numeros;
            this.valor1 = valor1;
            this.valor2 = valor2;
            this.resultado = resultado;
            this.signo = signo;
            this.padre = padre;
            this.hijo = null;
            // Para saber cuantos nodos se han creado.
            Nodo.numeroNodos++;
            // Vamos guardando el número cercano más próximo al buscado.
            if (Math.Abs(buscado - resultado) < Math.Abs(buscado - aproximado))
            {
                // Creamos un camino alternativo duplicando los nodos.
                // Esto es necesario porque en backtracking los nodos que no sirven se eliminan y necesitamos
                // tener un camino hacia el resultado aproximado que perdure en toda la ejecución de la función.
                Nodo historico = this;
                Nodo copia = (Nodo)this.MemberwiseClone();
                while (historico.padre != null)
                {
                    copia.padre = (Nodo)historico.padre.MemberwiseClone();
                    copia.padre.hijo = copia;
                    historico = historico.padre;
                    copia = copia.padre;
                }
                cercano = copia;
                aproximado = resultado;
            }
 
        }
 
        // La función principal que busca el resultado combinando el conjunto de números del nodo con las
        // operaciones de suma, resta, multiplicación y división.
        public bool busca()
        {
            // Si el nodo actual contiene el número buscado ya no hacemos más búsquedas
            if (resultado == buscado)
            {
                return true;
            }
 
            // Vamos recorriendo cada elemento del conjunto de números operándolo con los demás.
            for (int indice1 = 0; indice1 < numeros.Count; indice1++)
            {
                for (int indice2 = indice1 + 1; indice2 < numeros.Count; indice2++)
                {
                    if (calculos(indice1, indice2, OPERACIONES.SUMA) == true)
                    {
                        return true;
                    }
                    if (calculos(indice1, indice2, OPERACIONES.RESTA) == true)
                    {
                        return true;
                    }
                    if (calculos(indice1, indice2, OPERACIONES.MULTIPLICACION) == true)
                    {
                        return true;
                    }
                    if (calculos(indice1, indice2, OPERACIONES.DIVISION) == true)
                    {
                        return true;
                    }
                }
            }
            // Si llegamos aquí es que todos los cálculos en esta rama del arbol han sido infructuosos.
            return false;
        }
 
        // Esta función crea un nuevo nodo después de operar los números. Le asigna un nuevo conjunto de números, 
        // el resultado de la operación, y los números involucrados.
        private bool calculos(int indice1, int indice2, OPERACIONES operacion)
        {
            int resultado = 0;
            string signo = "";
            int valor1 = (int)numeros[indice1];
            int valor2 = (int)numeros[indice2];
 
            // Hacemos que en la resta, división y multiplicación el primer operando sea mayor que el segundo
            if ((operacion == OPERACIONES.RESTA) || (operacion == OPERACIONES.DIVISION) || (operacion == OPERACIONES.MULTIPLICACION))
            {
                if (valor1 < valor2)
                {
                    int valor3 = valor1;
                    valor1 = valor2;
                    valor2 = valor3;
                }
            }
            // Calculamos la operación con los números, haciendo la poda del arbol si es necesario.
            switch (operacion)
            {
                case OPERACIONES.SUMA:
                    resultado = valor1 + valor2;
                    signo = "+";
                    break;
                case OPERACIONES.RESTA:
                    if ((valor1 - valor2) == 0) // Un número que da cero no sirve para seguir
                    {
                        return false;
                    }
                    resultado = valor1 - valor2;
                    signo = "-";
                    break;
                case OPERACIONES.MULTIPLICACION:
                    if (valor2 == 1) // Una multiplicación que por 1 da el mismo resultado no sirve
                    {
                        return false;
                    }
                    resultado = valor1 * valor2;
                    signo = "*";
                    break;
                case OPERACIONES.DIVISION:
                    if ((valor2 == 1) || ((valor1 % valor2) != 0)) // Un división que por 1 da el mismo resultado o que tiene decimales no sirve
                    {
                        return false;
                    }
                    resultado = valor1 / valor2;
                    signo = "/";
                    break;
            }
            // Generamos el nuevo conjunto de números sobre los que operar.
            ArrayList posibilidades = new ArrayList();
            posibilidades.Add(resultado);
            for (int indice = 0; indice < numeros.Count; indice++)
            {
                // No permitimos que se incluyan los números que ya se han operado.
                if ((indice != indice1) && (indice != indice2))
                {
                    posibilidades.Add(numeros[indice]);
                }
            }
            // Creamos el nuevo nodo.
            Nodo opcion = new Nodo(posibilidades, valor1, valor2, resultado, signo, this);
            // Hacemos la búsqueda recursiva. Si lo encontramos vamos generando el camino hacia el nodo con el
            // número exacto.
            if (opcion.busca() == true)
            {
                hijo = opcion;
                return true;
            }
            else
            {
                return false;
            }
        }
 
    }
}

También podéis descargaros el ejecutable del programa para poder hacer las pruebas.

Así por ejemplo este reto:

Se resuelve como:

El hecho de que Microchip saque al mercado PICs de 32 bit con encapsulado DIP va a revolucionar el mundo de los aficionados a la electrónica. Un simple chip con 28 pines tan potente como el primer 386 de intel (salvando las arquitecturas Harvard y von Neumann) que podemos poner en nuestras protoboards. Puede correr hasta 80 Mhz., 512KB de Flash (donde se almacena el código), 128KB. de SRAM (donde se almacenan los datos) y la posibilidad de conectar con periféricos mediante DMA.

Se pueden pedir samples, pero pueden tardar 42 días en enviarlos.

Todo el mundo ha hablado de la reciente muerte de Steve Jobs. Sin embargo también recientemente ha fallecido una persona que ha contribuido enormemente al desarrollo de la informática: Dennis Ritchie. Este hombre fue el creador junto a Ken Thompson del sistema operativo Unix (en el cual está basado GNU/Linux de Richard Stallman y Linus Torvalds) pero su mayor aportación fue crear el lenguaje de programación C, quizá el más usado de la historia y del que derivan otros tantos como objective-c, java y c#. Hasta siempre Dennis.

int *born1941 = malloc(70);
int *die2011 = born1941;
free(die2011);
printf("bye world\n");

(Fuente: chw.net)

Ya han publicado el vídeo de la charla de telemetría que di en la OSHWCON 2011.

Toda la documentación de mi charla (presentación, código fuente, esquemáticos, etc.) lo podeis descargar aquí.

Agradecer a los organizadores su tiempo, esfuerzo y ganas por sacar adelante algo tan novedoso y pionero. También dignos de mención son los ponentes que de forma altruista hemos hecho realidad este fantástico evento. Por supuesto no nos olvidemos de los patrocinadores que han permitido que este evento tuviese un nivel alto y de calidad.

A todos, nos vemos en la OSHWCON 2012.