Máquina de juegos casera con uVGA-PICASO

Publicado por Oscar Gonzalez en Electrónica el 30/06/2011

máquina juegos casera uvga-picaso C8051F330 pwm

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.