EJEMPLOS

Código Concurrente: cada línea del código es evaluada en paralelo, por lo

que una señal no puede tener asignaciones diferentes

En el código concurrente pueden usarse en general sentencias o declaraciones con:

1. Operadores (aritméticos, lógicos, etc.)
2. WHEN (WHEN/ELSE y WITH/SELECT/WHEN)
3. GENERATE
4. BLOCK
1. Usando Operadores:

 Multiplexor
1 ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------
5 ENTITY mux IS
6 PORT ( a, b, c, d, s0, s1: IN STD_LOGIC;
7 y: OUT STD_LOGIC);
8 END mux;
9 ---------------------------------------
10 ARCHITECTURE pure_logic OF mux IS
11 BEGIN
12 y <= (a AND NOT s1 AND NOT s0) OR
13 (b AND NOT s1 AND s0) OR
14 (c AND s1 AND NOT s0) OR
15 (d AND s1 AND s0);
16 END pure_logic;
17 ---------------------------------------
 Buffer Tri-estado

1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3 ----------------------------------------------
4 ENTITY tri_state IS
5 PORT ( ena: IN STD_LOGIC;
6 input: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
7 output: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
8 END tri_state;
9 ----------------------------------------------
10 ARCHITECTURE tri_state OF tri_state IS
11 BEGIN
12 output <= input WHEN (ena='0') ELSE
13 (OTHERS => 'Z');
14 END tri_state;
15 ----------------------------------------------
2. Usando WHEN/ELSE y WITH/SELECT/WHEN:
Sintaxis:
o Con WHEN/ELSE
Asignación WHEN condición ELSE
Asignación WHEN condición ELSE
……… ;
o Con WITH/SELECT/WHEN
WITH identificador SELECT
Asignación WHEN valor,
Asignación WHEN valor,
………;

1 ------- Solución 1: con WHEN/ELSE --------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -------------------------------------------
5 ENTITY mux IS
6 PORT (a, b, c, d: IN STD_LOGIC;
7 sel: IN STD_LOGIC_VECTOR (1 DOWNTO 0);
8 y: OUT STD_LOGIC);
9 END mux;
10 -------------------------------------------
11 ARCHITECTURE mux1 OF mux IS
12 BEGIN
13 y <= a WHEN sel="00" ELSE
14 b WHEN sel="01" ELSE
15 c WHEN sel="10" ELSE
16 d;
17 END mux1;
18 -------------------------------------------

1 --- Solución 2: con WITH/SELECT/WHEN -----

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -------------------------------------------
5 ENTITY mux IS
6 PORT ( a, b, c, d: IN STD_LOGIC;
7 sel: IN STD_LOGIC_VECTOR (1 DOWNTO 0);
8 y: OUT STD_LOGIC);
9 END mux;
10 -------------------------------------------
11 ARCHITECTURE mux2 OF mux IS
12 BEGIN
13 WITH sel SELECT
14 y <= a WHEN "00", -- nota "," en lugar de ";"
15 b WHEN "01",
16 c WHEN "10",
17 d WHEN OTHERS; -- no puede ser "d WHEN "11" "
18 END mux2;
19 --------------------------------------------

-- Solución usando tipo de dato ENTERO (INTEGER) --

1 ----------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY mux IS
6 PORT ( a, b, c, d: IN STD_LOGIC;
7 sel: IN INTEGER RANGE 0 TO 3;
8 y: OUT STD_LOGIC);
9 END mux;
10 ---- Solución 1: con WHEN/ELSE ---------------
11 ARCHITECTURE mux1 OF mux IS
12 BEGIN
13 y <= a WHEN sel=0 ELSE
14 b WHEN sel=1 ELSE
15 c WHEN sel=2 ELSE
16 d;
17 END mux1;
18 – Solución 2: con WITH/SELECT/WHEN --------
19 ARCHITECTURE mux2 OF mux IS
20 BEGIN
21 WITH sel SELECT
22 y <= a WHEN 0,
23 b WHEN 1,
24 c WHEN 2,
25 d WHEN 3; -- aquí, 3 y otras opciones son lo mismo,
26 END mux2;
27 -----------------------------------------------

 Codificador

1 ---- Solución 1: con WHEN/ELSE -------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY encoder IS
6 PORT (x: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
7 y: OUT STD_LOGIC_VECTOR (2 DOWNTO 0));
8 END encoder;
9 ---------------------------------------------
10 ARCHITECTURE encoder1 OF encoder IS
11 BEGIN
12 y <= "000" WHEN x="00000001" ELSE
13 "001" WHEN x="00000010" ELSE
14 "010" WHEN x="00000100" ELSE
15 "011" WHEN x="00001000" ELSE
16 "100" WHEN x="00010000" ELSE
17 "101" WHEN x="00100000" ELSE
18 "110" WHEN x="01000000" ELSE
19 "111" WHEN x="10000000" ELSE
20 "ZZZ";
21 END encoder1;
22 ---------------------------------------------

1 ---- Solución 2: con WITH/SELECT/WHEN ------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY encoder IS
6 PORT ( x: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
7 y: OUT STD_LOGIC_VECTOR (2 DOWNTO 0));
8 END encoder;
9 ---------------------------------------------
10 ARCHITECTURE encoder2 OF encoder IS
11 BEGIN
12 WITH x SELECT
13 y <= "000" WHEN "00000001",
14 "001" WHEN "00000010",
15 "010" WHEN "00000100",
16 "011" WHEN "00001000",
17 "100" WHEN "00010000",
18 "101" WHEN "00100000",
19 "110" WHEN "01000000",
20 "111" WHEN "10000000",
21 "ZZZ" WHEN OTHERS;
22 END encoder2;
23 ---------------------------------------------

 ALU

1 ----------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 ----------------------------------------------
6 ENTITY ALU IS
7 PORT (a, b: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
8 sel: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
9 cin: IN STD_LOGIC;
10 y: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
11 END ALU;
12 ----------------------------------------------
13 ARCHITECTURE dataflow OF ALU IS
14 SIGNAL arith, logic: STD_LOGIC_VECTOR (7 DOWNTO 0);
15 BEGIN
16 ----- Unidad Aritmética: ------
17 WITH sel(2 DOWNTO 0) SELECT
18 arith <= a WHEN "000",
19 a+1 WHEN "001",
20 a-1 WHEN "010",
21 b WHEN "011",
22 b+1 WHEN "100",
23 b-1 WHEN "101",
24 a+b WHEN "110",
25 a+b+cin WHEN OTHERS;
26 ----- Unidad Lógica: -----------
27 WITH sel(2 DOWNTO 0) SELECT
28 logic <= NOT a WHEN "000",
29 NOT b WHEN "001",
30 a AND b WHEN "010",
31 a OR b WHEN "011",
32 a NAND b WHEN "100",
33 a NOR b WHEN "101",
34 a XOR b WHEN "110",
35 NOT (a XOR b) WHEN OTHERS;
36 -------- Mux: ---------------
37 WITH sel(3) SELECT
38 y <= arith WHEN '0',
39 logic WHEN OTHERS;
40 END dataflow;
41 ----------------------------------------------

3. Usando GENERATE
Se usa generalmente con la forma:
FOR /GENERATE
Sintaxis:
Etiqueta: FOR identificador IN rango GENERATE
(Asignaciones concurrentes)
END GENERATE;

Anidado dentro de un FOR/GENERATE se usa IF/GENERATE

Sintaxis:
Etiqueta 1: FOR identificador IN rango GENERATE
...
Etiqueta 2: IF condición GENERATE
(Asignaciones concurrentes)
END GENERATE;
...
END GENERATE;

 Vector de desplazamiento

1 ------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ------------------------------------------------
5 ENTITY shifter IS
6 PORT (inp: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
7 sel: IN INTEGER RANGE 0 TO 4;
8 outp: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
9 END shifter;
10 ------------------------------------------------
11 ARCHITECTURE shifter OF shifter IS
12 SUBTYPE vector IS STD_LOGIC_VECTOR (7 DOWNTO 0);
13 TYPE matrix IS ARRAY (4 DOWNTO 0) OF vector;
14 SIGNAL row: matrix;
15 BEGIN
16 row(0) <= "0000" & inp;
17 G1: FOR i IN 1 TO 4 GENERATE
18 row(i) <= row(i-1)(6 DOWNTO 0) & '0';
19 END GENERATE;
20 outp <= row(sel);
21 END shifter;
22 ------------------------------------------------

4. Usando BLOCK:

Sintaxis del BLOCK simple:

Etiqueta: BLOCK
[Parte Declarativa]
BEGIN
(Instrucciones concurrentes)
END BLOCK Etiqueta;

 Ejemplo:
b1: BLOCK
SIGNAL a: STD_LOGIC;
BEGIN
a <= input_sig WHEN ena='1' ELSE 'Z';
END BLOCK b1;

Sintaxis del BLOCK guarded o asegurado:

Etiqueta: BLOCK (Expresión para asegurar)
[Parte Declarativa]
BEGIN
(Instrucciones concurrentes aseguradas y no aseguradas)
END BLOCK etiqueta;

 Ejemplo: LATCH
1 -------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -------------------------------
5 ENTITY latch IS
6 PORT (d, clk: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END latch;
9 -------------------------------
10 ARCHITECTURE latch OF latch IS
11 BEGIN
12 b1: BLOCK (clk='1')
13 BEGIN
14 q <= GUARDED d;
15 END BLOCK b1;
16 END latch;
17 -------------------------------

 Ejemplo: FFD

1 -------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -------------------------------
5 ENTITY dff IS
6 PORT (d, clk, rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END dff;
9 -------------------------------
10 ARCHITECTURE dff OF dff IS
11 BEGIN
12 b1: BLOCK (clk'EVENT AND clk='1')
13 BEGIN
14 q <= GUARDED '0' WHEN rst='1' ELSE d;
15 END BLOCK b1;
16 END dff;
17 ------------------------------

PROBLEMAS PROPUESTOS

Problema 5.3: multiplicador/Divisor Sencillo

Usando sólo código concurrente, diseñar el Multiplicador/Divisor de la Figura. El circuito
tiene dos entradas de tipo entero de 8 bits (a,b) y dos salidas enteras (x,y), donde
x=a*b y y=a/2

Problema 5.4: Sumador

Usando únicamente instrucciones concurrentes, diseñar un sumador de 8 bits sin signo
o unsigned de la figura

Problema 5.5: Signed/Unsigned Sumador/Restador

En la figura tenemos adicionalmente una entrada extra de 2 Bits (sel), escriba un
código concurrente para este diseño.
Problem 5.6: Convertidor de código binario a Gray

EJEMPLOS Código Secuencial:

Existen secciones del código en VHDL que se ejecutan secuencialmente. Todas las
instrucciones que discutiremos en los ejemplos siguientes son secuenciales, o sea, se
pueden ejecutar sólo dentro de:
Secciones de
Código Lista de instrucciones

PROCESSES
FUNCTIONS IF, WAIT, CASE, y LOOP.
PROCEDURES. VARIABLE

1. Sección con PROCESS

Se caracteriza por la presencia de IF, WAIT, CASE, y LOOP, y por la lista sensible excepto
con WAIT.

Sintaxis
[Etiqueta:] PROCESS (lista sensible)
[VARIABLE nombre: tipo [rango] [:= valor inicial;]]
BEGIN
(Código secuencial)
END PROCESS [etiqueta];
  Ejemplo: FFD con reset asincrónico

1 --------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 --------------------------------------
5 ENTITY dff IS
6 PORT (d, clk, rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END dff;
9 --------------------------------------
10 ARCHITECTURE comportamiento OF dff IS
11 BEGIN
12 PROCESS (clk, rst)
13 BEGIN
14 IF (rst='1') THEN
15 q <= '0';
16 ELSIF (clk'EVENT AND clk='1') THEN
17 q <= d;
18 END IF;
19 END PROCESS;
20 END comportamiento;
21 --------------------------------------

Código con IF
Sintaxis:

IF condición THEN asignaciones;

ELSIF condiciones THEN asignaciones;
...
ELSE asignaciones;
END IF;

 Ejemplo:
IF (x<y) THEN temp:="11111111";
ELSIF (x=y AND w='0') THEN temp:="11110000";
ELSE temp:=(OTHERS =>'0');

 Ejemplo contador de 0 a 9:

1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY contador IS
6 PORT (clk: IN STD_LOGIC;
7 digit: OUT INTEGER RANGE 0 TO 9);
8 END contador;
9 ---------------------------------------------
10 ARCHITECTURE contador OF contador IS
11 BEGIN
12 cont: PROCESS(clk)
13 VARIABLE temp: INTEGER RANGE 0 TO 10;
14 BEGIN
15 IF (clk'EVENT AND clk='1') THEN
16 temp:= temp + 1;
17 IF (temp=10) THEN temp:= 0;
18 END IF;
19 END IF;
20 digit <= temp;
21 END PROCESS cont;
22 END contador;
23 ---------------------------------------------

 Ejemplo Registro de Desplazamiento:

1 --------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 --------------------------------------------------
5 ENTITY shiftreg IS
6 GENERIC (n: INTEGER:= 4); -- # de etapas
7 PORT (d, clk, rst: IN STD_LOGIC;
8 q: OUT STD_LOGIC);
9 END shiftreg;
10 --------------------------------------------------
11 ARCHITECTURE behavior OF shiftreg IS
12 SIGNAL internal: STD_LOGIC_VECTOR (n-1 DOWNTO 0);
13 BEGIN
14 PROCESS (clk, rst)
15 BEGIN
16 IF (rst='1') THEN
17 internal <= (OTHERS => '0');
18 ELSIF (clk'EVENT AND clk='1') THEN
19 internal <= d & internal (internal'LEFT DOWNTO 1);
20 END IF;
21 END PROCESS;
22 q <= internal(0);
23 END behavior;
24 --------------------------------------------------

Código con WAIT

El WAIT es similar al IF pero dentro del process no se usa lista sensible, debido a que este se
ejecuta cuando la condición para la señal (WAIT UNTIL) o una de las señales (WAIT ON) se
cumpla.
Existen tres formas para el WAIT.

Sintaxis:

1. WAIT UNTIL condición para una señal;

2. WAIT ON señal1 [,señal2, ... ];
3. WAIT FOR tiempo;

WAIT UNTIL condición para una señal

 Ejemplo

PROCESS – sin lista sensible

BEGIN
WAIT UNTIL (clk'EVENT AND clk='1');
IF (rst='1') THEN
output <= "00000000";
ELSIF (clk'EVENT AND clk='1') THEN
output <= input;
END IF;
END PROCESS;
  Ejemplo: contador con WAIT UNTIL

1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY counter IS
6 PORT (clk : IN STD_LOGIC;
7 digit : OUT INTEGER RANGE 0 TO 9);
8 END counter;
9 ---------------------------------------------
10 ARCHITECTURE counter OF counter IS
11 BEGIN
12 PROCESS -- no sensitivity list
13 VARIABLE temp : INTEGER RANGE 0 TO 10;
14 BEGIN
15 WAIT UNTIL (clk'EVENT AND clk='1');
16 temp := temp + 1;
17 IF (temp=10) THEN temp := 0;
18 END IF;
19 digit <= temp;
20 END PROCESS;
21 END counter;
22 ---------------------------------------------

WAIT ON condición para varias señales

 Ejemplo

PROCESS
BEGIN
WAIT ON clk, rst;
IF (rst='1') THEN
Output <= "00000000";
ELSIF (clk'EVENT AND clk='1') THEN
Output <= input;
END IF;
END PROCESS;

 Ejemplo: FFD con reset asincrónico y WAIT ON

1 --------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 --------------------------------------
5 ENTITY dff IS
6 PORT (d, clk, rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END dff;
9 --------------------------------------
10 ARCHITECTURE dff OF dff IS
11 BEGIN
12 PROCESS
13 BEGIN
14 WAIT ON rst, clk;
15 IF (rst='1') THEN
16 q <= '0';
17 ELSIF (clk'EVENT AND clk='1') THEN
18 q <= d;
19 END IF;
20 END PROCESS;
21 END dff;
22 --------------------------------------

WAIT FOR asigna retardos, está pensado sólo para simulaciones.

Ejemplo: WAIT FOR 5ns;

Código con CASE

Sintaxis:
CASE identificador IS
WHEN valor => asignaciones;
WHEN valor => asignaciones;
...
END CASE;

 Ejemplo:

CASE control IS
WHEN "00" => x<=a; y<=b;
WHEN "01" => x<=b; y<=c;
WHEN OTHERS => x<="0000"; y<="ZZZZ";
END CASE;

 Ejemplo: FFD con reset asincrónico y CASE

1 ----------------------------------------------
2 LIBRARY ieee; -- Declaración innecesaria,
3 -- por que
4 USE ieee.std_logic_1164.all; -- BIT se usa dentro de
5 -- STD_LOGIC
6 ----------------------------------------------
7 ENTITY dff IS
8 PORT (d, clk, rst: IN BIT;
9 q: OUT BIT);
10 END dff;
11 ----------------------------------------------
12 ARCHITECTURE dff3 OF dff IS
13 BEGIN
14 PROCESS (clk, rst)
15 BEGIN
16 CASE rst IS
17 WHEN '1' => q<='0';
18 WHEN '0' =>
19 IF (clk'EVENT AND clk='1') THEN
20 q <= d;
21 END IF;
22 WHEN OTHERS => NULL; -- innecesario, rst es de tipo
23 -- BIT
24 END CASE;
25 END PROCESS;
26 END dff3;
27 ----------------------------------------------

 Ejemplo: Contador de dos dígitos con salida a displays de siete

segmentos
1 --------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 --------------------------------------------------
5 ENTITY counter IS
6 PORT (clk, reset: IN STD_LOGIC;
7 digit1, digit2: OUT STD_LOGIC_VECTOR (6 DOWNTO 0));
8 END counter;
9 --------------------------------------------------
10 ARCHITECTURE counter OF counter IS
11 BEGIN
12 PROCESS(clk, reset)
13 VARIABLE temp1: INTEGER RANGE 0 TO 10;
14 VARIABLE temp2: INTEGER RANGE 0 TO 10;
15 BEGIN
16 ---- contador: ----------------------
17 IF (reset='1') THEN
18 temp1:= 0;
19 temp2:= 0;
20 ELSIF (clk'EVENT AND clk='1') THEN
21 temp1:= temp1 + 1;
22 IF (temp1=10) THEN
23 temp1:= 0;
24 temp2:= temp2 + 1;
25 IF (temp2=10) THEN
26 temp2:= 0;
27 END IF;
28 END IF;
29 END IF;
30 ---- conversión de BCD a siete segmentos: --------
31 CASE temp1 IS
32 WHEN 0 => digit1 <= "1111110"; --7E
33 WHEN 1 => digit1 <= "0110000"; --30
34 WHEN 2 => digit1 <= "1101101"; --6D
35 WHEN 3 => digit1 <= "1111001"; --79
36 WHEN 4 => digit1 <= "0110011"; --33
37 WHEN 5 => digit1 <= "1011011"; --5B
38 WHEN 6 => digit1 <= "1011111"; --5F
39 WHEN 7 => digit1 <= "1110000"; --70
40 WHEN 8 => digit1 <= "1111111"; --7F
41 WHEN 9 => digit1 <= "1111011"; --7B
42 WHEN OTHERS => NULL;
43 END CASE;
44 CASE temp2 IS
45 WHEN 0 => digit2 <= "1111110"; --7E
46 WHEN 1 => digit2 <= "0110000"; --30
47 WHEN 2 => digit2 <= "1101101"; --6D
48 WHEN 3 => digit2 <= "1111001"; --79
49 WHEN 4 => digit2 <= "0110011"; --33
50 WHEN 5 => digit2 <= "1011011"; --5B
51 WHEN 6 => digit2 <= "1011111"; --5F
52 WHEN 7 => digit2 <= "1110000"; --70
53 WHEN 8 => digit2 <= "1111111"; --7F
54 WHEN 9 => digit2 <= "1111011"; --7B
55 WHEN OTHERS => NULL;
56 END CASE;
57 END PROCESS;
58 END counter;
59 --------------------------------------------------

Código con LOOP

FOR / LOOP: el LOOP se repite un número fijo de veces.

[Etiqueta:] FOR identificador IN rango LOOP
(Instrucciones secuenciales)
END LOOP [etiqueta];

 Ejemplo

FOR i IN 0 TO 5 LOOP
x(i) <= enable AND w(i+2);
y(0, i) <= w(i);
END LOOP;

WHILE / LOOP:
[Etiqueta:] WHILE condición LOOP
(Instrucciones secuenciales)
END LOOP [etiqueta];

 Ejemplo

WHILE (i < 10) LOOP

WAIT UNTIL clk'EVENT AND clk='1';
(Otras instrucciones)
END LOOP;

EXIT: Usado para finalizar un LOOP.

[Etiqueta:] EXIT [etiqueta] [WHEN condición];

 Ejemplo

FOR i IN data'RANGE LOOP

CASE data(i) IS
WHEN '0' => count:=count+1;
WHEN OTHERS => EXIT;
END CASE;
END LOOP;

NEXT: Usado para saltar de uno a otro LOOP.

[Etiqueta:] NEXT [loop_ etiqueta] [WHEN condición];

 Ejemplo

FOR i IN 0 TO 15 LOOP
NEXT WHEN i=skip; -- salta a la siguiente iteración
(...)
END LOOP;

 Ejemplo: sumador de rizado

1 ----- Solución 1: Generic, con VECTORES --------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ------------------------------------------------
5 ENTITY sumador IS
6 GENERIC (longitud: INTEGER:= 8);
7 PORT (a, b: IN STD_LOGIC_VECTOR (longitud-1 DOWNTO 0);
8 cin: IN STD_LOGIC;
9 s: OUT STD_LOGIC_VECTOR (longitud-1 DOWNTO 0);
10 cout: OUT STD_LOGIC);
11 END adder;
12 -----------------------------------------------
13 ARCHITECTURE sumador OF sumador IS
14 BEGIN
15 PROCESS (a, b, cin)
16 VARIABLE carry: STD_LOGIC_VECTOR (longitud DOWNTO 0);
17 BEGIN
18 carry(0) := cin;
19 FOR i IN 0 TO longitud - 1 LOOP
20 s(i) <= a(i) XOR b(i) XOR carry(i);
21 carry(i+1) := (a(i) AND b(i)) OR (a(i) AND
22 carry(i)) OR (b(i) AND carry(i));
23 END LOOP;
24 cout <= carry(longitud);
25 END PROCESS;
26 END sumador;
27 ------------------------------------------------
1 ---- Solución 2: sin-generic, con INTEGERS ----
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ------------------------------------------------
5 ENTITY sumador IS
6 PORT (a, b: IN INTEGER RANGE 0 TO 255;
7 c0: IN STD_LOGIC;
8 s: OUT INTEGER RANGE 0 TO 255;
9 c8: OUT STD_LOGIC);
10 END sumador;
11 ------------------------------------------------
12 ARCHITECTURE sumador OF sumador IS
13 BEGIN
14 PROCESS (a, b, c0)
15 VARIABLE temp: INTEGER RANGE 0 TO 511;
16 BEGIN
17 IF (c0='1') THEN temp:=1;
18 ELSE temp:=0;
19 END IF;
20 temp:= a + b + temp;
21 IF (temp > 255) THEN
22 c8 <= '1';
23 temp:= temp---256;
24 ELSE c8 <= '0';
25 END IF;
26 s <= temp;
27 END PROCESS;
28 END sumador;
29 ------------------------------------------------

1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY barrel IS
6 GENERIC (n: INTEGER:= 8);
7 PORT (inp: IN STD_LOGIC_VECTOR (n-1 DOWNTO 0);
8 shift: IN INTEGER RANGE 0 TO 1;
9 outp: OUT STD_LOGIC_VECTOR (n-1 DOWNTO 0));
10 END barrel;
11 ---------------------------------------------
12 ARCHITECTURE RTL OF barrel IS
13 BEGIN
14 PROCESS (inp, shift)
15 BEGIN
16 IF (shift=0) THEN
17 outp <= inp;
18 ELSE
19 outp(0) <= '0';
20 FOR i IN 1 TO inp'HIGH LOOP
21 outp(i) <= inp(i-1);
22 END LOOP;
23 END IF;
24 END PROCESS;
25 END RTL;
26 ---------------------------------------------

1 --------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 --------------------------------------------
5 ENTITY LeadingZeros IS
6 PORT ( data: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
7 zeros: OUT INTEGER RANGE 0 TO 8);
8 END LeadingZeros;
9 --------------------------------------------
10 ARCHITECTURE behavior OF LeadingZeros IS
11 BEGIN
12 PROCESS (data)
13 VARIABLE count: INTEGER RANGE 0 TO 8;
14 BEGIN
15 count := 0;
16 FOR i IN data'RANGE LOOP
17 CASE data(i) IS
18 WHEN '0' => count := count + 1;
19 WHEN OTHERS => EXIT;
20 END CASE;
21 END LOOP;
22 zeros <= count;
23 END PROCESS;
24 END behavior;

1 ---------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------------
5 ENTITY ram IS
6 GENERIC ( bits: INTEGER := 8; -- # of bits per word
7 words: INTEGER := 16); -- # of words in the memory
8 PORT ( wr_ena, clk: IN STD_LOGIC;
9 addr: IN INTEGER RANGE 0 TO words-1;
10 data_in: IN STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
11 data_out: OUT STD_LOGIC_VECTOR (bits-1 DOWNTO 0));
12 END ram;
13 ---------------------------------------------------
14 ARCHITECTURE ram OF ram IS
15 TYPE vector_array IS ARRAY (0 TO words-1) OF
16 STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
17 SIGNAL memory: vector_array;
18 BEGIN
19 PROCESS (clk, wr_ena)
20 BEGIN
21 IF (wr_ena='1') THEN
22 IF (clk'EVENT AND clk='1') THEN
23 memory(addr) <= data_in;
24 END IF;
25 END IF;
26 END PROCESS;
27 data_out <= memory(addr);
28 END ram;
29 ---------------------------------------------------
PROBLEMAS PROPUESTOS

Problema 6.1: Contador de flancos

Diseñe un circuito que cuente el número de flancos de un reloj.

Problema 6.2: Registro de desplazamiento

Escriba un código en VHDL con el que se implemente un registro de desplazamiento de
4 etapas como el mostrado en la figura P6.2. la solución debe ser diferente a la dada
en los ejemplos anteriores

Problema 6.3: Codificador de prioridad

La figura siguiente muestra un codificador de prioridad. Escriba un código secuencial
en VHDL que use IF y otro que use CASE.

Problema 6.4: Divisor de frecuencia con GENERIC.

Escriba un código en VHDL que divida la frecuencia de una entrada de reloj CLK por un
entero n como se muestra en la figura. El código debe usar GENERIC, esto es, que n
debe ser definido usando la instrucción GENERIC.

Problema 6.5: Multiplicador de frecuencia

ES lo opuesto al problema anterior. En este se debe multiplicar la frecuencia del Reloj
CLK por un entero n.

Problema 6.6: Temporizador #1

Diseñe un temporizador capaz de correr de 0min:00seg a 9min:59seg (ver figura). El
circuito tiene los botones de start, clk, stop, y reset como entradas. Las salidas deben
ser displays de 7 segmentos codificados. Una señal de Reloj clk=1Hz está disponible.

Problema 6.7: Temporizador #2

Considere el temporizador del problema 6.6. Para un nuevo diseño se dispone de un
sólo botón para el start y stop alternadamente, y también de reset presionando el
botón por más de 2 segundos. Clk = 1Hz

Problema 6.8: Detector de Paridad

La siguiente figura muestra un detector de paridad. El detector debe tener la salida
output=0, cuando el número de 1s de la entrada input de 8 bits sea par y output=1
cuando sea impar.

Problema 6.9: Contador de unos.

Se busca contar el número de 1s presentes en un vector binario dado por la tabla
siguiente. Escriba un código en VHDL que implemente tal circuito.
Problema 6.10: Codificador de intensidad.
Diseñe un codificador que reciba un vector de entrada din de 7 bits, y genere una un
vector de salida dout en el cual se coloca un 1 en la posición que corresponde al
número de unos contados en din, el resto de posiciones se rellenan con ceros como se
muestra en la tabla.

Problema 6.11: Multiplexor

Escribir el código secuencial para el multiplexor genérico que se muestra en la figura.

Problema 6.12: Vector de desplazamiento.

Escribir el código secuencial para el vector de desplazamiento que se muestra en la
figura.
Problema 6.13: ALU
Escriba un código secuencial para el ejemplo de la ALU implementada en la sección de
código concurrente.

Problema 6.14: Signed/Unsigned Sumador/Restador

Resuelva el problema 5.5 usando código secuencial.

Problema 6.15: Comparador

Resuelva el comparador de la figura usando código secuencial.

Problema 6.16: SUMADOR DE RIZADO

Considere el sumador de rizado del ejemplo mostrado en la sección de código
secuencial.
(a) Por qué no puede ser reemplazada la instrucción IF de las líneas 17-19, por
simplemente ‘‘temp:=c0;’’?
(b) Note que el ejemplo es completamente combinacional por lo que debe realizarse
con código concurrente, o sea, sin PROCESS. Escriba un código para el problema.
Problema 6.17: FFD
Defina cuál de los códigos de abajo relacionados con un FFD funciona adecuadamente.
--------------------------------------
LIBRARY ieee; BEGIN
USE ieee.std_logic_1164.all; PROCESS (clk)
-------------------------------------- BEGIN
ENTITY dff IS IF (rst='1') THEN
PORT ( d, clk, rst: IN BIT; q <= '0';
q: OUT BIT); ELSIF (clk'EVENT AND clk='1') THEN
END dff; q <= d;
----- Solution 1 --------------------- END IF;
ARCHITECTURE arch1 OF dff IS END PROCESS;
BEGIN END arch2;
PROCESS (clk, rst) ----- Solution 3 ---------------------
BEGIN ARCHITECTURE arch3 OF dff IS
IF (rst='1') THEN BEGIN
q <= '0'; PROCESS (clk)
ELSIF (clk'EVENT AND clk='1') THEN BEGIN
q <= d; IF (rst='1') THEN
END IF; q <= '0';
END PROCESS; ELSIF (clk'EVENT) THEN
END arch1; q <= d;
----- Solution 2 --------------------- END IF;
ARCHITECTURE arch2 OF dff IS END PROCESS;
END arch3; ----- Solution 5 ---------------------
----- Solution 4 --------------------- ARCHITECTURE arch5 OF dff IS
ARCHITECTURE arch4 OF dff IS BEGIN
BEGIN PROCESS (clk, rst, d)
PROCESS (clk) BEGIN
BEGIN IF (rst='1') THEN
IF (rst='1') THEN q <= '0';
q <= '0'; ELSIF (clk='1') THEN
ELSIF (clk='1') THEN q <= d;
q <= d; END IF;
END IF; END PROCESS;
END PROCESS; END arch5;
END arch4; --------------------------------------