Pontificia Universidad Católica Madre y Maestra

Facultad de Ciencias de la Ingeniería

Departamento Ingeniería Electrónica y Telecomunicaciones

Nombres:
Ángel Osvaldo

Apellidos:
Richard Peña

Matricula:
2018-0772

Materia:
Laboratorio de Circuito Lógico

Profesor/a:
Ing. Javier Marte

Asunto:
Quinta Práctica

Titulo:
Declaraciones, asignación procesal y conductual

Fecha de Entrega:
31ro de octubre del 2019

1
Índice
I.- Introducción…………………………………………………..... Pág. 03
II.- Objetivos………………………..…………………………...... Pág. 03
III.- Materiales……………………………………………………. Pág. 03
IV.- Marco Teórico……………………………………………...... Pág. 04
V. Procedimiento……….………………………………………… Pág. 07
VI.- Conclusión…………………………………………………… Pág. 16
VII.- Bibliografía…………………………………………………. Pág. 17

2
I.- Introducción

Pues al introducir el lenguaje de Verilog, pudimos ver en las diferentes formas por las cuales,
utilizando sentencias y sintaxis sencillas, podíamos crear simulaciones digitales de cualquier
circuito o sistema lógico que podamos crear.
En esta práctica seguiremos incrementando nuestros conocimientos en la creación de
simulaciones digitales con este lenguaje de programación, y así perfeccionar nuestras
habilidades en la elaboración de las mismas.
Por lo mismo, veremos diferentes tipos de asignaciones, con las cuales nos permitirá ver las
simulaciones anteriores desde otro punto de vista y claramente, poder tener una gran gama
de habilidades de creación.

II.- Objetivos

1. Que el estudiante se familiarice con lenguaje de descripción de hardware.

2. Familiarizarse con la implementación en Verilog de bloques digitales.
3. Crear soluciones con diversos tipos de declaraciones, asignación procesal y
conductual.

III.- Materiales

1. Laptop o Computadora Personal.

2. EDA PlayGround.
3. Libro de Textos.

3
IV.- Marco Teórico

Regs vs Wires

Ambos pertenecen a los dos tipos de datos principales con los cuales se trabaja en el Lenguaje
en Verilog, los cuales son “Registers” y “Nets”.

Los “Registers” se caracterizan por ser variables con capacidad de almacenar información,
siendo los regs parte de estos datos. Mientras que los “Nets” o “wire” solo representan
conexiones estructurales entre componentes y estos al contrario que los primeros, no tienen
la capacidad de almacenar información (1).

Ejemplo #1

Ejemplo #2

4
Descripción de Procedimiento

Toda descripción de comportamiento en lenguaje Verilog debe declararse dentro de un

proceso,
aunque existe una excepción. En Verilog existen dos tipos de procesos, también
denominados bloques concurrentes.

Initial. Este tipo de proceso se ejecuta una sola vez comenzando su ejecución en
tiempo cero. Este proceso no es sintetizable, es decir no se puede utilizar en una
descripción RTL. Su uso está íntimamente ligado a la realización del testbecnh.

Always. Este tipo de proceso se ejecuta continuamente a modo de bucle. Tal y como
su nombre indica, se ejecuta siempre. Este proceso es totalmente sintetizable. La
ejecución de este proceso está controlada por una temporización (es decir, se ejecuta
cada determinado tiempo) o por eventos. (1)

Ejemplo #3

Ejemplo #4

5
Comportamientos Secuenciales

La principal característica de este nivel es su total independencia de la estructura del diseño.

En este nivel, el diseñador define el comportamiento del circuito, definiéndonos mediante
algoritmos en paralelo. Cada uno de los algoritmos están formados por un conjunto de
instrucciones que se ejecutan de forma secuencial. En ocasiones es posible utilizar código no
sintetizable con el fin de realizar los denominados testbenches (2).

Ejemplo #5

Descripción Continua

Se utiliza exclusivamente para modelar lógica combinacional. A diferencia de la asignación

procedural, se ejecuta de forma continua por lo que no neceita de una lista sensible (1). La
sintáis se expresa de la siguiente manera:

La variable sólo puede estar declarada tipo net (en nuestro caso tipo wire). La asignación
continua debe estar declarada fuera de cualquier proceso y nuca dentro de bloques always o
bloques initial (1).

6
 Ejemplo #6

En el ejemplo no se ha añadido una temporización en la asignación, por lo tanto en cada ciclo

se revisará dicha sentencia. Estas asignaciones también se ejecutan de forma secuencial las
cuales se pueden controlar mediante la temporización (3).

Asignación procedural con “always”

La asignación procedural es la que se ha visto hasta el momento, donde a las variables se le
asigna un valor dentro de un proceso always o initial, el tipo de variable a la que se le asigna
el valor puede ser de cualquier tipo (3).

Ejemplo #7

Sentencia “case”
La sentencia case evalúa una expresión y en función de su valor ejecuta la sentencia o grupos
de sentencias agrupadas en el primer caso en que coincida. El uso de múltiples sentencias o
asignaciones requiere el uso de begin – end. En caso de no cubrir todos los posibles valores
de la expresión a avaluar, es necesario el uso de un caso por defecto (default). Este caso se
ejecutará siempre y cuando no se cumplan ninguno de los casos anteriores (1).

Ejemplo #8

7
V.- Procedimiento

I. Implementar en Verilog el siguiente cloque multiplexor MUX de 4 a 1utilizando

always and case. Agregue el enlace de su playground y escriba el código fuente
en esta sección.

module MUX1 (A,B,C,D,Q);

input A,B,C,D;
reg [1:0]sel;
output Q;

always @(A,B,C,D)
begin
case (sel)
2'b00: Q=A;
2'b01: Q=B;
2'b10: Q=C;
2'b11: Q=D;

default: Q=2'bxx;

endcase
end
endmodule

Link: https://www.edaplayground.com/x/4W5Z

8
II. El sistema neumático de una fábrica cuenta con un sensor de presión que
proporciona un dato binario de cuatro bits D, C, B y A para indicar presiones
desde 0 a 150 PSI. Con resolución de 10 PSI. Tiene además tres bombas de 10,
20 y 40 caballos. Se quiere un circuito que:

1. Si la presión está en 100 PSI o más las bombas permanecen apagadas.

2. Cuando la presión baja hasta 90 PSI enciende solo la bomba10.
3. Cuando la presión baja hasta 80 PSI enciende solo la bomba20.
4. Cuando la presión baja hasta 70 PSI enciende las bomba10 y bomba20.
5. Cuando la presión baja hasta 60 PSI enciende solo la bomba40.
6. Cuando la presión baja hasta 50 PSI enciende la bomba10 y la
bomba40.
7. Cuando la presión baja hasta 40 PSI enciende la bomba20 y la bomba40
8. Cuando la presión baja a 30 PSI o menos encienden las tres bombas.

Instrucciones:
a) Hacer la tabla de verdad con las 16 combinaciones correspondientes a las 4
variables de entrada, cada combinación representa la medida de la presión
multiplicada por 10 en PSI. Como ejemplo las combinaciones desde 0 a 6 con la
escala en PSI que representa. Por último, sacar las ecuaciones correspondientes.

TABLA DE VERDAD
PSI D C B A B10 B20 B40
0 0 0 0 0 1 1 1
10 0 0 0 1 1 1 1
20 0 0 1 0 1 1 1
30 0 0 1 1 1 1 1
40 0 1 0 0 0 1 1
50 0 1 0 1 1 0 1
60 0 1 1 0 0 0 1
70 0 1 1 1 1 1 0
80 1 0 0 0 0 1 0
90 1 0 0 1 1 0 0
100 1 0 1 0 0 0 0
110 1 0 1 1 0 0 0
120 1 1 0 0 0 0 0
130 1 1 0 1 0 0 0
140 1 1 1 0 0 0 0
150 1 1 1 1 0 0 0

9
Tabla de Karnaugh
B10 𝐵̅ 𝐴̅ 𝐵̅ 𝐴 BA 𝐵𝐴̅
̅ 𝐶̅ 0 1 3 2 ̅ 𝐶̅
𝐷
𝐷 1 1 1 1
̅𝐶
𝐷 4
0 5
1 7
1 6
0 ̅𝐴
𝐷
12 13 15 14
DC 0 0 0 0
𝐷𝐶̅ 8
0 9
1 11
0 10
0 𝐶̅ 𝐵̅𝐴

̅ 𝐶̅ + 𝐷
B10 = 𝐷 ̅ 𝐴 + 𝐶̅ 𝐵̅ 𝐴

B20 𝐵̅ 𝐴̅ 𝐵̅ 𝐴 BA 𝐵𝐴̅
̅ 𝐶̅
𝐷 0
1 1
1 3
1 2
1 ̅ 𝐶̅
𝐷
̅𝐶
𝐷 4
1 5
0 7
1 6
0 ̅ 𝐵𝐴
𝐷
12 13 15 14
DC 0 0 0 0
𝐷𝐶̅ 8
1 9
0 11
0 10
0 𝐶̅ 𝐵̅𝐴̅
̅ 𝐵̅𝐴̅
𝐷
̅ 𝐶̅ + 𝐷
B20 = 𝐷 ̅ 𝐵𝐴 + 𝐶̅ 𝐵̅ 𝐴̅ + 𝐷
̅ 𝐵̅ 𝐴̅

B40 𝐵̅ 𝐴̅ 𝐵̅ 𝐴 BA 𝐵𝐴̅
̅ 𝐶̅
𝐷 0
1 1
1 3
1 2
1 ̅ 𝐶̅
𝐷
̅𝐶
𝐷 4
1 5
1 7
0 6
1 ̅ 𝐵̅
𝐷
12 13 15 14
DC 0 0 0 0
̅ 𝐴̅
𝐷
𝐷𝐶̅ 8
0 9
0 11
0 10
0

̅ 𝐶̅ + 𝐷
B40 = 𝐷 ̅ 𝐴̅
̅ 𝐵̅ + 𝐷

10
b) Implementar en Verilog el circuito anterior utilizando Data Flow o código de
primitivas de nivel de puertas. Además, agregue el circuito, el enlace de su
playground y escriba el código fuente en esta sección.

1:A U7
A An
and2_out
U11
U12
AND or_out1
B10_out
U24 U8
OR
B Bn and3_out OR

NOT
AND
U9
U25 U10
C Cn and4_out
and1_out
AND U18
NOT U20
AND
or2_out
U26 U13 and6_out B20_out
U14 or3_out
D Dn OR
OR
and5_out
NOT U19
AND
AND and7_out

U15 and9_out

OR U23
B40_out
AND U17
OR
U16
and8_out AND

U22
AND
or4_out

U21
OR
and10_out

AND

module pumps_v1(d, c, b, a, hp_40, hp_20, hp_10);

input d, c, b, a;
output hp_40, hp_20, hp_10;

assign hp_10 = ~d&~c|~d&a|~c&~b&a;

assign hp_20 = ~d&~c|~d&b&a|~c&~b&~a|~d&~b&~a;
assign hp_40 = ~d&~c|~d&~b|~d&~a;

endmodule

Link: https://www.edaplayground.com/x/2Lxx

11
c) Implementar en Verilog el circuito anterior utilizando código de primitivas de
nivel de puertas NAND.

12
module pumps_v2(d, c, b, a, hp_40, hp_20, hp_10);

input d, c, b, a;
output hp_40, hp_20, hp_10;
wire an, bn, cn, dn, nand1_out, nand2_out, nand3_out, nand4_out, nand5_out,
nand6_out, nand7_out, nan8_out;

nand nandnot1(an, a);

nand nandnot2(bn, b);
nand nandnot3(cn, c);
nand nandnot4(dn, d);

nand nand1(nand1_out, dn, cn);

nand nand2(nand2_out, dn, a);
nand nand3(nand3_out, cn, bn, a);
nand nandhp_10(hp_10, nand1_out, nand2_out, nand3_out);

nand nand4(nand4_out, dn, b, a);

nand nand5(nand5_out, cn, bn, an);
nand nand6(nand6_out, dn, bn, an);
nand nandhp_20(hp_20, nand4_out, nand5_out, nand6_out, nand1_out);

nand nand7(nand7_out, dn, bn);

nand nand8(nand8_out, dn, an);
nand nandhp_40(hp_40, nand7_out, nand8_out, nand1_out);

endmodule

Link: https://www.edaplayground.com/x/2Lxx

13
d) Implementar en Verilog el circuito anterior utilizando Always y Case.

module pumps_v3(d, c, b, a, hp_40, hp_20, hp_10);

input a, c, b, d;
output hp_40, hp_20, hp_10;
reg hp_40, hp_20, hp_10;

//CASE HP_10
always @(d,c,b,a)
begin
case({d,c,b,a})
4'b0000: hp_10=1;
4'b0001: hp_10=1;
4'b0010: hp_10=1;
4'b0011: hp_10=1;
4'b0100: hp_10=0;
4'b0101: hp_10=1;
4'b0110: hp_10=0;
4'b0111: hp_10=1;
4'b1000: hp_10=0;
4'b1001: hp_10=1;
4'b1010: hp_10=0;
4'b1011: hp_10=0;
4'b1100: hp_10=0;
4'b1101: hp_10=0;
4'b1110: hp_10=0;
4'b1111: hp_10=0;
endcase
end

//CASE HP_20

always @(d,c,b,a)
begin
case({d,c,b,a})
4'b0000: hp_20=1;
4'b0001: hp_20=1;
4'b0010: hp_20=1;
4'b0011: hp_20=1;
4'b0100: hp_20=1;

14
 4'b0101: hp_20=0;
4'b0110: hp_20=0;
4'b0111: hp_20=1;
4'b1000: hp_20=1;
4'b1001: hp_20=0;
4'b1010: hp_20=0;
4'b1011: hp_20=0;
4'b1100: hp_20=0;
4'b1101: hp_20=0;
4'b1110: hp_20=0;
4'b1111: hp_20=0;
endcase
end

//CASE HP_40
always @(d,c,b,a)
begin
case({d,c,b,a})
4'b0000: hp_40=1;
4'b0001: hp_40=1;
4'b0010: hp_40=1;
4'b0011: hp_40=1;
4'b0100: hp_40=1;
4'b0101: hp_40=1;
4'b0110: hp_40=1;
4'b0111: hp_40=0;
4'b1000: hp_40=0;
4'b1001: hp_40=0;
4'b1010: hp_40=0;
4'b1011: hp_40=0;
4'b1100: hp_40=0;
4'b1101: hp_40=0;
4'b1110: hp_40=0;
4'b1111: hp_40=0;
endcase
end
endmodule

Link: https://www.edaplayground.com/x/2Lxx

15
VI.- Conclusión

Pudimos apreciar a través de los procedimientos realizados, como la implementación de

dichas sentencias, al inicio llegan a ser complicadas en el sentido de la sintaxis al momento
de la elaboración.
Al iniciar un MUX de 2 a 4, pudimos probar de manera básica lo que con “always” y “case”
se volvió muy simple y eficiente. En conjunto con esto, desarrollamos un diseño de un
sistema neumático, con el cual la diseñamos de maneras diferentes, para al final compararlas
y ver cual resulta mas eficiente.
Vimos el Data Flow, la realizada por las NAND y con el ultimo sobre el “always” y “case”.
A pesar de las dificultades, este ultimo llega a resultar a ser más directo de lo que en verdad
queremos. Se pudo llegar a la conclusión de que estos tipos de sentencias ayudan más a
comprender los circuitos y simulaciones a realizar y así poder mejorarlo lo mejor posible.

16
VII.- Bibliografía
1 Tutorial Verilog. [Online]. [cited 2019 Octubre 31. Available from:
. http://www.iuma.ulpgc.es/~nunez/clases-FdC/verilog/Verilog%20Tutorial%20v1.pdf.
2 WikiBooks. [Online].; 2013 [cited 2019 10 31. Available from:
. https://es.wikibooks.org/wiki/Programación_en_Verilog/Introducción#Nivel_de_comporta
miento.
3 WIkiBooks. [Online].; 2019. Available from:
. https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Verilog/M%C3%B3dulos#Asignaci%
C3%B3n_procedural.

17
18