Está en la página 1de 20

Facultad de Ingeniera Universidad Nacional de San Juan

Ingeniera Electrnica

Sistemas Digitales Avanzados

Laboratorio N6:

PONG
Granero Eduardo Reg. 23217
Checcarelli Sergio Reg. 23185

-2013i

ndice
ndice de contenidos:
ndice .................................................................................................................................................... i
ndice de contenidos: ....................................................................................................................... i
ndice de ilustraciones:..................................................................................................................... i
Objetivos ............................................................................................................................................. 1
Desarrollo ............................................................................................................................................ 1
Sincronismo: .................................................................................................................................... 4
Generador de elementos: ............................................................................................................... 5
Problemas y soluciones ....................................................................................................................... 6
Apndice............................................................................................................................................... i
Sincronizacin: ................................................................................................................................. i
Generador de Elementos: ............................................................................................................... ii
Mov. de elementos ( divisor de frecuencia): ................................................................................ viii
Hexadecimal a 7 segmentos:...........................................................................................................ix
Top Level: .........................................................................................................................................x

ndice de ilustraciones:
Figura 1 ................................................................................................................................................ 2
Figura 2 ................................................................................................................................................ 2
Figura 3 ................................................................................................................................................ 3
Figura 4 ................................................................................................................................................ 3
Figura 5 ................................................................................................................................................ 4
Figura 6 ................................................................................................................................................ 4

Objetivos
Realizacin del juego PONG utilizando el puerto VGA.

Desarrollo
Para realizar este laboratorio se investigo la forma de trabajar del tubo de rayos catdicos
el cual se ve en la Figura 1 y Figura 2.
Se uso una resolucin de 640x480 pixeles. Esto significa que, como se ve en las Figura 2 y
Figura 6, se genero un barrido, el cual recorre pixel por pixel avanzando a la siguiente fila cuando
llega a la ltima columna. Para esto se tuvo que tener en cuenta los mrgenes de la pantalla.
A la par de barrido se genero una seal(Video ON/OFF) la cual se activa cuando nos
encontramos en un sector visible de la pantalla (dentro de la matriz de 640 x 480). Esta seal es la
que nos indica que podemos asignarle un color al pixel actual.
Junto a la seal Video ON/OFF se envi el valor de los contadores a otra entidad, el
generador de elementos. En esta, estn definido todo lo que compone al juego (pelota, paletas,
paredes , etc).
Para definir los elementos se usa como referencia la posicin 0 de los contadores (primer
pixel, ubicado en la esquina superior izquierda de la pantalla).
El generador de elementos barre la pantalla y determina si en el pixel actual hay algn
elemento, si esta fuese la situacin, activa la seal correspondiente a ese elemento (wall_on,
ball_on, bar_on, etc). Luego en funcin de cul es la seal activa es el color que se aplicara en ese
pixel. Si ninguna seal esta activa significa que en ese pixel no hay ningn elemento, en cuyo caso
tendr que poner el color del fondo (tambin se har esto si la seal video on/off esta
desactivada).

Figura 1

Figura 2

Recurriendo al manual de usuario de la placa DE2-115 se encontr que el fpga se conecta


al puerto vga mediante un vga dac (adv7123). En la Figura 3 se ve el esquema de conexiones entre
el fgpa y el dac y por ende las seales que son necesarias crear para poder controlar el puerto.
2

Figura 3

El mismo manual explica los tiempos de sincronismo y el pixel clock necesarios para cada
una de las resoluciones soportadas. As tambin presenta el diagrama temporal necesario para
poder sincronizar correctamente (Figura 4).

Figura 4

Para la generacin de los pixeles de la pantalla se opt por la generacin de de objetos


mapeada, debido a la baja cantidad de elementos presentes (paleta 1, paleta 2, bandas superior e
inferior y la pelota).
Basndonos en las especificaciones dadas por Altera para el uso del vga, y considerando el
mtodo de generacin de pixeles por objetos mapeados, se armo el siguiente diagrama de
bloques del proyecto (Figura 5).
3

Figura 5

En el diagrama se puede observar a grandes rasgos las seales generadas por fpga.
Partiendo de este esquema se comenz con el desarrollo del cdigo.

Sincronismo:
En primera instancia se desarrollo el controlador de sincronismo del vga.
Este cdigo define la seal de sincronismo de una manera muy conveniente, ya que los
contadores arrancan desde la primera posicin en la esquina superior izquierda de la pantalla. De
esta manera no hace falta tener en cuenta los mrgenes izquierdo y superior, y asi es ms fcil
trabajar disminuyendo las probabilidades de cometer un error. Esto puede verse en la Figura 6.

Figura 6

En esta parte se tuvieron inconvenientes que estn explicados en la parte correspondiente


del informe de problemas y soluciones.

Generador de elementos:
Al generador de elementos llega el valor de los contadores y la seal video on/off.
En el cdigo adjuntado en el anexo puede verse que este se divide en 4 secciones:
Definicin de elementos, definicin por pixel, movimiento y dibujo.
Definicin de elementos:
En la primer seccin, partiendo de que cuando los contadores estn en cero estamos
ubicados en el primer pixel superior izquierdo, determinamos con constantes las posiciones de
todos los elementos (limites superior, inferior, izquierdo y derecho).
Definicin por pixel:
En esta seccin generamos seales del tipo banderas. A medida que se hace el barrido de
la pantalla se determina en el pixel actual hay algn elemento, en cuyo caso se activa su respectiva
bandera (wall_on, bar1_on, bar2_on, ball_on, etc).
Movimiento:
Para realizar el movimiento de los elementos se planteo como origen de coordenadas el
centro de la pantalla, de esta manera, utilizando seales integer definidas entre (-a,a)
establecemos las nuevas posiciones de los elementos. Por ejemplo:
El elemento Bar1 est definido en la posicin vertical 240(centro del elemento). Si a esta
posicin se le suma la seal de movimiento movbar1 que est definida entre -200 y 200, la nueva
posicin del elemento, y por ende el momento que se activa la bandera bar1_on, va a depender
de el valor de de movbar1.
Para modificar el valor de movbar1 espero seales desde dos botones, en funcin de cual
este presionado aumento su valor o lo decremento.
En el caso de la pelota, para modificar el valor de movball_y(movimiento de la pelota en el
eje y) utilizamos otra seal integer (sumo_y) definida en (-1,1) la cual esta sumada a movball_y.
Esta cambia de 1 a -1 y viceversa siempre que llega al lmite superior e inferior (los limites serian 231 y 231). Lo mismo sucede con movball_x y sumo_x con los lmites impuestos por las paletas.
Dibujo: Finalmente se analiza que banderas estn encendidas (previamente se verifica que video
on/off este habilitada) y en funcin de cul sea, sera el color que se asigna al pixel actual.

Problemas y soluciones
Sincronismo de vga:
Utilizando el diagrama temporal propuesto por Altera, no se pudo realizar el sincronismo
del puerto. Se reviso con la simulacin de bajo nivel (gate level) que se cumpliesen los
requerimientos de tiempos previstos, pero, aunque se cumplan, no se logro mostrar nada en la
pantalla (el monitor no sala del stand-by). Para poder solucionarlo se investigo otros proyectos
que usaran VGA y, luego de probar con numerosos y diferentes diagramas de sincronismo, se
encontr un programa que funcionaba correctamente (tena que encender la pantalla y mostrarla
en color verde). A partir de este, se desarrollo la entidad de sincronismo usada para este trabajo.

Pelota redonda:
Al definir la pelota en un principio se la hizo cuadrada, una vez que el funcionamiento del
juego fue correcto se procedi por hacerla redonda. Para esto haba muchas maneras de
proceder.
La manera correcta de trabajar era con una memoria(o arreglo bidimensional) de 8x8 el
cual se determina ubicacin por ubicacin la forma de la pelota (se asigna 1 cuando corresponda).
De esta manera en la seccin 2(definicin por pixel) se analiza la matriz (siempre y cuando
estemos en uno de los pixel donde debera estar la pelota) y si se lee un 1 se activa la seal
ball_on, caso contrario se desactiva.
Por motivos de tiempo, en este trabajo se procedi de otra manera. Se definieron tres
pelotas en vez de 1: una de 6x6, otra de 8x4 y otra de 4x8. As, superponindolas y haciendo que
se muevan juntas, se simul una pelota redonda.
Teclado:
Como curiosidad, se intento conectar a la placa de desarrollo un teclado PS/2 para poder
jugar desde el mismo. Aunque se pudo avanzar bastante, los resultados no fueron del todo
satisfactorios.
Se uso un cdigo provisto para la realizacin de este proyecto(es decir que no fue
realizado por los autores de este trabajo). Se logro mover las paletas de ambos jugadores, pero
tena el problema de que no se reiniciaba el valor de la salida cuando se soltaba la tecla, por lo
tanto para cortar el movimiento de las paletas se tena que apretar otra tecla cualquiera. Al
terminarse el plazo para la presentacin del trabajo, este problema no pude ser solucionado.

Fondo:
Una vez finalizado con lo requerido por el proyecto, se trato de agregar un fondo.
Para el desarrollo del cdigo del fondo no se lo considero como un elemento, ya que la
generacin los pixeles del fondo se hace mediante memoria y se aplica en la pantalla cuando no
hay un elemento.
Para poder tener el fondo en memoria se necesitan 307400 palabras de 8 bits por cada
color para poder adquirir de las memorias todos los pixeles para una resolucin de 640x480. Para
obtener los datos para las memorias, se parti de una imagen en formato jpg, y mediante matlab
se obtuvieron las matrices de cada color. Para la inicializacin de las memorias se generaron los
archivos .mif; en esta parte se noto que la memoria no inicializaba si el dato estaba en slo una
lnea, mediante prueba y error se logro inicializar 2^12 palabras de 8 bits por lnea.
El inconveniente se presento al momento de inicializar todas las memorias juntas, el
compilador encontraba un error en la misma lnea de las memorias de la 5 en adelante. Se prob
inicializando slo las memorias de la 6 a la 15, y se presento el mismo problema. Debido a eso, se
pens en disminuir la cantidad de memorias a 5, para ello se utilizaron palabras de 24 bits para
incluir todos los colores, pero el resultado fue el mismo, a partir de la memoria 3 se presento el
mismo error que para el caso de 15 memorias.
Debido a que no pudimos inicializar las memorias se abandono esta idea, y no se presento
en la versin final del proyecto. Una alternativa que surgi despus fue trabajarlo bajo el concepto
de texturas. Esto consiste en una imagen ms pequea que se repite, con lo cual se podra
inicializar en memorias ROM, y tambin se podra aplicar a los dems objetos de la pantalla,
mejorando el apartado grfico del proyecto. Debido a razones de tiempo, no se pudo implementar
esta ltima idea.

Apndice
Sincronizacin:
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
entity sync is
port(
reset,clk : in std_logic;
pixel_x,pixel_y: out std_logic_vector (9 downto 0);
VGA_HS, video_on, VGA_VS: out std_logic);
end sync;
architecture rtl of sync is
signal h_cnt,v_cnt: std_logic_vector(9 downto 0);
begin
process (clk)
begin
if reset='1' then
h_cnt<="0000000000";
v_cnt<="0000000000";
video_on<='0';
elsif(clk'EVENT) AND (clk = '1') then
------Sync Horizontal------------------IF (h_cnt = 799) THEN
h_cnt <= "0000000000";
ELSE
h_cnt <= h_cnt + 1;
END IF;
IF (h_cnt <= 755) AND (h_cnt >= 659) THEN
vga_HS <= '0';
ELSE
vga_HS <= '1';
END IF;
------Sync Horizontal------------------------Sync Vertical------------------IF (v_cnt >= 524) AND (h_cnt >= 699) THEN
v_cnt <= "0000000000";
i

ELSIF (h_cnt = 699) THEN


v_cnt <= v_cnt + 1;
END IF;
IF (v_cnt <= 494) AND (v_cnt >= 493) THEN
vga_VS <= '0';
ELSE
vga_VS <= '1';
END IF;
------Sync Vertical---------------------------Video on-----------IF (h_cnt <= 639) THEN
video_on<='1';
ELSE
video_on<='0';
END IF;
IF (v_cnt > 479) THEN
video_on<='0';
END IF;
---------Video on-----------end if;
end process;
pixel_x<=h_cnt;
pixel_y<=v_cnt;
end rtl;

Generador de Elementos:
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity elementos is
port(
video_on,subebar1, bajabar1,subebar2, bajabar2,clkmov,start,reset,jugadores: in
std_logic;
teclado,fred,fgreen,fblue: in std_logic_vector (7 downto 0);
reiniciar: out std_logic;
pla1,pla2: out std_logic_vector (3 downto 0);
pixel_x, pixel_y: in std_logic_vector(9 downto 0);
red: out std_logic_vector (7 downto 0);
blue: out std_logic_vector (7 downto 0);
green: out std_logic_vector (7 downto 0)
);
end elementos;

ii

architecture rtl of elementos is


signal pix_x, pix_y: unsigned (9 downto 0);
constant MAX_X: integer:=640;
constant MAX_Y: integer:=480;
-- variables peredes(wall)
-- limites derecho e izquierdo
constant WALL_Y_up: integer:=5;
constant WALL_Y_R: integer:=475;
constant WALL_Y_dw: integer:=480;
constant WALL_X_L: integer:=35;
constant WALL_X_R: integer:=40;
-- variables para linea vertical (paddle)
-- limites derecho e izquierdo bar 1
constant BAR1_X_L: integer:=37;
constant BAR1_X_R: integer:=40;
-- limites superior e inferior bar 1
constant BAR1_Y_SIZE: integer:=72; --tamao del paddle
constant BAR1_Y_T: integer:=(MAX_Y/2-BAR1_Y_SIZE/2);
constant BAR1_Y_B: integer:=(BAR1_Y_T+BAR1_Y_SIZE-1);
-- limites derecho e izquierdo bar 2
constant BAR2_X_L: integer:=600;
constant BAR2_X_R: integer:=603;
-- limites superior e inferior bar 2
constant BAR2_Y_SIZE: integer:=72;
constant BAR2_Y_T: integer:=(MAX_Y/2-BAR2_Y_SIZE/2);
constant BAR2_Y_B: integer:=(BAR2_Y_T+BAR2_Y_SIZE-1);
------------ VARIABLES BALL------------------------------------------ variables para ball 1
constant BALL1_SIZE: integer:=6;
-- limites derecho e izquierdo
constant BALL1_X_L: integer:=(MAX_X/2-BALL1_SIZE/2);
constant BALL1_X_R: integer:=BALL1_X_L+BALL1_SIZE-1;
-- limites superior e inferior
constant BALL1_Y_T: integer:=(MAX_Y/2-BALL1_SIZE/2);
constant BALL1_Y_B: integer:=BALL1_Y_T+BALL1_SIZE-1;
------------------ variables para ball 2
constant BALL2_SIZE_X: integer:=4;
constant BALL2_SIZE_Y: integer:=8;
-- limites derecho e izquierdo
constant BALL2_X_L: integer:=(MAX_X/2-BALL2_SIZE_X/2);
constant BALL2_X_R: integer:=BALL2_X_L+BALL2_SIZE_X-1;
-- limites superior e inferior
constant BALL2_Y_T: integer:=(MAX_Y/2-BALL2_SIZE_Y/2);
iii

constant BALL2_Y_B: integer:=BALL2_Y_T+BALL2_SIZE_Y-1;


------------------- variables para ball 3
constant BALL3_SIZE_X: integer:=8;
constant BALL3_SIZE_Y: integer:=4;
-- limites derecho e izquierdo
constant BALL3_X_L: integer:=(MAX_X/2-BALL3_SIZE_X/2);
constant BALL3_X_R: integer:=BALL3_X_L+BALL3_SIZE_X-1;
-- limites superior e inferior
constant BALL3_Y_T: integer:=(MAX_Y/2-BALL3_SIZE_Y/2);
constant BALL3_Y_B: integer:=BALL3_Y_T+BALL3_SIZE_Y-1;
------------ SEALES
signal movbar1,movbar2,movball_x,movball_y: integer range -400 to 400 :=0;
signal sumo_x,sumo_y :integer range -10 to 10 :=-1;
signal contador: integer range 0 to 1000 :=0;
signal player1, player2 : integer range 0 to 15 :=0;
signal wall_on, bar1_on, bar2_on , sq_ball_on:std_logic;
signal w_red,w_green,w_blue,p1_red,p1_green,p1_blue,b_red,b_green,b_blue,
p2_red,p2_green,p2_blue : std_logic_vector (7 downto 0);
signal colorpelota : integer range 0 to 255 :=255;
signal contcolorpelota :integer range 0 to 100 :=0;
begin
pix_x <= unsigned(pixel_x);
pix_y <= unsigned(pixel_y);

-- definiendo pixel a pixel wall


wall_on <= '1' when (pix_y<walL_Y_up) AND (pix_y>=0) else
'1' when ((pix_y>=WALL_y_R) and (pix_y<=WALL_Y_dw)) else
'1' when (pix_x<walL_X_R) and (pix_x>walL_X_L) and jugadores='1' else
'0' ;
-- definiendo salida rgb paredes
w_red<="00000000";
w_green<="11111111";
w_blue<="00000000";
-- definiendo pixel a pixel linea vertical paleta 1
bar1_on <= '1' when (BAR1_X_L<=pix_x) and (pix_x<=BAR1_X_R) and
(BAR1_Y_T+movbar1<=pix_y) and (pix_y<=BAR1_Y_B+movbar1) and jugadores='0' else '0';
-- definiendo salida rgb paleta 1
p1_red<="00000000";
p1_green<="11111111";
p1_blue<="11111111";
-- definiendo pixel a pixel linea vertical paleta 2
iv

bar2_on <= '1' when (BAR2_X_L<=pix_x) and (pix_x<=BAR2_X_R) and


(BAR2_Y_T+movbar2<=pix_y) and (pix_y<=BAR2_Y_B+movbar2) else '0';
-- definiendo salida rgb paleta 2
p2_red<="11111111";
p2_green<="00000000";
p2_blue<="11111111";
-------DEFINIENDO PELOTA
-- definiendo pixel a pixel PELOTA
sq_ball_on <= '1' when
-- BALL 1
((BALL1_X_L+movball_x<=pix_x) and (pix_x<=BALL1_X_R+movball_x) and
(BALL1_Y_T+movball_y<=pix_y) and (pix_y<=BALL1_Y_B+movball_y)) or
--BALL 2
((BALL2_X_L+movball_x<=pix_x) and (pix_x<=BALL2_X_R+movball_x) and
(BALL2_Y_T+movball_y<=pix_y) and (pix_y<=BALL2_Y_B+movball_y)) or
--BALL 3
((BALL3_X_L+movball_x<=pix_x) and (pix_x<=BALL3_X_R+movball_x) and
(BALL3_Y_T+movball_y<=pix_y) and (pix_y<=BALL3_Y_B+movball_y)) else '0';
-- definiendo salida rgb de la pelota
b_red<="11111111";
b_green<=std_logic_vector(to_unsigned(colorpelota,8));
b_blue<=std_logic_vector(to_unsigned(colorpelota,8));

process(video_on, wall_on, bar1_on,bar2_on, sq_ball_on)


begin
if clkmov'event and clkmov='1' then
-----------movimiento paletas-----------if ((subebar1='0' and bajabar1='1') or (teclado=x"72") ) and movbar1<199 then
movbar1<=movbar1+2;
elsif ((bajabar1='0' and subebar1='1')or (teclado=x"75" )) and movbar1>(-199) then
movbar1<=movbar1-2;
end if;
if ((subebar2='0' and bajabar2='1') or teclado=x"23") and movbar2<199 then
movbar2<=movbar2+2;
elsif ((bajabar2='0' and subebar2='1')or teclado=x"24") and movbar2>(-199) then
movbar2<=movbar2-2;
end if;
---------movimiento pelota---------if reset='1' then
sumo_x<=-1;
sumo_y<=1;
v

movball_x<=0;
movball_y<=0;
player1<=0;
player2<=0;
reiniciar<='1';
end if;
if start='1' then
movball_x<=movball_x+sumo_x; ------ muevo pelota en x
movball_y<=movball_y+sumo_y;
------- muevo pelota en y
pla1<=std_logic_vector(to_unsigned(player1,4)); ------puntaje player 1
pla2<=std_logic_vector(to_unsigned(player2,4)); ------ puntaje player 2
----- cambio color pelota
if contcolorpelota=30 and colorpelota>0 then
colorpelota<=colorpelota-1;
contcolorpelota<=0;
else
contcolorpelota<=contcolorpelota+1;
end if;

----------DINAMICA DE LA PELOTA
if (movball_y)=231 then ----- techo rebota
sumo_y<=(-1);
elsif (movball_y)=(-231) then ------- piso rebota
sumo_y<=(1);
end if;
if (movball_x)=276
--------------paleta 2 rebota
and(movball_y-(BALL3_SIZE_Y/2))<(movbar2+(bar2_Y_SIZE/2)) and
(movball_y+(BALL3_SIZE_Y/2))>(movbar2-(bar2_Y_SIZE/2))
then
sumo_x<=(-1);
reiniciar<='0';
elsif (movball_x)=350 then
-----------------------pierde player 2
sumo_x<=-1;
sumo_y<=1;
movball_x<=0;
movball_y<=0;
player1<=player1+1;
reiniciar<='1';
colorpelota<=255;
contcolorpelota<=0;
elsif (movball_x)=(-276)

--------------paleta 1 rebota
vi

and(((movball_y-(BALL3_SIZE_Y/2))<(movbar1+(bar1_Y_SIZE/2)) and
(movball_y+(BALL3_SIZE_Y/2))>(movbar1-(bar1_Y_SIZE/2))) or
jugadores='1')
then
sumo_x<=(1);
reiniciar<='0';
elsif (movball_x)=(-350) then
sumo_x<=1;
sumo_y<=1;
movball_x<=0;
movball_y<=0;
player2<=player2+1;
reiniciar<='1';
colorpelota<=255;
contcolorpelota<=0;
end if;

-----------------------pierde player 1

end if;
end if;
------ DETERMINO COLOR EN PIXEL
if (video_on='0') then
red<="00000000";
green<="00000000";
blue<="00000000";
else
if (wall_on='1') then
red<=w_red;
green<=w_green;
blue<=w_blue;
elsif (bar1_on='1') then
red<=p1_red;
green<=p1_green;
blue<=p1_blue;
elsif (bar2_on='1') then
red<=p2_red;
green<=p2_green;
blue<=p2_blue;
elsif (sq_ball_on='1') then
red<=b_red;
green<=b_green;
blue<=b_blue;
else
red<=fred; ----"00000000"
green<=fgreen; ----"00000000"
blue<=fblue; ----"00000000"
end if;
vii

end if;
end process;
end rtl;

Mov. de elementos ( divisor de frecuencia):


LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY div_f is
PORT(clock,reiniciar: IN std_logic;
sel: IN std_logic_vector(2 DOWNTO 0);
led: OUT std_logic);
END div_f;
ARCHITECTURE Behaivoral OF div_f IS
SIGNAL reloj: std_logic_vector (4 DOWNTO 0):="00000";
SIGNAL cont1,velocidad: integer range 0 to 5000001:= 0;
SIGNAL cont2: integer range 0 to 12500001:= 0;
BEGIN
PROCESS (clock,sel)
BEGIN
IF(clock'event and clock='1') THEN
cont1<= cont1+1;
cont2<= cont2+1;
IF cont1= 300000 THEN
reloj(0)<= NOT reloj(0);
cont1<= velocidad;
END IF;
IF cont2= 8000 THEN
cont2<= 0;
if velocidad < 200000 and reiniciar='0' then
velocidad<=velocidad+1;
elsif reiniciar='1' then
velocidad <=0;
end if;
END IF;
END IF;
viii

led<= reloj(0);
END PROCESS;
END Behaivoral;

Hexadecimal a 7 segmentos:
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY bcdseg IS
PORT(
I : in std_logic_vector (3 DOWNTO 0);
LE, BL, LT: in std_logic;
data : out std_logic_vector(6 downto 0));
END bcdseg;
ARCHITECTURE LogicFunction OF bcdseg IS
SIGNAL aux : std_logic_vector (6 DOWNTO 0);
SIGNAL auxi: std_logic_vector (3 DOWNTO 0);
BEGIN
auxi<= I when LE='0' else auxi;
aux<= "0000000" when LT= '0' else
"1111111" when (BL= '0') and (LT='1') else
"1000000" when (auxi="0000") and (BL='1')and(LT='1') else --0
"1111001" when (auxi="0001") and (BL='1')and(LT='1') else --1
"0100100" when (auxi="0010") and (BL='1')and(LT='1') else --2
"0110000" when (auxi="0011") and (BL='1')and(LT='1') else --3
"0011001" when (auxi="0100") and (BL='1')and(LT='1') else --4
"0010010" when (auxi="0101") and (BL='1')and(LT='1') else --5
"0000010" when (auxi="0110") and (BL='1')and(LT='1') else --6
"1111000" when (auxi="0111") and (BL='1')and(LT='1') else --7
"0000000" when (auxi="1000") and (BL='1')and(LT='1') else --8
"0010000" when (auxi="1001") and (BL='1')and(LT='1') else --9
"0001000" when (auxi="1010") and (BL='1')and(LT='1') else --A
"1100000" when (auxi="1011") and (BL='1')and(LT='1') else --B
"1110010" when (auxi="1100") and (BL='1')and(LT='1') else --C
"1000010" when (auxi="1101") and (BL='1')and(LT='1') else --D
"0110000" when (auxi="1110") and (BL='1')and(LT='1') else --E
"0111000" when (auxi="1111") and (BL='1')and(LT='1') else --F
"0111111";-- GUION
data<=aux;
END LogicFunction;
ix

Top Level:
library ieee;
use ieee.std_logic_1164.all;
entity pong is
port(
clk, reset,subebar1,bajabar1,subebar2,bajabar2,start,jugadores: in std_logic;
hsync, vsync,vga_blank_n,vga_sync_n,vga_clk,nLED,listo: out std_logic;
p1sal,p2sal,D7SEG_L, D7SEG_H: out std_logic_vector (6 downto 0);
red,green,blue: out std_logic_vector(7 downto 0);
-------- teclado
PS2_Data,ps2_Clk: in std_logic);
end pong;
architecture rtl of pong is
signal pixel_x, pixel_y: std_logic_vector(9 downto 0);
signal video_on,clo,mov: std_logic;
signal reiniciar: std_logic :='0';
signal sred,sgreen,sblue,teclado: std_logic_vector(7 downto 0);
signal cuentap1,cuentap2: std_logic_vector(3 downto 0);
begin
ps2: entity work.PS2SIMPL
port map(Clk=>clo, Reset=>reset, D7SEG_L=>d7sEG_L, D7SEG_H=>d7sEG_H,
PS2_Data=>ps2_Data,
PS2_Clk=>ps2_Clk, nLED =>nled,teclado =>teclado,listo=>listo);
----player2: entity work.bcdseg
port map (I=>cuentap2,LE=>'0',BL=>'1',LT=>'1',data=> p2sal);
----player1: entity work.bcdseg
port map (I=>cuentap1,LE=>'0',BL=>'1',LT=>'1',data=> p1sal);
----velocidad: entity work.div_f
port map(clock=>clk , led =>mov,sel=>"000",reiniciar=>reiniciar);
----divisor: entity work.pll
port map(inclk0=>clk , c0 =>clo);
----sincronizacion: entity work.sync
port map(clk=>clo,reset=>reset, VGA_HS=>hsync, VGA_VS=>vsync, video_on=>video_on,
pixel_x=>pixel_x, pixel_y=>pixel_y );
x

----elemen : entity work.elementos


port map(video_on=>video_on, pixel_x=>pixel_x, pixel_y=>pixel_y, red=>red, green=>green,
blue=>blue,
subebar1=>subebar1,bajabar1=>bajabar1,subebar2=>subebar2,bajabar2=>bajabar2,clkmov=>mov
,start=>start,
reset=>reset,pla1=>cuentap1,pla2=>cuentap2,reiniciar=>reiniciar,jugadores=>jugadores,teclado=>
teclado);
vga_clk<=clo;
vga_blank_n<='1';
vga_sync_n<='0';
end rtl;

xi