FINAL - Manual - Practicas Sistemas Dig I PDF

!
! !
!
MANUAL DE PRÁCTICAS DE
SISTEMAS DIGITALES I
MC. Manuel Jesús López Sánchez

Dr. Alejandro Arturo Castillo Atoche
Agosto-Diciembre 2012
!
!
!
!
!
!
!
!
RESUMEN!DEL!MANUAL!DE!PRÁCTICAS!
!
En! este! documento! se! presenta! la! descripción! del! Manual! de! Prácticas!
de!la!asignatura!“Sistemas(Digitales(I”!,!del!plan!de!estudios!de!Ingeniería!
en!Mecatrónica!de!la!Facultad!de!Ingeniería!de!la!Universidad!Autónoma!
de! Yucatán.! El! contenido! del! presente! documento! abarca! todos! los!
temas!de!la!carta!descriptiva!de!la!asignatura.!
!
ACERCA!DE!LOS!LABORATORIOS!PROPUESTOS!
!
Se!proponen!14!laboratorios!para!el!presente!curso.!Estos!cursos!están!
orientados!a!utilizar!la!mejor!tecnología!disponible!utilizando!circuitos!
integrados! reconfigurables! como! es! el! Arreglo! de! Compuertas! en! el!
campo!(FPGA,!por!sus!siglas!en!inglés).!Desde!el!Lab.!1!hasta!el!Lab.!14,!
los! alumnos! utilizarán! todos! las! herramientas! software! (síntesis,!
verificación!funcional!mediante!camas!de!prueba,!etc.),!necesarias!para!
realizar!los!laboratorios!propuestos.!Estos!laboratorios!se!realizarán!en!
trabajo!de!equipo,!pudiendo!integrarse!hasta!un!máximo!de!3!alumnos.!
!
REPORTE!DE!LABORATORIO!
!
Los!equipos!de!trabajo!deberán!entregar!un!reporte!técnico!de!cada!una!
de! las! prácticas! realizadas.! Al! menos! dos! de! los! reportes! deben! ser!
escritos! en! el! idioma! inglés.! Adicionalmente,! los! alumnos! tendrán! que!
sintetizar!su!reporte!bajo!el!siguiente!criterio:!el!documento!debe!ser!a!
doble! columna! con! un! mínimo! de! letra! de! Times! 10,! debe! contener! un!
resumen! general! que! describa! en! máx.! 150! palabras! que! es! lo! que! se!
realizó! en! la! práctica,! la! introducción! debe! contener! el! estado! del! arte!
del! tema! propuesto! y! debe! describir! el! objetivo! de! la! práctica.! En! el!
desarrollo! se! presentará! la! metodología! utilizada! para! implementar! la!
práctica!donde!incluirán!gráficas,!!esquemas,!tablas,!etc.!La!longitud!del!
documenta! será! máximo! de! 2! páginas.! Entregar! el! reporte! en! formato!
digital!(paperless)!!
!
EVALUACIÓN!DEL!LABORATORIO!
!
Práctica:!80%!!!Reporte:!20%!
!
!
!
ÍNDICE!GENERAL!
!
Lab!1.!Compuertas!lógicas.! 1!
1.1 Objetivo!
1.2 Justificación!
!
1.3 Introducción!
1.4 Herramientas!y!material!requerido!
1.5 Ejemplo!demostrativo!
1.6 Instrucciones!del!laboratorio!
Lab!2.!Demostración!del!Teorema!de! 7!
DeMorgan.! !
2.1 Objetivo!
2.2 Justificación!
2.3 Introducción!
Lab!3.!Minimización!de!funciones.! 12!
3.1 Objetivo!
3.2 Justificación!
3.3 Introducción!
Lab!4.!Diseño!de!sistemas! 20!
combinacionales!usando!Mapas!de!
Karnaugh:!Elevar!un!número!binario!
de!3bits!al!cuadrado.!
4.1 Objetivo!
4.2 Justificación!
4.3 Introducción!
Lab!5.!Decodificador!BCD!a!7! 25!
segmentos!en!FPGA.!
5.1 Objetivo!
5.2 Justificación!
5.3 Introducción!
Lab!6.!Sumador!binario!en!FPGA.! 35!
6.1 Objetivo!
6.2 Justificación!
6.3 Introducción!
Lab!7.!Sumador!binario!en!FPGA.! 45!
7.1 Objetivo!
7.2 Justificación!
7.3 Introducción!
Lab!8.!Multiplicador!binario.! 56!
8.1 Objetivo!
8.2 Justificación!
8.3 Introducción!
Lab!9.!Mux,!Demux,!Decodificadores! 63!
en!FPGAs.!
9.1 Objetivo!
9.2 Justificación!
9.3 Introducción!
Lab!10.!Registros.! 75!
10.1 Objetivo!
10.2 Justificación!
10.3 Introducción!
Lab!11.!Contadores!binarios!en! 83!
FPGAs.!
11.1 Objetivo!
11.3 Introducción!
Lab!12.!Cronómetro.! 92!
12.1 Objetivo!
12.3 Introducción!
Lab!13.!Control!de!velocidad!de!un! 99!
motor!DC!con!PWM!
13.1 Objetivo!
13.3 Introducción!
!
!
!
!
!
!
ÍNDICE!DE!FIGURAS!
!
Fig.!1.1.!!Símbolos!de!las!compuertas!lógicas!básicas:!!!!!!!!!
(a)!AND;!(b)!OR;!(c)!NOT.!
1!
Fig.!1.2.!Símbolo!de!las!compuertas!lógicas:!(a)!NAND;!(b)!
NOR;!(c)!XOR;!(d)!XNOR.!
1!
Fig.!1.3!Código!en!VHDL!utilizado!que!describe!a!una!
compuerta!AND!de!dos!entradas!
3!
Fig.!1.4.!Diagrama!lógico!obtenido!de!la!síntesis!del!código!
utilizada!para!describir!una!compuerta!AND!de!dos! 3!
entradas.!
Fig.!1.5.!Código!!para!implementar!la!simulación!por!
software!de!la!compuerta!lógica!AND!
3!
Fig.!1.6.!Formas!de!onda!obtenidas!en!el!simulador!ISim!
que!corresponden!a!la!compuerta!lógica!AND.!
4!
Fig.!1.7.!Dispositivos!conectados!al!FPGA!Spartan!3E!en!la!
tarjeta!Basys!de!Digilent.!(Imagen!tomada!de! 4!
www.digientinc.com).!
Fig.!1.8!!Ubicación!de!los!LEDs!y!de!los!interruptores!en!la!
tarjeta!Basys.!
5!
Fig.!1.9.!Listado!del!archivo!UCF!para!definir!las!conexiones!
de!la!compuerta!AND!implementada!
5!
! !
Fig.!2.1!Comprobación!del!Teorema!de!Karnaugh!utilizando!
tablas!de!verdad.!
7!
Fig.!2.2.!Implementación!de!los!operadores!lógicos!
utilizando!únicamente!compuertas!NAND!y!NOR.!
8!
Fig.!2.3!Implementación!en!código!VHDL!de!las!funciones!
equivalentes!del!teorema!de!DeMorgan.!
9!
Fig.!2.4.!Síntesis!del!código!del!código!de!las!funciones!de!
las!funciones!equivalentes!del!teorema!de! 9!
DeMorgan.!
Fig.!2.5.!Código!para!!describir!el!test!bench!para!las!
funciones!equivalentes!por!el!teorema!de! 10!
DeMorgan.!
Fig.!2.6.!Simuación!del!testbench!para!las!funciones!
equivalentes!por!el!teorema!de!DeMorgan.!
10!
!
!
Fig.!3.1.!Mapas!de!Karnaugh,!(a)!de!dos!variables,!(b)!de!
tres!variables!y!(c)!de!cuatro!variables.!
13!
Fig.!3.2.!Mapa!de!F = ab + a b + c + b b + c ! 14!
Fig.!3.3.!Mapa!de!F = ab + a b + c + b b + c ! 15!
Fig.!3.4.!!Código!en!VHDL!utilizado!para!implementar!la!
función!original!del!ejemplo!1.!
15!
Fig.!3.5.!!Listado!del!testbench!para!el!ejemplo!1.! 16!
Fig.!3.6.!Formas!de!onda!obtenidas!en!el!simulador!Isim!
para!la!función!original!del!ejemplo!1.!
17!
Fig.!3.7.!Lisado!para!implementar!la!función!minimizada!el!
ejemplo!1.!
17!
Fig.!3.8.!Listado!del!archivo!UCF!para!el!ejemplo!1.! 17!
Fig.!3.9.!!Diagrama!del!ejercicio!1!a!simplificar.! 18!
! !
Fig.!4.1.!Sistema!Combinacional.! 20!
Fig.!4.2.!!Tabla!de!verdad!de!la!función!booleana! 22!
Fig.!4.3.!!Karnaugh:!(a)!función!booleana!con!minitérminos,!
(b)!función!booleana!con!maxitérminos!
22!
! !
Fig.!5.1.!Display!de!siete!segmentos.! 25!
Fig.!5.2.!Diagrama!esquemático!del!FPGA!Basys!con!el!
display!de!siete!segmentos.!
26!
Fig.!5.3.!Tabla!de!verdad!para!el!segmento!‘a’.! 28!
Fig.!5.4.!!Karnaugh:!(a)!cuadrantes!con!los!valores!XqNo!
importa,!(b)!agrupaciones!
29!
! !
Fig.!6.1.!Tabla!de!verdad!y!circuito!de!la!suma!aritmética!de!
un!HA.!
36!
Fig.!6.2.!Tabla!de!verdad!y!circuito!del!FA.! 37!
Fig.!6.!3.!Reducción!de!la!función!acarreo!del!FA.! 38!
Fig.!6.4.!Código!VHDL!del!FA.! 39!
Fig.!6.5.!!Módulo!Top!del!sumador!de!4!bits.! 40!
Fig.!6.6.!!Diagrama!esquemático!del!Sumador!de!4!bits!con!
decodificador!de!7!segmentos!
41!
Fig.!6.7.!!Diagrama!esquemático!sugerido!para!el!Sumador!
4!bits!con!HAs!
41!
Fig.!6.8.!Dispositivos!conectados!al!FPGA!Spartan!3E!en!la! 43!
tarjeta!Basys!de!Digilent.!(Imagen!tomada!de!
!
Fig.!7.1.!Suma!de!dos!números!binarios!de!4!bits.! 46!
Fig.!7.2.!Numeración!en!complemento!a!2.! 47!
Fig.!7.3.!!Diagrama!esquemático!del!Sumador/Restador!de!
4!bits.!
53!
! !
Fig.!8.1.!Ejemplo!de!la!multiplicación!binaria!de!dos!
números!de!4!bits.!
56!
Fig.!8.2.!Arquitectura!1,!para!el!multiplicador!
combinacional!de!4!bits.!
57!
Fig.!8.3.!Bloques!utilizados!para!la!arquitectura!2.! 58!
Fig.!8.4!Arquitectura!2,!para!el!multiplicador!combinacional!
de!4!bits.!
58!
Fig.!8.5.!Código!VHDL!para!la!arquitectura!1!del!
multiplicador!de!4!bits.!
59q60!
Fig.!8.6.!Estructura!de!archivos!del!multiplicador!de!4!bits.! 60!
Fig.!8.7.!!Código!VHDL!del!testbench!del!multiplicador!de!4!
bits.!
61!
Fig.!8.8.!Señales!obtenidas!en!la!simulación!del!
multiplicador!(a)!en!binario!(b)!en!decimal.!
62!
! !
Fig.!9.1.!Decodificador!2q4:!(a)!símbolo!esquemático,!(b)!
tabla!de!verdad,!y!(c)!diagrama!lógico.!
65!
Fig.!9.2.!Codificador! 66!
Fig.!9.3.!Mux!8q1:!(a)!tabla!de!verdad,!(b)!diagrama!lógico.! 67!
Fig.!9.4.!Comparativo!de!un!Mux!y!Demux.! 67!
Fig.!9.5.!Código!VHDL!del!Mux!usando!case.! 68!
Fig.!9.6.!Código!VHDL!del!Mux!usando!if!else!if.! 69!
Fig.!9.7.!Código!VHDL!del!Mux!usando!when!else.! 70!
Fig.!9.8.!Código!VHDL!del!Mux!usando!with!select.! 70!
Fig.!9.9.!Diagrama!esquemático!propuesto.! 72!
!
Fig.!10.1.!Registro!de!4!bits.! 76!
Fig.!10.2!Registro!con!carga!en!paralelo!con!flipqflops!D.! 76!
! ! Fig.!10.3.!Registro!con!carga!de!datos!en!serie.! 77!
Fig.!10.4.!Registro!de!desplazamiento!bidireccional!de!4!bit!
con!carga!en!paralelo.!
78!
Fig.!10.5.!Código!en!VHDL!con!la!descripción!del!flipqflop!D.! 79!
Fig.!10.6.!Esquemático!obtenido!de!la!síntesis!del!código!del!
flipqflop!D.!
80!
Fig.!10.7.!Código!del!test!bench!para!realizar!la!simulación!
del!flipqflop!D.!
81!
Fig.!10.8.!Resultado!de!la!simulación!del!flipqflop!tipo!D.! 81!
!
!
Fig.!11.1.!Transiciones!de!estado!del!contador!binario!de!3!
bits.!
84!
Fig.!11.2.!Transiciones!del!contador!binario!usando!flipq
flops!JK.!
84!
Fig.!11.3.!Funciones!lógicas!para!el!diseño!del!contador!
binario.!
85!
Fig.!11.4.!Contador!binario.! 85!
Fig.!11.5.!Código!VHDL!del!contador!4!bits.! 86!
Fig.!11.6.!Simulación!del!diseño!del!contador!4!bits.! 87!
Fig.!11.7.!Diseño!e!implementación!del!módulo!divisor!de!
frecuencia!
87!
Fig.!11.8.!Diagrama!esquemático!propuesto!para!el!
laboratorio.!
88!
! !
Fig.!12.1.!Estructura!de!los!contadores!del!cronómetro.! 93!
Fig.!12.2.!Control!del!multiplexado!de!los!displays!de!7!
segmentos.!
94!
Fig.!12.4.!Código!VHDL!con!el!instanciado!de!dos!
contadores!para!la!cuenta!de!0!a!59!segundos.!
96!
Fig.!12.5!Código!VHDL!del!testbench!para!el!contador!de!0!a!
59!segundos.!
97!
Fig.!12.6!Señales!obtenidas!en!el!simulador!donde!se!
muestra!la!cuenta!de!0!a!16!segundos.!
97!
Fig.!12.7!Señales!obtenidas!en!el!simulador!donde!se!
muestra!la!cuenta!de!35!a!59!segundos.!
97!
! !
Fig.!13.1.!Señal!PWM.! 100!
Fig.!13.2.!Control!de!la!velocidad!de!un!motor!DC!con!PWM.! 100!
Fig.!13.3.!PWM!con!3!bits!de!resolución.! 101!
Fig.!13.4.!Circuito!electrónico!de!potencia.! 102!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
! !
ÍNDICE!DE!TABLAS!
!
Tabla.!1.1.!!Tabla!1.1.!Tablas!de!verdad!de!las!compuertas!
lógicas.!
2!
Tabla!3.1.!Postulados!y!teoremas!del!álgebra!de!Boole.! 12!
Tabla!3.2.!Tabla!de!verdad!de!F=ab+a(b+c)+b(b+c)! 14!
!
Manual de Prácticas de Sistemas Digitales I 1
Lab.%1.%Compuertas%Lógicas%
1.1%Objetivo%
El objetivo de esta práctica de laboratorio es comprobar las funciones lógicas básicas
del algebra de Boole, mediante simulaciones realizadas por software así como su posterior
implementación y verificación en un dispositivo denominado “arreglo de compuertas
programable en el campo” (FPGA, por sus siglas).
1.2%Justificación%
Esta práctica de laboratorio cumple con el objetivo específico (ver carta descriptiva
de la asignatura) del siguiente tema:
- Unidad 2
- Sub-tema 2.1
1.3 Introducción
Las compuertas lógicas son las implementaciones físicas de los operadores lógicos,
estos dispositivos constituidos internamente por transistores que actúan como pequeños
interruptores electrónicos con el propósito de manejar señales eléctricas de entrada y salida
equivalentes al ‘1’ lógico y al ‘0’ lógico. De esta forma tenemos las compuertas lógicas
AND, OR y NOT, correspondientes a los operadores lógicos básicos AND, OR y NOT. En
la Fig. 1.1 se muestran los símbolos utilizados para representar cada una de estas.
(a) (b) (c)

Fig. 1.1. Símbolos de las compuertas lógicas básicas: (a) AND; (b) OR; (c) NOT.
Además de estas compuertas básicas existen otras variantes frecuentemente utilizadas

dentro de los circuitos digitales estas son: la compuerta NAND, la compuerta NOR, la
compuerta OR exclusiva (XOR) y la compuerta NOR exclusiva (XNOR). En la Fig. 1.2 se
muestran los símbolos de estas compuertas.
(a) (b) (c) (d)

Fig. 1.2. Símbolo de las compuertas lógicas: (a) NAND; (b) NOR; (c) XOR; (d) XNOR.
Las tablas de verdad de las compuertas lógicas se muestran en la Tabla 1.1.
MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

AND OR NOT NAND
! ! ! =!∙! ! ! ! =!+! ! !=! ! ! ! =!∙!

0 0 0 0 0 0 0 1 0 0 1
0 1 0 0 1 1 1 0 0 1 1
1 0 0 1 0 1 1 0 1
1 1 1 1 1 1 1 1 0
NOR XOR XNOR Buffer
! ! ! =!∙! ! ! ! =!∙! ! ! ! =!∙! ! !=!

0 0 1 0 0 0 0 0 1 0 0
0 1 0 0 1 1 0 1 0 1 1
1 0 0 1 0 1 1 0 0
1 1 0 1 1 0 1 1 1
Tabla 1.1. Tablas de verdad de las compuertas lógicas.
1.4%Herramientas%y%materiales%requeridos%
El material y las herramientas (software) requeridas para poder implementar el ejemplo
demostrativo de la sección 1.5, se presentan a continuación.
• Computadora con los paquetes de software Xilinx ISE Design Suite y Digilent
Adept precargados.
• Tarjeta Digilent Basys ó Digilent Nexys 3.
1.5%Ejemplo%%demostrativo%
Con este ejemplo demostrativo se presenta el procedimiento utilizado para implementar el
laboratorio propuesto:
1. Mediante el uso del programa Project Navigator que forma parte del paquete de
software Xilinx ISE Design Suite, crea un nuevo proyecto y se agrega un nuevo
archivo de texto con el código VHDL que se muestra en la figura x.x, el cual
describe a un componente llamado compuerta_AND que posee dos entradas y una
salida, todas de tipo BIT y cuya función de salida “f” está dada por la operación
lógica AND de las entradas “x” y “y”.
1 ----------------------------------------------
2 ENTITY compuerta_AND IS
3 PORT ( x : IN BIT;
4 y : IN BIT;
5 f : OUT BIT );
6 END compuerta_AND;
7 -----------------------------------------------
8 ARCHITECTURE rtl OF compuerta_AND IS
9 BEGIN
10 f <= x AND y;

11 END rtl;
12 -----------------------------------------------
Fig. 1.3 Código en VHDL utilizado que describe a una compuerta AND de dos entradas.
2. Realice la síntesis del código y verifique el diagrama esquemático RTL del código
el cual debe coincidir con el mostrado en la figura.
Fig. 1.4. Diagrama lógico obtenido de la síntesis del código utilizada para describir una compuerta
AND de dos entradas.
3. Agregue un nuevo archivo de texto a l proyecto que contenga el código que se

muestra en la Fig. 1.5.
1 ------------------------------------------------------------
2 ENTITY Compuerta_AND_testbench IS
3 END ENTITY Compuerta_AND_testbench;
4 ------------------------------------------------------------
5 ARCHITECTURE rtl OF compuerta_AND_testbench IS
6 COMPONENT compuerta_AND IS
7 PORT ( x : IN BIT;
8 y : IN BIT;
9 f : OUT BIT );
10 END COMPONENT;
11 SIGNAL x: BIT;
12 SIGNAL y: BIT;
13 SIGNAL f: BIT;
14 BEGIN
15 compuerta_01: compuerta_AND port map ( x => x,
16 y => y,
17 f => f);
18 x <= '0', '1' after 100 ns;
19 y <= '0', '1' after 50 ns, '0' after 100 ns, '1' after 150 ns;
20
21 END rtl;
22 --------------------------------------------------------------
Fig. 1.5. Código para implementar la simulación por software de la compuerta lógica AND.
4. Seleccione el menú de simulación en la venta del Project Navigator y corra la

simulación descrita en el test bench realizado en el apartado anterior. Una vez
abierto el simulador ajuste la escala de tiempo y deberá observar las formas de onda

mostradas en la Fig. 1.6. Verifique que estas corresponde al comportamiento de la

compuerta AND.
Fig. 1.6. Formas de onda obtenidas en el simulador ISim que corresponden a la compuerta lógica AND.
5. Para llevar a cabo la implementación física del circuito en el FPGA que se

encuentra en la tarjeta Basys, se requiere agregar el archivo de restricciones de
usuario (UCF por sus siglas en ingles), el cual define las conexiones entre las
entradas y las salidas del circuito diseñado hacia los pines del FPGA; en la tarjeta
Basys existen un conjunto de dispositivos de entrada y salida, como se muestra en la
Fig. 1.7, por lo que hay que seleccionar estos pines del FPGA de acuerdo al
dispositivo de entrada o salida que nos sea conveniente para realizar nuestras
pruebas, para esta práctica seleccionaremos los interruptores y los LEDs mostrados
en la Fig. 1.8. La Fig. 1.9 se muestra el listado del archivo UCF donde se han
seleccionado los interruptores SW0 y SW1 como entradas y el LED LD0 como
salida. Agregue este archivo al proyecto y posteriormente genere el archivo de
programación.
Fig. 1.7. Dispositivos conectados al FPGA Spartan 3E en la tarjeta Basys de Digilent. (Imagen tomada
de www.digientinc.com).

FPGA
LEDs
Interruptores
Fig. 1.8 Ubicación de los LEDs y de los interruptores en la tarjeta Basys.
1 NET "x" LOC = P36; #entrada x conectada al Interruptor SW1

2 NET "y" LOC = P38; #entrada y conectada al Interruptor SW0
3 NET "f" LOC = P15; #salida f conectada al LED LD0
Fig. 1.9 Listado del archivo UCF para definir las conexiones de la compuerta AND implementada.
6. Lleve a cabo la programación de la tarjeta Basys descargando el archivo de programación a

la tarjeta utilizando el programa Adept de Digilent. Una vez programado el FPGA pruebe
todas las combinaciones de entrada cambiando las posiciones de los interruptores SW0 y
SW1 y verifique la salida en el led LD0.
1.6%Instrucciones%del%laboratorio%
PARTE I. Implementación en el FPGA

Implementar el diseño digital de funciones lógicas en el FPGA seleccionado, siguiendo el
procedimiento descrito en el “ejemplo demostrativo de la sección 1.5”. Particularmente, las
siguientes tareas deben llevarse a cabo.
a) Implementar los códigos en VHDL para describir las siguientes compuertas

lógicas:
i. OR,
ii. NOT,
iii. NAND,
iv. NOR,
v. XOR,
vi. XNOR.

b) Realizar la síntesis del código VHDL y verifique que el diagrama lógico, del
circuito obtenido, corresponda a la función lógica que se describe.
c) Implementar el código para realizar las simulaciones de cada una de las
compuertas lógicas.
PARTE II. Análisis del desempeño de las arquitecturas en el FPGA
d) Después del proceso de síntesis:
Copie la imagen de las formas de onda para su reporte y verifique que correspondan a
las funciones lógicas implementadas.
e) Desarrollar la cama de prueba (testbench) de cada implementación y verificar

funcionalmente el resultado de cada función lógica.
f) Implementar cada una de las funciones lógicas en la tarjeta Digilent Basys.
Visualizar con leds si se cumple la tabla de verdad de cada función lógica,
además de la validación con su correspondiente simulación.
g) Analizar el desempeño en términos de su área, después del proceso de síntesis.
Responder lo siguiente para cada función lógica:
¿Cuál es la cantidad de LUTs utilizados en la síntesis?___________________
¿ Cuál es la cantidad de FlipFlops s utilizados en la síntesis?___________________
¿Cuál es la cantidad de IOBs utilizados en la síntesis?___________________
¿Cuál es el procentaje total de compuertas lógicas utilizados en el

diseño?_________________
Anoten sus conclusiones finales

Lab.%2.%Demostración%del%Teorema%de%DeMorgan%
2.1%Objetivo%
El objetivo de este laboratorio es verificar el teorema de DeMorgan del algebra
Booleana. Después de su realización, tendrás la capacidad de simplificar expresiones
Booleanas aplicando los teoremas de DeMorgan.
2.2%Justificación%
Esta práctica de laboratorio cumple con el objetivo específico de la unidad 1 y
abarca los sub-temas 1.2 y 1.3.
2.3%Introducción%
DeMorgan propuso dos teoremas que son una parte importante del algebra Boolena,
en términos prácticos, estos teoremas establecen la equivalencia entre la operación lógica
NAND y la operación lógica OR con las entradas negadas, mediante la negación de sus
entradas:
Teorema 1. El complemento de un producto es igual a la suma de sus complementos.
!" = ! + !
Teorema 2. El complemento de una suma es igual al producto de sus complementos.
! + ! = !!
Comprobación de los teoremas utilizando la tabla de verdad:
Fig. 2.1 Comprobación del Teorema de Karnaugh utilizando tablas de verdad.
Estos teoremas son de mucha importancia ya que son de gran utilidad en la

simplificación de funciones. Además podemos observar en estas transformaciones que es
MC. Manuel Jesús López Sánchez Lab. 2. Demostración del Teorema de

Dr. Alejandro Arturo Castillo Atoche DeMorgan
posible implementar cualquier función lógica utilizando únicamente compuertas NAND o

NOR, como se muestra en la Fig. 2.2.
Fig. 2.2. Implementación de los operadores lógicos utilizando únicamente compuertas NAND y NOR.

Adept precargados.
A continuación se presenta como ejemplo para la realización de este laboratorio, la
comprobación del teorema 1, realizando utilizando como herramientas la simulación de las
funciones lógicas equivalentes y su posterior implementación en el FPGA. En la Fig. 2.3,
se muestra el código en VHDL en el cual se describe un componente con dos entradas y
dos salidas, todas de tipo bit. La función de de la salida x corresponde a la función lógica
NAND y la función y es la operación OR entre las señales de entrada negadas. Agregue
este archivo de texto previamente guardado con extensión .vhd ó .vhdl.
1 ----------------------------------------
2 ENTITY DeMorgan_01 IS
3 PORT ( a : IN BIT;
4 b : IN BIT;
5 x : OUT BIT;
6 y : OUT BIT );
7 END DeMorgan_01;
8 ----------------------------------------
9 ARCHITECTURE rtl OF DeMorgan_01 IS
10 BEGIN
11 x <= a NAND b;
12 y <= (NOT (a)) OR (NOT(b));
13 END rtl;
14 -----------------------------------------
Fig. 2.3 Implementación en código VHDL de las funciones equivalentes del teorema de DeMorgan.
Realice la síntesis del código y verifique el esquemático del circuito obtenido, el cual
se muestra en la Fig. 2.4.
Fig. 2.4. Síntesis del código del código de las funciones de las funciones equivalentes del teorema de
DeMorgan.

Agregue el archivo para llevar a cabo el test bench que se muestra en la Fig. 2.5.
1 ------------------------------------------------------------
2 ENTITY DeMorgan_01_testbench IS
3 END ENTITY DeMorgan_01_testbench;
4 ------------------------------------------------------------
5 ARCHITECTURE rtl OF DeMorgan_01_testbench IS
6 COMPONENT DeMorgan_01 IS
8 b : IN BIT;
9 x : OUT BIT;
10 y : OUT BIT );
11 END COMPONENT;
12 SIGNAL a: BIT;
13 SIGNAL b: BIT;
14 SIGNAL x: BIT;
15 SIGNAL y: BIT;
16 BEGIN
17 CIRCUITO_01: DeMorgan_01 port map ( a => a,
18 b => b,
19 x => x,
20 y => y );
21 a <= '0', '1' after 100 ns;
22 b <= '0', '1' after 50 ns, '0' after 100 ns, '1' after 150 ns;
23 END rtl;
24 --------------------------------------------------------------
Fig. 2.5. Código para describir el test bench para las funciones equivalentes por el teorema de
DeMorgan.
Al ejecutar la simulación descrita en el test bench se obtienen las siguientes formas

que permiten verificar la equivalencia de las funciones descritas en el teorema 1 de
DeMorgan.
Fig. 2.6. Simuación del test bench para las funciones equivalentes por el teorema de DeMorgan.


a) Implementar los códigos en VHDL para describir las funciones lógicas descritas
en el teorema 2 de DeMorgan.
b) Genere el código para el test bench y realice la simulación, copie las formas de
onda para su reporte. Verifique que la equivalencia entre las funciones.
c) Cree el archivo .UCF y programe la tarjeta basys para verificar los resultados de
la simulación.
d) Implemente cada una de las funciones lógicas utilizando primero únicamente
compuertas NAND y posteriormente compuertas NOR, tal como se describe en
la Fig. 2.2.
e) Implemente el test bench y verifique la equivalencia de los circuitos
implementados con la función lógica equivalente.
f) Después del proceso de síntesis:
g) Desarrollar la cama de prueba (testbench) de cada implementación y verificar

h) Implementar cada una de las funciones lógicas en la tarjeta Digilent Basys.
i) Analizar el desempeño en términos de su área, después del proceso de síntesis.

diseño?_________________

Lab.%3.%Minimización%de%funciones%
3.1%Objetivo%
El objetivo de esta práctica de laboratorio es comprender el proceso de simplificación
utilizando como herramientas los teoremas del Algebra de Boole y los Mapas de Karnaugh;
así como verificar que las funciones simplificadas que se obtienen sean equivalentes a la
función original.
3.2%Justificación%
Esta práctica de laboratorio cumple con el objetivo específico de la unidad 2 y abarca
el sub-tema 2.2.
3.3 Introducción
El proceso de minimización de funciones lógicas consiste en pasar de una expresión
algebraica a otra equivalente que requiera para su implementación de un menor número de
compuertas lógicas. Para llevar a cabo este proceso en este laboratorio se analizaron dos
métodos, primero utilizando los teoremas del algebra de Boole y después utilizando los
mapas de Karnaugh.
Minimización mediante las propiedades del algebra de Boole.
Para aplicar este método de manera eficaz se requiere conocer las propiedades básicas
del algebra de Boole así como de una buena experiencia en su aplicación. En la Tabla 3.1
se muestra una lista de 6 teoremas y 4 postulados del algebra de Boole, los cuales describen
las relaciones más básicas que existen en el algebra de Boole.
Postulado 2 (a) ! + 0 = ! (b) ! ∙ 1 = !

Postulado 5 (a) ! + ! = 1 (b) ! + ! = 1
Teorema 1 (a) ! + ! = ! (b) ! ∙ ! = !
Teorema 2 (a) ! + 1 = 1 (b) ! ∙ 0 = 0
Teorema 3, involución !=!
Postulado 3, conmutativo (a) ! + ! = ! + ! (b) ! ∙ ! = ! ∙ !
Teorema 4, asociativo (a) ! + ! + ! = ! + ! + ! (b) ! !" = !" !
Postulado 4, distributivo (a) ! ! + ! = !" + !" (b) ! + !" = ! + ! ! + !
Teorema 5, DeMorgan (a) ! + ! = !! (b) !" = ! + !
Teorema 6, absorción (a) ! + !" = ! (b) ! ! + ! = !
Tabla 3.1. Postulados y teoremas del álgebra de Boole.
A continuación se muestran algunos ejemplos de la aplicación de estas propiedades

descritas en el algebra de Boole con la finalidad de minimizar una función.
! = !" + ! ! + ! + ! ! + !
! = !" + !" + !" + !! + !" del postulado 4(a)
! = !" + !" + ! + !" del teorema 1(b)
MC. Manuel Jesús López Sánchez Lab. 3. Minimización de funciones

! = !" + !" + ! ! + 1 del postulado 4(a)

! = !" + !" + ! del teorema 2(a) y postulado 2(b)
! = !" + ! ! + 1 del postulado 4(a)
! = !" + ! del teorema 2(a) y postulado 2(b)
Otro ejemplo de minimización utilizando estas propiedades es:
! = !!! + !!" + !"! + !"#

! = !! ! + ! + !" ! + ! del postulado 4(a)
! = !! ∙ 1 + !" ∙ 1 del postulado 5(a)
! = !! + !" del postulado 2(b)
! =! !+! del postulado 4(a)
! =!∙1 del postulado 5(a)
! =! del postulado 2(b)
Este método de minimización de funciones en la práctica tiene una aplicación muy

limitada, debido a que en una expresión algebraica compleja es muy difícil visualizar todas
las posibles simplificaciones por lo que únicamente se recomienda aplicar en expresiones
algebraicas simples.
Minimización utilizando los mapas de Karnaugh
El método del Mapa de Karnaugh presenta un procedimiento fácil y directo de

minimización de funciones Booleanas. Este método se basa en una representación gráfica
de la tabla de verdad, que se construye a base de celdas o cuadros, que representan a cada
uno de los términos mínimos que componen a una función. En la figura se muestran los
diagramas que utilizan para aplicar este método a funciones de 2, 3 y 4 variables.
Fig. 3.1. Mapas de Karnaugh, (a) de dos variables, (b) de tres variables y (c) de cuatro variables.
Se aplicará este método a los dos ejemplos a los que se les realizó la minimización
por medio de las propiedades del algebra de Boole, con la finalidad de explicar brevemente
su aplicación.

Para el primer ejemplo se tiene la siguiente función:
! = !" + ! ! + ! + ! ! + !
Se puede observar que esta función no se encuentra en forma canónica, por lo que
para determinar los miniterminos que la componen, se obtiene su tabla de verdad, la cual se
muestra en la Tabla 3.2.
a b c F
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 1
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1
Tabla 3.2. Tabla de verdad de ! = !" + ! ! + ! + ! ! + !
De esta forma podemos expresar F como la suma de los miniterminos que la

componen:
! = Σ 2, 3, 5, 6, 7
Ahora hay que colocar en un mapa de tres variables 1’s en la posición que
corresponde a cada minitermino de la función y agrupamos los 1’s que sean vecinos y que
se encuentren en posición horizontal o vertical. El tamaño permitido para los grupos es de
2n (1, 2, 4, 8, etc.). En la Fig. 3.3 se muestra el resultado.
Fig. 3.2. Mapa de ! = !" + ! ! + ! + ! ! + !
De esta manera se obtiene la siguiente función minimizada:
! = !" + !
En el caso del segundo ejemplo tenemos:
! = !!! + !!" + !"! + !"#
En este caso la función se encuentra en forma canónica y la podemos expresar como

la suma de los siguientes miniterminos:

! = Σ 2, 3, 6, 7
Por lo que el mapa queda como se muestra en la Fig. 3.3:
Fig. 3.3. Mapa de ! = !" + ! ! + ! + ! ! + !
La función minimizada queda de la siguiente forma:
!=!
Adept precargados.
Ahora a continuación se muestra a manera de ejemplo demostrativo como
implementar cada una de las funciones de los ejemplos que se analizaron en el apartado de
introducción.
1. Creé un nuevo proyecto en el ISE Design Suite, y agregue un nuevo archivo de

texto con el código en VHDL mostrado en la figura.
1 ------------------------------------------------------------
2 ENTITY ejemplo_01 IS
4 b : IN BIT;
5 c : IN BIT;
6 f : OUT BIT );
7 END ejemplo_01;
8 -------------------------------------------------------------
9 ARCHITECTURE rtl OF ejemplo_01 IS
10 BEGIN
11 f <= (a AND b) OR (a AND (b OR c)) OR (b and(b OR c));
12 END rtl;
13 -------------------------------------------------------------
Fig. 3.4. Código en VHDL utilizado para implementar la función original del ejemplo 1.

2. Implemente el test bench con el código que se muestra en la figura y agréguelo al

proyecto.
1 ------------------------------------------------------------
2 ENTITY ejemplo_01_testbench IS
3 END ENTITY ejemplo_01_testbench;
4 ------------------------------------------------------------
5 ARCHITECTURE rtl OF ejemplo_01_testbench IS
6
7 COMPONENT ejemplo_01 IS
9 b : IN BIT;
10 c : IN BIT;
11 f : OUT BIT );
12
13 END COMPONENT;
14 SIGNAL a: BIT;
15 SIGNAL b: BIT;
16 SIGNAL c: BIT;
17 SIGNAL f: BIT;
18 BEGIN
19
20 compuerta_01: ejemplo_01 port map ( a => a,
21 b => b,
22 c => c,
23 f => f );
24 a <= '0',
25 '1' after 200 ns;
26 b <= '0',
27 '1' after 100 ns,
28 '0' after 200 ns,
29 '1' after 300 ns;
30 c <= '0',
31 '1' after 50 ns,
32 '0' after 100 ns,
33 '1' after 150 ns,
34 '0' after 200 ns,
35 '1' after 250 ns,
36 '0' after 300 ns,
37 '1' after 350 ns;
38 END rtl;
39 --------------------------------------------------------------
Fig. 3.5. Listado del test bench para el ejemplo 1.
3. Abra la ventana de simulador y se deben observar las señales que se muestran en

la Fig. 3.6, las cuales corresponden al con la tabla de verdad que se muestra en la
Tabla 3.2.

Fig. 3.6. Formas de onda obtenidas en el simulador lsim para la función original del ejemplo 1.
4. Para comprobar la equivalencia de la función minimizada con la original se

modifica se reemplaza en el código la función original por la función minimizada,
como se muestra en la Fig. 3.7.
1 ---------------------------------------------------------
2 ENTITY ejemplo_01 IS
4 b : IN BIT;
5 c : IN BIT;
6 f : OUT BIT );
7 END ejemplo_01;
8 ----------------------------------------------------------
9 ARCHITECTURE rtl OF ejemplo_01 IS
10 BEGIN
11 f <= (a AND c) OR b;
12 END rtl;
13 ----------------------------------------------------------
Fig. 3.7. Lisado para implementar la función minimizada el ejemplo 1.
5. Ejecute nuevamente el test bench de la Fig. 3.5, y deberá obtener las mismas
formas de onda que se observaron en la Fig. 3.6.
6. Para verificar de el funcionamiento físico se agrega el archivo UCF que se
muestra en la Fig. 8, se genera entonces el archivo de programación el cual deberá
descargarse en la tarjeta Digilent Basys utilizando el software digilent Adep.
1 NET "a" LOC = P29; #entrada x conectada al Interruptor SW2

2 NET "b" LOC = P36; #entrada y conectada al Interruptor SW1
3 NET "c" LOC = P38; #entrada y conectada al Interruptor SW0
4 NET "f" LOC = P15; #salida f conectada al LED LD0
Fig. 3.8. Listado del archivo UCF para el ejemplo 1.


a) Implemente el código VHDL que describa al circuito mostrado en la Fig. 3.9.
A B C
Fig. 3.9. Diagrama del ejercicio 1 a simplificar.
b) Realizar la síntesis del código VHDL y verifique que el diagrama lógico, del
c) Genere el código para el test bench y lleve a cabo la simulación.
d) Simplifique la función de salida del circuito mostrado en la Fig. 3.9, utilizando las
propiedades básicas del algebra de Boole. Genere la descripción en VHDL de la
función minimizada, realice la síntesis y lleve a cabo la simulación.
e) Compare las formas obtenidas en las simulaciones realizadas en los puntos c y d.
f) Para cada una de las expresiones lógicas obtenga su tabla de verdad, dibuje sus
mapas de Karnaugh correspondientes y simplifique las expresiones lógicas.
i. ! = !!! + !! ! + ! + !"#
ii. '! = !!!! + !!!! + !! + !!!! + !!!!
g) Implemente los códigos VHDL de las funciones originales así como los códigos del
test bench para cada circuito.
h) Realice la simulación y copie las formas de onda obtenidas en su reporte.
i) Implemente los códigos VHDL de las funciones simplificadas así como los códigos
del test bench para cada circuito.
j) Realice la simulación de las funciones simplificadas y copie las formas de onda
obtenidas en su reporte.
k) Compare las formas de onda obtenidas en las simulaciones de las funciones
originales y en las de las funciones ya simplificadas.

l) Después del proceso de síntesis:
m) Desarrollar la cama de prueba (testbench) de cada implementación y verificar

n) Implementar cada una de las funciones lógicas en la tarjeta Digilent Basys.
Visualizar con leds si se cumple la tabla de verdad de cada función lógica, además
de la validación con su correspondiente simulación.
o) Analizar el desempeño en términos de su área, después del proceso de síntesis.

diseño?_________________

Lab.%4.%Diseño%de%sitemas%combinacionales%usando%Mapas%de%
Karnaugh:%Elevar%un%número%binario%de%3bits%al%cuadrado%
4.1%Objetivo%
El objetivo de esta práctica de laboratorio es implementar un sistema digital
combinacional que eleve un número binario de 3bits al cuadrado. Este laboratorio empleará
la técnica de reducción de funciones booleanas mediante mapas de Karnaugh y éste diseño
será implementado en la plataforma reconfigurable FPGA.
4.2%Justificación%
Con esta práctica de laboratorio, los estudiantes podrán analizar, conceptualizar,
diseñar e implementar un sistema digital combinacional mediante un caso de estudio
específico. Esta práctica de laboratorio impacta los siguientes temas del plan de estudios de
la asignatura (ver carta descriptiva de la asignatura):
- Unidad 3 - Unidad 4.
- Sub-tema 3.2 y 3.3 - Sub-tema 4.2.
4.3 Introducción
Los circuitos lógicos combinacionales son aquellos en los que, en cada instante, el
nivel lógico de sus variables de salida depende únicamente de sus variables de entrada. Un
circuito combinacional es por tanto una función lógica que puede ser representada mediante
una tabla de verdad o mediante una expresión numérica correspondiente a la suma se
productos canónicos o a un producto de sumas canónicas. En la Fig. 4.1 se muestra la
representación de la estructura de un sistema combinacional.
Fig. 4.1. Sistema Combinacional.
Todos los circuitos combinacionales pueden representarse empleando álgebra de Boole a

partir de su función lógica, generando de forma matemática el funcionamiento del sistema
MC. Manuel Jesús López Sánchez Lab. 4. Diseño de sitemas combinacionales

Dr. Alejandro Arturo Castillo Atoche usando Mapas de Karnaugh: Elevar un
número binario de 3bits al cuadrado
combinacional. De este modo, cada señal de entrada es una variable de la ecuación lógica
de salida.
ALGEBRA BOOLENA
En Álgebra Booleana, se conoce como término canónico de una función lógica, a todo
producto o suma en la cual aparecen todas las variables en su forma directa o inversa. Una
función lógica que está compuesta por un operador lógico puede ser expresada en forma
canónica usando los conceptos de mintérminos y maxterm. Todas las funciones lógicas son
expresables en forma canónica, tanto como una "suma de minitérminos" como "producto de
maxitérminos". Esto permite un mejor análisis para la simplificación de dichas funciones,
lo que es de gran importancia para la minimización de circuitos digitales.
MAPAS DE KARNAUGH
Un mapa de Karnaugh (también conocido como tabla de Karnaugh) es un diagrama

utilizado para la simplificación de funciones algebraicas Booleanas. El mapa de Karnaugh
fue inventado en 1950 por Maurice Karnaugh, un físico y matemático de los laboratorios
Bell. Los mapas de Karnaugh reducen la necesidad de hacer cálculos extensos para la
simplificación de expresiones booleanas.
El mapa de Karnaugh consiste en una representación bidimensional de la tabla de verdad de

la función a simplificar. Puesto que la tabla de verdad de una función de N variables posee
2N filas, el mapa K correspondiente debe poseer también 2N cuadrados. Las variables de la
expresión son ordenadas en función de su peso y siguiendo el código Gray, de manera que
sólo una de las variables varía entre celdas adyacentes. La transferencia de los términos de
la tabla de verdad al mapa de Karnaugh se realiza de forma directa, albergando un 0 ó un 1,
dependiendo del valor que toma la función en cada fila. Las tablas de Karnaugh se pueden
utilizar para funciones de hasta 6 variables.
Adept precargados.
Con este ejemplo demostrativo se presenta el procedimiento para implementar el sietma
combinacional utilizando mapas de Karnaugh.

1.- Considere la siguiente función booleana representada con minitérminos-maxitérminos,

! = ! 2,5,6 = ∏(0,3,4,6,7).
2.- Realizar la tabla de verdad correspondiente a la función booleana. En la Fig. 4.2 se

muestra la tabla de verdad de este ejemplo demostrativo.
Fig. 4.2. Tabla de verdad de la función booleana
3.- Aplicar la técnica de mapas de Karnaugh para simplificar la función booleana si

consideramos la representación con minitérminos. La Fig. 4.3(a) ilustra las agrupaciones
realizadas con la técnica de Karnaugh para la representación con minitérminos.
4.- Aplicar la técnica de mapas de Karnaugh para simplificar la función booleana si

consideramos la representación con maxitérminos. La Fig. 4.3(b) ilustra las agrupaciones
con maxitérminos.
Fig. 4.3. Karnaugh: (a) función booleana con minitérminos, (b) función booleana con maxitérminos
Después de aplicar la técnoica de Karnaugh, los siguientes resultados se obtuvieron:
!!"# = !!! + !! y !!"# = ! + ! ! + ! ! + !
Resulta evidente que la ecuación más simplificada resulta de la representación con suma de
productos o minitérminos.

4.6%Instrucciones%del%laboratorio%No.4%

Implementar en un FPGA el diseño digital de un sistema combinacional que eleve un
número binario de 3bits al cuadrado. Este laboratorio empleará la técnica de reducción de
funciones booleanas mediante mapas de Karnaugh.
1. Lleve a cabo la programación de la tarjeta Basys descargando el archivo de programación

a la tarjeta utilizando el programa Adept de Digilent. Una vez programado el FPGA pruebe
todas las combinaciones de entrada (corresponden al resultado del análisis de la tabla de
verdad) cambiando las posiciones de los interruptores SW0 y SW1 y verifique la salida en
el led LD0.
a) Analíticamente realizar la tabla de verdad

b) Obtener la función booleana basada en minitérminos y maxitérminos.
c) Implementar el código en VHDL:
i. Utilizar la función basdada en minitérminios
ii. Utilizar la función con maxitérminos.
d) Realizar la síntesis del código VHDL y verifique que el diagrama lógico, del
e) Implementar la cama de prueba para realizar las simulaciones de cada una de las
f) Mediante el uso del programa Project Navigator que forma parte del paquete de
archivo de texto con el código VHDL, en donde las señales de entrada “a”, “b” ,
c, todas del tipo std_logic, genrarán la salida std_logic “f”.
g) Realice la síntesis del código y verifique el diagrama esquemático RTL del
código el cual debe coincidir con el mostrado en la figura.
h) Seleccione el menú de simulación en la venta del Project Navigator y corra la
abierto el simulador ajuste la escala de tiempo y deberá observar las formas de
onda de la señal. Verifique que estas corresponde al comportamiento del
sistema.
2. Para llevar a cabo la implementación física del circuito en el FPGA que se encuentra en
la tarjeta Basys, se requiere agregar el archivo de restricciones de usuario (UCF por sus
siglas en ingles), el cual define las conexiones entre las entradas y las salidas del circuito
diseñado hacia los pines del FPGA.

3. En la tarjeta Basys existen un conjunto de dispositivos de entrada y salida, como se

muestra en la Fig. 4.4, por lo que hay que seleccionar estos pines del FPGA de acuerdo al
dispositivo de entrada o salida que nos sea conveniente para realizar nuestras pruebas, para
esta práctica seleccionaremos los interruptores y los LEDs. La Fig. 4.4 muestra los
interruptores SW0, SW1 y SW2 como entradas y los LEDs LD0-LD5 como salidas.
FPGA
LEDs
Interruptores
i) Después del proceso de síntesis:
Copie la imagen de las formas de onda para su reporte y verifique que correspondan a las funciones
lógicas implementadas.
j) Desarrollar la cama de prueba (testbench) de cada implementación y verificar funcionalmente el

resultado de cada función lógica.
k) Visualizar con leds si se cumple la tabla de verdad de cada función lógica, además de la
validación con su correspondiente simulación.
l) Analizar el desempeño en términos de su área, después del proceso de síntesis. Responder lo
siguiente para cada función lógica:
¿Cuál es el procentaje total de compuertas lógicas utilizados en el diseño?_________________

Lab.%5.%Decodificador%BCD%a%7%segmentos%en%FPGA%
5.1%Objetivo%
El objetivo de esta práctica de laboratorio es comprender e implementar un
decodificador BCD-a-7-segmentos. En este laboratorio se empleará la técnica de reducción
de funciones booleanas mediante mapas de Karnaugh, y se instanciará la función booleana
de cada segmento en una arquitectura Top en el FPGA.
5.2%Justificación%
diseñar e implementar un sistema digital combinacional relacionado al tema de
decodificadores, mediante un caso de estudio específico. Esta práctica de laboratorio
impacta los siguientes temas del plan de estudios de la asignatura Sistemas Digitales I (ver
carta descriptiva de la asignatura):
- Unidad 3 - Unidad 4.
- Sub-tema 3.2 y 3.3 - Sub-tema 4.2 y 4.3.
5.3 Introducción
Los decodificadores BCD-a-siete-segmentos son circuitos combinacionales que
convierten un número BCD en su correspondiente representación de dígito decimal,
mediante un código que obtiene la apropiada selección de los segmentos del display que
está compuesto de 8 diodos-emisores de luz, incluyendo el punto decimal (pin 5). Las ocho
salidas del decodificador (a, b, c, d, e, f, g, punto decimal) activarán los diodos del display
como puede observarse en la Fig. 5.1.
Fig. 5.1. Display de siete segmentos.
MC. Manuel Jesús López Sánchez Lab. 5. Decodificador BCD a 7 segmentos

En la Fig. 5.2, se puede observar el diagrama esquemático de la tarjeta FPGAS Basys

que contiene los displays de siete-segmentos.
Fig. 5.2. Diagrama esquemático del FPGA Basys con el display de siete segmentos.
Como se puede observar en la Fig. 5.2, se indica a que terminales está físicamente
conectado cada segmento a las terminales del fpga. Ahora, la relación de decodificación
que requiere el sistema combinacional por el display, puede ser obtenido a través de su
representación en la tabla de verdad de este sistema.
El decodificador de BCD-a-siete-segmentos es un dispositivo electrónico que se
utiliza en muchos dispositivos electrónicos. Este proceso consiste en tomar un número
binario de 4-bits y proporcionar las salidas correspondientes para activar los diodos del
display de siete segmentos. Específicamente, cada segmento es un led, cuyas terminales

estan asociadas a las salidas de decodificador y a una terminal común que pueden ser de
cátodo común o de ánodo común. Para encender un segmento de un display de cátodo
común se tiene que emitir un “uno” lógico de la salida del decodificador. Pero si el display
es de ánodo común, se tiene que enviar un “cero” lógico a los segmento para poder
activarlos.
Adept precargados.
5.5%Ejemplo%%demostrativo%BCDJaJsieteJsegmentos%
Con este ejemplo demostrativo se presenta el procedimiento para implementar el sistema
decodificador BCD-siete-segmento utilizando mapas de Karnaugh. Note que solo se
demuestra el procedimiento para obtener la función booleana de un segmento, los demás
segmentos serán encontrados por los alumnos en esta práctica de laboratorio. El proceso
metodológico de diseño es el siguiente:
1.- Determinar la tabla de verdad correspondiente al segmento ‘a’ del sistema decodificador
propuesto. En la Fig. 5.3 se muestra la tabla de verdad para el segmento ‘a’, de este ejemplo
demostrativo.

Fig. 5.3. Tabla de verdad para el segmento ‘a’.
En la Fig. 5.3 se puede observar que los valores a partir del número 9 no serán desplegados
en el display, por lo tanto en la tabla de verdad se coloca la condición “no importa - con la
X”, así aplicando la técnica de mapas de Karnaugh se podrá simplificar aún más la función
booleana.
3.- Aplicar la técnica de mapas de Karnaugh para simplificar la función booleana

considerando la representación con minitérminos. La Fig. 5.4(a) ilustra la representación de
los cuadrantes de Karnaugh donde se incluyen las condiciones “no importa” con las X.
4.- Con la técnica de mapas de Karnaugh agrupar y simplificar la función booleana. La Fig.
5.4(b) ilustra las agrupaciones con minitérminos.

Fig. 5.4. Karnaugh: (a) cuadrantes con los valores X-No importa, (b) agrupaciones
Después de aplicar la técnica de Karnaugh, los siguientes resultados se obtuvieron:
!!"#_! = ! + !" + !" + !!
5.- Ver el laboratorio 1 de este manual, para seguir el diagrama de flujo de diseño con el
FPGA utilizando el lenguaje de descripción de hardware VHDL.

Implementar en un FPGA el diseño digital de un sistema decodificador BCD-a-siete
segmentos aplicando la técnica e instanciación de las funciones booleanas encontradas en el
FPGA.
1. Lleve a cabo la programación de la tarjeta Basys descargando el archivo de

programación a la tarjeta utilizando el programa Adept de Digilent. Una vez
programado el FPGA pruebe todas las combinaciones de entrada (corresponden al
resultado del análisis de la tabla de verdad) cambiando las posiciones de los
interruptores SW0 a SW3 y verifique la salida en un display de siete segmentos.
a) Analíticamente encontrar la tabla de verdad de los segmentos restantes. Llenar

la tabla de verdad presentada abajo.

b) Obtener la función booleana basada en minitérminos.


i. Utilizar la función basdada en minitérminios
ii. Integrar el diseño mediante la instancia de los componentes de las
funciones booleanas encontradas en a).
e) Implementar la cama de prueba para realizar las simulaciones de cada una de las
archivo de texto con el código VHDL, en donde las señales de entrada “D”, “C”,

“B” y “A”, todas del tipo std_logic, genrarán la salida “Leds” del tipo
std_logic_vector (6 downto 0).
sistema.
2. Para llevar a cabo la implementación física del circuito en el FPGA con la tarjeta Basys,
se requiere agregar el archivo de restricciones de usuario (UCF, por sus siglas en inglés), el
cual define las conexiones entre las entradas y las salidas del circuito diseñado hacia los
pines del FPGA.

esta práctica seleccionaremos los interruptores y un display.

j) Desarrollar la cama de prueba (testbench) de cada implementación y verificar

k) Visualizar con leds si se cumple la tabla de verdad de cada función lógica,
l) Analizar el desempeño en términos de su área, después del proceso de síntesis.

diseño?_________________
m) Actividad adicional de aprendizaje
m.1. ¿Por qué solamente se puede visualizar un display? Explique brevemente.
m.2 ¿Se podrá modificar la tabla de verdad para desplegar en el display otros dígitos
hexadecimales como G, H, J, L,P,H? Si es así describa su hipótesis.
m.3 ¿Cuál de los siguientes incisos describe mejor la función de un decodificador?
a. Un decodificador convierte un número decimal al equivalente binario que

le corresponde.
b. Un decodificador convierte un número binario en una salida específica

que representa un dígito o un carácter particular.
c. Los decodificadores se utilizan para evitar la operación inadecuada de los

sistemas digitales.

d. Los decodificadores son CI’s especiales que se usan para hacer posible
que una marca de computadoras establescan una representación de números y
caracteres.

Lab.%6.%Sumador%binario%en%FPGA%
6.1%Objetivo%
El objetivo de esta práctica de laboratorio consiste en diseñar e implementar un
sumador binario de 4 bits. En este laboratorio se analizarán las operaciones binarias y se
diseñará un sumador binario de 4 bits utilizando la estructura de medio, y de sumador
completo (HA y FA, por sus siglas en inglés) en una arquitectura Top en el FPGA. Para
verificar el resultado de las operaciones aritméticas se integrará un decodificador BCD-a-
siete-segmentos.
6.2%Justificación%
diseñar e implementar un sistema digital relacionado al tema de diseño de arquitecturas que
realicen operaciones aritméticas, mediante un caso de estudio específico. Esta práctica de
laboratorio impacta los siguientes temas del plan de estudios de la asignatura Sistemas
Digitales I (ver carta descriptiva de la asignatura):
- Unidad 3 - Unidad 4
- Sub-tema 3.3 - Sub-tema 4.4.1 y 4.5.1
6.3 Introducción
En la mayoría de los sistemas digitales, desde el circuito de control más sencillo hasta
el computador o el sistema de comunicación más complejo, se realizan operaciones
aritméticas. Estas operaciones aritméticas utilizan códigos binarios que pueden ser
implementados con circuitos integrados de escala de integración pequeña (SSI), escala de
integración media (MSI) y últimamente con circuitos integrados reconfigurables a una
escala muy grande de integración (VLSI).
6.3.1 Suma aritmética binaria
La suma aritmética de dos variables binarias resulta muy sencilla porque sólo pueden tener
dos posibles valores, 0 y 1 lógico. El resultado de una suma con sistema base dos (binaria)
obtiene el valor lógico de 1 cuando solamente uno de los sumandos tiene dicho nivel
lógico. Cuando ambos sumandos tienen el nivel lógico 1, la suma es cero y se produce un
acarreo.
MC. Manuel Jesús López Sánchez Lab. 6. Sumador binario en FPGA

6.3.2 Medio Sumador binario (HA)

Un medio sumador (HA, por sus siglas en inglés) es un circuito lógico que realiza la
suma binaria de dos variables binarias. Esto es, el circuito HA se puede implementar
mediante la descripción de sus funciones booleanas.
Fig. 6.1. Tabla de verdad y cicuito de la suma aritmética de un HA.
De Fig. 6.1 se pueden deducir dichas funciones booleanas que a continuación se

presentan
• !! = !! !! + !! !! = !⨁!
• !! = !".
Así, se puede deducir que de las ecuaciones algebraicas !! y !! , se observa que la
suma binaria !! es equivalente a la función Or-exclusiva y el acarreo !! es igual al producto
lógico implementado con la función and.

Fig. 6.2. Tabla de verdad y cicuito del FA.
1.3.2 Sumador completo (FA)

Un sumador completo (FA, por sus siglas en inglés) es un circuito lógico que realiza la
suma binaria de tres variables binarias. Cuando dos variables binarias que forman parte de
un número binario se suman, es necesario añadir a la operación el acarreo. Esto es, con el
medio sumador NO se puede integrar el acarreo !! procedente de la operación del bit
anterior. Con el circuito FA, !!!! generará el acarreo del resultado de la suma de las
variables !! y !! , y considerará como entrada el acarreo !! .
En la Fig. 6.2, se puede observar la tabla de verdad y el circuito esquemático del
sumador FA.
De Fig. 6.2 también se pueden deducir las funciones booleanas del FA que a
continuación se presentan
• !! = !! !! !! + !! !! !! + !! !! !! + !! !! !! = !! ⨁!! ⨁!!
• !!!! = !"!! + !! !! !! + !! !! !! + !! !! !! .
Se puede deducir que de las ecuaciones algebraicas !! y !!!! del FA, !! es

equivalente a implementar la triple operación Or-exclusiva.
En cuanto a la función booleana !!!! , esta puede simplificarse utilizando la técnica
de reducción mediante mapas de Karnaugh. Así, realizando las agrupaciones pertinentes
como se observa en la Fig. 6.3, la función es simplificada.

Fig. 6. 3. Reducción de la función acarreo del FA.
La función acarreo resultante es la siguiente

• !!!! = !" + !! !! + !! !!
Adept precargados.
6.5%Ejemplo%%demostrativo:%Sumador%completo%en%VHDL%
Con este ejemplo demostrativo se presenta el procedimiento para implementar el circuito
FA utilizando las funciones booleanas obtenidas en la sección anterior. Note que solo se
demuestra el procedimiento para obtener la implementación del sumador de 4-bits mediante
las funciones del FA. El proceso metodológico de diseño es el siguiente:
1.- Crear un proyecto en el ISE webpack en el folder de su conveniencia.
Consideraciones de diseño:.Implementar una arquitectur estructural de 2 niveles en

VHDL. En en nivel más bajo, se definen los componentes que serán instanciados en el
nivel más alto. Por ejemplo, en este ejercicio demostrativo, se implementará un sumador de
4 bits a partir de una estructura FA. Por lo tanto, en el nivel más bajo se implementará la
estructura FA y luego, se instanciará en cascada para obtener el sumador de 4 bits.
2.- Crearun Archivo nuevo del tipo VHDL.con el nombre FA.vhd
3.- Utilizar el siguiente código VHDL

Fig. 6.4. Código VHDL del FA.
Note que la descripción de la arquitectura del código VHDL de la Fig. 6.4 corresponde a las
funciones booleanas descritas en la sección introducción.
4.- Salva el código VHDL con el nombre “FA.vhd”. Sintetizalo e impleméntalo para
analizar su desempeño en área del FPGA.
5.- Crea un segundo archivo del tipo VHDL con el nombre Top_Sum4b_FA.vhd.
6.- Utilizar la siguiente dscipción en VHDL

Fig. 6.5. Módulo Top del sumador de 4 bits.
Note que en éste código se puede observar el componente FA que es integrado y

estructurado en cascada en la arquitectura Sumador de 4 bits.
7.- Implementar su correspondiente cama de pruebas (Test bench, en inglés) para verificar
el comportamiento del circuito.

Implementar en un FPGA el diseño digital de un sumador de 4 bits. Para verificar el
funcionamiento de la operación aritmética integrar un decodificador BCD-a-siete
segmentos y así, desplegar los resultados de la suma.
En la Fig. 6.6 se puede observar el diagrama esquemático del laboratorio solicitado. Este
diagrama esquemático ayudrá a los estudiantes a reconocer en el diseño estructural cuáles
son las estructuras de nivel inferior y cuáles las de nivel superior. Este diagrama
esquemático también servirá de guía para definir las terminales de entrada y salida que se
utilizarán en la entidad del diseño.

Fig. 6.6. Diagrama esquenático del Sumador de 4 bits con decodificador de 7 segmentos
Consideraciones de diseño: Realizar para el diseño del nivel interior, la estructura

del medio sumador (HA) como se puede observar en la Fig. 6.7.
Fig. 6.7. Diagrama esquenático sugerido para el Sumador 4 bits con HAs

todas las combinaciones de entrada (ver análisis de la tabla de verdad) cambiando las

posiciones de los interruptores SW0 a SW3 y verifique el resultado de cada operación

aritmética en el display de siete segmentos.
a) Analíticamente realizar las siguientes operaciones aritméticas.
b) Realizar el análisis estructural del diseño (niveles de jerarquía para definir los
módulos de nivel inferior y superior).
i. Diseñar la arquitectura HA.
ii. Integrar el diseño mediante la instancia de los componentes HA en
cascada para estructurar el sumador de 4 bits).
circuito obtenido, corresponda a la arquitectura de la Figura 6.
e) Implementar la cama de prueba para realizar las simulaciones del sumador de 4
bits.
archivo de texto con el código VHDL, en donde se definan las señales de
entrada, del tipo std_logic_vector (3 downto 0), y la salida “Leds” del tipo
std_logic_vector (6 downto 0).
sistema.

pines del FPGA.





diseño?_________________

Lab.%7.%Sumador/Restador%binario%en%FPGA%
7.1%Objetivo%
El objetivo de esta práctica de laboratorio consiste en diseñar e implementar un
sumador/restador binario de 4 bits. En este laboratorio se analizarán las operaciones en
punto fijo, así como el formato en complemento a 2, para diseñar un sumador/restador
binario de 4 bits. Los alumnos reutilizarán los diseños previos y estructuralmente se
implementará la estrcutura sumador/restador propuesta. Para verificar el resultado de las
operaciones suma/resta aritméticas se integrará el decodificador BCD-a-siete-segmentos.
7.2%Justificación%
diseñar e implementar un sistema digital aritmético sumador/restador empleando los
conceptos de completo a 2 y operaciones en punto fijo. Particularmente, esta práctica de
laboratorio impacta los siguientes temas del plan de estudios de la asignatura Sistemas
Digitales I (ver carta descriptiva de la asignatura):
- Unidad 4
- Sub-tema 4.4.1, 4.5
7.3 Introducción
La resta o sustracción de números binarios es similar a los números decimales. La
diferencia radica en que, en binario, cuando el minuendo es menor que el sustraendo, se
produce un préstamo o borrow de 2, mientras que en decimal se produce un préstamo de
10. Antes de iniciar, recordemos la operación de suma de dígitos decimales, al realizar
cualquier suma decimal no existe problema al realizar una suma que de como resultado un
número inferior a 9.
Ejemplo:
1+8=9
Pero que ocurre al realizar una suma como 1 + 9, el resultado es 0 unidades con una
unidad de acarreo, esta unidad se coloca delante del 0 y se le denomina decena, así el
resultado es diez 10.
1 + 9 = 0 (unidades) + 1 (acarreo) = 10
Este mismo procedimiento se lleva a cabo al utilizar cualquier sistema numérico. En
el sistema binario. En este caso las primeras tres operaciones producen un resultado de un
solo dígito, pero cuando ambos bits sumados son “1”, el resultado de la suma binaria consta
MC. Manuel Jesús López Sánchez Lab. 7. Sumador/restador binario en FPGA

de dos dígitos. En donde al bit más significativo del resultado de la suma se le denomina
acarreo.
Este resultado es similar al que se da en el sistema numérico decimal como se vio
anteriormente. Entonces si en el sistema decimal de la “segunda” posición equivale a
multiplicar el dígito por la base, entonces en el sistema binario equivale a multiplicar al
valor del dígito por 2.
En la Fig. 7.1 muestra una suma de 4 bits, en donde se realizan sumas de 0000 binario
a 1111 binario, es decir en decimal de 0 a 15, al realizar las sumas se tienen resultados de
0000 a 1 1110, esto quiere decir que al realizar sumas de 4 bits es posible tener un acarreo
dependiendo de los sumandos.
Fig. 7.1. Suma de dos números binarios de 4 bits.
7.3.1 Resta aritmética binaria
La operación de resta no es “sencilla” de implementar con circuitos integrados, debido a

esto, la realización de las operaciones de restas se utiliza un método alterno, que se basa en
realizar la resta utilizando un sumador donde uno de los sumandos se hace “negativo”, esto
se puede observar en decimal al realizar la resta.
25 -7 = 25 + (-7) = 18
En circuitos digitales así como en computadoras digitales se usan los “complementos” que
equivalen a tener números negativos, para simplificar la operación de resta y efectuar
manipulaciones lógicas. Esta es la forma más conveniente de realizar la resta de números
binarios.
Hay dos tipos de complementos para cada sistema base, el complemento a la base y el
complemento a la base disminuida.
Si utilizamos la base 2 (binaria) se tiene el complemento a “2” (complemento a la base) y el
complemento a “1” (complemento a la base disminuida).

7.3.2 Representación de números negativos.

En el sistema de numeración de complemento a la base r, los números negativos de n
dígitos se representan por la cantidad que les falta para completar rn. Es decir, en este
sistema, la cantidad –Nr se representa por su complemento, es decir, como rn-N y en
ocasiones se denota [N]r.
Por ejemplo, en base decimal:
Complemento a 10 para 2 dígitos (r=10, n=2) por ejemplo para representar el número
15 en complementos se realiza la siguiente operación:
-1510 = 102 - 15 = 100 -15 = [85]10 De esta manera, una resta como 45 - 15, se puede
realizar mediante la suma
45 + 85 = (1)30.
Despreciando el acarreo indicado entre paréntesis, ya que sólo se están usando 2
dígitos.
Ahora, en base binaria:

Complemento a 2 para 4 dígitos (r=2, n=4) de la misma manera para representar el
número -5 base 2, se realiza la siguiente operación:
(-0101)2 = 24 – [0101]2 = (10000 - 0101)2 = [1011]2, de esta manera, una resta como
[1010]2-[0101]2, se puede realizar mediante la suma de [1010]2 – [1011]2.
[0101]2 + [1011]2 = [(1)0101]2

Despreciando el acarreo indicado entre paréntesis, ya que sólo se están usando 4
dígitos.
7.3.3 Complemento a 1
Una alternativa al sistema de complemento a la base es el complemento a la base
menos 1. En este sistema, un número negativo -N de n dígitos en base r se representa por lo
que le falta para llegar a rn-1 y se suele denotar por [N]r-1, es decir, [N]r-1 = rn - 1 - N. en
otra palabras, [N]r-1 = [N]r -1.
Ejemplos:
Caso decimal para 2 dígitos (r=10, n=2, complemento a 9) (-15)10 = (102 – 1) - 15 = 99 - 15

= [84]9 de esta manera, una resta como 45 - 15, se puede realizar mediante la suma 45 + 84
= (1) + 29, (sumando el acarreo indicado entre paréntesis como una corrección del

resultado).
Caso binario para 4 dígitos (r=2, n=4, complemento a 1) (-0101)2 = (24-1) – (0101)2 =
(10000 – 1)2 – (0101)2 = (1111)2 – (0101)2 = [1010]1, de esta manera, una resta como
(1010)2 – (0101)2, = (0101)2 se puede realizar mediante la suma (1010)2 + (1010)2 =
[(1)0100]2 + (1)2 = (0101)2
7.3.4 Complemento a 2
A continuación se dan algunos ejemplos de restas usando complemento a dos, se introduce
el concepto de sobreflujo y de bit de signo.
Sobreflujo. Se dice que en una operación (en el sistema de complemento a dos) produce un
sobreflujo, cuando el resultado requiere más bits que los que se están usando en la
operación. Para visualizar el concepto de sobreflujo, es conveniente tener en mente el
rango representable en complemento a dos con n bits.
Ejemplo: ¿Cuál es el rango de números representables en complemento a dos con 3 bits?

En este caso es simple representar todos los números e interpretarlos en decimal. En la Fig.
7.2 se puede observar todas las posibles representaciones:
Fig. 7.2. Numeración en complemento a 2.
Analizando la Fig. 7.2, se puede deducir que el rango representable con n=3 bits será de -
2n-1 a +2n-1-1, esto es, de -4 a +3. Por lo tanto, si intentamos sumar (por ejemplo) 3+2

usando tres bits, el resultado (5) no podrá ser expresado con tres bits, ya que se sale del
rango y se tendrá un sobreflujo.
Adept precargados.
7.5%Ejemplo%%demostrativo:%Operaciones%con%complemento%a%2%
Con estos ejemplos demostrativos se presenta como realizar las operaciones de suma/resta
utilizando el algoritmo de complemento a 2.
Note que solo se demuestra el procedimiento para realizar las operaciones del
sumador/restador de 4-bits, los alumos serán los encargados de diseñar la arquitectura en
esta práctica de laboratorio. Los ejemplos demostrativos son los siguientes:
1.- Crear un algoritmo para resolver las operaciones en complemento a 2.
Sol: El algoritmo es el siguiente
- Se obtiene el complemento a 1 del número invirtiendo todos sus bits.

- Se suma 1 al resultado anterior.
Ejemplo.
Para obtener el complemento a 2 de N= 010110, se invierten todos los bits (complemento a

1) 101001, y se suma 1 al resultado, resultando finalmente: 101010
010110 Dato Original

101001 Se invierten los bits
+1 Se suma +1
resultado
101010
2.- Realizar las siguientes sumas/restas utilizando el algoritmo anterior. Indicar el signo del
resultado y en donde se produce sobreflujo:

a) 4+3
0 1 0 0
+ 0 0 1 1
0 1 1 1
El resultado es positivo y no hay sobreflujo
b) 5-4
0 1 0 1
+ 1 1 0 0
1 0 0 0 1
El resultado es positivo y no hay sobreflujo
c) -4 – 5
1 1 0 0
+ 1 0 1 1
1 0 1 1 1
El resultado es positivo, lo cual no puede ser pues se están sumando dos datos negativos
por lo que hay sobreflujo.
d) 6 + 5
0 1 1 0

+ 0 1 0 1
0 1 0 1 1
El resultado es negativo, lo cual no puede ser pues se están sumando dos datos positivos
por lo tanto hay sobreflujo, ya que el resultado requiere de otro bit adicional para
representar el resultado de la suma, que en este caso es el bit de signo.
e) 9 + 2
Esta operación NO se puede realizar con 4 bits, ya que el 9 requiere al menos 5 bits para ser
expresado en el sistema de complemento a 2
3. Interpretación del acarreo en el resultado de sumas en complemento a 2
"Si los signos de los números que se suman son diferentes, cualquier acarreo obtenido es
falso y deberá de ser ignorado".
Ejemplo: Ver inciso (b) del ejemplo anterior.

"Si los signos de los números que se suman son iguales, el acarreo es verdadero y actúa
como el bit de signo. En ausencia de acarreo se considera que este es 0, así la respuesta es
positiva".
Ejemplos ver incisos (a), (c) y (d) del ejemplo anterior.
Ejemplo: Efectúe las siguientes operaciones y exprese el resultado en decimal con su signo
(MSB = bit de signo)
a).-
0 1 1 1 1 0 1 1 Signo positivo
+ 1 0 1 1 0 0 1 0 Signo negativo
1 0 0 1 0 1 1 0 1 El acarreo se ignora
bit signo = 0 = positivo

resultado = (+)00101101 = (+)4510

b).-
1 0 0 1 0 1 1 1 Signo negativo
+ 1 0 1 0 0 1 1 0 Signo negativo
1 0 0 1 1 1 1 0 1 El acarreo es el bit de signo
los signos son iguales, el acarreo es el bit de signo del resultado
acarreo = bit signo = 1 = (-)
resultado =(-) complemento a 2 de 00111101 = (-)11000011 = - 19510

Implementar en un FPGA el diseño digital de un sumador/restador de 4 bits. Para verificar
el funcionamiento de la operación aritmética integrar un decodificador BCD-a-siete
segmentos y así, desplegar los resultados de las operaciones aritméticas.
En la Fig. 7.3 se puede observar el diagrama esquemático del laboratorio solicitado. Este
diagrama esquemático ayudrá a los estudiantes a reconocer en el diseño estructural, cuáles
son las estructuras de nivel inferior y cuáles las de nivel superior.
Este diagrama esquemático también servirá de guía para definir las terminales de entrada y
salida que se utilizarán en la entidad del diseño.

Fig. 7.3. Diagrama esquemático del Sumador/Restador de 4 bits.
Consideraciones de diseño: Realizar para el diseño del nivel interior con la

estructura del sumador de 4 bits.

todas las combinaciones de entrada (ver análisis de la tabla de verdad) cambiando las
posiciones de los interruptores SW0 a SW3 y verifique el resultado de cada operación
a) Analíticamente realizar las siguientes operaciones aritméticas.

i. Diseñar la arquitectura del sumador de 4 bits.
ii. Integrar al diseño la estructura XOR con la instancia del sumador de 4
bits.
d) Realizar la síntesis del código VHDL y verifique que el diagrama lógico del
circuito obtenido, corresponda a la arquitectura de la Fig. 7.3.
e) Implementar la cama de prueba para realizar las simulaciones del
sumador/restador de 4 bits.
software Xilinx ISE Design Suite, cree un nuevo proyecto y anexar el archivo de

texto con el código VHDL, en donde se definan las señales de entrada, del tipo
std_logic_vector (3 downto 0), y la salida “Leds” del tipo std_logic_vector (6
downto 0) para el decodificador BCD-a-siete segmentos.
sistema.
pines del FPGA.




diseño?_________________

Lab.%8.%Multiplicador%binario%
8.1%Objetivo%
El objetivo de esta práctica es implementar multiplicadores combinacionales, con el
propósito de mejorar la comprensión acerca de la multiplicación binaria, además de ser un
buen ejemplo de cómo es posible construir estructuras complejas a partir de los bloques
básicos que se han implementado previamente (sumadores y compuertas lógicas).
8.2%Justificación%
Esta práctica de laboratorio cumple con el objetivo específico de la unidad 4 y abarca
el sub-tema 4.4.
8.3%Introducción%
La multiplicación de números binarios realiza de la misma forma en la cual
realizamos la multiplicación de números decimales. El multiplicando es multiplicado por
cada unos de los bits del multiplicador, iniciando por el menos significativo y cada una de
estas multiplicaciones forma un producto parcial. Los cuales se van desplazando
sucesivamente una posición a la izquierda y el producto final se obtiene de la suma de los
productos parciales. En la Fig. 8.1 se muestra un ejemplo de la multiplicación de dos
números de 4 bits.
1 1 0 1 (13)
x 1 0 1 1 (11)
1 1 0 1
1 1 0 1
0 0 0 0
1 1 0 1
1 0 0 0 1 1 1 1 (143)
Fig. 8.1. Ejemplo de la multiplicación binaria de dos números de 4 bits.
En el ejemplo se ve con claridad que la obtención de los productos parciales se

pueden reducir simplemente a operaciones AND entre los bits correspondientes del
multiplicando y el multiplicador. Por lo que ahora para obtener el producto final es
necesario obtener la suma de los productos parciales, a continuación se describen dos
arquitecturas utilizadas comúnmente para ello.
Arquitectura 1.
En esta arquitectura se requiere primero de una estructura formada por compuertas

AND para la obtención de los productos parciales. En la Fig. 8.2 se observan en la parte
superior del diagrama estas compuertas AND organizadas en 4 grupos de 4 bits cada uno y
en la salida de cada uno de estos grupos tenemos los productos parciales. Posterior a esta
MC. Manuel Jesús López Sánchez Lab. 8. Multiplicador binario

etapa tenemos una estructura formada por 3 sumadores de 4 bits, la cual por medio de
sumas acumuladas nos permite obtener el producto final. La función del primer sumador, es
sumar el primer producto parcial con el segundo el cual ha sido desplazado una posición a
la izquierda a este resultado se le suma el tercer producto parcial utilizando el segundo
sumador de 4 bits y de nueva cuenta a la suma obtenida le sumamos el cuarto producto
parcial utilizando el tercer sumador. La estructura completa se observa en la Fig. 8.2.
Fig. 8.2. Arquitectura 1, para el multiplicador combinacional de 4 bits.
Arquitectura 2.
Esta arquitectura es ligeramente distinta a la anterior, esta se constituye por pequeños

bloques, dentro de los cuales se realiza el cálculo del producto parcial correspondiente.
También se lleva a cabo la suma de este producto con la suma del bloque superior (Sum In)
y con el acarreo de entrada (Cin) proveniente del bloque superior en diagonal. A partir de
estas entradas genera una nueva salida de suma (Sum Out) y un acarreo de salida (Cout).

Fig. 8.3. Bloques utilizados para la arquitectura 2.
En la Fig. 8.4, se muestra la interconexión de estos bloques para implementar un

multiplicador de 4 bits. Los valores de Ai, se encuentran distribuidos en los cada uno de los
bloques en alineación diagonal mientras que los valores de Bi se distribuyen de forma
horizontal.
Fig. 8.4 Arquitectura 2, para el multiplicador combinacional de 4 bits.
El material y las herramientas (software) requeridas para poder implementar el
ejemplo demostrativo de la sección 8.5, se presentan a continuación.
Adept precargados.

En esta sección se describe el procedimiento para implementar el multiplicador con la
arquitectura 1, que se ha descrito en el apartado de introducción.
1. Cree un nuevo proyecto y agregue un nuevo archivo de texto con extensión VHDL
con el código que se muestra en la Fig. 8.5.
1 LIBRARY IEEE;
2 USE IEEE. STD_LOGIC_1164.ALL;
3
4
5 ENTITY four_bit_multiplier IS
6 PORT ( a : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ;
7 b : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ;
8 s : OUT STD_LOGIC_VECTOR(7 DOWNTO 0) ) ;
9 END four_bit_multiplier;
10
11 ARCHITECTURE arch1 OF four_bit_multiplier IS
12
13 COMPONENT four_bit_adder IS
14 port ( a : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ;
15 b : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ;
16 ci : IN STD_LOGIC;
17 s : OUT STD_LOGIC_VECTOR(3 DOWNTO 0) ;
18 co : OUT STD_LOGIC ) ;
19 end COMPONENT;
20
21 signal C0 : STD_LOGIC_VECTOR(3 DOWNTO 0);
27
28 begin
29
30 C0 <= (b(3) AND a(0)) & (b(2) AND a(0)) & (b(1) AND a(0)) & (b(0) AND a(0));
31 C1 <= (b(3) and a(1)) & (b(2) AND a(1)) & (b(1) AND a(1)) & (b(0) AND a(1));
34
35 s(0) <= C0(0);
36
37 sumador_1 : four_bit_adder PORT MAP ( a(3) => '0',
38 a(2 DOWNTO 0) => C0(3 DOWNTO 1),
39 b => C1,
40 ci => '0',
41 s(0) => s(1),
42 s(3 DOWNTO 1) => C4(2 DOWNTO 0),
43 co => C4(3) );
44
45 sumador_2 : four_bit_adder PORT MAP ( a => C4,
46 b => C2,
47 ci => '0',
48 s(0) => s(2),
49 s(3 DOWNTO 1) => C5(2 DOWNTO 0),
50 co => C5(3) );
51
52 sumador_3 : four_bit_adder PORT MAP ( a => C5,

53 b => C3,
54 ci => '0',
55 s(3 DOWNTO 0) => s(6 DOWNTO 3),
56 co => s(7) );
57 end arch1;
Fig. 8.5. Código VHDL para la arquitectura 1 del multiplicador de 4 bits.
2. Agregue al proyecto el archivo los archivos VHDL con la descripción del sumador
de 4 bits, y verifique que los nombres de los puertos coincidan con los utilizados en
el archivo del multiplicador, de ser necesario cambie los nombres de los puertos.
Después de agregar estos archivos, deberá mostrarse en la ventana del proyecto la
estructura de archivos como se muestra en la Fig. 8.6.
Fig. 8.6. Estructura de archivos del multiplicador de 4 bits.
3. Agregue al proyecto el archivo VHDL con el código mostrado en la Fig. 8.7. para
llevar a cabo el test bench,

1 LIBRARY IEEE;
2 USE IEEE.STD_LOGIC_1164.ALL;
3
4
5 ENTITY multiplicador_tb IS
6 END multiplicador_tb;
7
8 ARCHITECTURE behavior OF multiplicador_tb IS
9
10 COMPONENT four_bit_multiplier
11 PORT(
12 a : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
13 b : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
14 s : OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
15 );
16 END COMPONENT;
17
18 --Entradas
19 SIGNAL a : STD_LOGIC_VECTOR(3 DOWNTO 0) := (OTHERS => '0');
20 SIGNAL b : STD_LOGIC_VECTOR(3 DOWNTO 0) := (OTHERS => '0');
21 --Salidas
22 SIGNAL s : STD_LOGIC_VECTOR(7 DOWNTO 0);
23
24 BEGIN
25
26 multiplicador: four_bit_multiplier PORT MAP ( a => a,
27 b => b,
28 s => s )
29 a <= "1010",
30 "1000" AFTER 100 ns,
31 "0111" AFTER 200 ns,
32 "0011" AFTER 300 ns,
33 "1111" AFTER 400 ns;
34
35 b <= "0110",
36 "1100" AFTER 100 ns,
37 "1111" AFTER 200 ns,
38 "1100" AFTER 300 ns,
39 "1111" AFTER 400 ns;
40 END;
Fig. 8.7. Código VHDL del test bench del multiplicador de 4 bits.
4. Abra la ventana del simulador y compruebe el funcionamiento del multiplicador en

la Fig. 8.8(a) se muestra las señales en binario obtenidas. Para facilitar el análisis es
recomendable cambiar la base del sistema de numeración a decimal sin signo como
se muestra en la Fig. 8.8(b).

(a)
(b)
Fig. 8.8. Señales obtenidas en la simulación del multiplicador (a) en binario (b) en decimal.

1. Agregue al proyecto creado en el ejemplo anterior el archivo UCF y programe el
FPGA.
2. Compruebe que la correcta operación realizando diversas multiplicaciones.
3. Cree un nuevo proyecto y realice la implementación de arquitectura 2 que se
describe en el apartado de introducción.
4. Realice la simulación y verifique el correcto funcionamiento del multiplicador.
5. Cree el archivo UCF e implemente el multiplicador en la tarjeta BASYS.
a) Después del proceso de síntesis:
b) Desarrollar la cama de prueba (testbench) de cada implementación y verificar


c) Implementar cada una de las funciones lógicas en la tarjeta Digilent Basys.

Visualizar con leds si se cumple la tabla de verdad de cada función lógica, además
de la validación con su correspondiente simulación.
d) Analizar el desempeño en términos de su área, después del proceso de síntesis.

diseño?_________________

Lab.%9.%Mux,%Demux,%Decodificadores%en%FPGAs%
9.1%Objetivo%
El objetivo de esta práctica de laboratorio consiste en diseñar e implementar circuitos
combinacionales Mux, Demux y Decodificadores mediante la técnica de diseño para
FPGAS de Lógica de Transferencia de Registros (RTL, por sus siglas en inglés). En este
laboratorio se analizarán las diferentes estructuras computacionales en VHDL para
implementar dichas arquitecturas, particularmente con las estructuras if else if, case, with
select y when else.
9.2%Justificación%
diseñar e implementar circuitos combinacionales Mux, Demux y Decodificadores, además
de familiarizarse con las estructuras en VHDL descritas en 1.1. Específicamente, esta
práctica de laboratorio impacta los siguientes temas del plan de estudios de la asignatura
Sistemas Digitales I (ver carta descriptiva de la asignatura):
- Unidad 4
- Sub-tema 4.5.2, 4.5.3
9.3 Introducción
9.3.1 Decodificador
Un decodificador acepta un código de entrada de N bits y produce un estado lógico en

1 o 0 en una y solo una terminal de salida. En otras palabras, se dice que un decodificador
identifica, reconoce o bien detecta un código específico. Ejemplos típicos de
decodificadores convierten una palabra de N-bits en 2N señales individuales lógicas. Esto
es, un decoder 2–4 toma 2 señales lógicas y decodifica su valor en una de las posibles 4
salidas (22). El símbolo de un decodificador 2-4, su tabla de verdad que describe su
funcionamiento y su diagrama lógico se pueden observar en la Fig. 9.1.
MC. Manuel Jesús López Sánchez Lab. 9. Mux, Demux, Decodificadores

a)
b)
c)
Fig. 9.1. Decodificador 2-4: (a) símbolo esquemático, (b) tabla de verdad, y (c) diagrama lógico.
9.3.2 Codificador
Lo opuesto a este proceso se denomina codificación y es realizado por un circuito

lógico que se conoce como codificador . Un codificador tiene varias líneas de entrada, solo
una de ellas se activa en un momento dado, y produce un código de salida de N bits, según
la entrada que se active. La Fig. 9.2 presenta el diagrama general de un codificador con M
entradas y N salidas. Aquí, las entradas son activas en ALTO, lo cual significa que
normalmente son BAJAS.

Fig. 9.2. Codificador
9.3.3 Multiplexor
Un multiplexor o selector de datos es un circuito lógico que acepta varias entradas de

datos y permite solo a una de ellas alcanzar la salida. Un multiplexor de 2N entradas tiene N
terminales de selección, las cuales son usadas para seleccionar que terminal de entradaserá
conectada a la única terminal de salidawhich. Un multiplexor-electrónico puede ser
considerado como un dispositivo interruptor de múltiples entradas con una sola salida.
El funcionamiento es el siguiente: un código digital es aplicado a la entrada selector

la cuál determinará que señal de entrada será interconectada a la salida.
Un ejemplo común de multiplexaje ocurre cuando varios periféricos de algún equipo

son interconectados en una sola línea o bus de transmisión. Así, en un periodo de tiempo
dado, un solo periférico es interconectado en el bus de transmisión. Este es un claro
ejemplo de multiplexaje en el tiempo que es ampliamente utilizado en otras áreas de la
ingeniería.
Otro ejemplo inetersante es multiplexaje en frecuencia, en donde, un dispositivo
utiliza una línea de transmisión pero transmite a diferentes frecuencias.
En la Fig. 9.3 se puede observar la tabla de verdad y el diagrama lógico de un
multiplexor de 8 a 1.

a)
b)
Fig. 9.3. Mux 8-1: (a) tabla de verdad, (b) diagrama lógico.
9.3.4 Demultiplexor.
Un demultiplexor (o demux) es un dispositivo que tiene una simple señal de entrada y
que dependiendo de la combinación del selector, genera varias señales de salida. Un
demultiplexor estradicionalmente utilizado como dispositivo complementario en un
esquema de comunicación en el lado receptor. En otras palabras, el demultiplexor toma una
fuente de datos de entrada y la distribuye selectivamente a uno de N canales de salida, igual
que un interruptor de múltiples posiciones. La Fig. 9.4 muestra el diagrama general de un
Mux y de un Demux.
Fig. 9.4. Comparativo de un Mux y Demux.

Adept precargados.
9.5%Ejemplo%%demostrativo:%Operaciones%con%complemento%a%2%
En esta sección se presenta como implementar un mux/demux utilizando el lenguaje de
descripción de hardware VHDL.
Note que solo se demuestra el procedimiento para implementar las arquitecturas digitales
mencionadas anteriormente utilizando las estructuras if else if, case, with select y when else.
El procedimiento de diseño es el siguiente:
Consideraciones de diseño: Implementar una arquitectura del multiplexor con la

técnica RTL en VHDL, usando la estructura case.
2.- Crear un Archivo nuevo del tipo VHDL con el nombre mux_case.vhd
Fig. 9.5. Código VHDL del Mux usando case.

Note que la descripción del case debe encontrarse dentro de un process.
4.- Salva el código VHDL con el nombre “mux_case.vhd”. Sintetizalo e impleméntalo para

técnica RTL en VHDL, utilizando la estructura if else if.
6.- Crear un Archivo nuevo del tipo VHDL con el nombre mux_if_else_if.vhd
Fig. 9.6. Código VHDL del Mux usando if else if.
Note que la descripción del if else if debe encontrarse dentro de un process.
8.- Salva el código VHDL con el nombre “mux_if_else_if.vhd”. Sintetizalo e impleméntalo

para analizar su desempeño en área del FPGA.

técnica RTL en VHDL, utilizando la estructura if else if.
10.- Crear un Archivo nuevo del tipo VHDL con el nombre when_else.vhd

Fig. 9.7. Código VHDL del Mux usando when else.
Note que la descripción del when else NO debe encontrarse dentro de un process.
12.- Salva el código VHDL con el nombre “when else.vhd”. Sintetizalo e impleméntalo
Fig. 9.8. Código VHDL del Mux usando with select.

Consideraciones de diseño: Implementar la arquitectura del multiplexor con la

técnica RTL en VHDL, utilizando la estructura with_select.
10.- Crear un Archivo nuevo del tipo VHDL con el nombre with_select.vhd
Note que la descripción del with select NO debe encontrarse dentro de un process.
12.- Salva el código VHDL con el nombre “when else.vhd”. Sintetizalo e impleméntalo
Sistema de seguridad y vigilancia.

Considere el caso de un sistema de vigilancia y seguridad para una planta industrial donde
debe vigilarse el estado abierto/cerrado de muchas puertas de acceso. Cada puerta es
monitoreada/controlada dependiendo del estado de un interruptor y además es necesario
presentar de manera visual el estado de cada uno sobre varios LED que están montados
sobre un panel de vigilancia remoto que se encuentra en la estación del guardia de
seguridad. Una manera tradicional para solucionar este problema es tender un cable para
cada señal desde el interruptor de cada puerta hasta el LED que se encuentra en el panel.
Esto requeririía tender muchos alambres sobre distancias grandes. Una mejor solución, que
además reduce la cantidad de alambres que van hacia el panel central, es utilizar una
combinación multiplexor/demultiplexor. La Fig. 9.9 muestra el diagrama esquemático del
laboratorio solicitado para solucionar este problema.

Fig. 9.9. Diagrama esquemático propuesto.
Este diagrama esquemático se puede observar que el usuario del sistema de seguriad podrá
monitorear cada interruptor de la puerta isualizando su estado (leds y display 7-segmentos)
mediante la apropiada selección de los switches en los selectores.

todas las combinaciones de entrada (analizar la tabla de verdad del sistema) cambiando las
posiciones de los interruptores de entrada y verifique el resultado de cada operación
a) Analíticamente analizar el funcionamiento del sistema.

i. Diseñar la arquitectura de los multiplexores y decodificadores.
ii. Integrar todo el diseño.
d) Realizar la síntesis del código VHDL y verifique que el diagrama lógico del
circuito obtenido, corresponda a la arquitectura de la Fig. 9.9.
e) Implementar la cama de prueba del sistema.
std_logic_vector (N downto 0), y la salida “Leds” y “display” del tipo
std_logic_vector (6 downto 0) para el decodificador BCD-a-siete segmentos.


código el cual debe coincidir con el mostrado en la Fig. 9.9.
sistema.
pines del FPGA.




diseño?_________________

Lab.%10.%Registros%
10.1%Objetivo%
El objetivo de esta práctica es llevar a cabo la implementación de los diferentes tipos
de registros (con carga en paralelo y con carga en serie).
10.2%Justificación%
Esta práctica de laboratorio cumple con el objetivo específico (ver carta descriptiva
de la asignatura) del siguiente tema:
- Unidad 5
- Sub-tema 5.3
10.3 Introducción
Un registro consiste en un conjunto de flip-flops, cada uno de los cuales tiene la
capacidad de almacenar un bit de información. Un registro de n bits consiste en un grupo n
flip-flops capaz de almacenar n bits de información. Adicionalmente un registro puede
contener compuertas lógicas que realizan tareas de procesamiento de los datos. De tal
manera que los flip-flops almacenan la información binaria, y las compuertas como esta
información es transferida a los circuitos.
Registros con carga en paralelo.

Los registros son sistemas digitales síncronos, es decir existe un reloj maestro que
suministra que genera de manera continua pulsos de reloj, que son aplicados a todos los
flip-flops, con la finalidad de que las transiciones en cada uno de los flip-flops sean
simultáneas. La transferencia de datos hacia el registro se denomina como carga o
actualización el registro, en el caso de que todos los bits del registro sean cargados de
manera simultánea, tenemos una carga de datos en paralelo.
En la Fig. 10.1 se aprecia la estructura más básica de un registro con carga en

paralelo, en este registro los datos son cargados en paralelo al registro cada vez que se
recibe un nuevo pulso de reloj.
MC. Manuel Jesús López Sánchez Lab. 10. Registros

Fig. 10.1. Registro de 4 bits.
En la Fig. 10.1 se muestra un registro de 4 bits con carga en paralelo con una entrada
de control de carga.
Este control se lleva a cabo por la compuertas lógicas del circuito, las cuales realizan
la función de un multiplexor dos canales, el cual selecciona la fuente de los datos que se
cargaran en el registro, cuando la entrada de carga es 1, los datos de las cuatro entradas
externas son transferidas al registro y cuando la entrada es 0, las salidas de los flip-flops
son conectadas a sus entradas respectivas, por lo que en este caso el registro permanece sin
cambio.
Fig. 10.2 Registro con carga en paralelo con flip-flops D.

Registros con carga en serie.
En un sistema digital que opera en modo en serie la información se transfiere bit a bit,
uno cada vez, desplazando los bits del registro fuente hacia el registro de destino. Los
registros que permiten la transferencia en serie también son conocidos como registros de
desplazamiento. El registro de desplazamiento más sencillo es aquel que usa solamente
flip-flops como se muestra en la Fig. 10.2. La salida de Q de un flip-flop dado, se conecta
con la entra D del flip-flop de la derecha. Cada pulso de reloj desplaza el contenido del
registro un bit en posición a la derecha. La entrada serial determina el dato que va en el
flip-flop que se encuentra a la izquierda durante el desplazamiento. La salida serial se toma
de la salida del flip-flop que se encuentra en el extremo derecho después de la aplicación
del pulso. Este registro realiza el desplazamiento de manera unidireccional hacia la derecha,
aunque si simplemente se voltea, podemos ver que el desplazamiento sería hacia la
izquierda.
Fig. 10.3. Registro con carga de datos en serie.
Registro%de%desplazamiento%bidireccional%con%carga%en%paralelo.%
Si se tiene acceso a cada una de las salidas de los flip-flops de un registro de
desplazamiento, se pueden extraer los datos que se han introducido de manera serial.
Además si agregamos la capacidad de cargar los datos en paralelo, entonces estos los datos
que entran al registro pueden extraerse en serie desplazando los datos almacenados en el
registro.
Algunos registros proveen de las terminales de entrada y de salida para la

transferencia en paralelo. Además pueden poseer a capacidad de desplazamientos hacia la
derecha o hacia la izquierda. El registro mas general tiene las siguientes características:
1. Una entrada de borrado que lleva al registro a 0.

2. Una entrada de reloj para sincronizar las operaciones.
3. Una entrada de control para habilitar el desplazamiento hacia la derecha y las
líneas de entrada y salida asociadas con este tipo de desplazamiento.

4. Una entrada de control para habilitar el desplazamiento hacia la izquierda y

las líneas de entrada y salida asociadas con este tipo de desplazamiento.
5. Un control de carga en paralelo para habilitar una transferencia en paralelo y
las n líneas de entrada asociadas con la transferencia en paralelo.
6. n líneas de salida en paralelo
7. Un estado de control que de la información sin variar en el registro aunque los
pulsos de reloj se apliquen continuamente.
En la Fig.10.4 se muestra el diagrama de un registro que posee todas estas

características, es decir es un registro de desplazamiento bidireccional con carga en
paralelo, al tener estas capacidades también se le conoce como registro universal.
Fig. 10.4. Registro de desplazamiento bidireccional de 4 bit con carga en paralelo.
Adept precargados.

En el ejemplo de esta sección se describe la implementación de un flip-flop tipo D,
con control de carga, el cual posee las siguientes terminales de entrada y salida:
1. CLK : entrada de reloj.

2. Reset: Pone el estado del flip-flop a 0.
3. En (enable): habilita la carga de datos en el flip-flop.
4. D: entrada de datos.
5. Q: salida de datos.
En la descripción de la operación del flip-flop que se hace en el código mostrado en

la Fig. 10.5, se puede observar que la señal de reset tiene la capacidad poner al flip-flop a 0
de manera asíncrona, también se observa que la carga de datos se habilitan con la señal en
puesta a 1 y cuando se da una transición de subida en la señal de reloj.
1 library ieee;
2 use ieee.std_logic_1164.all ;
3
4 entity d_ff_en is
5
6 port ( clk : in std_logic;
7 reset : in std_logic;
8 en : in std_logic;
9 d : in std_logic;
10 q : out std_logic
11 ) ;
12 end d_ff_en ;
13
14 architecture arch of d_ff_en is
15 begin
16 process (clk, reset, d, en)
17
18 begin
19 if (reset='1') then
20 q <= '0' ;
21 elsif (clk'event and clk='1') then
22 if (en='1') then
23 q <= d;
24 end if ;
25 end if ;
26 end process;
27 end arch;
Fig. 10.5. Código en VHDL con la descripción del flip-flop D.
En la Fig. 10.6 se puede observar que efectivamente el circuito sintetizado corresponde a un

flip-flop tipo D.

Fig. 10.6. Esquemático obtenido de la síntesis del código del flip-flop D.
Para comprobar el funcionamiento del flip-flop tipo D, se agrega el archivo con el

código que se muestra en la Fig. 10.7 el cual describe el test bench a realizar.
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.ALL;
3
4 ENTITY ff_d_tb IS
5 END ff_d_tb;
6
7 ARCHITECTURE behavior OF ff_d_tb IS
8
9
10 COMPONENT d_ff_en
11 PORT(
12 clk : IN std_logic;
13 reset : IN std_logic;
14 en : IN std_logic;
15 d : IN std_logic;
16 q : OUT std_logic
17 );
18 END COMPONENT;
19
20 --Inputs
21 signal clk : std_logic := '0';
22 signal reset : std_logic := '0';
23 signal en : std_logic := '0';
24 signal d : std_logic := '0';
25
26 --Outputs
27 signal q : std_logic;
28
29 -- Clock period definitions
30 constant clk_period : time := 10 ns;
31
32 BEGIN
33
34 uut: d_ff_en PORT MAP (
35 clk => clk,

36 reset => reset,

37 en => en,
38 d => d,
39 q => q
40 );
41
42 clk_process :process
43 begin
44 clk <= '0';
45 wait for clk_period/2;
46 clk <= '1';
48 end process;
49
50 reset <= '0', '1' after 20 ns, '0' after 40 ns;
51
52 d <= '0', '1' after 50 ns;
53
54 en <= '0', '1' after 100 ns;
55
56 END;
Fig. 10.7. Código del test bench para realizar la simulación del flip-flop D.
Una vez agregado el archivo del test bench al proyecto se abre la ventana del simulador
y se deben observar las señales que se muestran en la Fig. 10.8.
| "
Fig. 10.8. Resultado de la simulación del flip-flop tipo D.

1. A partir del código mostrado en el ejemplo, describa la estructura de un registro de
4 bits con carga en paralelo.
a. Implemente el test bench y verifique en el simulador el funcionamiento del
registro.
b. Creé el archivo UCF y genere el archivo de programación.
c. Compruebe el funcionamiento del registro en la tarjeta Basys.
2. Implemente mediante el instanciado del FF D, la estructura del registro de
desplazamiento de la Fig. 10.3.


registro.
3. Implemente mediante el instanciado del FF D, la estructura del registro de
desplazamiento bidireccional de 4 bit con carga en paralelo que se muestra en la
Fig. 10.4.
registro.


diseño?_________________

Lab.%11.%Contadores%binarios%en%FPGAs%
11.1%Objetivo%
El objetivo de esta práctica de laboratorio consiste en diseñar e implementar circuitos
con contadores binarios en lógica reconfigurable, específicamente FPGAS.
diseñar e implementar circuitos contadores binarios, además de familiarizarse con las
estructuras en VHDL para su diseño. Específicamente, esta práctica de laboratorio impacta
los siguientes temas del plan de estudios de la asignatura Sistemas Digitales I (ver carta
descriptiva de la asignatura):
- Unidad 5
- Sub-tema 5.4, 5.5
11.3 Introducción
Un contador es un circuito secuencial cuya función es seguir una cuenta o conjunto

predeterminado de estados como consecuencia de la aplicación de un tren de pulsos (reloj)
en una de sus entradas. Los contadores son circuitos construidos a base de flip-flops,
sincronizados a flancos, y de compuertas lógicas para realizar la conexión entre los flip-
flops. Las compuertas lógicas en un contador se conectan de forma que fuercen a los flip-
flops a seguir la secuencia prescrita de estados.
Dado que cada flip-flop es capaz de almacenar 2 estados, un sistema de n flip-flops podrá
codificar 2n estados (números de cuenta) diferentes. El paso del estado o número de cuenta
actual al estado siguiente se realiza en sincronismo con la señal de reloj, de tal forma que el
contador va avanzando por la secuencia de estados hasta que termina de completar un ciclo,
es decir, una secuencia de conteo particular. Una vez terminado el ciclo, vuelve al estado de
partida y comienza un nuevo ciclo. Como cada estado sólo posee un estado siguiente, es
fácil deducir que todos los estados que recorre un contador en un ciclo o secuencia de
conteo son diferentes. Si el número de estados diferentes que recorre es k, se habla de un
contador módulo k. El número máximo de estados posibles es 2n, por lo que k ≤2n. Un
contador se denomina binario si k=2n.
Un contador, como todo circuito secuencial, se puede implementar como un autómata,
MC. Manuel Jesús López Sánchez Lab. 11. Contadores binarios

puesto que no posee entradas (cada estado sólo posee un único estado siguiente al que
accede cuando existe una variación o flanco en la señal de reloj), y no posee salidas (la
salida de un contador es su propio estado interno, es decir, el valor almacenado en sus
biestables). El método de diseño es el mismo que el usado en el tema anterior, e incluso
algo más sencillo puesto que ya no es necesario minimizar ni asignar estados. Veamos un
ejemplo de un contador binario ascendente módulo 8, es decir, un contador que siga la
secuencia {..., 0, 1, 2, 3, 4, 5, 6, 7, ...}. En la Fig. 11.1 se pueden observar las transiciones
de estado del contador.
Fig. 11.1. Transiciones de estado del contador binario de 3 bits.
Ahora, para conocer las funciones de cada biestable hay que utilizar la tabla de transiciones
de estado de la Fig. 1, que corresponden a flip-flops JK. De la Fig. 11.2 se pueden deducir
las expresiones de las entradas J y K de cada biestable en función del estado actual.
Fig. 11.2. Transiciones del contador binario usando flip-flops JK.
Finalmente, se minimizan las funciones de la Fig. 11.2 utilizando mapas de

Karnaugh. La Fig. 11.3 muestra la simplificación de las funciones utilizando los mapas de
Karnaugh.

Fig. 11.3. Funciones lógicas para el diseño del contador binario.
La arquitectura final del contador se puede ver en la Fig. 11.4.
Fig. 11.4. Contador binario.
El principal problema de este diseño es que, para un número elevado de biestables, se

necesitan compuertas AND cada vez con un número mayor de entradas y pueden aparecer
problemas de fan-in y fan-out.
Adept precargados.
11.5%Ejemplo%%demostrativo:%contador%binario%de%4%bits%
En esta sección se presenta como implementar un contador binario de 4 bits utilizando el
lenguaje de descripción de hardware VHDL.

El procedimiento de diseño es el siguiente:
Consideraciones de diseño: Implementar una arquitectura del contador binario con

la técnica RTL en VHDL.
2.- Crear un Archivo nuevo del tipo VHDL con el nombre contador4b.vhd
Fig. 11.5. Código VHDL del contador 4 bits.
Note que la descripción del código debe encontrarse dentro de un process y es sensible al
reloj.
4.- Salva el código VHDL con el nombre “contador4b.vhd”. Sintetizalo e impleméntalo

5.- Verifica el diseño utilizando su respectivo “testbench” para simular los resultados. Ver
Fig. 11.6.

Fig. 11.6. Simulación del diseño del contador 4 bits.
11.6%Instrucciones%del%laboratorio%No.%11%
Contador de 10 segundos.
En esta práctica de laboratorio se va a diseñar e implementar en un FPGA un contador de
10 segundos que se verificará en un display de siete segmentos y en leds. La cuenta irá de 0
a 9 (un dígito BCD) para el display y su representación binaria en Leds.
En la primera etapa del diseño se generará una señal de 1 segundo (s1seg) del reloj
principal de 50 MHz. Esto es, esta señal dividirá la frecuencia de 50 MHz a 1 Hz, para
generar el nuevo reloj de 1 segundo. En la Fig. 11.7 se puede observar el diagrama
esquemático de la primera etapa del diseño de esta práctica 11 de laboratorio.
Fig. 11.7. Diseño e implementación del módulo divisor de frecuencia
En la segunda etapa del diseño, se implementará un segundo contador que contará diez
cuentas de un segundo (s1seg). En resumen se puede deducir que la arquitectura de este

laboratorio consistirá de la implementación de dos contadores en cascada. El esquema del

circuito se muestra en la Fig. 11.8. A este esquema le falta el control de los ánodos para que
ilumine el display. Como se puede observar, la cuenta de 10 segundos se mostrará por un
display de siete segmentos y su representación binaria se desplegará por cuatro LEDs.
Fig. 11.8. Diagrama esquemático propuesto para el laboratorio.
El proceso metodológico para implementar el laboratorio es el siguiente:
1. Realizar la programación en VHDL del diagrama esquemático propuesto. Una vez

programado el FPGA se verificará el resultado del contador de 10 segs en el display de
siete segmentos y en los Leds.
Analíticamente analizar el funcionamiento del sistema. Cálculos de las temporizaciones.

Esto es, para pasar de 20 ns a 1 segundo (de 50 MHz a 1 HZ), tenemos que contar hasta 50
millones (50· 106). La menor potencia14 de dos superior a 50·106 es 26. Esto es, 226 >
50·106 > 225. Por lo tanto, se necesitan 26 bits para poder representar el número 50·106. Así
que la señal de cuenta va a tener 26 bits.
Para llevar la cuenta se puede utilizar una señal de tipo entero o natural (integer o natural).
Esta señal debe de tener un rango potencia de dos.
a) Realizar el análisis estructural del diseño (niveles de jerarquía para definir los
b) Implementar el código en VHDL:
i. Diseñar la arquitectura divisor de frecuencia y del contador a
10segundos.
c) Realizar la síntesis del código VHDL y verifique que el diagrama del circuito
obtenido, corresponda a la arquitectura de la Fig. 11.8.

d) Implementar la cama de prueba del sistema.

e) Mediante el uso del programa Project Navigator que forma parte del paquete de
std_logic_vector (N downto 0), y la salida “Leds” y “display” del tipo
f) Realice la síntesis del código y verifique el diagrama esquemático RTL del
código el cual debe coincidir con el mostrado en la Fig. 11.8.
g) Seleccione el menú de simulación en la venta del Project Navigator y corra la
sistema.
pines del FPGA.


h) Después del proceso de síntesis:
i) Desarrollar la cama de prueba (testbench) de cada módulo y verificar su

funcionamiento.
j) Visualizar con leds si se cumple la cuenta de 0-9 en binario.
k) Analizar el desempeño en términos de su área, después del proceso de síntesis.


diseño?_________________

Lab.%12.%Cronómetro%
12.1%Objetivo%
El objetivo de esta práctica consiste en la integración de varios contadores para
implementar un cronometro digital, con una cuenta de minutos y segundos. El tiempo
medido deber ser desplegado en los displays de siete segmentos por lo que se necesita
implementar el control del multiplexado de estos.
Con esta práctica de laboratorio se busca la integración de algunos de los elementos
que se desarrollado en las prácticas anteriores, como el decodificador de 7 segmentos, los
contadores y el divisor de frecuencia. En está práctica de se cubren de manera específica los
siguientes temas del plan de estudios de la asignatura Sistemas Digitales I (ver carta
- Unidad 4
- Sub-tema 4.5 (4.5.2, 4.5.3 y 4.5.4)
- Unidad 5
- Sub-tema 5.4 y 5.5.
12.3 Introducción
Los contadores son elementos ampliamente utilizados en los sistemas digitales y una
aplicación muy común es en la medición de intervalos de tiempo, por lo que los podemos
ver cronómetros integrados, en una muy amplia diversidad de dispositivos.
Para llevar a cabo la medición del tiempo necesitamos al igual que en la práctica 11,
una señal de reloj de 1 Hz la cual es nuestra referencia para llevar a cabo el conteo, por lo
tanto se utilizará el modulo de división que se diseño anteriormente.
Para implementar el cronómetro se propone hacerlo mediante la estructura que se

observa en la Fig. 12.1. Esta estructura está conformada por cuatro contadores de 4 bits,
donde dos de ellos tienen como cuenta máxima el 9 (el contador de unidades de segundo y
el de unidades de minuto) y dos contadores cuya cuenta máxima en el 5 (el contador de
decenas de segundo y el decenas de minuto). Cada uno de los contadores cuenta con una
entrada que habilita la cuenta (E), una entrada de Reset que pone a 0 al contador (R), una
salida que indica que el contador a llegado a su cuenta máxima (ya sea 5 ó 9 dependiendo
del contador del que se trate) y las salida de cuenta de 4 bits las cuales indican los
segundos, decenas de segundos, minutos y decenas de minutos que han transcurrido desde
que se ha habilitado el cronómetro.
MC. Manuel Jesús López Sánchez Lab. 12. Cronómetro

El funcionamiento del circuito inicia con la cuenta de los segundos en el contador de

mas a la derecha y este al llegar a su cuenta máxima que es nueve, habilita al contador de
de las decenas de segundos el cual al recibir el siguiente pulso de reloj incrementa su
cuenta, es decir por ejemplo de la cuenta 00:09 el cronómetro pasaría al estado 00:10.
Cuando los contadores de segundos estén en su cuenta máxima habilitaran al contador de
minutos para que en el siguiente pulso de reloj se incremente su cuenta, por ejemplo del
estado 00:59 el siguiente estado será 01:00. Finalmente cuando el contador de minutos y los
contadores de segundos, alcancen su cuenta máxima habilitaran al contador de decenas de
minutos, por ejemplo al estar en el estado 09:59 el siguiente estado será 10:00. La cuenta
máxima para este cronómetro se ha definido como 59:59. El control de la puesta en marcha
y paro del cronómetro, se realiza con la habilitación del contador de las unidades de
segundo. La entrada de reset pone en ceros a todos los contadores. La señal de reloj clk
debe ser de una frecuencia de 1 Hz y distribuida a todos los contadores.
Fig. 12.1. Estructura de los contadores del cronómetro.
Para desplegar la cuenta del tiempo en los displays es necesario llevar a cabo el
multiplexado de las salidas de los contadores. Esta tarea se realizará por el circuito que se
muestra en la Fig. 12.2, este se encarga de tomar el valor de alguna de las 4 entradas de 4
bits y desplegar su valor ya decodificado en el display de 7 segmentos. Esta tarea la hace en
forma secuencial con cada una de las entradas y con una frecuencia lo suficientemente
rápida para que nuestra vista no perciba la condición de apagado de alguno de los displays.

Fig. 12.2. Control del multiplexado de los displays de 7 segmentos.
Adept precargados.
En la arquitectura que se ha descrito en el aparado de introducción, se requieren
contadores con diferente valor máximo de cuenta por lo que se hará uso de un parámetro
genérico, lo que nos permite en una misma arquitectura describir cada uno de estos
contadores, simplemente al asignar durante el instanciado un diferente valor a este
parámetro genérico. En el código mostrado en la Fig. 12.3 se puede el código en VHDL
con la descripción para os contadores donde n es el parámetro genérico que define la cuenta
máxima.
1 LIBRARY IEEE;
3 USE IEEE.STD_LOGIC_ARITH.ALL;
4 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
5
6 ENTITY contador IS
7 GENERIC( n : STD_LOGIC_VECTOR:= "0101");
8 PORT ( clk : IN STD_LOGIC;
9 Reset : IN STD_LOGIC;
10 en : IN STD_LOGIC;
11 m : OUT STD_LOGIC;
12 salida : OUT std_logic_vector(3 downto 0)
13 );
14 END contador;

15
16 ARCHITECTURE arch OF contador IS
17
18 SIGNAL cuenta_s: std_logic_vector(3 DOWNTO 0) := (OTHERS => '0');
19
20 BEGIN
21
22 PROCESS (clk, cuenta_s)
23
24 BEGIN
25 IF (reset='1') THEN
26 cuenta_s <= "0000" ;
27 ELSIF (clk'event AND clk = '1' and en = '1') THEN
28 IF cuenta_s <= n-1 THEN
29 cuenta_s <= cuenta_s + "0001";
30 ELSE
31 m <= '0';
32 cuenta_s <= "0000";
33 END IF;
34 END IF;
35 IF cuenta_s = n THEN
36 m <= '1';
37 ELSE
38 m <= '0';
39 END IF;
40 END PROCESS;
41
42 salida <= cuenta_s;
43
44 end arch;
Fig. 12.3 Código VHDL con la descripción para los contadores limitados a una cuenta máxima.
Esta arquitectura que se propone para la implementación de los contadores cuenta con
una salida que indica que el contador ha llegado a su cuenta máxima lo que nos permite
habilitar a los contadores de las etapas subsecuentes. Como ejemplo de la interconexión de
los contadores para implementar la estructura propuesta para el cronómetro, en el código
que se muestra en la Fig. 12.4 se describe como conectar dos de estos contadores para
realizar la cuenta de 00 a 59 segundos.
1 LIBRARY IEEE;
3 USE IEEE.STD_LOGIC_ARITH.ALL;
4 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
5
6 ENTITY cronometro IS
8 reset : IN STD_LOGIC;
10 segundos : OUT std_logic_vector(3 downto 0);
11 dec_segundos: OUT std_logic_vector(3 downto 0)
12 );
13 END cronometro;
14
15 ARCHITECTURE arch OF cronometro IS
16
17 COMPONENT contador IS
18 GENERIC( n : STD_LOGIC_VECTOR:= "0101");
20 reset : IN STD_LOGIC;

22 m : OUT STD_LOGIC;
23 salida : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
24 );
25 END COMPONENT;
26
27 SIGNAL m1 : STD_LOGIC;
28
29 BEGIN
30
31 contador_1: contador GENERIC MAP ( n => "1001" )
32 PORT MAP ( clk => clk,
33 reset => reset,
34 en => en,
35 m => m1,
36 salida => segundos );
37
38 contador_2: contador GENERIC MAP ( n => "0101" )
39 PORT MAP ( clk => clk,
40 reset => reset,
41 en => m1,
42 m => open,
43 salida => dec_segundos );
44
45
46 END ARCHITECTURE;
Fig. 12.4. Código VHDL con el instanciado de dos contadores para la cuenta de 0 a 59 segundos.
En la Fig. 12.5 se muestra el código en VHDL para describir el test bench con el que
se llevara a cabo la simulación.
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.ALL;
3
4 ENTITY cronometro_tb IS
5 END cronometro_tb;
6
7 ARCHITECTURE behavior OF cronometro_tb IS
8
9 COMPONENT cronometro
10 PORT(
11 clk : IN std_logic;
12 reset : IN std_logic;
13 en : IN std_logic;
14 segundos : OUT std_logic_vector(3 downto 0);
15 dec_segundos : OUT std_logic_vector(3 downto 0)
16 );
17 END COMPONENT;
18
19
20 --Inputs
21 signal clk : std_logic := '0';
22 signal reset : std_logic := '0';
23 signal en : std_logic := '0';
24
25 --Outputs
26 signal segundos : std_logic_vector(3 downto 0);
27 signal dec_segundos : std_logic_vector(3 downto 0);
28
29 -- Clock period definitions
30 constant clk_period : time := 10 ns;
31
32 BEGIN
33
34 -- Instantiate the Unit Under Test (UUT)
35 uut: cronometro PORT MAP (

36 clk => clk,

37 reset => reset,
38 en => en,
39 segundos => segundos,
40 dec_segundos => dec_segundos
41 );
42
43 -- Clock process definitions
44 clk_process :process
45 begin
46 clk <= '0';
48 clk <= '1';
50 end process;
51
52 reset <= '0', '1' after 50 ns, '0' after 70 ns;
53
54 en <= '0', '1' after 150 ns;
55
56
57 END;
Fig. 12.5 Código VHDL del test bench para el contador de 0 a 59 segundos.
Una vez agregado al proyecto el código para el test bench, se abre la venta del
simulador y se obtienen las siguientes gráficas. En la Fig. 12.6 se muestra la cuenta de los
primeros 16 segundos.
Fig. 12.6 Señales obtenidas en el simulador donde se muestra la cuenta de 0 a 16 segundos.
En la Fig. 12.7 se muestra las señales que corresponden a los últimos 15 segundos.
Fig. 12.7 Señales obtenidas en el simulador donde se muestra la cuenta de 35 a 59 segundos.

1. Complete el circuito del ejemplo demostrativo para tener un cronómetro con una
cuenta máxima de 59 minutos con 59 segundos.
2. Creé el archivo VHDL para describir el test bench y obtenga las gráficas en el
simulador.
3. Implemente el circuito de control para el multiplexado de los displays de 7
segmentos que se ha explicado en la sección de introducción.
4. Creé el archivo UCF, implemente el circuito en la tarjeta Digilent Basys y
compruebe la correcta operación del sistema.


diseño?_________________

Lab.%13.%Control%de%velocidad%de%un%motor%DC%con%PWM%
13.1%Objetivo%
El objetivo de esta práctica de laboratorio consiste en diseñar e implementar el
circuito controlador de la velocidad de un motor DC mediante la modulación del ancho de
pulso de una señal cuadrada (PWM, por sus siglas en inglés), en un FPGA.
diseñar e implementar un circuito controlador digital para una aplicación ampliamente
utilizada en el ámbito Mecatrónico. Específicamente, esta práctica de laboratorio impacta
los siguientes temas del plan de estudios de la asignatura Sistemas Digitales I (ver carta
- Unidad 6
- Sub-tema 6.1, 6.2 y 6.3
13.3 Introducción
El diseño de máquinas de estado se puede realizar de una forma muy simple en VHDL, y
constituye un claro ejemplo de la potencia de los lenguajes de descripción de hardware
frente a los métodos tradicionales de diseño. La metodología tradicional comienza por
construir un diagrama de estados, de la que se deriva una tabla de estados. Sobre esta tabla
se pueden agrupar estados equivalentes, si se da el caso. A continuación se asignan los
estados y se pasa a una tabla de excitación de las que se obtienen las ecuaciones de estados
de los estados siguientes y de las salidas según el tipo de biestable (Flip Flop) elegido para
el diseño del sistema secuencial. Se trata de un método algorítmico y por tanto susceptible
de ser realizado por una herramienta de software en VHDL. El código VHDL describe la
tabla de estados o el diagrama de estados y es la herramienta de síntesis quien lleva a cabo
todo el proceso de implementación de compuertas lógicas y biestables. En general, las
máquinas de estado se clasifican como máquina de Moore o de Mealy. La primera se
caracteriza porque las salidas dependen únicamente del estado, en cambio la de Mealy
dependen del estado y de las entradas y se diferencia en la forma de expresar las señales de
salida. En VHDL no es necesario resolver ninguna tabla de estados. Las transiciones de
estados se pueden expresar con una estructura combinacional del tipo IF-THEN-ELSE o lo
que es más habitual con una estructura CASE-WHEN. Ambas deben ser utilizadas en un
proceso.
MC. Manuel Jesús López Sánchez Lab. 13. Control de velocidad de un motor
Dr. Alejandro Arturo Castillo Atoche DC con PWM
La modulación por ancho de pulso (PWM, por sus siglas en inglés) es un tipo de control
que se puede utilizar para muchas aplicaciones Mecatrónicas. En este laboratorio se
explicará de manera simplificada el funcionamiento de un PWM.
Los parámetros fundamentales del PWM son el periodo (T) y el ciclo de trabajo (D). El
ciclo de trabajo indica el tiempo que la función es activada con respecto al tiempo total (el
periodo). La Fig. 13.1 muestra tres ciclos de trabajo distintos. Se puede observar que el
periodo del PWM se mantiene constante, y lo que cambia es el tiempo en que la señal se
mantiene activa respecto al periodo total.
Fig. 13.1. Señal PWM.
Si el periodo del PWM es suficientemente pequeño, el dispositivo que está gobernado (en
este laboratorio el motor) no notará las variaciones de la tensión y el resultado es que el
motor recibirá una corriente promedio dada por el ciclo de trabajo. La Fig. 13.2 muestra
dos PWM con ciclos de trabajo distintos que se aplicarán al motor para controlar su
velocidad.
Fig. 13.2. Control de la velocidad de un motor DC con PWM.
Adept precargados.
13.5%Ejemplo%%demostrativo:%PWM%
En esta sección se presenta como implementar un controlador digital PWM de 3 bits de
resolución utilizando el lenguaje de descripción de hardware VHDL.
El procedimiento de diseño del controlador PWM es el siguiente:
Consideraciones de diseño: Implementar una arquitectura del controlador PWM con

la técnica RTL en VHDL.
2.- Crear un Archivo nuevo del tipo VHDL con el nombre pwm3b.vhd
3.- Realizar el código VHDL, en relación al comportamiento descrito en la siguiente Fig.

13.3.
Fig. 13.3. PWM con 3 bits de resolución.
Note que la descripción del código debe encontrarse dentro de un process y es sensible al
reloj.
4.- Salva el código VHDL con el nombre “pwm3b.vhd”. Sintetizalo e impleméntalo para
5.- Verifica el diseño utilizando su respectivo “testbench” para simular los resultados.
13.6%Instrucciones%del%laboratorio%No.%13%
Controlador digital de la velocidad de un motor DC con PWM.

En esta práctica de laboratorio se va a diseñar e implementar en un FPGA un controlador
digital PWM que modulará la velocidad de un motor DC.
Mediante un circuito de potencia adecuado se puede controlar la velocidad y el sentido de

un motor. Habitualmente se usa un puente en H. El puente en H (H‐bridge) se puede hacer
con tranasistores MOSFETs, o bien comprar un módulo PMOD de digilent (PMODHB320
o PMODHB521).
Otra opción para implementar el diseño es mediante un transistor de potencia. El esquema

básico del circuito se muestra en la Fig. 13.4.
Fig. 13.4. Circuito electrónico de potencia.
Según el motor, se debe seleccionar la tensión (Vcc), el transistor y resistencias adecuadas.
El proceso metodológico para implementar el laboratorio es el siguiente:
1. Realizar la programación en VHDL del diagrama esquemático propuesto. Una vez

programado el FPGA se verificará el resultado del controlador en el display de siete
segmentos, indicando que velocidad tiene (1 de 8 posibles).
Para realizar el laboratorio se considerará lo siguiente:
a) Generar el ciclo de trabajo (dutycycle).
b) 103 Generar la señal periódica que produzca una señal con periodo T
(cuentaPWM). En realidad será un contador. ¿De cuánto sería este contador?
c) 103 Comparar la cuenta de la señal periódica con el valor del ciclo de trabajo, si
el ciclo de trabajo es mayor que la señal del PWM será uno, y si no, será cero
lógico.
d) Implementar el código en VHDL:
i. Diseñar la arquitectura divisor de frecuencia y del PWM.
e) Realizar la síntesis del código VHDL.
f) Implementar la cama de prueba del sistema.
g) Mediante el uso del programa Project Navigator que forma parte del paquete de
std_logic_vector (N downto 0), y la salida “motor” y “display” del tipo
h) Realice la síntesis del código.
i) Seleccione el menú de simulación en la venta del Project Navigator y corra la
sistema.
pines del FPGA.

dispositivo de entrada o salida que nos sea conveniente para realizar nuestras pruebas.
j) Después del proceso de síntesis:
k) Desarrollar la cama de prueba (testbench) de cada módulo y verificar su

funcionamiento.
l) Visualizar con el display la velocidad correspondiente aplicada al motor.
Cotejarlo con la señal del PWM.
m) Analizar el desempeño en términos de su área, después del proceso de síntesis.

diseño?_________________

FINAL - Manual - Practicas Sistemas Dig I PDF

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

FINAL - Manual - Practicas Sistemas Dig I PDF

Cargado por

Copyright:

Formatos disponibles

!

MC. Manuel Jesús López Sánchez

(a) (b) (c)

Además de estas compuertas básicas existen otras variantes frecuentemente utilizadas

(a) (b) (c) (d)

Las tablas de verdad de las compuertas lógicas se muestran en la Tabla 1.1.

MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

AND OR NOT NAND

! ! ! =!∙! ! ! ! =!+! ! !=! ! ! ! =!∙!

NOR XOR XNOR Buffer

! ! ! =!∙! ! ! ! =!∙! ! ! ! =!∙! ! !=!

MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

3. Agregue un nuevo archivo de texto a l proyecto que contenga el código que se

4. Seleccione el menú de simulación en la venta del Project Navigator y corra la

MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

mostradas en la Fig. 1.6. Verifique que estas corresponde al comportamiento de la

5. Para llevar a cabo la implementación física del circuito en el FPGA que se

MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

Fig. 1.8 Ubicación de los LEDs y de los interruptores en la tarjeta Basys.

1 NET "x" LOC = P36; #entrada x conectada al Interruptor SW1

6. Lleve a cabo la programación de la tarjeta Basys descargando el archivo de programación a

PARTE I. Implementación en el FPGA

a) Implementar los códigos en VHDL para describir las siguientes compuertas

MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

PARTE II. Análisis del desempeño de las arquitecturas en el FPGA

d) Después del proceso de síntesis:

e) Desarrollar la cama de prueba (testbench) de cada implementación y verificar

¿Cuál es la cantidad de LUTs utilizados en la síntesis?___________________

¿ Cuál es la cantidad de FlipFlops s utilizados en la síntesis?___________________

¿Cuál es la cantidad de IOBs utilizados en la síntesis?___________________

¿Cuál es el procentaje total de compuertas lógicas utilizados en el

Anoten sus conclusiones finales

MC. Manuel Jesús López Sánchez Lab. 1. Compuertas Lógicas

Teorema 1. El complemento de un producto es igual a la suma de sus complementos.

Teorema 2. El complemento de una suma es igual al producto de sus complementos.

Comprobación de los teoremas utilizando la tabla de verdad:

Fig. 2.1 Comprobación del Teorema de Karnaugh utilizando tablas de verdad.

Estos teoremas son de mucha importancia ya que son de gran utilidad en la

MC. Manuel Jesús López Sánchez Lab. 2. Demostración del Teorema de

posible implementar cualquier función lógica utilizando únicamente compuertas NAND o

MC. Manuel Jesús López Sánchez Lab. 2. Demostración del Teorema de

MC. Manuel Jesús López Sánchez Lab. 2. Demostración del Teorema de

Al ejecutar la simulación descrita en el test bench se obtienen las siguientes formas

PARTE I. Implementación en el FPGA

MC. Manuel Jesús López Sánchez Lab. 2. Demostración del Teorema de

PARTE II. Análisis del desempeño de las arquitecturas en el FPGA

f) Después del proceso de síntesis:

g) Desarrollar la cama de prueba (testbench) de cada implementación y verificar

¿Cuál es la cantidad de LUTs utilizados en la síntesis?___________________

¿ Cuál es la cantidad de FlipFlops s utilizados en la síntesis?___________________

¿Cuál es la cantidad de IOBs utilizados en la síntesis?___________________

¿Cuál es el procentaje total de compuertas lógicas utilizados en el

Anoten sus conclusiones finales

MC. Manuel Jesús López Sánchez Lab. 2. Demostración del Teorema de

Minimización mediante las propiedades del algebra de Boole.

Postulado 2 (a) ! + 0 = ! (b) ! ∙ 1 = !

A continuación se muestran algunos ejemplos de la aplicación de estas propiedades

MC. Manuel Jesús López Sánchez Lab. 3. Minimización de funciones

! = !" + !" + ! ! + 1 del postulado 4(a)

Otro ejemplo de minimización utilizando estas propiedades es:

! = !!! + !!" + !"! + !"#

Este método de minimización de funciones en la práctica tiene una aplicación muy