Contador de 4 bits ascendente y en código Gray

INSTITUTO TECNOLÓGICO DE MORELIA
MAESTRIA EN CIENCIAS EN INGENIERÍA
ELECTRÓNICA
ELECTRONICA DIGITAL AVANZADA
REPORTE 2
“CONTADOR DE 4 BITS ASCENDENTE Y EN CODIGO
GRAY (ESTRUCTURAL Y SECUENCIAL)”
NOMBRE:
ING. ANTONY MORALES CERVANTES
N. C. M06120218
PROFESOR:
DR. ARTURO MENDEZ PATIÑO
06 DE FEBRERO DEL 2012
Durante la práctica se realizó un contador de 4 bits en VHDL mediante una programación
estructural y una secuencial. La practica consiste en hacer un contador ascendente y otro en gray
mediante un bit de selección. La programación estructural se especifican cuales componentes son
usados y de qué manera están interconectados. La programación secuencial utiliza condiciones o
comandos que se utilizan comúnmente en el lenguaje de programación como las condiciones IF,
THEN o CASE sin que el programador se preocupe de la distribución de las compuertas del PLD, es
necesario incluir un proceso ya que es una estructura secuencial.
Programación estructural
Para la primera parte se describe la programación estructural. En la Tabla 1 se muestran los
estados actuales y estados futuros del contador ascendente de 4 bits.
Tabla 1. Tabla de verdad del contador ascendente de 4 bits.
CONTADOR
ASCENDENTE
Q(3)
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
ESTADO ACTUAL
Q(2)
Q(1)
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
Q(0)
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
Q(3)
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
ESTADO FUTURO
Q(2)
Q(1)
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
Q(0)
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
A partir de la Tabla de verdad de la Tabla 1 se obtuvieron los mapas de karnaugh del estado
siguiente en base a la tabla de verdad del Flip Flop D descrito en la tabla 2.
Tabla 2. Tabla de verdad del Flip Flop D.
Q
D
0
0
1
1
Q+1
0
1
0
1
0
1
0
1
Los mapas de karnaugh están descritos en las siguiente tablas.
Tabla 3. Mapa de Karnaugh del contador ascendente para D0.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
1
1
1
1
0
0
0
0
0
0
0
0
1
1
1
1
Tabla 4. Mapa de Karnaugh del contador ascendente para D1.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
Tabla 5. Mapa de Karnaugh del contador ascendente para D2.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
0
1
1
0
0
1
1
0
1
0
0
1
0
1
1
0
Tabla 6. Mapa de Karnaugh del contador ascendente para D3.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
0
0
1
1
0
0
1
1
0
1
0
1
0
0
1
1
En la Tabla 7 se muestran los estados actuales y estados futuros del contador en código gray de 4
bits.
Tabla 7. Tabla de verdad del contador en código gray de 4 bits.
CONTADOR
EN CODIGO
GRAY
Q(3)
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
ESTADO ACTUAL
Q(2)
Q(1)
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
Q(0)
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
Q(3)
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
ESTADO FUTURO
Q(2)
Q(1)
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
0
A partir de la Tabla de verdad de la Tabla 7 se obtuvieron los mapas de karnaugh del estado
siguiente en base a la tabla de verdad del Flip Flop D descrito en la tabla 2.
Q(0)
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
Tabla 8. Mapa de Karnaugh del contador en código gray para D0.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
1
0
1
0
1
0
1
0
0
1
0
1
0
1
0
1
Tabla 9. Mapa de Karnaugh del contador en código gray para D1.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
0
0
0
0
1
0
1
0
1
0
1
0
1
1
1
1
Tabla 10. Mapa de Karnaugh del contador en código gray para D2.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
0
1
1
0
0
1
1
0
0
1
1
0
1
1
0
0
Tabla 11. Mapa de Karnaugh del contador en código gray para D3.
Q1 Q0
Q3 Q2
00
01
11
10
00
01
11
10
0
1
1
0
0
0
1
1
0
0
1
1
0
0
1
1
Para la parte de selección de contador o código gray lo que se realizó fue utilizar un bit de
selección y a la parte que se utilizó para seleccionar con 0 (cero) se le agregó una compuerta AND
NEGADA a todas las ecucaciones con el bit de selección y para la parte que se seleccionó en 1
(uno) se le agregó una compuerta AND. Una vez obtenidos los resultados para las diferentes
salidas se obtuvieron las ecuaciones descritas en el programa de VHDL.
El código se muestra a continuación:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity FFDcontador is
Port ( clk : in STD_LOGIC;
SEL: in STD_LOGIC;
Q : INout STD_LOGIC_VECTOR (3 downto 0):= (others => '0'));
end FFDcontador;
architecture Behavioral of FFDcontador is
signal D : STD_LOGIC_VECTOR (3 downto 0):= (others => '0');
begin
D(0) <= (((not(Q(1))and not(Q(2)) and not(Q(3))) or (Q(1) and Q(2)and not (Q(3))) or (not(Q(1))and
Q(2) and Q(3)) or (Q(1)and not(Q(2)) and Q(3)))and not SEL)or (((not(Q(0))and not(Q(1))) or
(not(Q(0)) and Q(1)))and SEL);
D(1) <= (((Q(0)and not(Q(2)) and not(Q(3)))or (Q(0)and Q(2) and Q(3)) or (not(Q(0))and Q(1)))and
not SEL)or(((Q(0)and not(Q(1)))or (not(Q(0))and Q(1)))and SEL);
D(2) <= (((not(Q(0))and Q(1) and not(Q(3))) or (not(Q(1))and Q(2))or (Q(0) and Q(2)))and not
SEL)or (((not(Q(1))and Q(2)) or (not(Q(0))and Q(2))or (Q(0) and Q(1)and not (Q(2))))and SEL);
D(3) <= (((not(Q(0))and not (Q(1)) and Q(2))or (Q(0)and Q(3)) or (Q(1) and Q(3)))and not
SEL)or(((not(Q(1))and Q(3)) or (not (Q(0)) and Q(1) and Q(3))or (not (Q(2)) and Q(3))or (Q(0)and
Q(1) and Q(2) and not (Q(3))))and SEL);
process (clk, D) begin
if (clk'event and clk='1') then
Q<= D;
end if;
end process;
end Behavioral;
Simulación estructural
Una vez sintetizado el programa se realizó una simulación para comprobar el resultado, descrito a
continuación:
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
use IEEE.STD_LOGIC_ARITH.all;
use IEEE.STD_LOGIC_UNSIGNED.all;
ENTITY TB_FFDcontador IS
END TB_FFDcontador;
ARCHITECTURE behavior OF TB_FFDcontador IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT FFDcontador
PORT(
SEL : IN std_logic;
clk : IN std_logic;
Q : INOUT std_logic_vector(3 downto 0)
);
END COMPONENT;
--Inputs
signal D : std_logic_vector(3 downto 0) := (others => '0');
signal SEL: std_logic := '0';
signal clk : std_logic := '0';
--Outputs
signal Q : std_logic_vector(3 downto 0):= (others => '0');
-- Clock period definitions
constant clk_period : time := 10 ns;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: FFDcontador PORT MAP (
SEL => SEL,
clk => clk,
Q => Q
);
-- Clock process definitions
clk_process :process
begin
clk <= '0';
wait for clk_period/2;
clk <= '1';
wait for clk_period/2;
end process;
-- Stimulus process
stim_proc: process
begin
SEL<='0' after 160ns;
SEL<='1' after 160ns;
wait;
end process;
END;
En las figuras 1-5 se muestra la simulación del contador ascendente y en código gray. Notandose
que cuando el Bit de selección “sel” está en 0 (cero) el contador es en gray y cuando el bit de
selección está en 1 (uno) el contador es ascendente.
Figura 1. Simulación del contador ascendente y gray en programación estructural (0 a 50 nS).
Figura 2. Simulación del contador ascendente y gray en programación estructural (50 a 120 nS).
Figura 3. Simulación del contador ascendente y gray en programación estructural (120 a 180 nS).
Figura 4. Simulación del contador ascendente y gray en programación estructural (180 a 240 nS).
Figura 5. Simulación del contador ascendente y gray en programación estructural (240 a 320 nS).
Programación secuencial
Para la parte del contador ascendente y gray en modo secuencial se realizó con un process para
realizar el contador y la selección de contador-gray, con un decodificador para la realización del
código gray. Las instrucciones se muestran en el siguiente programa de VHDL.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity conta4bits is
Port ( clk : in STD_LOGIC;
seleccion : in STD_LOGIC;
salida : out STD_LOGIC_VECTOR (3 downto 0):= (others => '0'));
end conta4bits;
architecture Behavioral of conta4bits is
signal gray : STD_LOGIC_VECTOR (3 downto 0):= (others => '0');
signal contador : STD_LOGIC_VECTOR (3 downto 0):= (others => '0');
begin
with contador select
gray <= "0000" when "0000",
"0001" when "0001",
"0011" when "0010",
"0010" when "0011",
"0110" when "0100",
"0111" when "0101",
"0101" when "0110",
"0100" when "0111",
"1100" when "1000",
"1101" when "1001",
"1111" when "1010",
"1110" when "1011",
"1010" when "1100",
"1011" when "1101",
"1001" when "1110",
"1000" when others;
process (clk, seleccion) begin
if (clk'event and clk= '1') then
if (seleccion ='1') then
contador <= contador+1;
salida <=contador;
else
contador <=contador+1;
salida <= gray;
end if;
end if;
end process;
end Behavioral;
Simulación en secuencial
Una vez sintetizado el programa se realizó una simulación para comprobar el resultado, descrito a
continuación:
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
use IEEE.STD_LOGIC_ARITH.all;
use IEEE.STD_LOGIC_UNSIGNED.all;
ENTITY TB_conta4bits IS
END TB_conta4bits;
ARCHITECTURE behavior OF TB_conta4bits IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT conta4bits
PORT(
clk : IN std_logic;
seleccion : IN std_logic;
salida : OUT std_logic_vector(3 downto 0)
);
END COMPONENT;
--Inputs
signal clk : std_logic := '0';
signal seleccion : std_logic := '0';
signal salida : std_logic_vector(3 downto 0):= (others => '0');
-- Clock period definitions
constant clk_period : time := 10 ns;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: conta4bits PORT MAP (
clk => clk,
seleccion => seleccion,
salida => salida
);
-- Clock process definitions
clk_process :process
begin
clk <= '0';
wait for clk_period/2;
clk <= '1';
wait for clk_period/2;
end process;
-- Stimulus process
stim_proc: process
begin
seleccion<='0' after 170ns;
seleccion<='1' after 170ns;
wait;
end process;
END;
En las figuras 6-9 se muestra la simulación del contador ascendente y en código gray. Notándose
que cuando el Bit de selección “sel” está en 0 (cero) el contador es en gray y cuando el bit de
selección está en 1 (uno) el contador es ascendente.
Figura 6. Simulación del contador ascendente y gray en programación secuencial (0 a 100 nS).
Figura 7. Simulación del contador ascendente y gray en programación secuencial (100 a 200 nS).
Figura 8. Simulación del contador ascendente y gray en programación secuencial (200 a 300 nS).
Figura 9. Simulación del contador ascendente y gray en programación secuencial (300 a 400 nS).
CONCLUSIONES
Para el desarrollo de esta práctica fue necesario el uso de las declaraciones de los puertos de
entrada y de salida necesarios para hacer el contador, tanto en programación estructural como en
secuencial. Se contaba con un bit de selección para la parte de contador y la parte de código gray.
Pudiéndose notar la para esta práctica fue más fácil desarrollarla en forma secuencial, ya que el
estar escribiendo las ecuaciones en el código es algo laborioso y hay que tener demasiado cuidado
en la escritura ya que con algún elemento que ponga uno mal, nos va dar un resultado erróneo.