Si aún no eres usuario, puedes crear una cuenta o entrar
Máquina de juegos casera con uVGA-PICASO

Esta máquina de juegos llamada "Números de la suerte" o "tragaperras" fué creada por Natalia Molinero desde Madrid con la colaboración de su compañero de laboratorio Stefan y su profesor Víctor, que amablemente nos han enviado su proyecto para compartirlo con todos vosotros. Esta máquina permite al usuario jugar un número de partidas específico según la cantidad de saldo que desee apostar. La respuesta obtenida ante los distintos tipos de apuestas es pseudo-aleatoria según la siguiente condición: la máquina siempre ha de contener más saldo del que está dispuesta a ofrecer. Lo cual tiene sentido.

Ha utilizado como base para su proyecto un controlador gráfico uVGA-PICASO que produce imágenes a todo color y sonido PWM junto con un procesador C8051F330.

No os perdais todos los detalles y video a continuación...

Gracias Natalia por enviarnos tu proyecto!





Máquina tragaperras casera

La implementación física de este proyecto se basa en el uso de un microcontrolador, un controlador gráfico con entrada serie, un monitor, un altavoz una tarjeta µSD de 4GB de memoria, cinco pulsadores  y un porta-baterías. El C8051F330 es el microcontrolador que lleva el programa con el algoritmo para la máquina de juegos y controla el funcionamiento del motor gráfico µVGA. Estos dos dispositivos se conectan entre sí mediante el puerto serie.

Desafortunadamente, este microcontrolador tiene un solo puerto  serie que ha tenido que ser compartido entre la placa depuradora y el motor gráfico, lo que ha imposibilitado en esta primera versión recibir las confirmaciones de los comandos; en su lugar, se ha añadido una función de demora que asegura que el comando ha sido recibido y procesado antes de pasar a enviar el siguiente.

Implementación

El  µVGA lee las imágenes, almacenadas en la µSD, según los comandos y parámetros enviados desde el C8051F330. Para ello, lo primero es ajustar la resolución de las imágenes, utilizando el comando “Display Control Functions”. En este caso vamos a ajustar la resolución del µVGA a 800x408. El  µVGA lee las imágenes, almacenadas en la µSD, según los comandos y parámetros enviados desde el C8051F330. Para ello, lo primero es ajustar la resolución de las imágenes, utilizando el comando “Display Control Functions”. En este caso vamos a ajustar la resolución del µVGA a 800x408.

De esta forma,  en el buffer de transmisión se escriben los caracteres correspondientes a dicho comando:

buffer[0]= 0x0C;		
buffer[1]= 0x02;
SendCommand(buffer,2);
delay(3000); // Este comando necesita una demora mayor en su ejecución

Y se envían por el puerto serie utilizando la función SendCommand:

void SendCommand(UCHAR *pcmd, UCHAR ncmd)
{
 	unsigned char v;

	for(v=0; v < ncmd; v++) 
		putchar(pcmd[v]);

	delay(1000);  // Espera de 1 seg debido a que el puerto serie está compartido
}


Siendo UCHAR equivalente a unsigned char; el empleo de este tipo, siempre que sea posible, permite optimizar el uso del microcontrolador de 8 bits.

El diseño de las imágenes se consigue empleando la herramienta “Graphics Composer” para editar la resolución de los gráficos y convertirlos al formato .gci y .dat adecuados para el controlador gráfico, Picaso, que contiene el µVGA.

Los comandos que envía el microcontrolador al  µVGA para la lectura de imágenes se han programado en C mediante estructuras que incluyen los parámetros correspondientes a “Display Image-Icon from Card (FAT) -  @6hex”, que podemos encontrar en el Command Set del µVGA:

typedef struct 
{ UCHAR ext;					
  UCHAR cmd;				
  char file_name[12];		 
  char terminator;			 
  int posx;					 
  int posy;					 
  int imagePos1;			
  int imagePos2;} IMAGEN; 

IMAGEN IDX_ESTRELLA=
{ 0x40,
  0x6D,
  "cereza22.gci",
   0 ,
   0 ,   
   0	,
   0,
   0};

En el programa hay varias estructuras como la anterior, una para cada imagen: sólo tenemos que cambiar el nombre de archivo de la imagen.
La función empleada para leer los parámetros de la estructura de cada imagen es la siguiente:

void DisplayImage(IMAGEN *pImagen, int posx, int posy)
{	
	pImagen ->posx = posx;			
	pImagen ->posy = posy;
	SendCommand((UCHAR *)pImagen, sizeof(IMAGEN));

}


También se ha mostrado en el monitor el número de jugadas restantes que le quedan al usuario cuando está apostando.  Para ello, lo primero es utilizar el comando “Set Transparent-Opaque Text-4Fhex” en modo Opaco para evitar que la cadena que se muestra cada vez en la pantalla se solape con la anterior.

buffer[0]='O';		
buffer[1]='1';
 SendCommand(buffer,2);

Para mostrar el número de jugadas, se utiliza el comando “Draw String of ASCII Text (graphics format)-53hex”, creando nuevamente otra estructura:

typedef struct
{ UCHAR cmd;					
int x;	
int y;		
char font;			
int stringColour;					
char ancho;
char alto;	
char string[255];     			
int Terminator;			
  } TEXTO; 

TEXTO CONTADORES=
{ 0x53,
  0,
  0,
  0,
0xFFFF ,
   3 ,
   3,
   {0},
   0,	
   };

Para aumentar el tamaño del contador en el display, se ha aumentado el tamaño de las fuentes, poniendo en el ancho y en el alto un 3. La función encargada de mostrar los contadores es:

void DisplayContadores(TEXTO *pTexto, int x, int y, char valor)
{
	char decenas;
	char unidades;
	decenas=valor/10;
	unidades=valor%10;						
	pTexto ->x = x;
	pTexto ->y = y;
	pTexto ->string[0] = 0x30 + decenas;
	pTexto ->string[1] = 0x30 + unidades;

	SendCommand((UCHAR *) pTexto, sizeof(TEXTO));
}

Finalmente, se ha programado una melodía que anima al usuario cuando este ha ganado una apuesta. Para ello se utiliza un archivo de audio que se almacenará en la memoria µSD, el cual ha sido modificado según las especificaciones del µVGA: la frecuencia de muestreo a 16 kHz, con 8 bits de resolución y monoaural, parámetros conseguidos utilizando el software “Cool Edit Pro”.

La estructura y la función en este caso son muy similares a las de las imágenes y los comandos se encuentran en la sección “Play Audio WAW file from Card (FAT)-@6Chex”:

typedef struct 
{ UCHAR ext;					 
  UCHAR cmd;					 
  char option;		 
  char file_name[12];			 
  int terminator;} AUDIO; 

AUDIO audio2=
{ 0x40,
  0x6C,
  1,
   "Close2me.wav" ,
   0    
   };
void PlayWave(AUDIO *pAudio)
{	
	SendCommand((CHAR *)pAudio, sizeof(AUDIO));
}

Para la salida PWM del µVGA no hemos necesitado ningún tipo de circuito externo, sino que directamente se ha conectado el altavoz con amplificador (por ejemplo, un altavoz de ordenador) además de cortocircuitar la tierra con el pin AUDENB.
Si existen restricciones en el tamaño de la memoria RAM disponible y no hay espacio suficiente para las estructuras, éstas pueden almacenarse en la memoria de programa (ROM) y transferirse al buffer de transmisión (RAM), para una vez  allí ser modificadas (por ejemplo, estableciendo la posición de una imagen) y, finalmente, transferirse al puerto serie utilizando la función SendCommand().

A continuación se muestra un ejemplo específico para el C8051F330.

typedef struct 
{ UCHAR ext;					
  UCHAR cmd;				
  char file_name[12];		 
  char terminator;			 
  int posx;					 
  int posy;					 
  int imagePos1;			
  int imagePos2;} IMAGEN; 

IMAGEN *ps;	// Punteros auxiliares
char  code *p:     

code IMAGEN IDX_ESTRELLA=	// la palabra clave code indica que la estructura se almacenará 
{ 0x40,				// en la memoria de programa (ROM)
  0x6D,
  "cereza22.gci",
   0 ,
   0 ,   
   0	,
   0,
   0};

La función empleada para mostrar una imagen quedaría entonces así:

void DisplayImage(IMAGEN code *pImagen, int posx, int posy)
{	
	unsigned char i;

	// Transfiere la estructura desde la ROM al buffer de transmisión en RAM
	p = (char code *)(pImagen);	  
 for(i=0; iposx = posx;			// Establece la posición en el display
	ps->posy = posy;
	SendCommand(buffer, sizeof(IMAGEN));    // Envía el comando a través del puerto serie

}

En el caso del C8051F330 la palabra clave code permite almacenar la estructura en la memoria de programa; en otras plataformas, como Arduino, se puede usar la palabra clave PROGMEM.

Video

Espero que os haya gustado el proyecto y no dudeis en cometar y compartir!

En la tienda

Controlador uVGA-II (SGC) Pantalla LCD color uLCD-32PT Arduino UNO mbed - LPC1768


Comparte esto con tus amigos!

Si te ha gustado, quizás también te interese...
Cómo hacer tinta conductora casera
Publicado el 10/01/2014
Arpa láser casera
Publicado el 31/10/2013
Cámara térmica casera con Arduino
Publicado el 09/08/2013

Comentarios:



Enviar comentario

Debes disponer de una cuenta de usuario para publicar un comentario.

Si aún no dispones de una cuenta, únete a la comunidad de BricoGeek.com y registrate ahora, te llevará tan solo un minuto y es gratis. También puedes identificate si ya dispones de una cuenta de usuario.
rss

Conecta con BricoGeek.com

Canales sociales

Nos gusta mucho estar en contacto con nuestros lectores y saber más acerca de sus proyecto e inventos.


También puedes sugerir una noticia en el blog
Tienda de Electrónica DIY y Arduino

Lo que se cuece...

Comentarios recientes Más comentado Top noticias
Feed de novedades

Tienda BricoGeek.com

Electrónica para tus proyectos!

Estás preparando un proyecto o quieres iniciarte en la electrónica? Encuentra todo lo que necesitas en la tienda.

Visita la tienda BricoGeek!

La familia de BricoGeek.com

Conoce toda la gente que hace que BricoGeek.com sea posible cada día:

Alejandro Mallo
Colaborador
Puedes hacer click sobre un autor para ver todas sus noticias


Etiquetas más populares:

Descubre todo el contenido de bricogeek.com con las etiquetas más populares:


© BricoGeek.com 2005-2014

Demuestra lo que sabes hacer!