Archivo de la categoría: Proyectos

Proyectos que he desarrollado y quiero compartir con la comunidad

Televigilancia con un coche RC, arduino y la raspberry pi

¿Quién no ha tenido alguna vez la necesidad de poder ver nuestra casa desde otro lugar (oficina, hotel, otra casa, etc), o poder hacer inspección de tuberías, respiraderos o sitios inaccesibles? La idea que planteo en este artículo es la de un coche teledirigido al que podemos manejar remotamente mediante wifi y que veamos por donde va.

Principalmente está compuesto de un coche RC, una placa arduino duemilanove (o UNO) con una motorshield y una raspbery pi modelo B con dos USB (un WIFI y una webcam) y el sistema operativo Raspbian.

El funcionamiento es sencillo: Por un lado con un programa en python que se ejecuta en la raspberry pi hacemos un servidor que reciba los comandos por tcp/ip, estos son enviados mediante el puerto serie de la raspberry pi al puerto serie del arduino, que será el encargado de manejar la motorshield para mover el conjunto. Por otro lado en la propia Raspberry Pi hacemos streaming de vídeo para que podamos ver a través de su webcam remotamente.

Todo está alimentado con una batería Lipo 7,4 V. (2S) de 1000 mAh. Por un lado está conectado directamente a arduino y por otro a un regulador UBEC para alimentar a la raspberry pi a través de los pines GPIO de 5v y GND.

La comunicación entre la rasbperry Pi y arduino se hace simplemente con un cable, ya que no es necesario ninguna protección al ser el pin TX de la raspberry pi el que se conecta al pin RX de arduino, y por tanto no hay riesgo con los voltajes diferentes (siempre y cuando no reprogrames arduino, si es así desconecta el cable de RX hasta haber terminado).

El programa de Arduino es bastante simple, sólo comprueba si existe un byte en el puerto serie y si lo hay lo interpreta para saber qué movimiento hay que hacer con los motores. Se parte del byte 0x30 (0 en ASCII) y se comprueban sus bits:

Si el bit 0 está activado el coche va hacia delante.
Si el bit 1 está activado el coche va hacia atrás.
Si los bits anteriores están desactivados entonces el coche no se mueve.
Si el bit 2 está activado gira las ruedas a la izquierda.
Si el bit 3 está activado gira las ruedas a la derecha.
Si los bits anteriores están desactivados entonces la dirección el coche permanece recta.

int dirA = 12; // sentido
int dirB = 13;  // direccion 
int speedA = 10; // velocidad del motor
int speedB = 11; // parada o encendido de la dirección
int velocidad = 150; // PWM del motor de tracción

// El robot va hacia atrás
void atras()
{
  digitalWrite (dirA, HIGH);
}

// El robot va hacia alante
void alante()
{
  digitalWrite (dirA, LOW);
}

// El robot tuerce a la izquierda
void izquierda()
{
  digitalWrite (dirB, LOW);
}

// El robot tuerce a la derecha
void derecha()
{
  digitalWrite (dirB, HIGH);
}

void setup() 
{
  // Configuración de las comunicaciones
  Serial.begin(115200);

  // Configuración de los pines de la motorshield
  pinMode (dirA, OUTPUT); 
  pinMode (dirB, OUTPUT); 
  pinMode (speedA, OUTPUT); 
  pinMode (speedB, OUTPUT);
  
  digitalWrite(speedA, LOW); 
  digitalWrite(speedB, LOW);
}


void loop() 
{
  
    while (Serial.available())
    {
      int caracter = Serial.read();
      caracter -= 0x30;
      if(caracter == 0)
      {
        digitalWrite(speedA, LOW); 
        digitalWrite(speedB, LOW);
      }
      else
      {
        if(caracter & 1)
        {
          analogWrite(speedA, velocidad);
          alante();
        }
        else if(caracter & 2)
        {
          analogWrite(speedA, velocidad);
          atras();
        }
        else if((caracter & 3) == 0)
        {
          digitalWrite(speedA, LOW);  
        }
        
        if(caracter & 4)
        {
          digitalWrite(speedB, HIGH);
          izquierda();
        }
        else if(caracter & 8)
        {
          digitalWrite(speedB, HIGH);
          derecha();
        }
        else if((caracter & 12) == 0)
        {
          digitalWrite(speedB, LOW);
        }
      }
    }
}

int dirA = 12; // sentido

int dirB = 13; // direccion

int speedA = 10; // velocidad del motor

int speedB = 11; // parada o encendido de la dirección

int velocidad = 150; // PWM del motor de tracción

// El robot va hacia atrás

void atras()

{

digitalWrite (dirA, HIGH);

}

// El robot va hacia alante

void alante()

{

digitalWrite (dirA, LOW);

}

// El robot tuerce a la izquierda

void izquierda()

{

digitalWrite (dirB, LOW);

}

// El robot tuerce a la derecha

void derecha()

{

digitalWrite (dirB, HIGH);

}

void setup()

{

// Configuración de las comunicaciones

Serial.begin(115200);

// Configuración de los pines de la motorshield

pinMode (dirA, OUTPUT);

pinMode (dirB, OUTPUT);

pinMode (speedA, OUTPUT);

pinMode (speedB, OUTPUT);

digitalWrite(speedA, LOW);

digitalWrite(speedB, LOW);

}

void loop()

{

while (Serial.available())

{

int caracter = Serial.read();

caracter -= 0x30;

if(caracter == 0)

{

digitalWrite(speedA, LOW);

digitalWrite(speedB, LOW);

}

else

{

if(caracter & 1)

{

analogWrite(speedA, velocidad);

alante();

}

else if(caracter & 2)

{

analogWrite(speedA, velocidad);

atras();

}

else if((caracter & 3) == 0)

{

digitalWrite(speedA, LOW);

}

if(caracter & 4)

{

digitalWrite(speedB, HIGH);

izquierda();

}

else if(caracter & 8)

{

digitalWrite(speedB, HIGH);

derecha();

}

else if((caracter & 12) == 0)

{

digitalWrite(speedB, LOW);

}

En el lado de la Raspberry Pi hay que instalar primero varias cosas:

sudo apt-get update
sudo apt-get install gstreamer-tools gstreamer0.10-plugins-bad gstreamer0.10-plugins-good v4l-utils python-serial

1 2	sudo apt-get update sudo apt-get install gstreamer-tools gstreamer0.10-plugins-bad gstreamer0.10-plugins-good v4l-utils python-serial

Editado 17/04/2014: Desactivar la consola serie que viene por defecto activada:
En el fichero /etc/inittab poner una almohadilla (#) al principio en la línea:
T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
En el fichero /boot/cmdline.txt sustituir la línea:
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
por
dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
Finalmente hay que reiniciar la Raspberry Pi para que coja los cambios.

Después hay que dar permisos de lectura y escritura al puerto serie:

sudo chmod a+rw /dev/ttyAMA0

1	sudo chmod a+rw /dev/ttyAMA0

A continuación creamos un fichero llamado servidor.py:

import socket
import serial

ser=serial.Serial('/dev/ttyAMA0', 115200)

host = ''
port = 1976
backlog = 5

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host,port))
s.listen(backlog)
while 1:
	ser.write("0")
	print "se espera una conexion"
	client, address = s.accept()
	print "conectado " + address[0] 
	while 1:
		data = client.recv(1)
		if data == '':
			break
		else:
			ser.write(data)

import socket

import serial

ser=serial.Serial('/dev/ttyAMA0', 115200)

host = ''

port = 1976

backlog = 5

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((host,port))

s.listen(backlog)

while 1:

ser.write("0")

print "se espera una conexion"

client, address = s.accept()

print "conectado " + address[0]

while 1:

data = client.recv(1)

if data == '':

break

else:

ser.write(data)

Este programa python se encarga de crear un socket tcp/ip que escucha por el puerto 1976 , cuando alguien se conecta a este puerto entonces permanece a la espera de recibir los bytes que posteriormente enviará a Arduino a través del puerto serie.

Finalmente crearemos un fichero llamado webcam.sh con el siguiente contenido (cambiar 192.168.1.133 por la ip que tenga vuestra raspberry pi):

gst-launch -v v4l2src ! ffmpegcolorspace ! video/x-raw-yuv,width=320,height=240,framerate=\(fraction\)30/1 ! queue ! videorate ! video/x-raw-yuv,framerate=10/1 ! jpegenc ! multipartmux ! tcpserversink host=192.168.1.133 port=5000 sync=false

1	gst-launch -v v4l2src ! ffmpegcolorspace ! video/x-raw-yuv,width=320,height=240,framerate=$fraction$30/1 ! queue ! videorate ! video/x-raw-yuv,framerate=10/1 ! jpegenc ! multipartmux ! tcpserversink host=192.168.1.133 port=5000 sync=false

Este programa shell arrancará un servidor de streaming con GStreamer. De momento GStreamer es el software que conozco que funciona más rápido enviando imágenes con un retardo de 2 segundos, ffmpeg tenía un retardo de hasta ¡¡¡ 10 segundos !!!. La idea la cogí de aquí.

Ahora que ya tenemos lo necesario en nuestra parte del coche, necesitamos configurar el router para redirigir los puertos 22, 1976 y 5000 hacía la ip que tenga la Raspberry Pi.

Desde el ordenador remoto necesitaremos tener el programa VLC para el recibir el streaming, un cliente de ssh (en windows el mejor es el putty) y Processing para enviar los comandos.

Los pasos para hacer que nuestro sistema de televigilancia son los siguientes:

Conectar mediante ssh a la raspberry pi y ejecutar el comando:

sh webcam.sh

1	sh webcam.sh

Abrir otra sesión de ssh y ejecutar el comando:

python servidor.py

1	python servidor.py

Arrancar VLC y abrir una ubicación de red poniendo la siguiente línea, con esto podremos ver lo que hay frente a la webcam (cambiar 192.168.1.133 por la ip que tenga vuestra raspberry pi):

tcp://192.168.1.133:5000

1	tcp://192.168.1.133:5000

Arrancar el Processing con el siguiente programa y ejecutarlo (cambiar 192.168.1.133 por la ip que tenga vuestra raspberry pi):

import processing.net.*; 
Client myClient; 
int valor;
 
void setup() { 
  size(200, 200); 

  myClient = new Client(this, "192.168.1.133", 1976); 
  valor = 0;
} 
 
void draw() { 
} 

void keyReleased() 
{
  if (key == CODED) 
  {
    if (keyCode == UP)
    {
      valor &= 0xFFFFFFFE; 
    }
    else if (keyCode == DOWN)
    {
      valor &= 0xFFFFFFFD;
    }
    else if (keyCode == LEFT)
    {
      valor &= 0xFFFFFFFB;      
    }
    else if (keyCode == RIGHT)
    {
      valor &= 0xFFFFFFF7;
    }
    myClient.write(valor + 0x30);
  }
}

void keyPressed()
{
  if (key == CODED) 
  {
    if (keyCode == UP)
    {
      valor |= 1; 
    }
    else if (keyCode == DOWN)
    {
      valor |= 2;
    }
    else if (keyCode == LEFT)
    {
      valor |= 4;      
    }
    else if (keyCode == RIGHT)
    {
      valor |= 8;      
    }
    myClient.write(valor + 0x30);
  }
}

import processing.net.*;

Client myClient;

int valor;

void setup() {

size(200, 200);

myClient = new Client(this, "192.168.1.133", 1976);

valor = 0;

}

void draw() {

}

void keyReleased()

{

if (key == CODED)

{

if (keyCode == UP)

{

valor &= 0xFFFFFFFE;

}

else if (keyCode == DOWN)

{

valor &= 0xFFFFFFFD;

}

else if (keyCode == LEFT)

{

valor &= 0xFFFFFFFB;

}

else if (keyCode == RIGHT)

{

valor &= 0xFFFFFFF7;

}

myClient.write(valor + 0x30);

}

void keyPressed()

{

if (key == CODED)

{

if (keyCode == UP)

{

valor |= 1;

}

else if (keyCode == DOWN)

{

valor |= 2;

}

else if (keyCode == LEFT)

{

valor |= 4;

}

else if (keyCode == RIGHT)

{

valor |= 8;

}

myClient.write(valor + 0x30);

}

Si todo ha ido bien, ponemos la ventana de processing que nos ha abierto como activa cuando hemos lanzado el programa y pulsamos los botones de los cursores del teclado, momento en el cual veremos a través de la webcam (o en local si lo tenemos enfrente) cómo nos desplazamos.

Y finalmente un vídeo de cómo funciona:

L.I.O.S.: El robot de 10$

Deja un comentario

English version

Introducción:

Hace algún tiempo leí un artículo sobre un concurso para crear un robot con un coste de 10$ para el aprendizaje de robótica en escuelas con un coste admisible. Este concurso es el reto AFRON.

Así que me pareció una buena idea participar. Se me ocurrió que un robot muy simple de hacer pero que es un buen punto de partida para aprender es un seguidor de luz, donde los sensores del robot están buscando si hay un foco luz y cuando lo encuentran se dirigen hacia el. Me puse a buscar los componentes, a construir el robot y al final he terminado a L.I.O.S. (Light input output system):

Como se puede ver en el vídeo, las ruedas y el chasis son de cartón de una caja reciclada. Aunque no se aprecie, los sensores son LDR, los motores son dos servos trucados para rotación continua, el cerebro es un microcontrolador PIC 12F683, tiene dos diodos led para indicar el estado y una batería lipo de 3,7V. y 130 mAh para alimentar el sistema.

Funcionamiento:

Nada más enchufar la batería los leds parpadean varias veces. Hay dos LDR que el microcontrolador está comprobando constantemente; si este detecta que en uno de ellos hay una intensidad de luz grande, entonces enciende el led del lado del LDR y activa el servo del lado contrario (si la luz está a la derecha, entonces es la rueda izquierda la que tiene que moverse y viceversa); si ambos sensores detectan luz entonces los dos led se encienden y los dos motores se activan para ir recto; si no detecta suficiente luz entonces permanece parado y los leds apagados.

Consumo

En resposo consume 23 mA.
Cuando sigue una luz puede consumir hasta 300 mA.

Velocidad

8,7 cm/s. cuando la batería está a 3,7V.

Construcción:

Componentes

Nombre		Descripción	Precio unitario (enlace)	Cantidad	Total
	PIC12F683	El cerebro	1,78$	1	1,78$
	Zócalo DIP	Para meter o sacar el PIC	0,18$	1	0,18$
	Batería Lipo	Para alimentar el circuito	1,33$	1	1,33$
	Conector hembra	Para enchufar la batería	0,47$	1	0,47$
	LDR	Para detectar la luz	0,32$	2	0,64$
	Servo	Para mover el robot	2,69$	2	5,38$
	diodo led	Para mostrar estado	0,13$	2	0,26$
	Resistencia 180Ω	Para los led	0,08$	2	0,16$
	Resistencia 10KΩ	Para los LDR y los servos	0,08$	6	0,48$
	Otros	Cartón (reciclable de cualquier caja), cables (usar los del propio servo), estaño, pegamento y tubo termoretráctil	0,05$ (por reciclaje o mínimas cantidades)		0,05$
Total					10,73$

Herramientas

	Uso	Precio aproximado
Cutter	Cortar el cartón	4$
Pegamento	Pegar cartón, brazos de servos y servos	3$
Cinta adhesiva	Pegar la plantilla y la batería al cartón	1,50$
Aguja	Agujerear el cartón	0,02$
Pistola de termocola	Pegar LDR, leds, resistencias y zócalo al cartón	15$
Pelacables	Pelar todos los cables	10$
Mechero	Reducir los tubos termoretráctiles	2$
Corta cables	Cortar topes de los servos, cables y tubos termoretráctiles	5$
Destornillador PH0	Apretar o aflojar los tornillos de los servos	1$
Soldador	Soldar cables con LDR, leds, resistencias, enchufe y zócalo	10$ – 25$
Estaño	Para soldar	5$
Programador	Programar el PIC	14$ – 45$
Cargador de baterías	Cargar la batería Lipo	15$ – 75$
Multímetro	Medir la carga de la batería Lipo	5$ – 30$

Precauciones

La hoja del cutter es afilada, tener cuidado de no cortarse.
La aguja es muy fina, tener cuidado de no pincharse.
El pegamento es muy fuerte, tener cuidado de que no entre en contacto con los ojos y/o la piel.
La termocola está muy caliente, tener cuidado de no tocarla.
El soldador está muy caliente, tener cuidado de no tocarlo, de no ponerlo en contacto con el cartón y de evitar respirar el humo de la soldadura.
La batería lipo no debe cortocircuitarse, ni sobrecargarse por encima de 4,2V. ni descargarse por debajo de 3V.

Servos

Los servos contienen electrónica para manejar su sentido de rotación y tienen engranajes para aumentar su fuerza de tracción, sin embargo sólo pueden rotar 180º, por lo que vamos a modificarlos para que su rotación sea continua como la de cualquier motor.

Lo primero es desmontarlos extrayendo los 4 tornillos de su base y separar las tapas inferior y superior:

Después hay que extraer los engranajes. Uno de ellos contiene una pestaña para que haga de tope y no avance más (marcado con un circulo rojo):

Así es como queda al cortarla:

Por otro lado tenemos el potenciómetro. Aquí debemos desoldar los cables (las flechas verdes) y romper la pared que contiene las dos pestañas que también hacen tope (las fechas rojas):

Así es como quedaría la pared que comentaba:

A continuación debemos soldar las dos resistencias de 10KΩ formando un divisor resistivo en los cables que habíamos desoldado antes (el cable blanco entre las dos resistencias). Para aislar los contactos poner tubo termoretráctil:

También aislar el extremo con tubo termoretráctil:

Finalmente unir todos los engranajes de nuevo, meter la electrónica, poner las tapas y atornillarlas:

Chásis y ruedas

Imprimir en papel esta plantilla en DXF a escala 1:1 (yo he usado el programa de software libre LibreCad):

Pegar el papel con cinta adhesiva al cartón. Agujerear los círculos pequeños con una aguja y cortar las líneas con un cutter:

A continuación poner la aguja en el agujero de una rueda, poner pegamento en el brazo alargado de un servo e introducir el agujero central de este por la aguja hasta pegarlo a la rueda. Repetir el proceso con la otra rueda:

Quitar la pegatina del lateral del servo, poner pegamento en ese lateral y pegarlo en el extremo superior izquierdo de la superficie grande de cartón. Repetir el proceso en el otro lado con el otro servo:

Cortar levemente la superficie pequeña de cartón por el primer tercio, poner pegamento y adherirla a la incisión hecha anteriormente en la superficie grande de cartón (según la plantilla). Colocar las dos ruedas en los ejes del servo:

Agujerear 4 orificios entre los servos, introducir desde abajo los LDR, girarlos 30 grados desde el centro y pegarlos con termocola. Hacer dos orificios a cada lado, introducir desde abajo los diodos led y pegarlos con termocola:

Electrónica

Este es el esquema electrónico:

LDR

Soldar una de las patillas de cada LDR a VCC.
Soldar la otra patilla de cada LDR a un extremo de una resistencia de 10KΩ
Desde la anterior unión izquierda soldar un cable hasta el pin 7 del zócalo y poner tubo termoretráctil.
Desde la anterior unión derecha soldar un cable en hasta el pin 6 del zócalo y poner tubo termoretráctil.
Soldar el otro extremo de cada resistencia a GND.
Pegar las resistencias a la base con termocola.

SERVO

Pelar los cables y soldar el rojo a VCC y el marrón a GND de cada servo.
Soldar el cable naranja del servo izquierdo al pin 3 del zócalo y poner tubo termoretráctil.
Soldar el cable naranja del servo derecho al pin 2 del zócalo y poner tubo termoretráctil.

LED

Soldar un extremo de una resistencia de 180Ω a VCC.
Soldar el otro extremo al de otra resistencia de 180Ω.
Desde la anterior unión soldar un cable hacia la patilla del ánodo del led derecho.
Desde la anterior unión soldar un cable hacia la patilla del cátodo del led izquierdo.
Soldar el extremo restante de la segunda resistencia a GND.
Pegar las resistencias a la base con termocola.
Desde el cátodo del led derecho soldar un cable hacia el ánodo del led izquierdo.
Desde la anterior unión soldar un cable hacia el pin 5 del zócalo y poner tubo termoretráctil.

PIC

Soldar el pin 1 del zócalo a VCC y poner tubo termoretráctil.
Soldar el pin 8 del zócalo a GND y poner tubo termoretráctil.
Pegar el zócalo a la base con termocola.

Batería

Enchufar el conector a la batería y comprobar cual es VCC y cual GND con un polímetro.
Soldar un cable a VCC y otro a GND y juntarlos con el resto del circuito. Poner tubo termoretráctil.
Enrollar un trozo de cinta adhesiva y ponerla en la zona trasera de la base.
Poner la batería encima de la cinta adhesiva y enchufar esta al conector.

Programación:

Desde aquí se puede descargar el código fuente para el firmware del PIC. Para entender el funcionamiento de los registros del PIC 12F683 lo mejor es leerse el datasheet.

Desde aquí se puede descargar el fichero .hex para programar el PIC.

El compilador que se ha usado es el SDCC, que es software libre. Para compilarlo he usado el siguiente comando:

sdcc -mpic14 -p12f683 --use-non-free lios.c

1	sdcc -mpic14 -p12f683 --use-non-free lios.c

Para subir el fichero .hex al PIC hay que tener un programador de PICs y un software que maneje el programador. Hay mucha variedad. Yo he usado el pickit3 de Microchip y su software para windows, pero hay otras alternativas más baratas que se pueden usar con software libre o gratuitas para linux, mac y windows.

Explicación

A grandes rasgos el funcionamiento es el siguiente:

Al enchufar la batería los leds parpadean 10 veces rápidamente. Los leds están en una configuración determinada para que si el pin del PIC está configurado como salida y la pone en alto luzca un led, si la pone en bajo luce el otro led; si está configurado como entrada (alta impedancia) los leds permanecen apagados.

Se activan las interrupciones del timer0 y del ADC. La interrupción del timer0 está configurada para que salte cada 0,1 ms. y sirve para contabilizar los tiempos en los servos. La interrupción del ADC salta cada vez que un valor ha sido leído en un LDR para activar el led asociado (si se traspasa cierto umbral), poner un valor en una variable de estado, cambiar el canal de ADC y leer el siguiente LDR.

En el bucle principal del programa se comprueba la variable de estado para saber qué servos deben activarse. La activación de los servos es distinta ya que estos están enfrentados y la rotación para ir hacia delante es diferente en cada uno. Para uno supone una señal alta de 1 ms y otra baja de 19 ms., mientras que para el otro supone una señal alta de 2 ms y otra baja de 18 ms.

Modificaciones:

Los sensores del robot son LDR, pero podrían haberse cambiado por dos CNY70 para hacer un robot seguidor de línea con el siguiente esquema:

O dos interruptores de acción rápida para hacer un robot que detectase colisiones con el siguiente esquema:

Probando el marco digital Parrot DF3120 (parte 3 y final)

16 respuestas

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; 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

#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

1	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; 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

#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 0x56000000 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 0x58000000 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 0x56000050) y del puerto G (GPGCON 0x56000060) 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 0x58000000. 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 0x56000054) y G (GPGDAT 0x56000064), 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 0x58000000), 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; 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

#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

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

1	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

1	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

1	hciconfig hci0

En el marco dejar en modo de escucha para rfcomm

rfcomm listen /dev/rfcomm0

1	rfcomm listen /dev/rfcomm0

En el ordenador conectarse al marco mediante rfcomm

sudo rfcomm connect /dev/rfcomm0 <MAC ADDRESS>

1	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

1	sudo apt-get install screen

En el ordenador conectarse al dispositivo rfcomm0 con el programa screen

sudo screen /dev/rfcomm0

1	sudo screen /dev/rfcomm0

En el marco ejecutar el programa

./pruebacomunicaciones

1	./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 https://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

Recuperar una cámara Zaapa CIP-RW después de un fallo de actualización

53 respuestas

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

1 2	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

Probando el marco digital Parrot DF3120 (parte 2)

25 respuestas

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

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

1	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

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");
}

#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

1	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

1	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

1	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>

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

Para wget el comando sería:

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

1	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

1 2	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);

1	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);

1 2	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);

1	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);
 }
}

100

101

102

103

104

105

106

107

108

#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

Probando el marco digital Parrot DF3120 (parte 1)

24 respuestas

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>

1	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

Por fin se puede programar la cámara IP Zaapa CIPRW (ZA-CIPRW) fácilmente

28 respuestas

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>

<html>

<head>

.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>

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>

<table>

<tr><td> </td><td class="comando" onmousedown="empieza_arriba()" onmouseup="termina_arriba()">Arriba</td><td> </td></tr>

<tr><td class="comando" onmousedown="empieza_izquierda()" onmouseup="termina_izquierda()">Izquierda</td><td> </td><td class="comando" onmousedown="empieza_derecha()" onmouseup="termina_derecha()">Derecha</td></tr>

<tr><td> </td><td class="comando" onmousedown="empieza_abajo()" onmouseup="termina_abajo()">Abajo</td><td> </td></tr>

</table>

</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:

Fuerza bruta en .net para resolver las cifras del concurso cifras y letras

4 respuestas

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

1 2	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;
        }
    }
}

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;
            }
        }

    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

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:

Microchip va a sacar microcontroladores PIC de 32 bit con encapsulado DIP

1 respuesta

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.

Mi charla de telemetría

Deja un comentario

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.

Introducción:

Funcionamiento:

Consumo

Velocidad

Construcción:

Componentes

Total

10,73$

Herramientas

Precauciones

Servos

Chásis y ruedas

Electrónica

Programación:

Explicación

Modificaciones:

1- Librería SDL

[VÍDEO]

[CÓDIGO]

[COMPILACIÓN]

[EJECUCIÓN]

[EXPLICACIÓN]

2- Entradas de información

[VÍDEO]

[CÓDIGO]

[COMPILACIÓN]

[EJECUCIÓN]

[EXPLICACIÓN]

3- Comunicaciones

[VÍDEO]

[CÓDIGO]

[COMPILACIÓN]

[EJECUCIÓN]

[EXPLICACIÓN]