Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Práctica No. 1(6,7,8,9).

Tarjeta de desarrollo (práctica guiada).
Development Board (guided practice).

El éxito es la suma de tus pequeños esfuerzos día tras día.

Unidad Temática: I

Duración: 4.5 hrs. (3 clases).

(1er. clase guiada: implementación de las funciones con VHDL y Verilog; 2da. clase guiada:
implementación del registro de 8 bits con FF-D, un contador binario de 4 bits con salida a
display 7-seg y 3er. clase un diseño TLD y PmodALS)

Unidad de Competencia Específica:

Utiliza el FPGA de la tarjeta de desarrollo con base al lenguaje de descripción de hardware
y el software de desarrollo.

Competencia Específica:
Implementa los circuitos descritos con HDL y su software en los DLP (FPGA).

Contenido:
En esta práctica usted aprenderá a implementar los siguientes circuitos y máquinas de estado:
• Implementar y simular las funciones de la table 1.1, escritas en HDL (VHDL y
Verilog).
• Implementar y simular un registro de 8 bits basados en los FF tipo D.
• Implementar y simular un contador up-down de 4 bits con salida a display 7 seg.
• Implementar dos sirenas (policía, ambulancia) junto con sus etapas de potencia de
audio con control on-off.
• Top Level Design.
• Implementar un circuito de prueba para un encoder mecánico rotatorio y el
PmodALS.

Content:
In this practice, you will learn to implement combinatorial and sequential circuits, and also
Finite State Machines, with the next characteristics:
• Implement and simulate the functions of table 1.1, written with HDL.
• Implement and simulate a 8 bit register based on a D flip-flop circuit.
• Implement and simulate a 4bit up-down counter with 7 segment display output.
• Implement two sirens (police, ambulance), with the power circuit and on-off control.
• Top Level Design.
• Implement a test circuit for a rotary mechanical encoder and the PmodALS.

1
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Pre-reporte uno.
Previous work one.

Desarrollar los siguientes puntos como trabajo previo para el buen progreso de la práctica
[máximo 15 cuartillas si se solicita impreso (Letra Times New Roman de 12ptos,
interlineado sencillo)]:

1. Investigar las características de los HDL así como también las de los CPLD y FPGA.

2. Diseñar y construir los circuitos externos que necesite la tarjeta para cada punto del
desarrollo, particularmente un circuito amplificador de audio para una bocina de 4 u 8 ohms,
de por lo menos ½ W.

3. Escribir los códigos de VHDL y Verilog para programar las funciones de salida mostradas
en la entidad de la figura 1.1, que cumpla con la tabla 1.1. Compilar o sintetizar para tener
los archivos que se programarán en el dispositivo lógico programable que contiene su sistema
de desarrollo.

Figura 1.1. Entidad para el arreglo de 3 entradas y n salidas.

Tabla 1.1. Tabla de verdad de las funciones de salida S. Algunas funciones se propondrán
por el profesor en el salón.
ABC S1 S2 S3 S4 S5 S6
000 0 0 1
001 1 1 1
010 1 1 0
011 0 1 0
100 1 1 0
101 0 1 0
110 0 1 1
111 1 1 1

4. Escribir en VHDL y Verilog los códigos para programar (a) un registro de 8 bits basado
en un flip-flop tipo D, mostrado en la figura 1.2, y (b) un contador binario de 4 bits
ascendente-descendente con salida a display de 7 segmentos de ánodo común (0-9 y A-F),
con botón de sentido, reten (hold) y reset en bajo, como la entidad de la figura 1.3.

2
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 1.2. Flip-flop tipo D.

Figura 1.3. Contador binario ascendente descendente.

NOTA: En caso de no entregar el pre-reporte y/o de no traer el material (con los circuitos
armados), los alumnos NO TENDRÁN derecho a entrar al laboratorio. Los circuitos deben
de armarse de acuerdo con la indicación del archivo de restricciones. Coloque las preguntas
con su numeración en los pre-reportes y reportes.

"Coloca la parte UPIITA-IPN a tu trabajo, comparte la información adicional que

buscaste".

Material y Equipo.
Equipment and components.

Tarjeta de & software de desarrollo (Nexys/ISE-Vivado, DE2/Quartus II, etc.).

Componentes: Bocina de 4 u 8 ohms, 2W min y su etapa de potencia, PmodALS.
Circuito de reloj (oscilador) externo o generador de señales con conectores.
Varios: Fuente de alimentación regulada para alimentar de forma externa los circuitos.

Nota: las cantidades de componentes depende de los diseños que se realicen, además de
corroborar los componentes que se tengan en una tarjeta de desarrollo.

Introducción.
Introduction.

Loa lenguajes existentes de descripción de hardware se dividen en dos, los que abarcan
sistemas continuos o analógicos y los que trabajan sistemas discretos o digitales (binarios).
Por ejemplo, los primeros pueden utilizar los FPAA (Field Programmable Analog Array) y
los segundos emplean los FPGA (Field Programmable Gate Array).

El crecimiento exponencial de la gran capacidad de estos dispositivos se refleja claramente

en el diagrama de tiempo de la figura 1.4 y la fotografía de un circuito integrado en la figura
1.5.

3
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 1.4. Diagrama de tiempo de la integración de transistores en un circuito integrado.

Figura 1.5. Fotografía de un circuito integrado.

La gente encargada del desarrollo de esta tecnología logra el diseño de dispositivos más
potentes en espacios muy pequeños, lo cual se realiza por medio de algunas de las siguientes
técnicas: diseño totalmente a la medida (Full Custom Design), al diseñar transistor por
transistor hasta su implementación final en el circuito integrado (CI); diseño de los ASIC
(Application Specific Integrated Circuit), que propone la implementación de los diseños
sobre celdas programables. Dentro de ésta última se encuentra la familia de los Dispositivos
Lógicos Programables (PLD), tanto pequeños como los complejos (CPLD), cuyo nivel de
integración histórico se puede representar primeramente por los arreglos lógicos
programables (PAL), arreglos lógicos genéricos (GAL Generic Array Logic) hasta llegar a
los CPLD y los FPGA (arreglos lógicos programables en campo). Debido a su conectividad
han hecho posible la facilidad y factibilidad de disminuir los costos.

Los elementos mínimos necesarios para poder utilizar estas tecnologías se restringen a la
existencia y uso de una computadora con el software apropiado (por ejemplo: ISE de Xilinx)
y la tarjeta de desarrollo que ya contiene la interfaz, el programador y los elementos
conectados de entrada y salida junto con conectores disponibles para entradas y salidas de
otros componentes, como la mostrada en la figura 1.6.

Figura 1.6. Tarjeta de desarrollo Nexys 2.

4
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Lenguajes descriptivos de harware (HDL Harware Description Language)

VHDL y Verilog son lenguaje de descripción hardware (Hardware Description Language,

HDL) utilizados para describir sistemas digitales desde una compuerta o un flip flop hasta
un sistema complejo de más de un millón de transistores, tales como procesadores, memorias
sistemas de control y medidores, entre otros.

Ambos lenguajes describen con códigos los modelos de un hardware digital en distintos
niveles de abstracción. Dichos modelos requieren:
• Especificaciones
• Documentación
• Pruebas utilizando un simulador
• Verificación formal
• Síntesis
• Implementación
Como resultado de esto se obtiene un proceso de diseño muy confiable con el mínimo costo
y tiempo invertidos, evitando errores de diseño al aplicar una metodología eficaz.

Estilos de diseño y niveles de abstracción.

Los estilos y niveles de abstracción con los cuales se describe un circuito son:

• Nivel de compuertas (Gate Level)

• Descripción jerárquica (Hierarchical description)
• Nivel de transferencia de registros (RTL Register Transfer Level)
• Comportamental (Behavioral)
• Estructural (Structural)

A continuación, se muestran algunos ejemplos de estos niveles.

Nivel de compuertas (Gate Level)

Esta es una descripción de bajo nivel donde el diseño es descrito con compuertas básicas
como AND, NAND, OR, NOR, XOR XNOR y NOT, conectadas Corresponde a una
descripción a bajo nivel del diseño, también a través de señales o alambres (wire). Los valores
que pueden tomar son ‘0’, ‘1’, ‘X’ o ‘Z’. A continuación, se muestran unos ejemplos.

5
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

//multiplexor 2 a 1
module mux(f,a,b,sel);
//entradas y salidas
input a,b,sel;
output f;
//wire nsel,f1,f2;

and g1(f1,a,nsel),
g2(f2,b,sel);
or g3(f,f1,f2);
not g4(nsel,sel);

endmodule

//Descripción nivel de compuertas de un sumador completo

module full_adder(x,y,cin,s,cout);
//entradas y salidas
input x,y,cin;
output s,cout;
//conexiones
wire s1,c1,c2,c3;

xor(s1,x,y);
xor(s,cin,s1);
and(c1,x,y);
and(c2,y,cin);
and(c3,x,cin);
or(cout,c1,c2,c3);

endmodule

Descripción jerárquica (Hierarchical description)

//Descripción jerárquica de un sumador completo

//(todo se guarda en el mismo archivo *.v)

//Descripción nivel de compuertas de un medio sumador

module half_adder(x,y,s,c);
input x,y;
output s,c;
//half adder body
xor(s,x,y);
and(c,x,y);
endmodule

//Full Adder

6
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

module full_adder(X,Y,Cin,S,Cout);
input X,Y,Cin;
output S,Cout;
wire s1,c1,c2;
//full adder body
half_adder ha1(X,Y,s1,c1);
half_adder ha2(Cin,s1,S,c2);
or(Cout,c1,c2);
endmodule

//Descripción jerárquica de un sumador de 4 bits

//(todo se guarda en el mismo archivo *.v)

//Descripción nivel de compuertas de un medio sumador

module half_adder(x,y,s,c);
input x,y;
output s,c;
//half adder body
xor(s,x,y);
and(c,x,y);
endmodule

//Full Adder
module full_adder(X,Y,Cin,S,Cout);
input X,Y,Cin;
output S,Cout;
wire s1,c1,c2;
//full adder body
half_adder ha1(X,Y,s1,c1);
half_adder ha2(Cin,s1,S,c2);
or(Cout,c1,c2);
endmodule

//Four bit Full adder

module four_bit_adder(x,y,cin,sum,cout);
input [3:0] x,y;
input cin;
output[3:0] sum;
output cout;
wire c1,c2,c3;
//fourbit adder body
full_adder fa1(x[0],y[0],cin,sum[0],c1);
full_adder fa2(x[1],y[1],c1,sum[1],c2);
full_adder fa3(x[2],y[2],c2,sum[2],c3);
full_adder fa4(x[3],y[3],c3,sum[3],cout);
endmodule

7
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Diseño jerárquico vs no jerárquico (Hierarchical vs Non- Hierarchical)

Jerárquico (Hierarchical) No jerárquico (Non Hierarchical)

//ejemplo de una nand de 3 entradas //ejemplo de una nand de 3 entradas
//descripción jerárquica //descripción no jerárquica

//nand jerárquica module nand_no_jerarquica(a, b, c,out) ;

module nand_jerarquica(a,b,c,out) ; input a, b, c ;
input a, b, c ; output out ;
output out ; wire out ;
wire out, temp; //asignación
//llamado de la compuerta and assign out = ~(a&b&c) ;
and_gate U1(a,b,c,temp); endmodule
//asignación
assign out = ~temp ;
endmodule

//and de 3 entradas
module and_gate(a,b,c,out) ;
input a,b,c;
output out ;
wire out ;
//asignación
assign out = a&b&c ;
endmodule

Nivel de transferencia de registros (RTL Register Transfer Level)

//flip flop tipo D

module ff(d,clk,q,q_bar);
input d,clk;
output q,q_bar;
reg q,q_bar;
//proceso
always @(posedge clk)
begin
q <= d; // asigna d
q_bar <= !d; // asigna d negada
end
endmodule

8
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Descripción por flujo de datos (Data flow)

//Sumador de 4 bits
//Descripción por flujo de datos
module adder4(A,B,Cin,SUM,Cout);
input [3:0] A,B;
input Cin;
output [3:0] SUM;
output Cout;

assign {Cout,SUM}=A+B+Cin;

endmodule

Comportamental (Behavioral)

En este nivel (Behavioral level) se define el comportamiento del sistema mediante algoritmos
(típimamente en paralelo), descritos con distintas estructuras de lenguaje (if-then-else, case-
when, when-else, etc.).

//Descripción comportamental de un multiplexor 2 a 1

module mux2to1(Mout,a,b,s);
input a,b,s; //entradas del mux a y b, selector s
output Mout;
reg Mout;

always @(a or b or s)
if (s==1) Mout=a;
else Mout=b;
endmodule

//Descripción comportamental de un decodificador de 2 a 4

module dec2to4(Xin, Yout,enable);
input [1:0] Xin; input enable;
output[3:0] Yout;
reg[3:0] Yout;

always @(Xin or enable)

begin
if(enable==1)
case(Xin)
2'b00: Yout=4'b0001;
2'b01: Yout=4'b0010;
2'b10: Yout=4'b0100;
2'b11: Yout=4'b1000;
endcase

9
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

else
Yout=4'b0000;
end
endmodule

//Días en el mes
module DiasEnElMes(mes, dias) ;
input [3:0] mes ;
output [4:0] dias ;
reg [4:0] dias ;
//proceso de asignación
always @(*)
begin
case(mes)
0,13,14,15: dias = 5'b00000 ;
2: dias = 5'd28 ;
4,6,9,11: dias = 5'd30 ;
default: dias = 5'd31 ;
endcase
end
endmodule

Estructural (Structural)

Archive base Archivo Top Level gates2_top.v que utiliza

gates2.v a gates2.v
// Ejemplo de compuertas de 2 entradas // Ejemplo de compuertas de 2 entradas
module gates2 ( // instanciando a gates2
input wire a, module gates2_top (sw,ld) ;
input wire b, input wire [1:0] sw;
output wire sand, output wire [5:0] ld;
output wire snand,
output wire snor, //instanciación de gates2
output wire sor, gates2 U1
output wire sxnor, ( .a(sw[1]),
output wire sxor .b(sw[0]),
); .sand(ld[5]),
//declaración de las compuertas .snand(ld[4]),
assign sand = b & a; .sor(ld[3]),
assign snand = ~(b & a); .snor(ld[2]),
assign sor = b | a; .sxor(ld[1]),
assign snor = ~(b | a); .sxnor(ld[0])
assign sxor = b ^ a; );
assign sxnor = ~(b ^ a); endmodule
endmodule

10
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Un objetivo de estas prácticas del laboratorio y del curso es el de manejar y aplicar el lenguaje
de programación VHDL (lenguaje de descripción en hardware) y Verilog, los cuales son
considerados como las herramientas de diseño por las industrias y las universidades de todo
el mundo, pues presenta grandes ventajas en la planeación y diseño de los sistemas
electrónicos digitales.

Por último, es bueno saber que el manejo de bits en HDL (Verilog y VHDL) se realiza por
medio de operadores (mostrados más adelante), recomendando revisar las palabras
reservadas, los modos, tipos y estilos, entre otras cosas, que se utilizan para la descripción de
los sistemas digitales en cada lenguaje existente.

“Si tienes alguna duda, apóyate con tu profesor”

Desarrollo.
Procedure
Práctica Guiada.
Guided practice.

Recuerde MOSTRAR sus circuitos funcionando a su profesor para la valoración del trabajo
de laboratorio (TL1).

1. Escritura, simulación e implementación de los códigos en VHDL y Verilog para

programar las funciones de la tabla 1.1, repetida enseguida para su fácil implementación.
Reportar códigos, simulación y fotos.
Writing, simulation and implementation of the codes in VHDL and Verilog to program
the functions of table 1.1, repeated immediately for easy implementation. Report codes,
simulation and photographs.

Tabla 1.1. Tabla de verdad de las funciones de salida S. Algunas funciones se propondrán
por el profesor en el salón.
ABC S1 S2 S3 S4 S5 S6
000 0 0 1
001 1 1 1
010 1 1 0
011 0 1 0
100 1 1 0
101 0 1 0
110 0 1 1
111 1 1 1

Antes de continuar, recordamos que los operadores para el manejo de bits son:

11
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Operadores VHDL Verilog

Lógicos AND, NAND, & and, ~& nand
OR, NOR, | or, ~| nor,
XOR, XNOR, ^ xor, ~^ xnor
NOT ~ not,
En condicionales:
“!” negación lógica
“&&“ AND lógica
“||” OR lógica
Aritméticos + signo positivo o suma dos números, + signo o suma, a = b + c;
a <= b + c; - signo o resta, a = b – c;
- signo negativo o resta dos números, * multiplicación, a = b * c;
a <= b - c; / división, a = b / c; (entero)
* multiplicación, a <= b * c; % módulo, a = b % c;
/ división, a <= b / c;
** exponencial
ABS() valor absoluto
MOD módulo
REM resto de la división
Relacionales =, /=, igualdad, desigualdad == igual, != diferente
Entregan un >, >=, mayor que, mayor o igual que, incluyendo “x” y “z”:
valor booleano <, <=, menor que, menor o igual que === igual,
(true o false) !== diferente
< menor que, <= menor o igual
que
> mayor que, >= mayor o igual
que
Desplazamientos SLL (Shift Left Logic) y SRL (Shift << Desplazamiento a
Right Logic) izquierda
SLA (Shift Left Arithmetic) y SRA >> Desplazamiento a derecha
(Shift Right Arithmetic)
ROL (ROtate Left) y ROR (ROtate
Right)
Otros & concatenación de vectores, A & B, {} Concatenación de
‘0’ & A. operandos, {a,b[3:0],c},
{3{a}} = {a,a,a}

? Condicional,
(condición) ? true_expr :
false_expr

Primera parte en VHDL:

(a) Abrir el programa “ISE Project Navigator” y crear un nuevo proyecto seleccionando
HDL (VHDL) y las características del componente a utilizar, por ejemplo, para la Nexys

12
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

2: Spartan 3E, XC3S500E, FG320, XST (VHDL/Verilog), ISim (VHDL/Verilog).

Escribir el código en VHDL para declarar las funciones solicitadas (S1, S2, S3, etc.).

A continuación, se muestra una forma de escribir el código en VHDL de las funciones

de la tabla 1.1. Para mayor información sobre las convenciones, estilos, sentencias y
estructuras, revisar el Apéndice A así como la bibliografía recomendada, al final de este
manual de prácticas. Todos los comentarios empiezan con dos guiones ‘--’ y pueden ir
en cualquier parte del código. VHDL es insensible a las mayúsculas y minúsculas, todas
las palabras reservadas (listadas en el Apéndice B) se pondrán en negritas para su mejor
visualización. En el Apéndice C se muestran las operaciones, operadores, puertos y tipos
de datos.

Nota: En el listado, los números del lado izquierdo no pertenecen al código en VHDL, solo
se utilizan para hacer una referencia a los renglones.

1 -- Declaración de las funciones de la tabla 1.1

2 -- Autor: Juan Antonio Jaramillo Gómez
3 library ieee; -- Declaración de la biblioteca
4 use ieee.std_logic_1164.all;
5 entity funciones is -- Declaración de la Entidad
6 port ( a,b,c: in std_logic; -- Declaración de los puertos de entrada
7 s1,s2,s3: out std_logic -- puertos de salidas
8 -- s4,s5,s6: OUT std_logic -- salidas propuestas por el equipo
9 );
10 end funciones; -- Fin de la entidad
11 -- La asignación de los pines se realiza con el programa PlanAhead o
12 -- con un archivo de restricciones de usuario *.ucf, con el siguiente formato:
13 -- net “nombre_pin” loc = “pin_FPGA” ;#comentario
14 Architecture a_func OF funciones IS --Declaración de la Arquitectura
15 begin
16 -- process (a,b,c) --Inicia el proceso
17 -- begin
18 S1 <= a xor b xor c; --xor
19 S2 <= a or b or c; --or
20 S3 <= a xnor b; --xnor
21 -- S4 <= …; --asignar otras funciones
22 -- S5 <= …; --
23 -- S6 <= …; --
24 -- end process; --Fin del proceso
25 end a_func; --Fin de la Arquitectura

El renglón 1 y 2 son de comentarios, y en casi todos los renglones existen comentarios.

13
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Los renglones 3 y 4 se utilizan para declarar la biblioteca ‘library’ a utilizarse, y no

siempre tiene que escribirse, solo cuando se necesiten datos de estas, como por ejemplo
las operaciones lógicas y aritméticas.
De la línea 5 a la 10 se declara la entidad ‘entity’ y de la 15 a la 24 se declara la
arquitectura ‘architecture’.

En la ENTIDAD: la línea 6 ‘port’ se utiliza para iniciar la declaración de los puertos o

señales físicas que irán conectadas al circuito. Posteriormente se declaran los nombres
de las señales (a, b, c, s1, s2, etc.) separados por comas y seguidos por dos puntos. A
continuación, se colocan los modos de las señales (in, out, inout y buffer) y los tipos
de datos (bit, bolean, bit_vector, integer, std_logic, std_logic_vector, etc.). La línea 9
muestra cómo se cierra la declaración de los puertos.

En las líneas 11 a 13 se comenta como se declaran los pines con un archivo de

restricciones de usuario para el ISE de Xilinx, y se utiliza QuartusII de Altera se escribe
un archivo *.csv (valores separados por comas) que se puede crear en Excell.

En la ARQUITECTURA: En la línea 14 se inicia la arquitectura, dándole un nombre y

se haciendo referencia a la entidad. En la línea 15 comienza ‘begin’ toda la arquitectura.

Las líneas 16 a 24 declaran un proceso, que para este caso no es necesario ponerse,
porque es una asignación con ecuaciones booleanas. En las líneas 18 a la 23 se declaran
dichas ecuaciones, haciendo notar el uso de asignación ‘<=’hacia la izquierda y
terminándola con punto y coma ‘;’. Y finalmente se termina con el comando ‘end
nombre_arquitectura’ en la línea 25.

(b) Generar el archivo de programación de las funciones, después de asignar los elementos
que se conectarán al FPGA (ver asignación de terminales). Programar el dispositivo con
el archivo *.bit para un FPGA o un archivo *.jed para un CPLD, ya sea desde el ISE de
Xilinx o bien desde el programa Adept de Digilent y probar el funcionamiento.

#######################################
## Asignación de terminales de la nexys2 ##
#######################################

#// interruptores SW0 a SW2

NET "a" LOC = "G18"; // SW0
NET "b" LOC = "H18"; // SW1
NET "c" LOC = "K18"; // SW2

#// leds LD0 a LD2

NET "S1" LOC = "J14"; // LD0
NET "S2" LOC = "J15"; // LD1
NET "S3" LOC = "K15"; // LD2
// NET "S4" LOC = "K14"; // LD3
// NET "S5" LOC = "E17"; // LD4
// NET "S6" LOC = "P15"; // LD5

14
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

// NET "S7" LOC = "F4"; // LD6

// NET "S8" LOC = "R4"; // LD7

(c) Con el simulador elegido, probar todos los cambios de las entradas y obtener la
simulación mostrada en la figura 1.7. En un reporte se editarán las fotos o imágenes con
texto explicativo.

Figura 1.7. Simulación de las tres entradas (a,b,c) para generar las salidas (s1,s2,s3).

Segunda parte en Verilog:

(a) Abrir el programa “ISE Project Navigator” y crear un nuevo proyecto seleccionando
HDL (Verilog), colocando las características del FPGA a utilizar (i.e. en la Nexys 2:
Spartan 3E, XC3S500E, FG320, XST (VHDL/Verilog), ISim (VHDL/Verilog)).
Escribir el código en Verilog en donde se declaran las entradas y salidas solicitadas.

Se muestra a continuación una forma de realizar el programa de las compuertas

empleando Verilog. Para mayor información sobre las convenciones, estilos, sentencias
y estructuras, revisar el Apéndice D así como la bibliografía recomendada, al final de
este manual de prácticas. Todos los comentarios empiezan con dos diagonales ‘//’ para
la línea y también con “/*” se abren los comentarios y con “*/” se cierran los
comentarios, pudiendo ir en cualquier parte del código. Verilog si es sensible a las
mayúsculas y minúsculas. En el Apéndice E se da una lista de todas las palabras
reservadas, aquí se muestran en negritas en el código para su mejor visualización. En el
Apéndice F se muestran las operaciones, operadores, puertos y tipos de datos para
Verilog.

Nota: En el listado, los números del lado izquierdo no pertenecen al código en Verilog, solo
se utilizan para hacer una referencia a los renglones.

1 // Declaración de las compuertas básicas

2 // Autor: Juan Antonio Jaramillo Gómez
3 module funciones (
4 input wire a, b, c, // Entradas a, b y c
5 output wire s1, // declaración de las salidas

15
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

6 output wire s2,

7 output wire s3
8 ); // completar las otras 3 salidas
9 assign s1 = a ^ b ^ c; // ^ sale con “AltGr”+ “{”
10 assign s2 = a | b | c; // | con “Alt” + “124” o la tecla al lado del 1
11 assign s3 = ~( a ^ b ); // ~ con “Alt” + “126” o con “AltGr” + “+”
12 endmodule

El renglón 1 y 2 se ponen comentarios, empiezan con doble diagonal “//”. Aunque

también se pueden colocar dentro de los símbolos diagonal “/” y asterisco “*” como se
muestra enseguida: /* comentarios */.

En el renglón 3 se abre el módulo “module” seguido del nombre del módulo. En el

renglón 4 se declaran las entradas “input” y van alambradas “wire”, enseguida del
renglón 5 al 7 se declaran las salidas “output”, también alambradas, y se cierra el módulo
en el renglón 8. Todas las entradas y salidas van separadas por comas dentro de los
paréntesis del módulo y se cierra con punto y coma.

De la 9 a la 11 se declaran las asignaciones con “assign” “variable_salida = función” y

se termina con punto y coma.

Y por último en la línea 14 se cierra el módulo con “endmodule”.

(b) Generar el archivo de programación de las funciones, después de asignar los elementos
que se conectarán al FPGA (ver asignación). Programar el dispositivo con el archivo
*.bit para un FPGA o un archivo *.jed para un CPLD, ya sea desde el ISE de Xilinx o
bien desde el programa Adept de Digilent y probar el funcionamiento.

#######################################
## Asignación de terminales de la nexys2 ##
#######################################

#// interruptores SW0 a SW2

NET "a" LOC = "G18"; // SW0
NET "b" LOC = "H18"; // SW1
NET "c" LOC = "K18"; // SW2

#// leds LD0 a LD2

NET "S1" LOC = "J14"; // LD0
NET "S2" LOC = "J15"; // LD1
NET "S3" LOC = "K15"; // LD2
// NET "S4" LOC = "K14"; // LD3
// NET "S5" LOC = "E17"; // LD4
// NET "S6" LOC = "P15"; // LD5
// NET "S7" LOC = "F4"; // LD6
// NET "S8" LOC = "R4"; // LD7

16
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

(c) Con el simulador elegido, probar todos los cambios de las entradas y obtener la
simulación, como se mostró en la figura 1.7. En un reporte se editarán las fotos o
imágenes con texto explicativo.

2. Escritura, simulación e implementación de los códigos en VHDL y Verilog para

programar un registro de 8 bits basado en el FF-D. Reportar códigos, simulación y fotos.
Writing, simulation and implementation of the codes in VHDL and Verilog to program
a 4-bit register based on the FF-D. Report codes, simulation and photographs.

(a) Abrir un proyecto en el “ISE Project Navigator” seleccionando HDL (primero VHDL y
en otro Verilog), poner las características del componente a utilizar y escribir los códigos
en los dos lenguajes para declarar el FF-D para sintetizarlos.

(b) Simular el funcionamiento del FF para obtener algo parecido a lo mostrado en la figura
1.8.

(c) Crear el archivo de restricciones de usuario y generar el archivo *.bit para programar el
dispositivo. Probar el funcionamiento en la tarjeta con el archivo *.bit, esto para ambos
lenguajes. En un reporte se colocan los códigos comentados y fotos editadas con texto
explicativo.

Figura 1.8. Simulación del FF tipo D.

Se muestra a continuación una forma de realizar un solo FF-D, tanto en VHDL como en
Verilog, así como la asignación de terminales para la Nexys 2.

-- Flip-flop tipo D
-- código en VHDL
library ieee;
use ieee.std_logic_1164.all;

entity ff_d is port (

d, clk: in std_logic;
q, q_bar: out std_logic);
end ff_d;

architecture ff_d of ff_d is

begin

17
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

--siempre que exista un flanco positivo en clk, se asigna d a q

process (clk)
begin
if rising_edge(clk) then
q <= d;
q_bar <= not d;
end if;
end process; --fin del proceso
end ff_d; --fin de la arquitectura

// Flip-flop tipo D
// código en Verilog
module ff_d (d, clk, q, q_bar);
input d, clk; //entradas
output q, q_bar; //salidas
wire d, clk; //entradas alambradas
reg q, q_bar; //salidas registradas

always @ (posedge clk) //siempre que hay un flanco positivo en clk

//se actualizan q, q_bar
begin
q = d;
q_bar = ! d;
end //se cierra el always
endmodule //se cierra el módulo del FF

#######################################
## Asignación de terminales de la nexys2 ##
#######################################

#// interruptores SW0 a SW2

NET "D" LOC = "G18"; // SW0

#// leds LD0 a LD2

NET "q" LOC = "J14"; // LD0
NET "q_bar" LOC = "J15"; // LD1

3. Escritura, simulación e implementación de los códigos en VHDL y Verilog para

programar un contador binario de 4 bits ascendente-descendente con interruptor de
dirección (1 cuenta ascendente, 0 cuenta descendente), botón de reset en bajo y un botón
de habilitación (inicio), con salida a display de 7 segmentos (0-9, A-F). Reportar códigos,
simulación y fotos.
Writing, simulation and implementation of the codes in VHDL and Verilog to program
an up-down binary 4-bit counter with address switch (1 up count, 0 count down), reset
button on bass and an enable button (start) with 7 seg display (0-9, A-F). Report codes,
simulation and photographs.

18
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

(a) Abrir un proyecto en el “ISE Project Navigator” seleccionando HDL (primero VHDL y
en otro Verilog), poner las características del componente a utilizar y escribir los códigos
en los dos lenguajes para declarar el contador binario.

(b) Simular el funcionamiento del contador y probar su funcionamiento en la tarjeta con el

archivo *.bit, esto para ambos lenguajes. En un reporte se colocan los códigos
comentados y fotos editadas con texto explicativo.

Se muestra a continuación una forma de realizar los programas de un contador binario

con habilitación y dirección (sin reset ni salida a display), tanto en VHDL como en
Verilog.

-- contador de 4 bits en VHDL

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity contador is port (

clk, hab, dir: in std_logic; -- reloj, habilitación y dirección
cnt: out std_logic_vector (3 downto 0):=x''0''); -- salida del contador binario de 4 bits
end contador;

architecture contador of contador is

signal cont: std_logic_vector (3 downto 0):=x''0''); -- señal de conteo
begin

process (clk)
begin
-- cada vez que existe un flanco de subida se realiza lo siguiente:
-- si hab = '1' contará según dir
-- si dir = '1' contará hacia arriba, si dir = '0' contará hacia abajo
if rising_edge(clk) then
if hab = '1' and dir = '1' cont <= cont + 1; -- cuenta ascendente
elsif hab = '1' and dir = '0' cont <= cont - 1; -- cuenta descendente
else cont <= cont;
end if;
end if;
cnt <= cont; -- se actualiza el contador cnt con la señal cont
end process; --fin del proceso

end contador; --fin de la arquitectura

// contador en Verilog
module contador (clk, hab, dir, cnt); //reloj, reset, habilitación, dirección, conteo
input clk, hab, dir; //entradas
output [3:0] cnt; //salidas

19
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

reg [3:0] cnt = 4'b0000; // Contador de 4 bits, comienza en 0

wire clk; // reloj
wire hab; // 0 desabilita el Contador, 1 lo habilita
wire dir; // 0 cuenta descendente, 1 cuenta ascendente

//si está habilitado hab = '1' se revisa dir, con dir = '1' cuenta ascendente
always @(posedge clk)
if (hab) cnt <= dir ? cnt+1 : cnt-1;
endmodule
/*otra forma de poner el always es:
always @(posedge clk)
if (hab == '0') cnt <= cnt;
else if (dir == '1') cnt <= cnt+1;
else cnt <= cnt-1;
*/

#######################################
## Asignación de terminales de la nexys2 ##
#######################################

//CLK reloj 50MHz

NET "CLK" LOC = "B8";

#// interruptores SW0 y SW1 para hab y dir

NET "hab" LOC = "G18"; // SW0
NET "dir" LOC = "H18"; // SW1

#//salida del contador a leds

NET "cnt<0>" LOC = "J14"; // LD0
NET "cnt<1>" LOC = "J15"; // LD1
NET "cnt<2>" LOC = "K15"; // LD2
NET "cnt<3>" LOC = "K14"; // LD3

Nota: se recomienda utilizar un divisor de frecuencia de 22 ó 23 bits para generar una

señal del orden de los Hz y así poder visualizar la salida.

20
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Figura 1.8. Simulación del Contador ascendente-descendente.

4. Implementar un circuito para tocar la sirena (i) de policía y (ii) de una ambulancia con
distintos barridos de tonos, controlando en encendido y apagado con un interruptor.
Reportar códigos y fotos.
Implement a circuit to play the siren of (i) police and (ii) an ambulance with different
sweeps of tones, controlling then on and off with a switch. Report codes and photos.

La salida tendrá que ir a un conector de expansión. La Nexys 2 tiene 4 conectores

llamados JA, JB, JC y JD, cada uno de ellos tiene 8 salidas. A continuación, se muestran
los terminales de salida JA:

// Pmod ALS en JA
NET "JA1" LOC = "L15"; // JA1
NET "JA2" LOC = "K12"; // JA2
NET "JA3" LOC = "L17"; // JA3
NET "JA4" LOC = "M15"; // JA4

5. Implementar el diseño de dos circuitos utilizando alto nivel (Top Level Design), uno
con VHDL y uno con Verilog. Reportar códigos y fotos. Nota: deben se distintos a los
otros puntos entregados.
Implement the design of two circuits using high level (Top Level Design), one with VHDL
and one with Verilog. Report codes and photos. Note: must be different to another point
reviewed.

6. Implementar con TLD un circuito de prueba del giro de un encoder mecánico rotatorio,
mostrado en las referencias y uno para el PmodALS. En caso de no tener los módulos
periféricos para implementar, realizar solo la simulación. Reportar códigos y fotos.

21
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Implement using TLD a test circuit for rotatory mechanical encoder, showing in
references and one for the PmodALS. If you do not have the peripheral modules, realize
only the simulation. Repor codes and photos.

7. Realizar sus comentarios y conclusiones (incluir en por lo menos un párrafo Gracias

“Gracias a esta práctica…”). Todos los códigos van en una sola columna con
comentarios, no en imagen.
Write your comments and conclutions. All the codes are written in one column with
comments, only text, not images.

NOTA: Respetar la numeración de cada punto de este formato en el reporte escrito [máximo
15 cuartillas si se entrega impreso (Letra Times New Roman de 12ptos, interlineado
sencillo)].

Proyectos opcionales utilizando PLDs y HDL.

Optional projects using PLDs and HDL.

Diseñar y construir un circuito con los 4 tipos de flip-flops.

Design and build a circuit with the 4 types of flip-flops.

Diseñar y construir un contador de década up-down para display jumbo.

Design and build an up-down decade counter for jumbo display.

Diseñar y construir un sistema de apertura y cierre de puertas automáticas.

Design and build a system for opening and closing automatic doors.

Diseñar y construir una ALU con 4 operaciones lógicas y 4 operaciones aritméticas, por lo
menos, manejando datos de nibles, bytes y words.
Design and build an ALU with 4 logical operations and 4 arithmetic operations, at least,
handling data of nibles, bytes and words.

Diseñar y construir un sistema para el control de encendido y apagado de luces exteriores.

Design and build a system to control on and off exterior lights.

Revisar y explicar el funcionamiento de los siguientes códigos escritos en Verilog y VHDL:

Review and explain the operation of the following codes written in Verilog and VHDL:

module xxx (c, r, h, d, cnt);

input c, h, d, r;
output [23:0] cnt;
reg [23:0] cnt = 24'd0;
wire c,r,h,d;

always @(posedge c)
if (r == 1) cnt <= 0;
else if(h) cnt <= d ? cnt+1 : cnt-1;

22
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

endmodule

module music(clk, speaker); //Police Siren

input clk;
output speaker;

reg [22:0] tone;

always @(posedge clk) tone <= tone+1;

wire [6:0] ramp = (tone[22] ? tone[21:15] : ~tone[21:15]);

wire [14:0] clkdivider = {2'b01, ramp, 6'b000000};

reg [14:0] counter;

always @(posedge clk) if(counter==0) counter <= clkdivider; else counter <= counter-1;

reg speaker;
always @(posedge clk) if(counter==0) speaker <= ~speaker;
endmodule

module music(clk, speaker); //Ambulance Siren

input clk;
output speaker;

reg [27:0] tone;

always @(posedge clk) tone <= tone+1;

wire [6:0] fastsweep = (tone[22] ? tone[21:15] : ~tone[21:15]);

wire [6:0] slowsweep = (tone[25] ? tone[24:18] : ~tone[24:18]);
wire [14:0] clkdivider = {2'b01, (tone[27] ? slowsweep : fastsweep), 6'b000000};

reg [14:0] counter;

always @(posedge clk) if(counter==0) counter <= clkdivider; else counter <= counter-1;

reg speaker;
always @(posedge clk) if(counter==0) speaker <= ~speaker;
endmodule

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity musicVHDL is -- Police Siren

port(
clk: in std_logic; --clock

23
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

speaker: out std_logic --speaker

);
end musicVHDL;

architecture music of musicVHDL is

--SIGNALS
signal spkr: std_logic;
signal tone: std_logic_vector(22 downto 0);
signal ramp: std_logic_vector(6 downto 0);
signal clkdivider: std_logic_vector(14 downto 0);
signal counter: std_logic_vector(22 downto 0);

begin -- begin architecture ------------------------------------

-- tono --
process (clk)
begin
if clk'event and clk='1' then
tone <= tone + '1';
end if;
end process;

-- rampa y divisor --
process (tone)
begin
if tone(22) = '1' then ramp <= tone(21 downto 15);
else ramp <= not(tone(21 downto 15));
end if;
clkdivider <= "01" & ramp & "000000";
end process;

--contador up-down --
process (clk)
begin
if clk'event and clk='1' then
if counter = x"00000"&"00" then counter <= "00000000" & clkdivider;
else counter <= counter - '1';
end if;
end if;
end process;

--contador up-down --
process (clk, spkr)
begin
if clk'event and clk='1' then
if (counter = x"00000"&"00") then spkr <= not spkr;

24
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

end if;
end if;
speaker <= spkr;
end process;

end music;

Pmod ALS

Pmod ALS, mostrado en la figura 1.9, utiliza el sensor TEMT6000X01 de Vishay

Semiconductor's y el ADC081S021 de 8 bits de Texas Instruments. Consultar las
especificaciones de los componentes.

Figura 1.9. Pmod ALS Módulo periférico con sensor de luz ambiental PmodALS, diagrama
esquemático y distribución de terminales.

El protocolo de comunicación empleado con la tarjeta es SPI de solo lectura, nunca se envía
información (datos) hacia el Pmod. Utiliza un ADC de 8 bits cuyo valor está relacionado al
nivel de luz ambiental.

Como se muestra en la figura 1.10, el dato viene conformado en una trama de 15 bits, siendo
los primeros 3 bits de valor cero, los bits del 4 al 11 son la información del nivel de luz con
el primer bit como MSB, los últimos 4 bits del 12 al 15 son ceros. Sin embargo, hay 16 pulsos
de reloj asociados con la operación de este Pmod. La comunicación comienza con un flanco
de bajada del selector del chip CS y la toma de datos se realiza con el siguiente flanco de
subida del reloj serial SCLK, es necesario dejar 50 ns o más para tQUIET esto para asegurar
una mejor conversión.

Figura 1.10. Diagrama de tiempos del control de la comunicación SPI.

25
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Para el manejo de los tiempos, se recomienda que el reloj serial corra entre 1 y 4 MHz con
un ciclo de trabajo del 50%.

-- PmodALS Ambient Light Sensor

-- SPI CONTROLLER

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity SPI_ctrl_ALS is

generic(
N : integer := 8; -- number of bit to serialize
MAX : integer := 333_333 -- number of us to sample
);
port (
--FPGA clock and button
clk : in std_logic; -- 50MHz
rst : in std_logic; -- reset
--PmodALS
CS : out std_logic; -- Pmod chip selec
SDO : in std_logic; -- Pmod Serial Data Output
SCK : out std_logic; -- Pmod Serial Clock
-- led output
data : out std_logic_vector(N-1 downto 0):=x"00"; -- received data
-- Display "abcdefgP"
DISPLAY: out STD_LOGIC_VECTOR(7 DOWNTO 0); -- segmentos del display
AN: out STD_LOGIC_VECTOR(3 DOWNTO 0):="0111" -- ánodos del display
);
end SPI_ctrl_ALS;
--------------------------------------------------------------------------------

architecture behav of SPI_ctrl_ALS is

--Declaración de señales para SPI

signal clkdiv : std_logic; -- divisor
signal counter : integer range 0 to MAX:=0; -- control counter
signal cnt : std_logic_vector(4 downto 0); -- divisor counter
signal tempo : std_logic_vector(0 to 15):=x"0000"; -- save data

--Declaración de señales de la asignación de U-D-C

signal P: std_logic_vector (9 DOWNTO 0); -- asigna UNI,DEC,CEN
signal UNI,DEC,CEN: std_logic_vector (3 DOWNTO 0); -- unidades, decenas, centenas

26
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

-- Declaración de señales de la multiplexación y asignación de U-D-C-UM al display

signal SEL: std_logic_vector (1 downto 0):="00"; -- selector de barrido
signal D: std_logic_vector (3 downto 0); -- sirve para almacenar los valores del display

-- Declaración de señales de los divisores

signal contadors: integer range 1 to 6250:=1; -- pulso1 de 0.25ms (pro. divisor ánodos)
-- para la nexys 2 6250, si se usa la nexys 3 cambiar a 12500
signal SAL_250us: std_logic; --

begin

--------------------------------------------------------------------------------
div : process(rst,clk,clkdiv,counter)
begin
-- divisor 1MHz (1us)
if(rst='1') then clkdiv <= '0';
elsif(rising_edge(clk)) then
if cnt = "11000" then cnt <= "00000"; -- 0 a 24
clkdiv <= not clkdiv; -- 0.5us alto, 0.5us bajo
else cnt <= cnt + '1';
end if;
end if;
SCK <= clkdiv;
end process div;

--------------------------------------------------------------------------------
cnter : process(rst,counter,clkdiv)
begin
-- divisor 1MHz (1us)
if(rst='1' or counter = MAX) then counter <= 0;
elsif(rising_edge(clkdiv)) then counter <= counter + 1 ;
end if;

end process cnter;

--------------------------------------------------------------------------------
receive : process(clkdiv,counter,tempo,SDO,rst)
begin
--
if(rst='1') then tempo <= (others => '0');
elsif(rising_edge(clkdiv)) then
case counter is
when 0 => CS <= '1';
when 1 => CS <= '1';
when 2 => CS <= '0';
when 3 => tempo(0) <= SDO; --0
when 4 => tempo(1) <= SDO; --0

27
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

when 5 => tempo(2) <= SDO; --0

when 6 => tempo(3) <= SDO; --DB7
when 7 => tempo(4) <= SDO; --DB6
when 8 => tempo(5) <= SDO; --DB5
when 9 => tempo(6) <= SDO; --DB4
when 10 => tempo(7) <= SDO; --DB3
when 11 => tempo(8) <= SDO; --DB2
when 12 => tempo(9) <= SDO; --DB1
when 13 => tempo(10) <= SDO; --DB0
when 14 => tempo(11) <= SDO; --0
when 15 => tempo(12) <= SDO; --0
when 16 => tempo(13) <= SDO; --0
when 17 => tempo(14) <= SDO; --0
when 18 => tempo(15) <= SDO; --tri state
when 19 => CS <= '1'; --
when others => CS <= '1'; --
end case;
end if;
data <= tempo (3 to 10);
end process receive;

----------- CONVERTIR DE BIN A BCD -----------------------------

-- utilizando shift and add
PROCESS(tempo(3 to 10))
VARIABLE C_D_U:STD_LOGIC_VECTOR(17 DOWNTO 0);
--18 bits para separar las Centenas-Decenas-Unidades
BEGIN

--ciclo de inicialización
FOR I IN 0 TO 17 LOOP --
C_D_U(I):='0'; -- se inicializa con 0
END LOOP;

C_D_U(7 DOWNTO 0):=tempo (3 to 10); --tempo de 8 bits

--ciclo de asignación C-D-U

FOR I IN 0 TO 7 LOOP

-- los siguientes condicionantes comparan (>=5) y suman 3

IF C_D_U(11 DOWNTO 8) > 4 THEN -- U

C_D_U(11 DOWNTO 8):= C_D_U(11 DOWNTO 8)+3;
END IF;

IF C_D_U(15 DOWNTO 12) > 4 THEN -- D

C_D_U(15 DOWNTO 12):= C_D_U(15 DOWNTO 12)+3;
END IF;

28
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

IF C_D_U(17 DOWNTO 16) > 4 THEN -- C

C_D_U(17 DOWNTO 16):= C_D_U(17 DOWNTO 16)+3;
END IF;

-- realiza el corrimiento
C_D_U(17 DOWNTO 1):= C_D_U(16 DOWNTO 0);
END LOOP;

P<=C_D_U(17 DOWNTO 8); -- guarda en P y en seguida se separan UM-C-D-U

END PROCESS;

--UNIDADES
UNI<=P(3 DOWNTO 0);
--DECENAS
DEC<=P(7 DOWNTO 4);
--CENTENAS
CEN<="00"&P(9 DOWNTO 8);

------------------- DIVISOR ÁNODOS ----------------------------------------

process (CLK) begin
if rising_edge(CLK) then
if (contadors = 6250) then --cuenta 0.125ms (50MHz=6250)
-- if (contadors = 12500) then --cuenta 0.125ms (100MHz=12500)
SAL_250us <= NOT(SAL_250us); --genera un barrido de 0.25ms
contadors <= 1;
else
contadors <= contadors+1;
end if;
end if;
end process; -- fin del proceso Divisor Ánodos

-------------------- MULTIPLEXOR ------------------------------------------

PROCESS(SAL_250us, sel, UNI, DEC,CEN)
BEGIN
IF SAL_250us'EVENT and SAL_250us='1' THEN SEL <= SEL+'1';
CASE(SEL) IS
when "00" => AN <="0111"; D <= UNI; -- UNIDADES
when "01" => AN <="1011"; D <= DEC; -- DECENAS
when "10" => AN <="1101"; D <= CEN; -- CENTENAS
when OTHERS=>AN <="1111"; -- OFF
END CASE;
end if;
END PROCESS; -- fin del proceso Multiplexor

29
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

-------------------- DISPLAY ------------------------------------------

PROCESS(D)
Begin
case(D) is -- abcdefgP
WHEN "0000" => DISPLAY <= "00000011"; --0
WHEN "0001" => DISPLAY <= "10011111"; --1
WHEN "0010" => DISPLAY <= "00100101"; --2
WHEN "0011" => DISPLAY <= "00001101"; --3
WHEN "0100" => DISPLAY <= "10011001"; --4
WHEN "0101" => DISPLAY <= "01001001"; --5
WHEN "0110" => DISPLAY <= "01000001"; --6
WHEN "0111" => DISPLAY <= "00011111"; --7
WHEN "1000" => DISPLAY <= "00000001"; --8
WHEN "1001" => DISPLAY <= "00001001"; --9
WHEN OTHERS => DISPLAY <= "11111111"; --apagado
END CASE;
END PROCESS; -- fin del proceso Display
------------------------------------------------------------------------------------------

end behav;

#######################################
## Asignación de terminales de la nexys2 ##
#######################################

//RESET--PUSH BUTTON
NET "RST" LOC = "H13"; // btn3 RST

//CLK reloj 50MHz

NET "CLK" LOC = "B8";

#//la nexys 2 habilita LD7 y LD6 pero al invertir el orden se corrige

NET "DATA<7>" LOC = "J14"; // LD0
NET "DATA<6>" LOC = "J15"; // LD1
NET "DATA<5>" LOC = "K15"; // LD2
NET "DATA<4>" LOC = "K14"; // LD3
NET "DATA<3>" LOC = "E17"; // LD4
NET "DATA<2>" LOC = "P15"; // LD5
NET "DATA<1>" LOC = "F4"; // LD6
NET "DATA<0>" LOC = "R4"; // LD7

// Pmod ALS en JA
NET "CS" LOC = "L15"; // JA1
#NET "NC" LOC = "K12"; // JA2
NET "SDO" LOC = "L17"; // JA3
NET "SCK" LOC = "M15"; // JA4

30
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

//DISPLAYS
NET "DISPLAY(7)" LOC = "L18"; // a
NET "DISPLAY(6)" LOC = "F18"; // b
NET "DISPLAY(5)" LOC = "D17"; // c
NET "DISPLAY(4)" LOC = "D16"; // d
NET "DISPLAY(3)" LOC = "G14"; // e
NET "DISPLAY(2)" LOC = "J17"; // f
NET "DISPLAY(1)" LOC = "H14"; // g
NET "DISPLAY(0)" LOC = "C17"; // P

//ANODOS
NET "AN(3)" LOC = "F17"; // AN0
NET "AN(2)" LOC = "H17"; // AN1
NET "AN(1)" LOC = "C18"; // AN2
NET "AN(0)" LOC = "F15"; // AN3

Probar los siguientes códigos y explicar su funcionamiento.

Test the next codes and exlain the function.

Código verilog
module FFD(d, clk, q); module FFDTL(ledq,swd,clock);
input d, clk; //entradas input clock;
output q; //salidas input wire [7:0] swd;
wire d, clk; //entradas alambradas output wire [7:0] ledq;
reg q; //salidas registradas
FFD U1
always @ (posedge clk) (.d(swd[0]),
begin .q(ledq[0]),
q = d; .clk(clock));
end
endmodule FFD U2
( .d(swd[1]),
.q(ledq[1]),
.clk(clock));

FFD U3
( .d(swd[2]),
.q(ledq[2]),
.clk(clock));

FFD U4
( .d(swd[3]),
.q(ledq[3]),
.clk(clock));

FFD U5
( .d(swd[4]),

31
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

.q(ledq[4]),
.clk(clock));

FFD U6
( .d(swd[5]),
.q(ledq[5]),
.clk(clock));

FFD U7
( .d(swd[6]),
.q(ledq[6]),
.clk(clock));

FFD U8
( .d(swd[7]),
.q(ledq[7]),
.clk(clock)
);
endmodule
Código vhdl
library IEEE; library ieee;
use ieee.std_logic_1164.all; use IEEE.STD_LOGIC_1164.ALL;

entity FF is port ( entity FlipFlop is port (

clk : in STD_LOGIC; clk : in STD_LOGIC;
d : in STD_LOGIC; swd : in STD_LOGIC_VECTOR(7 downto 0);
q : out STD_LOGIC); ledq : out STD_LOGIC_VECTOR(7 downto 0));
end FF; end FlipFlop;

architecture FFD of FF is architecture Behavioral of FlipFlop is

begin signal clock: STD_LOGIC;
process (clk) begin
begin clock <= clk;
if rising_edge(clk) then
q <= d; U1: entity [Link]
end if; port map( clk => clock,
end process; --fin del proceso d => swd(0),
end FFD; q => ledq(0) );

U2: entity [Link]

port map( clk => clock,
d => swd(1),
q => ledq(1) );

U3: entity [Link]

port map( clk => clock,

32
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

d => swd(2),
q => ledq(2) );

U4: entity [Link]

port map( clk => clock,
d => swd(3),
q => ledq(3) );

U5: entity [Link]

port map( clk => clock,
d => swd(4),
q => ledq(4) );

U6: entity [Link]

port map( clk => clock,
d => swd(5),
q => ledq(5) );

U7: entity [Link]

port map( clk => clock,
d => swd(6),
q => ledq(6) );

U8: entity [Link]

port map( clk => clock,
d => swd(7),
q => ledq(7) );
end Behavioral;

Referencias.
References.

Etapa de potencia, consultado enero-2023:

[Link]
[Link]
[Link]

Music box, consultado enero-2023, [Link]

[Link] [Link]
[Link]

Operadores de VHDL, consultado enero-2023:

[Link]
os_del_lenguaje#Operadores

Tutorial verilog, Operadores de Verilog pg. 15, consultado enero-2023:

33
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

[Link]

Naxeih M. Botros, HDL programming fundamentals VHDL and Verilog, Da Vinci

Engineering Press, Thomson 2006, pp. 7-15.

Código de prueba del encoder mecánico rotatorio PmodENC, consultado enero-2023:

[Link]

VHDL Predefined Attributes, consultado en enero-2023, disponible en:

[Link]

SPI: The serial peripheral interface, con sultado en enero-2023, disponible en:
[Link]
Bcharset%3DUTF-8

"Imprime la parte UPIITA a tu trabajo, busca información en la red y compártela

con tus compañeros".
Recuerda que:
"La práctica hace al maestro"

¡Si tienes alguna duda apóyate en tu profesor!

“Intercambia opiniones y experiencias con tus compañeros de grupo, acerca del

conocimiento que has adquirido después de haber finalizado la práctica.”

A continuación, se presenta una tabla para el registro de los puntos entregados en el

laboratorio de la práctica 1.
Next, a table is presented for the recording of the points delivered in the laboratory of the
practice 1.

34
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Tabla de registro para el trabajo de laboratorio (TL1).

Laboratory work register (LW1).

Laboratorio de Dispositivos Lógicos Programables

Práctica 1
Lab Tarjeta de desarrollo
DLP Pto 1 Pto 2 Pto 3 Pto 4 Pto 5/6 (Práctica guiada)
Func. TLD/
VHDL FF-D Cont. encoder Comments LW1
Nombre mesa Empresa Verilog HDL. HDL sirena PmALS Comentarios TL1 R1 P1
1
1
1
2
2
2
3
3
3
4
4
4
5
5
5
Fechas 4.5hr. 6ptos 6pts
1. Funciones de la tabla 1.1 escritas en HDL, simulación e implementación.
1. Table 1.1 write in HDL, simulation and implementation.
2. Implementación y simulación de un registro de 8 bits (FF D).
2. Implement and simulate a 8 bit register (FF-D).
3. Implementación y simulación de un contador UD de 4 bits,
salida a display de 7seg.
3. Implementation and simulation of a 4 bit UD counter, 7seg
display output.
4. Sirenas (policía, ambulancia) y etapa de potencia.
4. Sirens (pólice and ambulance) and power stage
5 circuitos en Top Level Design.
5 TLD circuits.
6 Encoder test. PmodALS.
6 Encoder test. PmodALS

35
 Prácticas de Laboratorio de Dispositivos Lógicos Programables .

Página dejada
en blanco

Page left
in blank

36