Archivo de la categoría: Informática

Un cajón de sastre donde comento temas relacionados con el mundo de la informática

Explorer.exe en Windows

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

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

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

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

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

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

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

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

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:

Descansa en paz Dennis MacAlistair Ritchie

1 respuesta

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

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

int *born1941 = malloc(70);

int *die2011 = born1941;

free(die2011);

printf("bye world\n");

(Fuente: chw.net)

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.

Convertir un fichero wav comprimido con el codec G729A

2 respuestas

Recientemente me ha surgido la necesidad de convertir unos ficheros de audio que estaban en formato .WAV comprimido con el codec G729A a un formato .WAV reproducible en cualquier PC para hacer unas pruebas. Se trataba de poder escuchar ficheros .WAV que estaban comprimidos con ese codec, pero dada la dificultad de encontrar el codec gratuitamente para poder instalarlo en Windows he encontrado una alternativa que sirve igualmente.

En la página de Voice Age he encontrado una librería gratuita para windows con ejemplos y ejecutables de cómo extraer el audio comprimido con un codec G729A. Si se va a usar comercialmente se debe pedir una licencia a sipro que es quien tiene los derechos de licenciamiento.

El problema con los ejecutables de Voice Age es que convierte de formato G729A a formato RAW, pero ni el origen tiene los datos por sí sólo (están embebidos en un fichero .wav) ni en la conversión se pasa a un fichero .wav reproducible en windows.

Por ello he creado un programa de consola en Visual C++ 6.0 que hace uso de la librería .lib que ofrece VoiceAge para hacer esos dos pasos. La idea es leer unos datos del fichero wav y moverse hasta el byte 44 del fichero wav de origen, accediendo así a los datos de audio directamente; crear un fichero .wav de destino, introduciendo en este la cabecera de un fichero .wav con el tamaño de los datos de audio descomprimido e indicando que tiene formato PCM; finalmente leer los datos de audio comprimido, descomprimirlos con la librería y escribirlos en el fichero de destino.

Este es el código fuente del mismo:

#include "stdafx.h"
#include "va_g729.h"
#include <stdio.h>
#include <memory.h>

int main(int argc, char* argv[])
{
	FILE *entrada;
	FILE *salida;
	unsigned char	serial[L_FRAME_COMPRESSED];
	short			synth[L_FRAME];
	int				bfi;
	unsigned char cabecera[] = {0x52,0x49,0x46,0x46,0x00,0x00,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6D,0x74,0x20,0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x40,0x1F,0x00,0x00,0x80,0x3E,0x00,0x00,0x02,0x00,0x10,0x00,0x64,0x61,0x74,0x61,0x00,0x00,0x00,0x00};
	unsigned long longitud;
	unsigned long *puntero;

	puts("SISTEMAS O.R.P.\nConvertidor de WAVs G729A a PCM\n");

	// Se comprueban los parámetros
	if(argc != 3)
	{
		puts("Debe introducir el archivo wav de origen y el archivo wav de destino.");
		return 1;
	}

	// Se abre el fichero de origen
	entrada = fopen(argv[1], "rb");
	if(entrada == NULL)
	{
		puts("No se pudo abrir el fichero de origen");
		return 2;
	}

	// Se abre el fichero de destino
	salida = fopen(argv[2], "wb");
	if(salida == NULL)
	{
		puts("No se pudo abrir el fichero de destino");
		fclose(entrada);
		return 2;
	}

	// Se comprueba que el fichero origen es un .wav
	fread(serial, sizeof(char), 4, entrada);
	if(memcmp(serial, "RIFF", 4) != 0)
	{

		puts("El fichero de entrada no es un wav");
		fclose(entrada);
		fclose(salida);
		return 3;
	}

	// Se lee el tamaño de los datos de audio del fichero origen
	// y se calcula el tamaño de los datis de audio del fichero destino
	fread(&longitud, sizeof(unsigned long), 1, entrada);
	puntero = (unsigned long *)(cabecera + 4);
	*puntero = 36 + (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;
	puntero = (unsigned long *)(cabecera + 40);
	*puntero = (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;
	// Se escribe la cabecera wav al fichero de destino
	fwrite(cabecera, sizeof(char), sizeof(cabecera), salida);
	// Saltamos al byte 44 donde se encuentran los datos de audio comprimido
	fseek(entrada, 44, SEEK_SET);

	// Se inicializa el descompresor
	va_g729a_init_decoder();

	// Se lee un grupo de bytes comprimidos y se escriben descomprimidos
	while (fread(serial, sizeof(char), L_FRAME_COMPRESSED, entrada) == L_FRAME_COMPRESSED)
	{
		bfi = 0;
		va_g729a_decoder(serial, synth, bfi);
		fwrite(synth, sizeof(short), L_FRAME, salida);
	}

	fclose(entrada);
	fclose(salida);

	puts("Proceso terminado");

	return 0;
}

#include "stdafx.h"

#include "va_g729.h"

#include <stdio.h>

#include <memory.h>

int main(int argc, char* argv[])

{

FILE *entrada;

FILE *salida;

unsigned char serial[L_FRAME_COMPRESSED];

short synth[L_FRAME];

int bfi;

unsigned char cabecera[] = {0x52,0x49,0x46,0x46,0x00,0x00,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6D,0x74,0x20,0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x40,0x1F,0x00,0x00,0x80,0x3E,0x00,0x00,0x02,0x00,0x10,0x00,0x64,0x61,0x74,0x61,0x00,0x00,0x00,0x00};

unsigned long longitud;

unsigned long *puntero;

puts("SISTEMAS O.R.P.\nConvertidor de WAVs G729A a PCM\n");

// Se comprueban los parámetros

if(argc != 3)

{

puts("Debe introducir el archivo wav de origen y el archivo wav de destino.");

return 1;

}

// Se abre el fichero de origen

entrada = fopen(argv[1], "rb");

if(entrada == NULL)

{

puts("No se pudo abrir el fichero de origen");

return 2;

}

// Se abre el fichero de destino

salida = fopen(argv[2], "wb");

if(salida == NULL)

{

puts("No se pudo abrir el fichero de destino");

fclose(entrada);

return 2;

}

// Se comprueba que el fichero origen es un .wav

fread(serial, sizeof(char), 4, entrada);

if(memcmp(serial, "RIFF", 4) != 0)

{

puts("El fichero de entrada no es un wav");

fclose(entrada);

fclose(salida);

return 3;

}

// Se lee el tamaño de los datos de audio del fichero origen

// y se calcula el tamaño de los datis de audio del fichero destino

fread(&longitud, sizeof(unsigned long), 1, entrada);

puntero = (unsigned long *)(cabecera + 4);

*puntero = 36 + (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;

puntero = (unsigned long *)(cabecera + 40);

*puntero = (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;

// Se escribe la cabecera wav al fichero de destino

fwrite(cabecera, sizeof(char), sizeof(cabecera), salida);

// Saltamos al byte 44 donde se encuentran los datos de audio comprimido

fseek(entrada, 44, SEEK_SET);

// Se inicializa el descompresor

va_g729a_init_decoder();

// Se lee un grupo de bytes comprimidos y se escriben descomprimidos

while (fread(serial, sizeof(char), L_FRAME_COMPRESSED, entrada) == L_FRAME_COMPRESSED)

{

bfi = 0;

va_g729a_decoder(serial, synth, bfi);

fwrite(synth, sizeof(short), L_FRAME, salida);

}

fclose(entrada);

fclose(salida);

puts("Proceso terminado");

return 0;

}

Y aquí dejo el fichero ejecutable:

G729AtoPCM

Restringir el area de uso del ratón

Deja un comentario

Con un simple comando de la API de windows, ClipCursor, podemos restringir el uso del ratón a una zona del escritorio de windows. Un posible uso es restringir a un usuario el uso del ratón a la ventana de una aplicación sin que pueda salir de ella, y por tanto no ejecutar otras opciones del escritorio, pulsar sobre otras ventanas, o deplegar el menú de inicio.

El prototipo de la función es:

bool ClipCursor(RECT *rectangulo);

1	bool ClipCursor(RECT *rectangulo);

Asi por ejemplo si queremos restringirlo a la ventana de la calculadora podemos hacerlo de la siguiente forma:

RECT retangulo;
HWND ventana = FindWindow(NULL, "Calculadora");
GetClientRect(ventana, &rectangulo);
ClipCursor(&rectangulo);

RECT retangulo;

HWND ventana = FindWindow(NULL, "Calculadora");

GetClientRect(ventana, &rectangulo);

ClipCursor(&rectangulo);

Base de datos de IPs

1 respuesta

Hoy en día se puede saber de cualquier IP a qué ciudad pertenece (incluso a veces hasta el barrio). Para ello existen bases de datos en Internet donde se puede consultar este tipo de información.

En concreto voy a comentar sobre un sitio que ofrece este servicio gratis y es mantenido por donaciones. Se llama IPInfoDB. Provee varios servicios:

Búsqueda por formulario.
Búsqueda mediante API mediante XML o JSON.
Descarga de base de datos en formato CSV o querys SQL y una precisión a nivel de país o de ciudad.

Los usos que se le pueden dar son muchos: Saber desde donde te envían los comentarios, crear un servicio en internet destinado a un país o ciudad en concreto, conocer donde están ubicados los datacenters de un dominio determinado, personalizar el idioma de una página al usuario que la visita, etc.

La información se actualiza a principios de cada mes.