TODOPIC

Microcontroladores PIC => * PROYECTOS * => Mensaje iniciado por: jgpeiro06 en 27 de Agosto de 2009, 17:57:58

Título: Juego de el Pong basado en FreeRTOS.
Publicado por: jgpeiro06 en 27 de Agosto de 2009, 17:57:58
Hola a todos!
Llevo ya unas semanas trabajando en el juego del Pong basado en FreeRTOS, y aunque aun no esta terminado, voy a empezar con la pequeña documentacion que necesita el proyecto y así ver si me podéis ayudar con los problemas que aun me quedan por solucionar.

El objetivo del proyecto es jugar un poco con los RTOS, con la POO y con el lenguaje C en general. En un principio intenté realizar el space invaders, pero tras darle unas cuantas vueltas me di cuenta de que el juego del pong me iva a resultar más sencillo sin dejar de lado los objetivos del proyecto. A pesar de que el juego es muy simple he tenido que pelearme para realizar un programa bien estructurado y robusto.

De momento tengo prevista una interfaz con 5 pulsadores( ONOFF, I1, D1, I2 y D2) y un LCD  grafico con un controlador pcd8544, como el del los nokia 3310.

El aspecto del juego podría ser este:
(http://farm3.static.flickr.com/2560/3862492501_e7cb1b75d8_o.jpg)

Preo lo primero es dividir el juego en tareas, tras hacer muchos dibujos y delegar responsabilidades la cosa quedo así:
(http://farm3.static.flickr.com/2435/3862303243_9c30ae22a9_o.jpg)
La tarea PONG se ocupa de mostrar mensajes al inicio y al fin del juego y lleva la cuenta de las rondas jugadas.
Las tareas PLAYER mantiene actualizado a su jugador en la pantalla, con su puntuación y sus vidas.
La tarea BALL mantiene actualizada la pelota en la pantalla y comprueba si rebota contra un jugador o si pasa.
La tarea KEY lee los pulsadores y periodicamente envia un mensaje indicando su estado.
La tarea LCD recibe todos los elementos a mostrar en el LCD y los va mostrando.

Las tareas se envian informacion mediante recursos como queues o semaforos o memoria compartida que aun no tengo del todo decididos. Pero esta es la info que deben compartir:
Key: Es el estado de los pulsadores.
LCD: Es la primitiva a representar.  Un circulo con parametros x0, y0 y r por ejemplo.
Start: Informa de que el juego va a empezar.
Position: Es la posición en la que se encuentra un jugador
Kill: Informa de que la bola a "entrado en la portería".
GameOver: Informa de que el jugador X se ha quedado sin vidas.

También he repartido el codigo en objetos, de esta manera hay un ojeto de la clase BALL almacena la posicion de la bola y define todas las funciones que necesita la bola. Ademas este objeto esta "vivo", ya que crea una tarea en el RTOS que le permite interactuar por si solo.

Estos son los metodos de la clase BALL:
Código: C
  1. BALL *BALLConstruct( xBALLResources resources, int iBallID );
  2. void BALLDestruct( BALL *this );
  3. static void BALLReset( BALL *this );
  4. static void BALLTask( void * pvParameters );
  5. static void BALLMove( BALL *this );
  6. static void BALLDraw( BALL *this );
  7. static int BALLBounce( BALL *this, int jugador );
  8. static int BALLGoal( BALL *this, int pared );

Estos son los atributos de la calse BALL:
Código: C
  1. typedef struct{
  2.         xTaskHandle xHandle;
  3.         xBALLResources resources;
  4.         float px;
  5.         float py;
  6.         int iBallID;
  7. }BALL;

Saludos
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: jgpeiro06 en 17 de Septiembre de 2009, 20:27:36
He estado un tiempo dedicandome a desarrollar los drivers que necesita el juego. Tanto el LCD como los botones son dispositivos externos al PIC que necesitan unas cuantas rutinas especificas para su manejo y funcionamiento. Ademas, ha sido necesario crear dos clases para el manejo DINAMICO de los perifericos del propio PIC.

Este es el diagrama del sistema algo más detallado:
(http://farm4.static.flickr.com/3480/3930307452_0fd48d9ab2_o.jpg)

Modelar el driver del PCD8544 como una clase tiene sus ventajas en cuanto al uso, pero la tarea de el diseño se puede volver algo más exigente debido a que el driver debe soportar distintas instancias a la clase. Cuando la clase es solo un conjunto de rutinas y datos que se almacenan en la RAM no hay problema, pero cuando cuando una clase encapsula un recurso limitado hay que diseñarlas de un modo especial, e irremediablemente con ciertas partes dependiendes del micro que estemos usando.

Por ejemplo, si creamos varios objeto de la clase BALL, el sistema simplemente ira añadiendolos al stack. Por otro lado, si creamos varios objetos de la clase PCD8544, cada uno tendra asociados un modulo SPI y 5 pines. Pero, ¿como hacer que varios objetos accedan automaticamente a sus respectivos modulos SPI si ambos tienen exactamente las mismas funciones? La solución propuesta ha sido que cada objeto contiene información sobre los módulos que controla, y que dos objetos nunca comparten el mismo modulo.

Un objeto SPIX almacena toda la informacion necesaria para controlar el periferico, como punteros a SFR's (Special Function Register), pines usados por el modulo, posiciones de los bits de interrupcion...

Esta es la definición de la estructura SPIX en el programa:
Código: C
  1. typedef struct{ // cambiar offset por mask
  2.         int moduleID;
  3.         PIN MOSI;
  4.         PIN MISO;
  5.         PIN SCK;
  6.         PIN SS;
  7.         volatile unsigned int *pIPC;
  8.         unsigned int IPCoffset;
  9.         volatile unsigned int *pIE;
  10.         unsigned int IEMASK;
  11.         volatile unsigned int *pIF;
  12.         unsigned int IFMASK;
  13.         volatile unsigned int *pstat;
  14.         volatile unsigned int *pcon1;
  15.         volatile unsigned int *pcon2;
  16.         volatile unsigned int *pbuf;
  17. }SPIX;


Cuando llamamos a la funcion SPIConstructor esta busca un modulo SPI libre, lo configura automaticamente con los pines que queramos y devuelve un objeto SPIX ya inicializado. Si no quedan modulos SPI libres, se imlementara por software de manera totalmente transparente al usuario. Aunque es cierto que la implemtentacion por software es mucho mas lenta y no acepta configuracion.

Este es un ejemplo de uso de tres modulos SPI: (Notese que el ultimo se implementa AUTOMATICAMENTE por software)

Código: C
  1. PIN SPI1PINS[5] = {
  2.         { &PORTB, 0x01<<0 },    // RB0 is MOSI1
  3.         { &PORTB, 0x01<<1 },    // RB1 is MISO1
  4.         { &PORTB, 0x01<<2 },    // RB2 is SCK1
  5.         { &PORTB, 0x01<<3 },    // RB3 is SS1
  6. };
  7.  
  8. PIN SPI2PINS[5] = {
  9.         { &PORTB, 0x01<<4 },    // RB4 is MOSI2
  10.         { &PORTB, 0x01<<5 },    // RB5 is MISO2
  11.         { &PORTB, 0x01<<6 },    // RB6 is SCK2
  12.         { &PORTB, 0x01<<7 },    // RB7 is SS2
  13. };
  14.  
  15. PIN SPI3PINS[5] = {
  16.         { &PORTB, 0x01<<8 },    // RB8 is MOSI3
  17.         { &PORTB, 0x01<<9 },    // RB9 is MISO3
  18.         { &PORTB, 0x01<<10 },   // RB10 is SCK3
  19.         { &PORTB, 0x01<<11 },   // RB11 is SS3
  20. };
  21.  
  22.  
  23. #include "SPIX.h"
  24. int main(){
  25.        
  26.         SPIX SPIX1, SPIX2, SPIX3;
  27.        
  28.         SPIX1 = *SPIXConstruct( NEXT_FREE, SPIPINS1 );
  29.         SPIX2 = *SPIXConstruct( NEXT_FREE, SPIPINS2 );
  30.         SPIX3 = *SPIXConstruct( NEXT_FREE, SPIPINS3 );
  31.        
  32.         SPIXOpen( &SPIX1,
  33.                 ENABLE_SCK_PIN & ENABLE_SDO_PIN & SPI_MODE16_OFF & SPI_SMP_OFF & SPI_CKE_ON & SLAVE_ENABLE_OFF & CLK_POL_ACTIVE_HIGH & MASTER_ENABLE_ON & SEC_PRESCAL_1_1 &PRI_PRESCAL_1_1 ,
  34.             FRAME_ENABLE_ON & FRAME_SYNC_OUTPUT & FRAME_POL_ACTIVE_LOW & FRAME_SYNC_EDGE_PRECEDE & FIFO_BUFFER_DISABLE ,
  35.                 SPI_ENABLE & SPI_IDLE_STOP & SPI_RX_OVFLOW_CLR
  36.         );
  37.  
  38.         SPIXOpen( &SPIX2,
  39.                 ENABLE_SCK_PIN & ENABLE_SDO_PIN & SPI_MODE16_OFF & SPI_SMP_OFF & SPI_CKE_ON & SLAVE_ENABLE_OFF & CLK_POL_ACTIVE_HIGH & MASTER_ENABLE_ON & SEC_PRESCAL_1_1 &PRI_PRESCAL_1_1 ,
  40.             FRAME_ENABLE_ON & FRAME_SYNC_OUTPUT & FRAME_POL_ACTIVE_LOW & FRAME_SYNC_EDGE_PRECEDE & FIFO_BUFFER_DISABLE ,
  41.                 SPI_ENABLE & SPI_IDLE_STOP & SPI_RX_OVFLOW_CLR
  42.         );
  43.  
  44.         SPIXOpen( &SPIX3,
  45.                 ENABLE_SCK_PIN & ENABLE_SDO_PIN & SPI_MODE16_OFF & SPI_SMP_OFF & SPI_CKE_ON & SLAVE_ENABLE_OFF & CLK_POL_ACTIVE_HIGH & MASTER_ENABLE_ON & SEC_PRESCAL_1_1 &PRI_PRESCAL_1_1 ,
  46.             FRAME_ENABLE_ON & FRAME_SYNC_OUTPUT & FRAME_POL_ACTIVE_LOW & FRAME_SYNC_EDGE_PRECEDE & FIFO_BUFFER_DISABLE ,
  47.                 SPI_ENABLE & SPI_IDLE_STOP & SPI_RX_OVFLOW_CLR
  48.         );
  49.  
  50.        
  51.         while(1){
  52.                 SPIXPuts( &SPIX1, "Hello World! from SPI1" );
  53.                 SPIXPuts( &SPIX2, "Hello World! from SPI2" );
  54.                 SPIXPuts( &SPIX3, "Hello World! from SPI3" );
  55.         }
  56. }


Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: jgpeiro06 en 18 de Septiembre de 2009, 08:18:16
Aquí dejo un ejemplo para usar 3 módulos LCD. Se puede ver como el objeto SPI3 funciona por software ya que es mucho más lento que el SPI1. Respecto al SPI2, he comprobado que no funciona debido a un bug del Proteus.
En un futuro quiero aprovechar utilizar el DMA para enviar directamente un buffer al modulo SPI y liberar la CPU.

(http://farm4.static.flickr.com/3523/3931419100_6e16a3cfff_o.jpg)

Código: C
  1. PIN PCD85441PINS[5] = {
  2.         { &PORTB, 0x01<<12 },   // RB12 is SDIN1
  3.         { &PORTB, 0x01<<11 },   // RB11 is SCLK1
  4.         { &PORTB, 0x01<<13 },   // RB13 is DC1
  5.         { &PORTB, 0x01<<14 },   // RB14 is SCE1
  6.         { &PORTB, 0x01<<15 },   // RB15 is RST1
  7. };
  8. PIN PCD85442PINS[5] = {
  9.         { &PORTB, 0x01<<7 },    // RB7 is SDIN2
  10.         { &PORTB, 0x01<<6 },    // RB6 is SCLK2
  11.         { &PORTB, 0x01<<8 },    // RB8 is DC2
  12.         { &PORTB, 0x01<<9 },    // RB9 is SCE2
  13.         { &PORTB, 0x01<<10 },   // RB10 is RST2
  14. };
  15. PIN PCD85443PINS[5] = {
  16.         { &PORTB, 0x01<<2 },    // RB2 is SDIN3
  17.         { &PORTB, 0x01<<1 },    // RB1 is SCLK3
  18.         { &PORTB, 0x01<<3 },    // RB3 is DC3
  19.         { &PORTB, 0x01<<4 },    // RB4 is SCE3
  20.         { &PORTB, 0x01<<5 },    // RB5 is RST3
  21. };
  22.  
  23. int main( void ){
  24.        
  25.         GLCD    GLCD1, GLCD2, GLCD3;
  26.         PCD8544 PCD85441, PCD85442, PCD85443;  
  27.  
  28.         GLCD1 = *GLCDConstruct( 84, 48 );
  29.         GLCD2 = *GLCDConstruct( 84, 48 );
  30.         GLCD3 = *GLCDConstruct( 84, 48 );
  31.        
  32.         PCD85441 = *PCD8544Construct( PCD85441PINS, GLCD1.pBuffer );
  33.         PCD85442 = *PCD8544Construct( PCD85442PINS, GLCD2.pBuffer );
  34.         PCD85443 = *PCD8544Construct( PCD85443PINS, GLCD3.pBuffer );
  35.        
  36.         PCD8544WriteCommand( &PCD85441, FUNCTION_SET | CHIP_ACTIVE );
  37.         PCD8544WriteCommand( &PCD85442, FUNCTION_SET | CHIP_ACTIVE );
  38.         PCD8544WriteCommand( &PCD85443, FUNCTION_SET | CHIP_ACTIVE );
  39.        
  40.         while( 1 ){
  41.                 GLCDText57( &GLCD1, 1, 10, "Hello World!  from LCD1", 1, BLACK );
  42.                 GLCDText57( &GLCD2, 1, 10, "Hello World!  from LCD2", 1, BLACK );
  43.                 GLCDText57( &GLCD3, 1, 10, "Hello World!  from LCD3", 1, BLACK );
  44.                
  45.                 PCD8544WriteBuffer( &PCD85441 );
  46.                 PCD8544WriteBuffer( &PCD85442 );
  47.                 PCD8544WriteBuffer( &PCD85443 );
  48.         }
  49. }
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: Nocturno en 18 de Septiembre de 2009, 09:05:49
Yo usé DMA para SPI en un 33F y es una gozada, la CPU sólo se asomaba por allí para poner o recoger datos.

Por cierto, te aplaudo por el proyecto. Me encanta como todo lo que haces.
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: jgpeiro06 en 18 de Septiembre de 2009, 10:05:41
Citar
Yo usé DMA para SPI en un 33F y es una gozada
Pues yo de momento estoy mirando ejemplos para ver como hay que configurar y usar el DMA, el problema es que el ni el Proteus ni el MPLAB simulan el DMA y voy un poco a ciegas... Supongo que será mejor esperar a construir la placa para probarlo.

Citar
Por cierto, te aplaudo por el proyecto. Me encanta como todo lo que haces.
Muchas gracias
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: jgpeiro06 en 21 de Septiembre de 2009, 19:26:04
Bueno, ya esta terminada la primera versión del software. Aún necesita retoques, pero ya esta lista para depurar en la placa real, así que ahora me voy a dedicar principalmente a diseñar y fabricar la PCB. Con el prototipo podré depurar mejor todo el sistema, corregir los errores y darle la forma definitiva.


(http://farm3.static.flickr.com/2635/3941946967_0afb94a132_o.jpg)

En la imagen de arriba no se pueden leer los textos en el LCD porque el BitFontCreator que uso es una demo y no genera todos los caracteres.
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: jgpeiro06 en 21 de Septiembre de 2009, 19:36:00
Aquí dejo el esquema para simular con Proteus, ya que no lo he podido adjuntar en el post anterior...
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: J1M en 21 de Septiembre de 2009, 20:08:47
Eres un figura macho!!! Sigue iluminandonos con los RTOS!!

Enhorabuena por el proyecto y gracias por compartirlo y explicarlo tan bien ;)

Un saludete José Antonio.
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: LABmouse en 12 de Mayo de 2010, 17:49:23
Hola!, te felicito por el proyecto y tan bien explicado que esta.. Muchas gracias por compartirlo.

Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: AKENAFAB en 08 de Agosto de 2010, 10:12:40
 :shock: :shock: No habia visto este post!

Buenisimo!

Saludos y gRacias por compartir !  :-/ :-/
Título: Re: Juego de el Pong basado en FreeRTOS.
Publicado por: wolfman77 en 11 de Agosto de 2010, 16:27:02
Espectacular!
Muy bueno, felicitaciones! :D