FACULTAD DE INGENIERIA
CARRERA INGENIERIA ELECTRONICA
ESTUDIANTE:
Amrico lvarez Surci
GESTION 2011
LA PAZ - BOLIVIA
II
Resumen
PONG, un video juego sencillo, es la representacin del deporte de TENIS, que consiste
en hacer botar el baln en una paleta a otra sin equivocarse. En el presente proyecto
describimos el movimiento del baln y de la paleta en un campo diseado para tal
cometido. Analizamos el monitor VGA para poder describir un controlador del mismo,
utilizando la descripcion de hardware que nos brinda el VHDL.
Por ultimo mostraremos como el monitor brinda el campo de juego y tambin hara de
interfas entre el juego y el jugador.
Abstract
"PONG", a simple video game, is the representation of the sport of tennis, which consists of
bouncing the ball on a pallet to another without making a mistake. In this project, we
describe the movement of the ball and paddle in a field designed for that purpose. We
analyze the VGA monitor to describe the same controller, using the hardware description
that gives us the VHDL.
Finally we show how the monitor provides the playing field and will make the interface
between the game and the player.
III
LISTA DE FIGURAS
Figura 1: Consola ATARI-PONG
Figura 2: Videojuego original pong. Museo Vienna-1998
Figura 3: Recursos de descripcin VHDL
Figura 4: Analoga de entidad y arquitectura
Figura 5: Compuerta and de 2 entradas
Figura 6: Ejemplo de descripcin en VHDL
Figura 7: Modelo Esquemtico
Figura 8: Diagrama conceptual de un monitor TRC
Figura 9: Trazado del Haz de electrones, en un monitor TRC
Figura 10: Diagrama de bloques de un simple controlador VGA
Figura 11: Diagrama de tiempos de un barrido horizontal
Figura12: Diagrama de tiempos de un barrido vertical
Figura13: Tarjeta XILINX Spartan-3AN
Figura 14: Monitor TRC
Figura 15: Conexin VGA, con salidas del FPGA
Figura 16: Flujo grama, Videojuego PONG
Figura 17: diagrama de bloques conceptual, de un trazador de objetos
Figura 18: Elementos primitivos del videojuego PONG
Figura 19: Mapeo de bits de un Redondo
IV
LISTA DE TABLAS
Tabla 1 : Combinacin a 3 bits, RGB
Tabla 2: Modulo de Sincronia en VHDL
Tabla 3: Modulo Generador de pixeles, 3 objetos cuadrados.
Tabla 4: Modulo Prueba 1.
Tabla 5: Generador de Pixeles, con animacin
Tabla 6: Modulo Final, videojuego PONG en VHDL
INDICE GENERAL
Resumen/Abstract
III
Lista de Figuras
IV
Lita de Tablas
1.2. Objetivos
2
1.2.1 Objetivo principal
1.2.2 Objetivos secundarios
6
2.2.1. Entidad y Arquitectura
2.2.2 Unidad de Diseo y Libreras
2.2.3. Modelo de Diseo Bsico
2.3 VGA.
10
2.3.1 Seales de Sincronizacin. Hsync y Vsync
2.3.2 Timing de Seales de Sincronizacin VGA
VI
17
19
20
Objetos Rectangulares
36
38
4. 2 Mejoras
39
5. BIBLIOGRAFA
39
6. ANEXOS
40
VII
Capitulo 1
ANTECEDENTES Y PROPOSITOS
1.1 INTRODUCCION
Pong fue el primer juego desarrollado por Atari Inc. Originalmente la placa de Pong
utilizaba transistores, condensadores, resistencias, etc. ocupando un espacio de unos
cuantos metros cuadrados. Aunque ya exista el primer microprocesador, hecho por Intel
en 1970, no fue utilizado an, por su reciente lanzamiento al mercado, alto coste y
ausencia de documentacin.
Atari Pong fue una consola creada por Atari en 1975, es la segunda videoconsola de la
historia. No llevaba cartuchos, sino que tena slo un juego, el PONG.
El jugador controla en el juego una paleta que tiene un movimiento rectilneo, haciendo las
veces de paleta para que la pelota rebote en esta y en las paredes del espacio de juego.
El jugador pierde en cuanto ms falle en hacer botar el baln en la paleta.
Se utilizara un lenguaje de descripcin de hardware para el cometido de reproducir el
juego propuesto.
1.2. OBJETIVOS
Con el presente trabajo se trata de enfocar los siguientes objetivos:
1.3.1 Objetivo Principal
Capitulo 2
MARCO TEORICO
antiguos lenguajes usados all por 1968, concretamente el TIBSD (TI Boolean System
Description), desarrollado como lenguaje de entrada de datos para un sistema CAD de
circuitos impresos, y Fusim (Functional Simulator), utilizado para describir modelos de alto
nivel de microprocesadores y para generar prototipos de patrones de tests.
2.1.2 Lenguajes Actuales: VERILOG, UDL/I, VHDL
Verilog
Es un lenguaje de descripcin hardware diseado por la compaa Cadence Design
Systems Inc., que se ha venido utilizando como lenguaje del simulador digital Cadence. El
uso de Verilog est promovido por la Open Verilog International (OVI), que public en
octubre del 91 la primera versin del Hardware Description Language Reference Manual.
En Verilog la unidad de diseo fundamental es el mdulo, que describe un componente
hardware con su interfaz y contenido. Desde un punto de vista funcional, un mdulo
Verilog contiene la informacin de una entidad y su correspondiente arquitectura VHDL.
Verilog no proporciona compilacin independiente de mdulos: todos los mdulos
relacionados con el mismo diseo y simulacin deben estar en el mismo archivo.
2.2 VHDL
Very High Speed Integrated Circuit Hardware Description Language (VHSIC HDL).
Desarrollado por el Departamento de Defensa de los Estados Unidos a finales de la
dcada de los 70's. El propsito era hacer un estndar para disear, modelar, y
documentar circuitos complejos de manera que un diseo desarrollado por una empresa
pudiera ser entendido por otra, adems, que pudiera ser procesado por software para
propsitos de simulacin.
En diciembre de 1987 VHDL se estableci como el estndar IEEE-1076. En 1993 el
estndar IEEE-1076 se actualiz y un estndar adicional, el IEEE-1164, fue adoptado. En
1996, el estndar IEEE-1076.3 se convirti en un estndar de VHDL para sntesis siendo
este el que se utiliza en el diseo de sistemas digitales.
Lo que ha hecho que VHDL sea en un tiempo tan corto el lenguaje de descripcin de
hardware ms utilizado por la industria electrnica, es su independencia con la
metodologa de diseo utilizada por cada programador, su capacidad de descripcin a
diferentes niveles de abstraccin (Fig.3), y en definitiva la posibilidad de poder reutilizar en
diferentes mdulos en cualquier aplicacin futura.
deber tener un modulo principal que haga el llamado a cualquier modulo segn sea el
caso.
Hay que mencionar adems que hay que incluir las libreras, en la declaracin de
paquetes a utilizar en nuestra descripcin en VHDL.
no se los aprecia, pero son descripciones bsicas de una compuerta and de 3 entradas y
una or de n entradas (utilizados en lneas 24,27-30 respectivamente).
2.3 VGA
El trmino Video Graphics Array (VGA) Sistema grfico de pantallas para PC que se
comercializ por primera vez en 1988 por IBM.
10
Osciladores internos del monitor generan formas de onda diente de sierra para controlar
las dos bobinas de deflexin. Por ejemplo, si el haz de electrones se mueve desde el
borde izquierdo al borde derecho, la tensin aplicada a la bobina de deflexin horizontal
se incrementa gradualmente. Despus de alcanzar el borde derecho, el haz vuelve
rpidamente a la orilla izquierda.
El funcionamiento bsico de un monitor RGB (a color) es muy similar al visto,
exceptuando que tiene 3 haces de electrones que inciden en los puntos de fsforo rojo,
verde y azul en la pantalla. Los tres puntos se combinan para formar un pxel. Podemos
ajustar los niveles de tensin de la entrada de video de tres seales para obtener el color
del pixel deseado.
11
El puerto VGA tiene cinco seales activas: seales de sincronizacin horizontal y vertical
(hsync y vsync), y tres seales de vdeo para el rojo, verde y azul. Un controlador de
vdeo genera todas estas seales. Un diagrama de bloques simplificado de un controlador
de VGA se muestra en la Fig.10. Contiene un circuito de la sincronizacin, con el nombre
vga_sync, y un circuito de generacin de pxel.
12
tiempo necesario para el recorrido transversal (scan) toda la pantalla. Las discusiones
posteriores se basan en una pantalla VGA 640 por 480, con una tasa de pxel de 25 MHz,
lo que significa que 25 millones de pxeles son procesadas en un segundo.
SEAL DE SINCRONIA HORIZONTAL: HSYNC
En la figura anterior se observa que se trabaja con 800 pixeles, esto se debe a que
usualmente los monitores CRT tienen un borde negro, conocidos como Backporch y
frontporch, que son el borde izquierdo y derecho respectivamente.
13
Display: Regin en que los pixeles son observables. Longitud de 640 pix.
de
lneas
de
exploracin
horizontal.
Un
perodo
de
14
La seal de Vsync se puede obtener con un contador modulo 525. El Bottom y top border
puede variar entre marcas de monitores.
2.3.2. Timing de Seales de Sincronizacin VGA
Como se mencion anteriormente, se supone que la tasa de pxel es de 25 MHz. Est
determinada por tres parmetros:
p: El nmero de pxeles de una lnea de exploracin horizontal.
pixels
line
p 800
L 525
lines
screen
s 60
screens
seconds
El parmetro s especifica la rapidez con la pantalla debe ser restaurada. Para un ojo
humano, la frecuencia de actualizacin debe ser al menos 30 pantallas por segundo para
un movimiento continuo debe de ser 60 pantallas por segundo.
El clculo del timing para las seales de sincronizacin se lo realiza de la siguiente
manera:
15
pixels
second
Esquemas de mapa de bits: Se traza grficos desde una memoria, pixel a pixel. Esto
consume mucha memoria, ya que cada grafico debe de estar guardado en mapa de
bits
16
Capitulo 3
DESARROLLO DEL PROYECTO
3.1 HARDWARE EMPLEADO:
XILINX SPARTAN-3AN
Se emplea como elemento base un kit de desarrollo FPGA comercial referencia
UG334 familia Spartan 3A/3AN de XILINX.
4-Mbyte SRAM
4 switches deslizables
1 Osciladores de 50-MHz.
1 puerto VGA.
1 core microblaze
4 salidas de DAC
2 entradas a ADC
Monitor VGA
18
Enviar
Reset
Movimiento balon
Boton
Arriba
19
20
--seales de syncronismo
--contador de pixels 800x525
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
end vga_sync;
architecture rtl of vga_sync is
--vga 640 por 480, parametros de sirncronia
constant HD: integer:=640;
--trazado horizontal
constant HR:integer:=96;
--recarga horizontal
constant HF:integer:=16;
--margen derecho
constant HB:integer:=48;
--margen izquierdo
constant VD:integer:=480;
--trazado vertical
constant VR:integer:=2;
--recarga vertical
constant VF:integer:=10;
--margen inferior
constant VB:integer:=33;
--margen superior
--Contador modulo 2
signal mod2_reg, mod2_next:std_logic;
--seal de contadores para la sincronia vertical y horizontal
signal v_count_reg, v_count_next: unsigned(9 downto 0);
signal h_count_reg, h_count_next: unsigned(9 downto 0);
--salidas buffer
signal v_sync_reg, v_sync_next: std_logic;
signal h_sync_reg, h_sync_next: std_logic;
--seales de estados
signal h_end, v_end, pixel_tick: std_logic;
begin
--registros
process(clk,reset)
begin
if(reset='1') then
mod2_reg <= '0';
v_count_reg <= (others => '0');
h_count_reg <= (others => '0');
v_sync_reg <= '0';
h_sync_reg <= '0';
elsif(clk'event and clk='1') then
mod2_reg <= mod2_next;
v_count_reg <= v_count_next;
h_count_reg <= h_count_next;
v_sync_reg <= v_sync_next;
h_sync_reg <= h_sync_next;
end if;
end process;
-- generador de 25Mhz con enable tick
mod2_next <= not mod2_reg;
-- 25Mhz con pixel tick
pixel_tick <= '1' when mod2_reg='1' else '0';
h_end <= '1' when h_count_reg=(HD+HR+HF+HB-1) else '0';
--finaliza contador horizontal(799) y pone en cero
v_end <= '1' when v_count_reg=(VD+VR+VF+VB-1) else '0';
--finaliza contador vertical(524) y pone en cero
--contador modulo 800, para sincronismo horizontal
process(h_count_reg, h_end, pixel_tick)
begin
if(pixel_tick='1') then
if(h_end='1') then
h_count_next <= (others=>'0');
else
h_count_next <= h_count_reg+1;
end if;
else
h_count_next <= h_count_reg;
end if;
end process;
--contador modulo 525, para sincronismo vertical
21
--flancos subida
-- stado
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
--656
--751
--690
--491
--VIDEO ON/OFF
video_on <= '1' when ((h_count_reg < HD) and (v_count_reg < VD)) else '0';
--Seales de Salida
hsync <= h_sync_reg;
vsync <= v_sync_reg;
pixel_x <= std_logic_vector(h_count_reg);
pixel_y <= std_logic_vector(v_count_reg);
p_tick <= pixel_tick;
end rtl;
22
Definimos 3 objetos: WALL: pared de rebote, PADDLE: paleta de juego, BALL: baln de
juego.
OBJETOS RECTANGULARES
Un objeto rectangular puede ser definido por sus lmites en coordenadas de pantalla yaxis y x-axis(ejes Y y X respectivamente). El juego Bsico cuenta con tres objetos como
muestra la figura 19, la pared (wall), el baln (ball), y la paleta (paddle).
23
-- azul
PADDLE: Es una barra vertical (bar) que se define de igual manera que wall, con el
agregado que aparte de tener lmites horizontales (X), tambin se tiene lmites verticales
(Y) superior e inferior, en semejanza se tiene adems las seales bar_on y bar_rgb que
ser el trazador de dibujo y la seal del color respectivamente.
-- limites derecho e izquierdo
constant BAR_X_L: integer:=600;
--left
constant BAR_X_R: integer:=603;
--rigth
-- limites superior e inferior
constant BAR_Y_SIZE: integer:=72;
--tamao del paddle
constant BAR_Y_T: integer:=MAX_Y/2-BAR_Y_SIZE/2; --204
constant BAR_Y_B: integer:=BAR_Y_T+BAR_Y_SIZE-1; --204 (variable)
Cabe mencionar que el cdigo muestra una paleta de 72 pixeles verticales por 4
horizontales, las constantes BAR_Y_T y BAR_Y_B, son los limites superior e inferior.
Podramos haber definido como un valor integer solamente, pero se opto con elementos a
manera de variables, por que el paddle se mover de arriba y abajo, as que no tenemos
limites superior (top) e inferior (bottom) fijos.
24
Como los limites vertical y horizontal cambiaran en el movimiento del balon, se utiliza
variables para definirlos.
El circuito de seleccin y la multiplexacin, que examina las seales de los tres objetos y
rutas de la seal RGB (rgb_mux: figura 18), y que traza los 3 objetos es:
process(video_on, wall_on, wall_rgb, bar_on, bar_rgb, sq_ball_on, ball_rgb)
begin
if (video_on='0') then
graph_rgb<="000";
else
if (wall_on='1') then graph_rgb<=wall_rgb;
elsif (bar_on='1') then graph_rgb<=bar_rgb;
elsif (sq_ball_on='1') then graph_rgb<=ball_rgb;
else graph_rgb<="110";
--fondo amarillo
end if;
end if;
end process;
En los casos en los que no este trazando ningn objeto, el fondo se mostrara color
amarillo, teniendo de esta manera un background de nuestra pantalla.
Entonces el Cdigo en Vhdl para definir nuestro generador de pixeles ser el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
25
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
--left
--rigth
--tamao del paddle
--204
--204 (variable)
--587
--594 (variable)
-- otras seales
signal wall_on, bar_on, sq_ball_on:std_logic;
signal wall_rgb, bar_rgb, ball_rgb: std_logic_vector(2 downto 0);
begin
pix_x <= unsigned(pixel_x);
pix_y <= unsigned(pixel_y);
-- definiendo pixel a pixel linea vertical izquierda (wall)
wall_on <= '1' when (WALL_X_L<=pix_x) and (pix_x<=WALL_X_R) else '0';
-- definiendo salida rgb (wall)
wall_rgb <= "001";
azul
-- definiendo pixel a pixel linea vertical bar (paddle)
bar_on <= '1' when
(BAR_X_L<=pix_x) and (pix_x<=BAR_X_R) and
(BAR_Y_T<=pix_y) and (pix_y<=BAR_Y_B) else '0';
-- definiendo salida rgb (bar)
bar_rgb <= "010";
--verde
-- definiendo pixel a pixel el balon cuadrado (sq_ball)
sq_ball_on <= '1' when
(BALL_X_L<=pix_x) and (pix_x<=BALL_X_R) and
(BALL_Y_T<=pix_y) and (pix_y<=BALL_Y_B) else '0';
-- definiendo salida rgb (sq_ball)
ball_rgb <= "100";
--rojo
--rgb mux (multiplexor para elegir rgb)
process(video_on, wall_on, wall_rgb, bar_on, bar_rgb, sq_ball_on, ball_rgb)
begin
if (video_on='0') then
graph_rgb<="000";
else
if (wall_on='1') then graph_rgb<=wall_rgb;
elsif (bar_on='1') then graph_rgb<=bar_rgb;
elsif (sq_ball_on='1') then graph_rgb<=ball_rgb;
else graph_rgb<="110";
--fondo amarillo
end if;
end if;
end process;
end rtl;
26
--
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
------------------------------------------------------------------ Modulo_PRUEBA
--Observando Figuras Cuadradas
-- Americo Alvarez Surci
----------------------------------------------------------------library ieee;
use ieee.std_logic_1164.all;
entity pong_esquema is
port(
clk, reset: in std_logic;
hsync, vsync: out std_logic;
rgb: out std_logic_vector(2 downto 0)
);
end pong_esquema;
architecture rtl of pong_esquema is
signal pixel_x, pixel_y: std_logic_vector(9 downto 0);
signal video_on, pixel_tick: std_logic;
signal rgb_reg, rgb_next: std_logic_vector(2 downto 0);
begin
-- modulo vga_sync
vga_sync_unidad: entity work.vga_sync
port map(clk=>clk, reset=>reset, hsync=>hsync, vsync=>vsync, video_on=>video_on, p_tick=>pixel_tick,
pixel_x=>pixel_x, pixel_y=>pixel_y);
--modulo pong_graph (pixel generator)
pong_graph_unidad: entity work.pong_graph
port map(video_on=>video_on, pixel_x=>pixel_x, pixel_y=>pixel_y, graph_rgb=>rgb_next);
--buffer de salida RGB
process (clk)
begin
if (clk'event and clk='1') then
if (pixel_tick='1') then
rgb_reg <= rgb_next;
end if;
end if;
end process;
rgb <= rgb_reg;
end rtl;
27
funcionamiento cuando se los carga por separado en el kit de desarrollo xilinx, porque
solo son contadores (modulo de sincrona), y habilitador de pixeles cuando est en cierta
cuenta (generador de pixeles). Por lo que para realizar nuestra primera prueba y observar
que estas descripciones son correctas se procedi a escribir el cdigo presentado en la
tabla 4 que ser implementada en la tarjeta.
Observando que nuestros cdigos anteriores no tiene errores continuamos con el
desarrollo de nuestro proyecto.
Si queremos
obtener un circulo utilizaremos un modelo de 8 por 8 pixels (figura 20). Para la generacin
del baln redondo seguimos el siguiente procedimiento:
Usando la activacin del crculo, obtenemos una seal para habilitar el rgb para
colorear el crculo.
De igual manera que hicimos en la seccin 2.3.2, se definen todos los parmetros con las
modificaciones siguientes: Para implementar el sistema con baln redondo, tenemos que
28
incluir un ROM para almacenar el patrn del mapa de bits de nuestra forma. El
BALL_ROM tiene por longitud de palabra 8 bits en 8 direcciones. Traza el crculo dentro
del cuadrado cuando se activa el rd_ball_on.
constant BALL_SIZE: integer:=8;
-- limites derecho e izquierdo
signal ball_x_l, ball_x_r: unsigned(9 downto 0);
-- limites superior e inferior
signal ball_y_t, ball_y_b: unsigned(9 downto 0);
--Imagen de BALL redondo utilizando ROM
type rom_type is array (0 to 7) of std_logic_vector(0 to 7);
--definiendo nuestra rom para la forma de balon
constant BALL_ROM: rom_type:=
(
"00111100",
-- ****
"01111110",
-- ******
"11111111",
-- ********
"11111111",
-- ********
"11111111",
-- ********
"11111111",
-- ********
"01111110",
-- ******
"00111100"
-- ****
);
signal rom_addr, rom_col: unsigned (2 downto 0);
signal rom_data: std_logic_vector(7 downto 0);
signal rom_bit: std_logic;
-- seal que indica el mapeo del redondo dentro del cuadrado 8x8
signal rd_ball_on: std_logic;
Adems tendremos que modificar la parte de generacin de pixeles para obtener nuestro
circulo:
-- definiendo pixel a pixel el baln (habilitando seal de mapeo)
sq_ball_on <= '1' when (ball_x_l<=pix_x) and (pix_x<=ball_x_r) and
(ball_y_t<=pix_y) and (pix_y<=ball_y_b) else '0';
-- mapeando el balon segun la ROM (redondo)
rom_addr <= pix_y(2 downto 0) - ball_y_t(2 downto 0);
rom_col <= pix_x(2 downto 0) - ball_x_l(2 downto 0);
rom_data <= BALL_ROM(to_integer(rom_addr));
rom_bit <= rom_data(to_integer(rom_col));
-- habilitando el balon redondo
rd_ball_on <= '1' when (sq_ball_on='1') and (rom_bit='1') else '0';
-- definiendo salida rgb del balon
ball_rgb <= "100";
--rojo
29
end process;
Todas las modificaciones al cdigo de las tablas 2 y 3 descritas en este subtitulo, se las
incluir en la siguiente subseccion.
de
ping
pong,
la
paleta
es
controlada
por
dos
pulsadores y se puede mover arriba y abajo, y la pelota puede moverse y rebotar en todas
las direcciones. Estos 2 elementos son los que presentaran animacin.
Si bien el controlador VGA es controlado por una tasa de pxel de 25 MHz, la pantalla del
monitor VGA slo se actualiza 60 veces por segundo. Por tal razn los registros se deben
actualizar a este ritmo. Definimos una seal refr_tick que afirma 60Hz en cada segundo.
Examinemos en primer lugar nuestro generador de pixeles para el paddle, debemos que
cambiar las constantes bar_y_t y bar_y_b por seales (lmite superior e inferior de la
paleta), y adems crear un registro bar_y_reg para almacenar el valor actual del lmite
superior y su actualizacin. Si uno de los botones del control del juego es presionado
30
Ahora enfoquemos el problema del baln, tenemos que cambiar las cuatro constantes
limite por cuatro seales y crear 2 registros ball_x_reg y ball_y_reg para obtener los
movimientos horizontales y verticales del baln, actualizando valores de posicin del
baln. El baln se mueve a velocidad constante en una misma direccin, la direccin
puede cambiar cuando bota en las paredes o en el paddle pero no cambia la velocidad.
La velocidad la descomponemos en componentes X y componentes Y, cuyos valores de
velocidad pueden ser positivos BALL_V_P, o negativos BALL_V_N. Los valores actuales
de las componentes las guardamos en registros x_delta_reg y y_delta_reg; el segmento
de cdigo para la actualizacin de ball_x_reg y ball_y_reg es:
-- posicionando el balon en pantalla
ball_x_next <= ball_x_reg + x_delta_reg when refr_tick='1' else ball_x_reg;
ball_y_next <= ball_y_reg + y_delta_reg when refr_tick='1' else ball_y_reg;
31
-- alcance superior
-- alcance inferior
-- alcance del wall
-- registro de mov.
Cabe mencionar que igual que el juego, cuando fallamos en acertarle al baln con la
paleta esta seguir su curso perdindose posteriormente.
A continuacin se presenta el cdigo del generador de pixeles, con animacin:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
32
--left
--rigth
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
33
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
34
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
--MOV. registro
end if;
end process;
--rgb mux (multiplexor para elegir rgb)
process(video_on, wall_on, bar_on, rd_ball_on, wall_rgb, bar_rgb, ball_rgb)
begin
if (video_on='0') then
graph_rgb<="000";
--negro
else
if (wall_on='1') then graph_rgb<=wall_rgb;
elsif (bar_on='1') then graph_rgb<=bar_rgb;
elsif (rd_ball_on='1') then graph_rgb<=ball_rgb;
else graph_rgb<="011";
--fondo amarillo
end if;
end if;
end process;
end rtl;
Para lo rebotes del baln en las paredes horizontales y verticales, se utilizo los registros:
x_delta_reg, x_delta_next, y_delta_reg, y_delta_next; que son registros que actualizaran los
35
verificamos esto, adems nos dio un avance de cmo sera nuestro programa
library ieee;
use ieee.std_logic_1164.all;
entity juego_pong is
port(
clk, reset:in std_logic;
btn:in std_logic_vector(1 downto 0);
hsync, vsync: out std_logic;
rgb: out std_logic_vector(2 downto 0)
);
end juego_pong;
architecture rtl of juego_pong is
signal pixel_x, pixel_y: std_logic_vector(9 downto 0);
signal video_on, pixel_tick: std_logic;
signal rgb_reg, rgb_next: std_logic_vector(2 downto 0);
begin
unidad_sincronia_vga: entity work.vga_sync
port map(clk=>clk, reset=>reset, video_on=>video_on, p_tick=>pixel_tick, hsync=>hsync, vsync=>vsync,
pixel_x=>pixel_x, pixel_y=>pixel_y);
unidad_pong_graph_animado: entity work.pong_graph_animado
port map(clk=>clk, reset=>reset, btn=>btn, video_on=>video_on, pixel_x=>pixel_x, pixel_y=>pixel_y,
36
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
graph_rgb=>rgb_next);
-- definiendo salida rgb en flancos subida de periodo de clock
process (clk)
begin
if (clk'event and clk='1') then
if (pixel_tick='1') then
rgb_reg <= rgb_next;
end if;
end if;
end process;
rgb <= rgb_reg;
end rtl;
37
Capitulo 4
CONCLUSIONES Y MEJORAS
4.1 CONCLUSIONES
Se describi un monitor CRT para computadora y se trabajo directamente en el puerto de
salida VGA de la tarjeta Xilinx.
Se defini cada seal del conector vga. La seal de sincronismo se la trato en un
principio, y se la defini con contadores distintos.
El circuito generador de pixeles se lo trato en diferentes niveles, primeramente generando
figuras bsicas, luego con figuras definidas en una ROM. Adems se vio que para la
animacin se utilizo registros varios.
Con el avanzar, de prueba y error en cdigo vhdl, se pudo implementar de manera exitosa
el videojuego en la tarjeta XILINX spartan-3an.
Se dio bases para futuros experimentos en tarjetas fpga, ya que el cdigo en VHDL
planteado se lo escribi de la manera ms desglosada y explicando todas las sentencias y
valores crticos. Los mdulos presentados son aptos para la sntesis, ya que muchas
lneas son reducibles y fusionarles.
38
4.1 MEJORAS
El sistema descrito en este proyecto, es a manera de introduccin a proyectos mas
grandes utilizando la tarjeta XILINX, por lo que se puede incluir muchas mejoras a este
modulo de juego.
1. Incluir otro jugador, para que se parezca ms al juego de PING-PONG de 2
jugadores.
2. Incluir un interfaz de juego. Un teclado ps2 para que 2 jugadores lo utilicen como
controles de juego.
3. Incluir texto al esquema generador de pixeles. Adems de un texto que indique los
puntos de ambos jugadores.
4. Mediante la memoria RAM de la tarjeta, incluir una presentacin en imgenes de
mapa de bits. A manera de modo de espera.
5. Adems mediante la RAM tambin definir una imagen de fondo, a manera de
escenario de juego (background).
6. Incluir sonidos, para el bote del baln en las paletas, adems msica de fondo en
midi.
5. BIBLIOGRAFIA
http://members.optusnet.com.au/jekent/FPGA.htm#Section5.1
http://hoper3d.blogspot.com/2008/09/vhdl-pong.html
http://es.scribd.com/doc/55055785/pingpong
39
Hwang
MIT
Press
6. ANEXOS
40