Source: http://blog.bricogeek.com/noticias/electronica/maquina-de-juegos-casera-con-uvga-picaso/
Timestamp: 2017-10-17 05:54:43+00:00

Document:
Máquina de juegos casera con uVGA-PICASO - BricoGeek.com
Publicado por Oscar Gonzalez en Electrónica el 30/06/2011 Comentarios:
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.
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)
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:
{ UCHAR ext;
UCHAR cmd;
int imagePos1;
int imagePos2;} IMAGEN;
IMAGEN IDX_ESTRELLA=
"cereza22.gci",
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';
Para mostrar el número de jugadas, se utiliza el comando “Draw String of ASCII Text (graphics format)-53hex”, creando nuevamente otra estructura:
{ UCHAR cmd;
int stringColour;
char ancho;
char alto;
int Terminator;
} TEXTO;
TEXTO CONTADORES=
{ 0x53,
0xFFFF ,
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”:
int terminator;} AUDIO;
AUDIO audio2=
"Close2me.wav" ,
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.
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)
La función empleada para mostrar una imagen quedaría entonces así:
void DisplayImage(IMAGEN code *pImagen, int posx, int posy)
// 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.
Espero que os haya gustado el proyecto y no dudeis en cometar y compartir!

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución