Diseño Formal Sistemas Digitales

011000010111001101100001011011100111101001100001
01101010011001010110000101101110
1
Sistemas Digitales II
011000010111001101100001011011100111101001100001
Objetivos:
01101010011001010110000101101110
• Al finalizar la unidad el estudiante estará en
capacidad de diseñar sistemas digitales, utilizando
metodología tradicional basada en máquinas
secuenciales sincrónicas.
• El estudiante podrá simular sistemas digitales
usando herramientas CAD (Computer Aided Design
– Diseño Asistido por Computador) y lenguaje de
descripción de hardware.
2
011000010111001101100001011011100111101001100001
OBJETIVO:
01101010011001010110000101101110
Habilidad de
Diseño
Diseño de
Sistemas
Digitales
Controlador (SD) Bloques MSI
MSS VHDL
3
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.1.- INTRODUCCION
4
011000010111001101100001011011100111101001100001
En esta unidad se presenta una metodología formal para diseñar sistemas
01101010011001010110000101101110
digitales de mediana y gran complejidad, basados en un controlador central
usando máquinas secuenciales sincrónicas y memorias.
Se muestra la forma de modelar el sistema usando un lenguaje de descripción de

hardware. Además, se presentan las simulaciones usando una herramienta CAD e
las implementaciones usando circuitos de lógica programable de muy alta
velocidad.
En este capítulo también se aborda la definición, clasificación y aplicaciones de
las memorias ROM (PROM, EPROM, EEPROM, Flash) y RAM (Estáticas y
Dinámicas).
5
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.2.- DIAGRAMA DE BLOQUES
GENERAL
6
011000010111001101100001011011100111101001100001
Las especificaciones del Sistema Digital a desarrollar, nos indican de forma

general las entradas y salidas del Sistema. Pero no detalla los componentes a
01101010011001010110000101101110
utilizar para resolver el problema planteado.
Fin
Start
Load_Reg Repeticiones
Detector de
Load_Pat 7
repeticiones de un
12
Data_In patrón en una trama de
3 Datos.
Pat
Clock Resetn
Lo aprendido en el capítulo anterior, nos sugiere utilizar un controlador MSS para

desarrollar las tareas secuenciales del Sistema Digital, pero para procesar datos
necesitamos PROESADORES DE DATOS.
7
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.3.- CIRCUITO
CONTROLADOR Y
PROCESADOR DE DATOS
8
011000010111001101100001011011100111101001100001
Las MSS estudiadas y diseñadas hasta ahora pueden ser usadas como
subcircuitos o bloques de los circuitos digitales más complejos llamados Sistemas
Digitales.
01101010011001010110000101101110
Las técnicas del diseño que estudiaremos a partir de ahora son aplicables al
diseño de Sistemas Digitales de cualquier tamaño.
Un Sistema Digital puede ser dividido en dos partes principales llamados

Procesador de Datos y circuito Controlador.
El Procesador de Datos es usado para almacenar y manipular datos y para

transferir datos de una parte del Sistema Digital al otro. El procesador de Datos
incluye bloques como registros de almacenamiento, registros de desplazamiento,
contadores, multiplexores, decodificadores, sumadores, etc.
El circuito Controlador es una MSS que controla la operación de Procesador de

Datos.
9
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Entradas Controlador MSS Salidas
Fin
Start
Load_Reg En1
Load_Pat Ld1
En2
Out
Igual?
MSS Ld2
En3
1min Ld3
En4
Clock
Enf
Resetn
10
011000010111001101100001011011100111101001100001
Datos Procesador de Datos (Bloques MSI) Datos
01101010011001010110000101101110
Comparador: Multiplexor:
11
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Sumadores: Decoder:
12
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Codificador BCD a 7 Segmentos: Convertidor o Codificador

Decimal a BCD:
13
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Registro de Sostenimiento:
Registro de Desplazamiento:
14
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Contador Up:
15
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Memoria RAM:
16
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.4.- PARTICION FUNCIONAL
17
011000010111001101100001011011100111101001100001
Diagrama de bloques general de un Sistema Digital.
01101010011001010110000101101110
18
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.5.- PROCEDIMIENTO
GENERAL DEL DISEÑO DE UN
SISTEMA DIGITAL
19
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
1.- Identificar el
algoritmo que 2.- Diseñar la 3.- Hacer el Diagrama
resuelve los partición funcional ASM del Controlador
requerimientos del del SD. MSS.
SD.
20
011000010111001101100001011011100111101001100001
1.- ALGORITMO:
Pseudocódigo para el ingreso de datos con un tamaño menor o igual a 10.
01101010011001010110000101101110
Se inicializa el contador i en cero. En este otro estado se desarrolla el algoritmo de
ingreso de datos. Siempre preguntamos primero
por la condición de salida en el ASM. Este estado
trabaja como anclaje para el bucle infinito.
i=0; El estado de anclaje tiene una salida moore
While(FinIngreso=0){ mediante un led indicando que se pueden seguir
ingresando datos.
LedIngreso=1; Este es otro estado en el que se valida que el
botón de Ingreso esté activado por el usuario y
If (IngresoA=1 and i≤10){ además que el número de datos ingresados es
menor a 10.
RAMA(i)=InNumero; En este caso luego de la validación, de forma

mealy en el mismo estado se puede generar el
i=i+1; enable para guardar en dato en la dirección i de la
memoria RAM.
}
} En el siguiente estado de forma moore se debe
hacer que el contador i incremente su valor. OJO
no se puede hacer el paso anterior (guardar un
Regreso al estado de anclaje del bucle while. dato en la dirección i) e incrementar el contador i,
en un mismo estado.
21
011000010111001101100001011011100111101001100001
1.- ALGORITMO:
Pseudocódigo para detectar las veces que se repite cada dígito común es.
01101010011001010110000101101110
For i=0 to TamSecuencia Se pueden usar instrucciones for que son similares a la While,
cuya única diferencia es que aquí nuestra condición de salida se
genera al comparar el contador up i con TamSecuencia.
CNT=0
Se inicializa un contador que nos permite registrar cuantas veces
se repite cada dígito. Se lo puede hacer de forma moore.
For j=0 to TamSecuencia Este segundo for recorre la memoria RAM comparando el dato
de la dirección i (controlado por el for principal que actúa como
R1=RAM(i) pivote) con el de la dirección j.
R2=RAM(j) El acceso a la ram solo se lo puede hacer una dirección a la vez,
por ello en los dos siguientes estados se guardan en dos
registros los valores RAM(i) y RAM(j).
If R1=R2
En este otro estado se pregunta si los valores R1 y R2 son igual,
Inc(CNT) en caso de serlo se incrementa de forma mealy en contador CNT.
Endif Regresa al estado de anclaje del segundo for.
endFor La RAMCnt utiliza el valor almacenado en la RAM(i) como
dirección. En este if se valida que el número de repeticiones del
if RAMCnt(RAM(i))<CNT dígito RAM(i) es mayor al número anteriormente guardado (por
RAM(RAM(i))=CNT defecto RAMCnt está llena de ceros).
Endif Se actualiza el número de veces que se repite el dígito RAM(i).
EndFor
Regreso al estado de anclaje del primer for. 22
011000010111001101100001011011100111101001100001
2.- PARTICION FUNCIONAL:
01101010011001010110000101101110
Señales Controlador Señales
DIGITALES 2 – Cap1
Señales
Datos Procesador de Datos Datos
DIGITALES 2 – Cap2
23
011000010111001101100001011011100111101001100001
3.- ASM:
01101010011001010110000101101110
While(Load_Reg=0){
En1=1; Ld1=1;
}
EnCnt=1; LdCnt=1;
While(Start=0){}
While(Val1=0 and Qreg(0)=0){
En1=1;
}
If(Val1=1){
Enf=1;
While(2segundos=0){
Fin=1;
}
}else{
En1=1;
}
24
011000010111001101100001011011100111101001100001
Ejemplo de una Partición Funcional.
Partición Funcional del Sistema de Control de una maquina vendedora
de colas.
01101010011001010110000101101110
25
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.6.- LENGUAJE DE
DESCRIPCIÓN DE HARDWARE
APLICADO AL DISEÑO DE UN
SISTEMA DIGITAL
26
011000010111001101100001011011100111101001100001
Para la implementación usando dispositivos lógicos programables (PLD) se debe:
•Ingresar el Sistema Digital en un software de diseño y simulación (por ejemplo,
QuartusII de Altera) utilizando cualquier de los editores (Editor Grafico, Editor de Formas
01101010011001010110000101101110
de Onda, Editor de texto / VHDL).
•Compilar el diseño, simular y revisar los resultados de simulación analizando los
Diagramas de Tiempo generados por el simulador.
COMENTARIOS IMPORTANTES:
• El circuito Controlador de un Sistema Digital maneja solamente señales de control de
un bit. Recibe las señales de entrada de un bit que pueden ser externas (Start, Inicio,
etc.) o internas provenientes de algunos subcircuitos Procesadores de Datos (AmenorB,
LSBigual0, etc.).
También, genera señales de salida de un bit que pueden ser externas (Fin, Error,etc.) o
internas que van a controlar las operaciones de subcircuitos que forman parte de
Procesador de Datos.
• Las señales de entrada de datos de múltiples bits no pueden nunca entrar al circuito
Controlador. Deben entrar en algún subcircuito del Procesador de Datos. También, las
señales de salida de múltiples bits deben ser generadas por algún circuito Procesador
de Datos. Pueden existir casos en los que las señales externas de control de un bit,
también entran o salen del Procesador de Datos. Pero nunca las señales de múltiples
bits pueden entrar o salir del Controlador.
27
011000010111001101100001011011100111101001100001
Estructura general del código VHDL en el diseño de un Sistema Digital.
Luego de estructurar la Partición Funcional se debe decidir que tipo de descripción se
01101010011001010110000101101110
desea usar para cada subcircuito del Sistema Digital y para el Sistema completo.
Un subcircuito o subsistema puede ser representado con un solo componente (registro,

multiplexor, comparador) o con varios componentes como, por ejemplo, el circuito
Acumulador (sumador + registro de sostenimiento).
Cada subcircuito en un diseño del Sistema Digital con VHDL representa una entity.
En caso que la entity represente un Sistema Digital completo, sus terminales de entrada y
salida le permiten interactuar con el mundo exterior.
La declaración de entity puede incluir también la keyword generic. Mediante VHDL, la

instrucción generic puede declarar y especificar parámetros constantes útiles para crear
bloques parametrizados, en los que los valores de algunos parámetros pueden ser
variados.
28
011000010111001101100001011011100111101001100001
Ejemplo:
01101010011001010110000101101110
La declaración de entidad solo proporciona la información necesaria para conectar el
subcircuito representado por esta entity con otros circuitos.
La declaración architecture describe el funcionamiento interno de una entity. VHDL

permite crear más de una alternativa para la architecture.
VHDL soporta tres tipos diferentes de descripción de architecture (o niveles de

abstracción) de los Sistemas Digitales:
29
011000010111001101100001011011100111101001100001
• Descripción estructural (nivel lógico de abstracción) en la que se

especifican los componentes que forman el sistema y sus interconexiones.
01101010011001010110000101101110
Para describir en VHDL el funcionamiento de este circuito utilizando la descripción
estructural hay que definir los componentes que forman parte del circuito (si es que no
están disponibles en la biblioteca library).
30
011000010111001101100001011011100111101001100001
Tanto las señales internas como los
componentes deben ser declarados en el
cuerpo de architecture antes del begin de
la descripción.
01101010011001010110000101101110
Se puede observar que la declaración
Luego se debe hacer la descripción component tiene una estructura similar a la
lógica del circuito declarando declaración entity, pero mientras la entity
previamente las señales (signals) proporciona la interfaz del circuito con el
internas de interconexión An y Bn y mundo exterior, la declaración component
los componentes a utilizar (inversor y proporciona la interfaz entre los componentes
puerta AND). del circuito.
31
011000010111001101100001011011100111101001100001
Cada component se conecta con los demás con ayuda de la keyword “port map”.
Las señales en la declaración port map deben aparecer en el mismo orden como ellas
fueron declaradas en component.
01101010011001010110000101101110
Se puede ver claramente que la descripción estructural es una descripción del diagrama
esquemático del circuito y que es muy extensa, incluso para los circuitos relativamente
pequeños.
Sin embargo, la descripción estructural se utiliza para la descripción de los diseños más
grandes.
32
011000010111001101100001011011100111101001100001
Descripción a nivel de transferencia entre registros o flujo de datos
(nivel RTL de abstracción) en la que se especifica el comportamiento
de las señales de salida a partir de las señales de entrada.
01101010011001010110000101101110
Esta descripción tiene un cierto grado de abstracción con respecto al hardware,
pero es necesario describir las distintas señales que interactúan en el circuito y su
comportamiento en función de las señales de entradas por medio de ecuaciones
lógicas y declaraciones de asignación.
Nota: el operador <= indica asignación a señal.
Se puede ver que en esta descripción se debe hacer la declaración de todas las
señales internas y se debe utilizar los operadores lógicos.
Los operadores lógicos que pueden ser usados en VHDL son definidos en la
biblioteca (library) estándar del lenguaje y son los siguientes: not, and, or, nand,
nor, xor y xnor.
33
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Al igual que otros lenguajes de programación, VHDL, utiliza diferentes operadores
que pueden ser utilizados con cualquier tipo de señal (bit, bit_vector, std_logic,
std_logic_vector).
34
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Por lo tanto, no se puede usar estos operadores como los nombres de las señales
de entrada o salida de los sistemas digitales diseñados.
Por ejemplo, para indicar las salidas del comparador no se puede usar A>B, A<B y
A=B. Se puede asignar AmayorB o AgtB, etc.
Se puede también utilizar declaraciones concurrentes condicionales when – else.
35
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Se puede también utilizar asignación selectiva with – select – when.
36
011000010111001101100001011011100111101001100001
En la declaración with – select – when se evalúa la expresión que acompaña a la

declaración with. Cuando el valor de esta expresión coincide con una de las
01101010011001010110000101101110
alternativas dadas después de “when”, el valor correspondiente a esta alternativa
se asigna a la señal de salida.
La expresión que debe evaluarse en este ejemplo es GBA que se declara como
una señal de tres bits. Mediante la concatenación (&) de las tres entradas (G, A y
B) se forma una string de tres bits.
Las alternativas dadas después de when pueden ser varias o una sola.
Por ejemplo, en vez de escribir “0000” when others podemos escribir lo siguiente:
“0000” when “000” | ”001” | ”010” | ”011”;
La barra “ | ” tiene el mismo significado que el operador lógico or.
37
011000010111001101100001011011100111101001100001
Descripción funcional o por comportamiento (nivel algorítmico de
abstracción) en la que se especifica el funcionamiento del sistema.
Esta es la descripción con mayor grado de abstracción. Solo se describe el
01101010011001010110000101101110
comportamiento del sistema, sin preocuparse por las señales o componentes
internos.
38
011000010111001101100001011011100111101001100001
Dentro de la arquitectura (architecture) aparece un proceso (process) que es la

declaración que representa un conjunto de declaraciones que se ejecutan en
01101010011001010110000101101110
secuencia.
La declaración process puede ser usada tanto en la descripción de circuitos

combinatoriales como secuenciales.
Los tres tipos de descripción de un Sistema Digital en VHDL pueden mezclarse en

un mismo diseño.
Si ya tenemos estructurada la Partición Funcional, se puede adoptar un modelo

de diseño top-down (de arriba hacia abajo).
El Diseño top-down comprende la construcción de cada subcircuito o subsistema

usando la descripción por comportamiento o por flujo de datos y luego,
conectándolos en un Sistema Digital utilizando la descripción estructural.
39
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.7.- EJEMPLOS DE DISEÑO DE
SISTEMAS DIGITALES
40
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Ejemplo:
DISEÑO DE UN SISTEMA DIGITAL
DETECTOR DE 1’s
41
011000010111001101100001011011100111101001100001
Datos:
Se desea detectar cuantos unos (1) hay en la entrada Datos, que está conformada
por n bits. Si la señal Load_Reg es verdadera, se asume que el dato es válido y
01101010011001010110000101101110
debe ser cargado en el circuito.
La detección debe iniciar si la señal START es verdadera.
En la salida Num_unos se debe indicar en binario, la cantidad de unos presentes
en el dato cargado. La salida Fin será verdadera cuando termine la detección.
42
011000010111001101100001011011100111101001100001
Tenemos que diseñar simultáneamente la Partición Funcional y el Diagrama
ASM del circuito Controlador.
La solución propuesta consiste en un registro de desplazamiento, donde se cargue
01101010011001010110000101101110
el dato original, y con cada pulso de reloj, en la posición menos significativa se
muestre cada uno de los bits. Si el bit es uno (1) se manda habilita a un contador
binario, mientras que si el bit es cero (0) no se cuenta.
Basándonos en las reglas básicas, podemos darnos cuenta que el registro de
desplazamiento y el contador deben ser subcircuitos del Procesador de Datos.
La Partición Funcional en este caso es sencilla. Necesitamos un registro de
desplazamiento de n bits (por ejemplo, de 8 bits) y un contador de log2n bits
(puede ser un contador de 4 bits).
43
011000010111001101100001011011100111101001100001
El registro debe ser de desplazamiento de izquierda a derecha y debe tener
capacidad de carga en paralelo para los datos de entrada de n bits.
El contador también debe tener capacidad de carga paralela para tener 0’s
01101010011001010110000101101110
(encerar el contador) en el estado inicial. Normalmentem no se utiliza la señal
Resetn para limpiar directamente a contadores en el estado inicial.
En la práctica, la señal de Resetn es usada en los Sistemas Digitales solo para dos
propósitos:
•Para colocar el circuito en el estado inicial luego de prender la fuente de poder.
•Para colocar el circuito en el estado inicial en caso que funcione
incorrectamente.
De esta manera decimos que de forma general, los subcomponentes para El
procesador de datos, tendrán dos tipos de señales:
En : Enable (Habilitación del dispositivo) y Ld = Load (carga de datos)
Si En=0 : El dispositivo mantiene el último valor en la salida

Si En=1 y Clock=flanco :
Si Ld=1 : Se carga el dato de la entrada paralela
Si Ld=0 : El dispositivo opera según su diseño (desplaza, cuenta, etc).
44
011000010111001101100001011011100111101001100001
Partición Funcional
01101010011001010110000101101110
Una vez elegidos los subcircuitos del Procesador de Datos, en el Diagrama ASM se debe
indicar exactamente que señales va a recibir y debe generar el circuito Controlador.
45
011000010111001101100001011011100111101001100001
Diagrama ASM del Controlador
01101010011001010110000101101110
En estado Ta el Controlador debe generar las señales incondicionales de habilitación EnCnt
y de carga LdCnt para encerar el contador_up.
Al finalizar el estado Ta el Controlador pregunta por la entrada externa Start. Si Start no ha
sido activado pregunta por la otra entrada externa LdReg que es la señal de carga del
registro_i_d. Si LdReg ha sido activada el Controlador genera la salida condicional de
habilitación EnReg.
46
011000010111001101100001011011100111101001100001
En el estado Tb el Controlador genera la salida incondicional EnReg que permitirá
01101010011001010110000101101110
el desplazamiento a la derecha del registro_i_d.
Puesto que para manejar el registro_i_d y el contador_up, se emplea la misma

señal de Clock que utiliza el Controlador, el desplazamiento del registro_i_d se
realizará al finalizar el estado Tb con el siguiente flanco de subida del Clock.
En el mismo instante de tiempo el Controlador preguntara si el Dato de 8 bits

cargado en el registro_i_d tiene 1´s.
El Controlador debe recibir esta entrada interna de algún circuito que analiza el
Dato cargado en la salida del registro_i_d y puede generar la señal Num = 0 (Reg
= 0). En este caso puede ser una simple puerta NOR de 8 entradas.
47
011000010111001101100001011011100111101001100001
Para evaluar si el Dato contiene 1´s es necesario preguntar bit por bit si cada uno
01101010011001010110000101101110
de ellos es 0 o 1.
La señal Q0 debe llegar al circuito desde la salida del registro_i_d, desde el bit
menos significativo (más a la derecha).
Si este bit es un 1 el Controlador debe generar la salida condicional de EnCnt que

habilitara el conteo del contador_up. Ya que al contador_up le llega la misma
señal de Clock, entonces, el contador_up se incrementa al finalizar el estado Tb.
Si el Dato no tiene ni un 1, entonces, el Controlador va al estado Tc, genera la

salida Fin y espera que la entrada Start se desactive. Este paso es necesario
porque los Sistemas Digitales trabajan con una frecuencia de Clock muy grande,
incomparable con el tiempo de reacción de un ser humano.
48
011000010111001101100001011011100111101001100001
IMPLEMENTACION CON VHDL
Se puede ahora diseñar el circuito Controlador y los subcircuitos del Procesador de
Datos en VHDL y luego interconectar todo utilizando el Editor Grafico.
Código VHDL para el contador_up.
01101010011001010110000101101110
49
011000010111001101100001011011100111101001100001
Código VHDL para el registro de desplazamiento i_d.
01101010011001010110000101101110
50
011000010111001101100001011011100111101001100001
Código VHDL para el controlador
01101010011001010110000101101110
51
011000010111001101100001011011100111101001100001
Código VHDL para el controlador
01101010011001010110000101101110
Ahora podemos interconectar el bloque controlador con el procesador de datos.
Para esto usaremos el editor gráfico de QUARTUS II, conectando cada uno de los componentes
previamente diseñados.
52
011000010111001101100001011011100111101001100001
Diseño completo interconectado
01101010011001010110000101101110
53
011000010111001101100001011011100111101001100001
Diagramas de tiempo del diseño completo
01101010011001010110000101101110
54
011000010111001101100001011011100111101001100001
También se puede unir el Controlador con el Procesador de Datos usando la
descripción estructural de VHDL.
Para esto, preparamos un package llamado componentes que incluya a los circuitos del
Procesador para poder usarlos en este diseño o en cualquier otro
01101010011001010110000101101110
55
011000010111001101100001011011100111101001100001
Código VHDL para el circuito Detector de 1’s con descripción estructural
01101010011001010110000101101110
56
011000010111001101100001011011100111101001100001
Código VHDL para el circuito Detector de 1’s con descripción estructural
01101010011001010110000101101110
57
011000010111001101100001011011100111101001100001
El primer process describe los cambios de estado del Controlador (Decodificador de
Estado Siguiente y Memoria de Estados) y el segundo describe cuando el
Controlador genera las salidas (Decodificador de Salida).
01101010011001010110000101101110
58
011000010111001101100001011011100111101001100001
Diagramas de tiempo del diseño estructural completo
01101010011001010110000101101110
59
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Ejemplo:
CONTADOR DE 1’s CONSECUTIVOS
CON TRASLAPE
60
011000010111001101100001011011100111101001100001
Se desea detectar cuantos unos (1) consecutivos con traslape, hay en la entrada Datos,
que está conformada por 8 bits. Si la señal Load_Reg es verdadera, se asume que el
01101010011001010110000101101110
dato es válido y debe ser cargado en el circuito. En la salida Num_unos se debe indicar
en binario, la cantidad de unos consecutivos presentes que hay en el dato cargado. La
salida Fin será verdad cuando termine la detección.
Ejemplo:
61
011000010111001101100001011011100111101001100001
Partición Funcional
01101010011001010110000101101110
62
011000010111001101100001011011100111101001100001
ASM:
01101010011001010110000101101110
63
011000010111001101100001011011100111101001100001
VHDL:
01101010011001010110000101101110
64
011000010111001101100001011011100111101001100001
VHDL:
01101010011001010110000101101110
65
011000010111001101100001011011100111101001100001
VHDL:
01101010011001010110000101101110
66
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Ejemplo:
MULTIPLICADOR
67
011000010111001101100001011011100111101001100001
Se desea diseñar un circuito Multiplicador de dos números binarios sin signo,

cada uno de n bits.
01101010011001010110000101101110
Utilizaremos en el diseño el mismo método de multiplicación que se utiliza en el
proceso de multiplicación manual.
El Producto esta formado por una serie de operaciones de suma.
Para cada i bit del Multiplicador_B que es igual a 1 sumamos al Producto el valor
de Multiplicando_A desplazado a la izquierda i veces.
68
011000010111001101100001011011100111101001100001
En el Procesador de Datos debemos usar un registro de desplazamiento

de derecha a izquierda de 2n bits para el número Multiplicando_A. El
01101010011001010110000101101110
Multiplicando_A es de n bits, pero debe ser desplazado n-1 veces, por lo tanto
debe tener 2n bits.
También necesitamos un registro de desplazamiento de izquierda a derecha de n

bits para analizar bit por bit el número Multiplicador_B.
El sumador debe ser de 2n bits también y necesitamos un registro de

sostenimiento de 2n bits para el Producto_P.
Inicialmente el registro P debe estar en 0. Ya que no podemos usar Resetn

debemos cargarlo con 0. Utilizaremos un conjunto de mux de 2-a-1 de 2n bits.
Cuando la entrada Sel= 0 a las entradas del registro P llegan 0 y cuando Sel=1 el
registro P puede ser cargado con P+A proveniente del sumador.
También necesitamos la puerta NOR para detectar que todos los bits del
Multiplicador_B son iguales a 0.
69
011000010111001101100001011011100111101001100001
Bosquejo del Procesador de Datos.
01101010011001010110000101101110
70
011000010111001101100001011011100111101001100001
Diagrama ASM del Controlador
01101010011001010110000101101110
Para implementar en VHDL nuestro diseño, primero desarrollamos individualmente cada
componente del procesador de datos:
71
011000010111001101100001011011100111101001100001
Diagrama de tiempo del circuito MULTIPLICADOR
01101010011001010110000101101110
72
011000010111001101100001011011100111101001100001
Código VHDL para el registro de desplazamiento_d_i
01101010011001010110000101101110
73
011000010111001101100001011011100111101001100001
Código VHDL para el registro de desplazamiento_i_d
01101010011001010110000101101110
74
011000010111001101100001011011100111101001100001
Código VHDL para el registro de sostenimiento
01101010011001010110000101101110
75
011000010111001101100001011011100111101001100001
Código VHDL para un BUS MUX 2 a 1
01101010011001010110000101101110
76
011000010111001101100001011011100111101001100001
Creación del paquete COMPONENTES
01101010011001010110000101101110
77
011000010111001101100001011011100111101001100001
Creación del paquete COMPONENTES
01101010011001010110000101101110
78
011000010111001101100001011011100111101001100001
Código VHDL del circuito total Multiplicador de dos palabras de n bits.
01101010011001010110000101101110
El numero de bits de los datos DataA y DataB es establecido por el parámetro genérico n.
Ya que los registros A y P deben ser de 2n bits se define un segundo parámetro genérico
nn para representar el tamaño 2 x n.
Cambiando los valores de los parámetros genéricos se puede usar el mismo código VHDL
para números de cualquier tamaño.
79
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
La entrada de carga en paralelo del Multiplicando_A es de 2n bits, pero el DataA es solo de
n bits. Por lo tanto se usa la señal interna n_zeros para completar con ceros los 2n bits.
La señal Ain concatena estos bits con DataA para cargarlos en el registro Multiplicando_A.
Los procesos MSS_transiciones y MSS_salidas definen las transiciones de estados y
generación de salidas del circuito Controlador.
80
011000010111001101100001011011100111101001100001
Los procesos MSS_transiciones y MSS_salidas definen las transiciones de
estados y generación de salidas del circuito Controlador.
01101010011001010110000101101110
81
011000010111001101100001011011100111101001100001
El Procesador de Datos esta descrito por el siguiente código VHDL:
01101010011001010110000101101110
82
011000010111001101100001011011100111101001100001
INTERFASES
Interfas de Entrada INTERFASES
01101010011001010110000101101110
83
011000010111001101100001011011100111101001100001
Diagrama ASM
01101010011001010110000101101110
84
011000010111001101100001011011100111101001100001
Interfaz de Salida
01101010011001010110000101101110
85
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Ejemplo:
DIVISOR
86
011000010111001101100001011011100111101001100001
Diseñar un circuito Divisor de dos números binarios sin signo de n bits.
01101010011001010110000101101110
Dados dos números sin signo DividendoA y DivisorB, el circuito debe producir dos salidas
de n bits CocienteQ y RestoR.
Los datos se cargarán en los registros internos, cuando la señal LdA sea verdadera. Al
finalizar la división se debe generar la salida Done.
Utilizaremos en el diseño el método que se utiliza en el proceso de división manual, es
decir, el método de desplazamientos y restas sucesivas.
87
011000010111001101100001011011100111101001100001
DISEÑO DE UN SISTEMA DIGITAL DIVISOR
A continuación se muestra un ejemplo de una división manual en decimal y en
01101010011001010110000101101110
binario:
El circuito debe desplazar a la izquierda los dígitos del registro Dividiendo A

para que vayan ingresando en el registro de desplazamiento Resto R.
88
011000010111001101100001011011100111101001100001
Inicialmente el Resto R debe ser cero. En R se van ingresando uno a uno
01101010011001010110000101101110
(desplazamiento a la izquierda) los bits de A desde el más significativo Para cada
desplazamiento, mientras R sea menor que el Divisor B, cada bit del Cociente Q
se va llenando con ceros (desplazamiento a la izquierda).
Si R es mayor o igual que B, en el cociente Q debe ingresar un 1 y el resultado de
la resta entre el valor actual de R con B (R – B), debe convertirse en el nuevo valor
del Resto R.
El proceso debe repetirse hasta que en R hayan ingresado todos los bits de A.
La implementación de la resta R – B es mediante la suma de R con el
complemento a 2 de B. Si R>=B se producirá la señal de acarreo de salida Cout = 1
que mediante un desplazamiento, se coloca en el registro Q.
Además, cuando Cout = 1 el resultado de la resta se cargará en R activando la
entrada Sel de un mux2a1.
89
011000010111001101100001011011100111101001100001
El circuito Procesador de Datos entonces debe tener tres registros de
desplazamiento a la izquierda (A, R y Q) y un registro de sostenimiento B.
01101010011001010110000101101110
90
011000010111001101100001011011100111101001100001
Para verificar que todos los dígitos
de A han ingresado a R, se puede
agregar un Contador Down de
01101010011001010110000101101110
modulo n que se inicia con n-1.
Su propósito es contar el número
de desplazamientos realizados
luego que se haya activado la
entrada Start.
También se requiere una puerta
NOR para detectar que el
Contador Down ha llegado a 0 y el
proceso de la división ha
terminado.
Para realizar la operación de resta mediante la suma con complemento a 2 se
necesita un grupo de inversores
R – B = R + not B + (Ci =1).
R inicialmente se carga con 0 y cuando R sea mayor o igual que B se debe cargar
con el resultado de la resta R – B. Para ésta operación por lo tanto se requiere un
grupo de mux2a1 para controlar la entrada de R.
91
011000010111001101100001011011100111101001100001
DIAGRAMA ASM DEL CONTROLADOR
01101010011001010110000101101110
En el estado inicial S1, se carga el ContadorDown (LdC y EnC) con el número n-1 y se
coloca la señal Sel del mux2a1, que está en la entrada de RestoR, en 0 para cargar R con 0
(LdR y EnR).
92
011000010111001101100001011011100111101001100001
Si Start = 0, y si externamente se habilita la señal LdA, se carga el valor del

Dividiendo A con EnA y del Divisor B con EnB.
01101010011001010110000101101110
Si Start = 1, el circuito Controlador va al estado S2. En el estado S2 se desplazan a
la izquierda los registros R y A (EnR y EnA). Luego de eso el Controlador va al
estado S3 donde se decrementa el ContadorDown (EnC), se habilita el registro Q
(EnQ) para que el valor de Cout entre en Q en serie y se coloca la señal Sel del
mux2a1 en 1.
Se pregunta si se generó Cout =1 (R³B), lo que significaría que hay que cargar R
con la resta de R – B. También se pregunta si el ContadorDown llego a 0 (Cntig0
es la salida de la puerta NOR).
Si Cntig0 = 0, el Controlador regresa al estado S2 y la operación de división
continua. Si Cntig0 = 1, el circuito va al estado S4, genera la salida Done y espera
que la entrada Start se desactive para regresar al estado inicial.
Si el divisor es de n bits el circuito Controlador va a pasar por los estados S2 y S3
en un tiempo igual a 2n periodos de Clock.
En el estado S2 se desplazan a la izquierda R y A.
En el estado S3, si Cout = 1, se carga el resultado de la resta desde el sumador a
R. 93
011000010111001101100001011011100111101001100001
REDUCCION:
Si las operaciones que se realizan en los estados S2 y S3 se ejecutarán en un solo
01101010011001010110000101101110
estado, necesitaríamos solamente n periodos de Clock.
Podemos darnos cuenta que a medida que registro del Dividiendo A se vacía, el
registro del Cociente Q se llena. Entonces, podemos usar un solo registro para A y
Q (A/Q).
Para combinar estos dos estados en uno solo es necesario cargar el resultado de
la suma al registro R y al mismo tiempo desplazar el MSB de A al LSB de R.
Para realizar las dos operaciones en el mismo ciclo de Clock, necesitaremos un

flip-flop D y un MUX 2 a 1 adicionales.
El Flip Flop se usara para alimentar los desplazamientos del Resto R que vienen
del Dividendo A. La salida del FF D esta indicada como r0 .
La idea es tener en R el valor del resto actual (del último desplazamiento) y al

mismo tiempo al concatenar R con el bit ro, poder tener el próximo valor de R y
saber con anticipación si debemos cargar la resta o seguir desplazando.
94
011000010111001101100001011011100111101001100001
Ejemplo:
Si se quiere dividir 13 para 5:
01101010011001010110000101101110
Como podemos notar, para efectos de desplazamiento y de estimar el valor del residuo,
usamos únicamente el registro R.
Pero para comparar R con B y por ende determinar si cargamos su resta como nuevo valor
de R, usamos la concatenación de R con ro.
95
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
96
011000010111001101100001011011100111101001100001
El Diagrama ASM del circuito Controlador puede ser estructurado de la
siguiente manera :
01101010011001010110000101101110
En el estado S1, mientras Start = 0 y se activa la entrada externa LdA, se carga el
Dividiendo A y el Divisor B generando las salidas condicionales EnA y EnB.
97
011000010111001101100001011011100111101001100001
En el mismo estado, el registro Resto R y el flip-flop D se cargan con 0
01101010011001010110000101101110
respectivamente ya que las entradas de selección de los mux2a1 Sel y ER0 no
están activadas. También se carga el ContadorDown con el valor n-1. Note que
ahora el registro R solo se carga con cero si start=0, caso contrario el ya comienza
a desplazar para evitar el estado adicional.
Cuando se activa la entrada externa Start = 1, entonces, estando todavía en el

estado S1, se generan las salidas condicionales EnA y ER0.
Con EnA se desplaza el registro A/Q. La señal ER0 habilita el mux2a1 que
selecciona el MSB del registro A/Q y lo coloca en la entrada del flipflop D.
Cuando llegue el flanco de subida del Clock se produce el desplazamiento de A/Q

y la carga de D. Note que en este estado S2, al sumador le llega la concatenación
de n-1 bits de R (desde Rn-2 hasta R0) con el bit ro que es la salida del D.
Entonces ro queda como el LSB del R modificado.
98
011000010111001101100001011011100111101001100001
El sumador realiza la resta R - B, y genera la salida Cout que entra como LSB del
01101010011001010110000101101110
A/Q en el momento del siguiente desplazamiento. Esto es porque se usa un
registro unificado A/Q para el Dividiendo A y el Cociente Q.
Como antes, dentro del estado S2, el Resto R se puede desplazar a la izquierda
entrando la salida del flip-flop D, si Cout =0, o puede caragarse con el resultado
de la resta R - B, si Cout =1. Para esto la señale Rsel está activada.
La señal Cig0 es generada por una puerta NOR conectada con las salidas del
ContadorDown.
Cuando el contador que estaba cargado con n -1 llegue a 0, Cig0 = 1 y el

Controlador pasa al estado S3.
En el estado S3, se genera la salida Done, se espera que Start se desactive y se

regresa al estado inicial.
99
011000010111001101100001011011100111101001100001
IMPLEMENTACION CON VHDL Vamos a detallar únicamente componentes
que no se han usado antes.
Código VHDL del circuito ContadorDown de módulo m.
01101010011001010110000101101110
100
011000010111001101100001011011100111101001100001
Código VHDL del MUX 2 a 1 con Flip Flop tipo D
01101010011001010110000101101110
101
011000010111001101100001011011100111101001100001
Código VHDL del circuito Divisor ORIGINAL
En la librería work ya tenemos todos los componentes necesarios para el Procesador de
01101010011001010110000101101110
Datos compilados y simulados.
Todos ellos deben formar parte del package.componentes.
De esta manera podemos usar estos componentes y reducir significativamente el trabajo
de elaboración del código VHDL para el Procesador de Datos.
Este paquete también debe estar en la carpeta del circuito Divisor compilado antes de que
se compile el código VHDL del programa completo.
102
011000010111001101100001011011100111101001100001
Procedemos a declarar la arquitectura del programa final detallando como
SIGNAL a todas las variables intermedias utilizadas.
Luego se declaran las transiciones del diagrama ASM.
01101010011001010110000101101110
103
011000010111001101100001011011100111101001100001
Aquí se detallan las salidas de la MSS controladora
01101010011001010110000101101110
104
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Finalmente se detalla
el procesador de datos
usando la descripción
estructural e
instanciando uno a uno
los componentes
detallados.
105
011000010111001101100001011011100111101001100001
DIAGRAMA DE TIEMPO DEL CIRCUITO DIVISOR ORIGINAL
01101010011001010110000101101110
106
011000010111001101100001011011100111101001100001
Código VHDL del circuito Divisor de dos palabras de n bits mejorado.
01101010011001010110000101101110
107
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
108
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
109
011000010111001101100001011011100111101001100001
La salida del mux2a1 que necesitamos para la entrada de R esta
representado por la señal DataR.
01101010011001010110000101101110
110
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Ejemplo:
CONTADOR DE
REPETICIONES DE UN PATRON EN
UNA TRAMA DE DATOS
111
011000010111001101100001011011100111101001100001
En este ejemplo nuestra trama de datos de 12 bits llamada Data_In es

“111101100101” y el patrón Pat a buscar dentro de ella es “101”. Si las señales
01101010011001010110000101101110
Load_Reg y Load_Pat son verdaderas se asume que los datos están listos para ser
ingresados. Se inicializa el sistema una vez que se presiona la tecla Start. Al final el
sistema digital deberá activar la salida Fin en un lapso de un minuto y también deberá
mostrar la cantidad de veces que se repite dicho patrón en la trama en un display de 7-
segmentos.
Fin
Start
Load_Reg Detector de Repeticiones
Load_Pat repeticiones de un 7
12
Data_In patrón en una trama
Pat
3 de Datos.
Clock Resetn
112
011000010111001101100001011011100111101001100001
Partición Funcional Data_In
12
01101010011001010110000101101110
Fin En1
I
Start Ld1
Reg
Load_Reg En1 Clock
Ld1
I -> D
Load_Pat Resetn
En2
Out
Igual?
MSS Ld2
En3
12
1min Ld3 Q1
En4
Clock
Enf Pat
Resetn
En4
En5
1min Reg
%f Clock Pat
Clock Resetn
Q2 113
011000010111001101100001011011100111101001100001
Partición Funcional 4
01101010011001010110000101101110
En2
Ld2
Repeticiones
Cont
Clock Up
7 Resetn
Conv BCD
Num_Pat
4 a 7-seg 4
Num_Pat
Q1(2-0) Qcont “0011” “1100”

Q2
4
3 3 4 4
En3
A B A B Ld3
Cont i
Comp 1 Comp 2 Clock Down
Resetn
A=B A<B
4
Igual? Out Qcont
114
011000010111001101100001011011100111101001100001
ASM:
01101010011001010110000101101110
115
011000010111001101100001011011100111101001100001
VHDL:
01101010011001010110000101101110
116
011000010111001101100001011011100111101001100001
VHDL:
01101010011001010110000101101110
117
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
118
011000010111001101100001011011100111101001100001
VHDL:
01101010011001010110000101101110
119
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Ejemplo:
ORDENADOR DE NUMEROS
120
011000010111001101100001011011100111101001100001
Diseñar un circuito Ordenador de Números: Dados k números de n-bits cada uno

almacenados en k registros Ri (R0,…, Rk-1) se desea ordenarlos en forma
01101010011001010110000101101110
ascendente.
Los datos vienen en la entrada DataIn, cuando WrInit es verdadera, el dato
presente en DataIn, se graba en el registro que tenga la dirección Radd.
Para mostrar los datos la señal Rd debe ser verdadera, en ese momento el se
muestra en la salida DataOut el dato presente en el registro de dirección Radd.
121
011000010111001101100001011011100111101001100001
La idea de solución es comparar cada dato de cada registro con todos los registros
siguientes. Si el nuevo dato es menor, se realiza un intercambio de datos, sino
01101010011001010110000101101110
queda igual.
Al terminar de comparar un registro se toma el siguiente, hasta que todos se
hayan comparado entre sí .
122
011000010111001101100001011011100111101001100001
Algoritmo de control:
Podemos describir el algoritmo de
control del circuito de la siguiente
manera:
01101010011001010110000101101110
En el estado inicial S1, mientras Start
(s)= 0, los registros (R0,…, Rk-1) deben
ser cargados desde la entrada externa.
Un contador Ci que representa el
número del registro i se pone en cero.
Al activar la entrada Start el circuito
pasa al estado S2. En S2 el registro A
es cargado con el contenido del registro
Ri (inicialmente R0). También, un
contador Cj que representa el número
del registro j se carga con el mismo
valor de i. Los contadores Ci y Cj se
utilizan para habilitar los registros de los
cuales se desea sacar la información para
compararla e intercambiarla de ser
necesario. 123
011000010111001101100001011011100111101001100001
El estado S3 se utiliza para inicializar el contador Cj con el valor i+1.

En el estado S4 se carga el valor del registro Rj (donde el valor j es el del contador
Cj) en el registro B. En el estado S5, A y B son comparados, y si B < A, el circuito
01101010011001010110000101101110
pasa al estado S6.
Los estados S6 y S7 se utilizan para intercambiar los contenidos de los registros Ri

y Rj solo si B fue menor que A.
En el estado S8, el contenido de Ri se carga en A. Aunque este paso es necesario
solo cuando B < A, el flujo de control es más simple si esta operación se realiza en
ambos casos, tanto cuando B < A, como cuando A < B (no afecta en nada a esta
otra condición).
Si Cj ≠ k-1 (que representa el ultimo registro), el circuito regresa de S8 a S4 y

repite este lazo interno hasta que Cj = k-1.
Si Cj = k-1 y Ci ≠ k-2 (que representa el penúltimo registro), entonces el circuito

habilita el siguiente registro incrementando el contador Ci y repite el lazo externo
regresando al estado S2.
124
011000010111001101100001011011100111101001100001
Procesador de Datos.
01101010011001010110000101101110
125
011000010111001101100001011011100111101001100001
Hay varias maneras de implementar el Procesador de Datos.

Para simplificar el diseño asumimos que k = 4. Por lo tanto necesitamos 4
registros. Inicialmente estos registros pueden ser cargados con datos usando la
01101010011001010110000101101110
entrada DataIn,activando la entrada de control externa WrInit e indicando la
dirección del registro al cual se desea cargar el dato por medio de entrada
externa RAdd.
Los datos desde las salidas de estos registros pueden ser cargados en registros A y
B usando bloques Mux 4 a 1 (salida ABData).
Las salidas de A y B se conectan a un comparador y, también, a través de un
bloque de Mux 2 a 1 pueden de nuevo ser cargados a los registros.
Los señales de habilitación de los registros Rin0,…, Rink-1 son controlados por
medio de un Decodificador de 2 a 4. Si la entrada de control Int =1, el
decodificador es manejado por uno de los contadores Ci o Cj. Si Int=0, entonces el
decodificador es controlado por la entrada externa RAdd.
Los señales zi y zj se hacen igual a 1 cuando Ci=k-2 y Cj=k-1, respectivamente.
El buffer de tres-estados controlado por la señal externa de control Rd, pasa el
contenido de los registros en la salida DataOut.
126
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
127
011000010111001101100001011011100111101001100001
Diagrama ASM del Controlador.
01101010011001010110000101101110
128
011000010111001101100001011011100111101001100001
En el Diagrama ASM no se indica la operación que se debe hacer en cada estado, si no la
señal especifica que debe generar en este estado el circuito Controlador.
En el estado S1 enceramos el contador Ci (Ei y Li), mientras que s=0. Si s=1 se pasa al
01101010011001010110000101101110
estado S2 donde se carga el contador Cj (Ej y Lj) con el valor actual de Ci, se habilita el
registro A (Ain) y para la dirección de los registros se escoge las salidas del contador Ci
(Int=1 y Csel=0), de esta manera el dato Ri se almacena en A.
En el estado S3 se habilita el contador Cj para que se incremente y así se lo pueda

comparar con el dato anterior. En el estado S4, se habilita el registro B (Bin) y como
dirección se escoge el valor de Cj (Int=1 y Csel=1), de esta manera el dato Rj se almacena
en B.
En S5 se pregunta si B es menor que A. De ser así se pasa a S6 y S7 donde se intercambia el

dato entre los registros A y B. Para esto el dato que está en A se graba en el registro Rj
(Csel=1, Int=1, Bout=0, Wr=1) y luego el dato en B se graba en Ri (Csel=0, Int=1, Bout=1,
Wr=1).
En S8 el dato del registro Ri se graba en A (Csel=0, Int=1, Ain=1). Aquí también se pregunta
si el número en Cj=k-1 (último registro). Si es falso, el contador Cj se incrementa. Si es
verdadero se pregunta si el número en Ci=k-2 (penúltimo registro). Si no es así, Ci se
incrementa. Si es cierto el proceso de finalización en S9 arranca.
129
011000010111001101100001011011100111101001100001
En este diseño utilizamos para el Procesador de Datos, los componentes
que están empaquetados y guardados en la librería work.
01101010011001010110000101101110
130
011000010111001101100001011011100111101001100001
VHDL posee una gran versatilidad para la definición de nuevos tipos de
datos (enteros, enumerados, arreglos, etc).
type < nombre> is <descripción>;
01101010011001010110000101101110
Por ejemplo,
type semana is (L, M, X, J, V, S, D);
type memoria is array (0 to 31) of bit_vector (4 downto 0);
En vez de definir las señales de datos con registros separados (R0, … , Rk-1), se puede
especificar al conjunto de registros como un arreglo (array), en forma similar a las
memorias RAM.
Este método permite referirse a cada uno de los cuatro registros como R(i), dentro de la
declaración for generate que utilizaremos más tarde para instanciar cada registro.
El arreglo de registros es definido en dos pasos:

Primero se define un tipo (type) que llamamos RegArray.
type RegArray is array (3 downto 0) of std_logic_vector (n-1 downto0);
Luego, la señal R es definida como tipo RegArray.
131
011000010111001101100001011011100111101001100001
A continuación, se describen los cambios de estados del circuito
Controlador usando la declaración process.
01101010011001010110000101101110
Las salidas del Controlador se generan de manera un tanto diferente a lo hecho
anteriormente.
La salida Int es igual a cero (Int = 0) solo en el estado inicial S1, con el fin de poder
direccionar los registros externamente y cargarlos con los valores de DataIn o para ver los
datos ordenados. Por lo tanto, la generamos utilizando la declaración concurrente
condicional. 132
011000010111001101100001011011100111101001100001
Para las demás salidas utilizamos declaración process y luego case.
01101010011001010110000101101110
Luego se debe describir cada uno de los componentes del Procesador de Datos.
133
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
La declaración for generate proporciona una manera muy conveniente de crear
instanciones múltiples, típicamente declaraciones de descripción de componentes.
También se puede tener la declaración if generate, que se utiliza para selectivamente
ejecutar un conjunto de declaraciones cuando las condiciones especificadas se hacen
presentes.
134
011000010111001101100001011011100111101001100001
Con estas declaraciones condicionales instanciamos el comparador y los
dos Mux de 2-a-1.
01101010011001010110000101101110
En el estado S1 se debe cargar el contador Ci con 0. Pero es ilegal asociar un valor
constante ‘0’ o ‘1’ con una entrada (port) del componente.
Por lo tanto, en la declaración architecture creamos la señal zero:

signal zero: integer range 3 downto 0.
Y asignamos el valor de ‘0’ a esta señal.
También describimos los Mux de 2-a-1 (Imux y Cmux) que se usaron para seleccionar la
dirección del registro a utilizar en cada paso.
135
011000010111001101100001011011100111101001100001
Para el Mux de 4-a-1 que selecciona el registro del dato a cargar en el
registro A o en el registro B, utilizamos la declaración with – select -when.
01101010011001010110000101101110
El Decodificador de 2-a-4 es instanciado con las declaraciones secuenciales process - if -
case.
136
011000010111001101100001011011100111101001100001
Solo faltan los circuitos para generar las salidas zi y zj que son las salidas
de los comparadores.
01101010011001010110000101101110
También falta describir los componentes “buffer” de tres estados.
Tanto las señales zi y zj como la señal de salida DataOut se genera n utilizando

declaraciones concurrentes condicionales.
137
011000010111001101100001011011100111101001100001
Diagramas de Tiempo.
01101010011001010110000101101110
138
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.8.- MEMORIAS ROM Y RAM
139
011000010111001101100001011011100111101001100001
INTRODUCCION
DISPOSITIVOS DE MEMORIA:
• Un sistema Digital tiene la habilidad de almacenar fácilmente grandes cantidades
01101010011001010110000101101110
de información y datos digitales durante períodos cortos o largos.
• Por ejemplo en una computadora digital la memoria principal interna almacena
instrucciones que le dicen que hacer ante todas las circunstancias posibles.
TECNOLOGÍA DE LA MEMORIA:
• Celda de memoria dispositivos o circuitos electrónico que se utiliza para
almacenar un solo bit (0 o 1). Ejemplo: un flip-flop, un capacitor con carga, y un
solo canal en cinta o en disco magnéticos.
• Palabra de memoria Grupo de bits (celdas) en una memoria que representa
instrucciones o datos de algún tipo. Por ejemplo, un registro que consta de ocho
FFs puede considerarse como una memoria que almacena una palabra de 8 bits.
• Byte Término especial que usa una palabra de 8 bits.
• Capacidad Forma de especificar cuantos bits pueden almacenarse en un
dispositivo de memoria o bien en un sistema de memoria completo. El primer
número es el de palabras y el segundo es el de bits. Ej.
• Memoria de 4096 x 20 significa que almacena 4096 palabras de 20
bits cada una.
• 1K= 1024 = 210
140
011000010111001101100001011011100111101001100001
TERMINOLOGÍA DE LA MEMORIA:
• Dirección Un número que identifica la ubicación de una palabra en la memoria. Cada
01101010011001010110000101101110
palabra almacenada tiene una dirección única. Son valores binarios, pero comúnmente
se los representa en forma hexadecimal
• Tiempo de acceso Medida de la velocidad de operación del dispositivo de memoria. Es
la cantidad de tiempo que se requiere para realizar una operación de lectura. En
términos más específicos, es el tiempo que transcurre entre la reposición de una nueva
dirección en la entrada de la memoria y la disposición de los datos en la salida.
• Memoria de acceso aleatorio (RAM) Memoria en la cual la localización física real de
una palabra de la memoria no tiene efecto sobre el tiempo que se tarda en leer de esa
localidad o bien en escribir en ella. En otras palabras, el tiempo de acceso es el mismo
para cualquier dirección de la memoria.
• Memorias sólo de lectura (ROM) Una extensa clase de memorias de semiconductor
diseñadas para aplicaciones donde la proporción de operaciones de lectura a
operaciones de escritura es muy alta. En términos técnicos, en una ROM sólo puede
escribirse una sola vez y esta operación normalmente se efectúa en la fábrica.
141
011000010111001101100001011011100111101001100001
OPERACIONES GENERALES EN LA MEMORIA:
Todo sistema de memoria requiere varios tipos diferentes de líneas de entrada y
01101010011001010110000101101110
salida para desempeñar las siguientes funciones:
1. Seleccionar la dirección de la memoria a la que se quiera tener acceso
para una operación de lectura o escritura.
2. Seleccionar ya sea una operación de lectura o bien de escritura para ser
efectuada.
3. Proporcionar los datos de entrada a ser almacenados en la memoria
durante una operación de escritura.
4. Retener los datos de salida que vienen de la memoria durante una
operación de lectura.
5. Habilitar (o deshabilitar) la memoria de manera que responda (o no) a las
entradas de dirección y al comando de lectura/escritura.
142
011000010111001101100001011011100111101001100001
MEMORIA DE ACCESO ALEATORIO (RAM)
La memoria de la figura (32 x 4) puede considerarse como un arreglo de 32
01101010011001010110000101101110
registros donde cada uno de ellos retiene una palabra de 4 bits, como se muestra
en la tabla.
143
011000010111001101100001011011100111101001100001
ENTRADAS DE DIRECCIONES:
• Dado que esta memoria almacena 32 palabras, tienen 32 diferentes
localidades de almacenamiento y, por consiguiente, 32 diferentes direcciones
01101010011001010110000101101110
binarias que van desde 00000 a 11111 (0 a 31 en decimal). En consecuencia,
existen 5 entradas para direcciones desde Ao hasta A4.Para tener acceso a una
de las localidades de la memoria, ya sea para leer su contenido o escribir en
ella, es necesario enviar a través de las entradas de direcciones la dirección de
5 bits que corresponde a la localidad de interés.
• En general se requiere de N direcciones de entrada para una memoria que
tiene una capacidad de 2N palabras.
HABILITACIÓN DE MEMORIA:
• Muchos sistemas de memoria tienen algún medio para deshabilita
completamente todo o parte de la memoria de manera que no responda a las
otras entradas.
144
011000010111001101100001011011100111101001100001
ENTRADA R/W:
• Determina la operación que llevará a cabo la memoria. Algunas memorias
utilizan 2 entradas diferentes (una para lectura (R) y otra para escritura (W))La
01101010011001010110000101101110
entrada se expresa como R/W; como no hay barra sobre R esto indica que la
operación de lectura tiene lugar cuando R/W=1. La barra sobre la W indica
que la operación de escritura tiene lugar cuando R/W = 0.
145
011000010111001101100001011011100111101001100001
ENTRADA R/W:
• En la figura se ilustra el proceso de escribir el dato 0100 en el registro de
memoria que está en la dirección 00011. Este dato es el que podría haberse
01101010011001010110000101101110
aplicado en las líneas de entrada para datos de la memoria y remplaza el dato
que antes se encontraba almacenado en la dirección 00011. La parte (b)
muestra el proceso de lectura de la palabra 1101 que se encuentra guardada
en la localidad cuya dirección es 11110. Esta palabra es la aparecerá en las
líneas de salida para datos de la memoria. Después de la operación de lectura,
la palabra 1101 seguirá almacenada en la memoria. En otras palabras, la
operación de lectura no cambia los datos que están almacenados en la
memoria.
146
011000010111001101100001011011100111101001100001
MEMORIA DE SOLO LECTURA (ROM)
• Las memorias de solo lectura son un tipo de memoria de semiconductor que
01101010011001010110000101101110
están diseñadas para retener datos que son permanentes o que no cambian
con mucha frecuencia. Durante la operación normal, no pueden escribirse
nuevos datos en una ROM pero sí pueden leerse información en ella.
• Los ROMs se utilizan para almacenar datos e información que no cambiará

durante la operación normal de un sistema. Un uso importante de las ROMs
se encuentra en el almacenamiento de programas en microcomputadoras. Ya
que todas las ROMs son no volátiles, estos programas no se pierden cuando la
microcomputadora es desconectada.
Diagrama de bloques en ROM:
• Un diagrama de bloques común para una ROM se muestra en la figura. Tiene

tres conjuntos de señales: entradas de dirección, entrada(s) de control y
salidas de datos.
147
011000010111001101100001011011100111101001100001
Salidas de 3 estados
01101010011001010110000101101110
Presenta
si CS = L las salidas
Salidas alta
si CS = H impedancia
Proceso de Lectura
1. Aplicar entradas de
dirección
2. CS = L
3. Aparecerán las salidas
148
011000010111001101100001011011100111101001100001
ARQUITECTURA DE LA ROM:
• Existen cuatro partes básicas: Decodificador de renglones, decodificador de
columnas, arreglo de registros y buffers de salida.
01101010011001010110000101101110
149
011000010111001101100001011011100111101001100001
TEMPORIZACION DE LA ROM:
• Habrá un retraso en la propagación entre las aplicaciones de las entradas de
una ROM y la aparición de datos durante una operación de lectura: Este
01101010011001010110000101101110
retraso, denominado tiempo de acceso, tACC, es una medida de velocidad de
operación de la ROM. El tiempo de acceso se describe por medio de la forma
de onda de la figura.
• La forma de onda de más arriba representa las entradas de dirección La del
medio es una selección de CI activa en BAJO, CS (negado), y la de más abajo
representa la salida de datos.
150
011000010111001101100001011011100111101001100001
TIPOS DE ROMs:
• ROM programada por mascarilla Este tipo de ROM tiene sus localidades de
almacenamiento escritas (programadas) por el fabricante según las
01101010011001010110000101101110
especificaciones del cliente. Se utiliza un negativo fotográfico llamado
mascarilla para controlar las conexiones eléctricas en el circuito. Se requiere
una mascarilla especial para cada conjunto diferente de información a ser
almacenada en la ROM. Ya que las mascarillas son costosas, este tipo de ROM
es económico sólo si se necesita una cantidad considerable de la misma ROM.
• ROM programables (PROM) Una ROM programable por mascarilla es muy
costosa y no se utilizará excepto en aplicaciones de grandes volúmenes, donde
el costo sería repartido sobre muchas unidades: para las aplicaciones de bajo
volumen, los fabricantes han creado PROMs con conexión fusible, que no se
propagan durante el proceso de fabricación sino que son programadas por el
usuario. Sin embargo una vez programada una PROM se parece a una MROM
en que no puede borrarse y reprogramarse. Por tanto, si el programa en la
PROM es erróneo o tiene que ser cambiado, la PROM tiene que ser
desechada. Es por esto que a menudo se hace referencia a estos dispositivos
como ROMs “programables una sola vez”.
151
011000010111001101100001011011100111101001100001
TIPOS DE ROMs:
• ROM programable y borrable (EPROM) Una EPROM puede ser programada
por el usuario y también puede borrarse y reprogramarse tantas veces como
01101010011001010110000101101110
se desee. Una vez programada la EPROM es una memoria no volátil que
contendrá sus datos almacenados indefinidamente.
152
011000010111001101100001011011100111101001100001
PROGRAMACIÓN:
1. Se aplican las direcciones en los pines respectivos
2. Poner los datos a grabarse en D7-D0 que funcionan como entradas durante
01101010011001010110000101101110
el proceso de grabación.
3. Se aplica un voltaje de programación mayor a 12.5V en Vpp
4. CE se mantiene en bajo
5. PGM se mantiene bajo durante 100us y los datos se leen de regreso.
6. Se verifican los datos almacenados entonces lectura. Para esto OE = L y se
aplica un pulso en CE = L entonces los buffers de salida muestran los valores
almacenados en la localidad de memoria indicada.
153
011000010111001101100001011011100111101001100001
PROM eléctricamente borrable (EEPROM):

• Las ventajas de la EPROM se eliminaron con la producción de la PROM
eléctricamente borrable (EEPROM) que fue una mejora respecto de la EPROM.
01101010011001010110000101101110
La EEPROM conserva la estructura de compuerta flotante de la EPROM, pero
con la inclusión duna región muy delgada encima del electrodo de drenaje de
la celda de memoria MOSFET. Esta es la principal característica de la EEPROM:
Su facilidad para el borrado eléctrico.
154
011000010111001101100001011011100111101001100001
APLICACIONES DE LAS ROM :

• Firmware
• Memoria de arranque
01101010011001010110000101101110
• Tabla de datos
• Convertidores de datos
• Generadores de caracteres
• Generadores de funciones
155
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
2.9.- EJEMPLO DE DISEÑO DE
SISTEMAS DIGITALES
UTILIZANDO MEMORIAS
156
011000010111001101100001011011100111101001100001
DISEÑO DE UN SISTEMA DIGITAL GENERADOR DE NUMERO PROMEDIO
Suponga que k números de n bits son almacenados en un conjunto de registros
01101010011001010110000101101110
(R0,….., Rk-1). El circuito Generador de Numero Promedio debe mostrar el valor
promedio M de los números almacenados en estos registros.
Primeramente los números deben ser sumados y luego divididos sobre la
cantidad (k) de números.
157
011000010111001101100001011011100111101001100001
El algoritmo del funcionamiento del circuito es siguiente:
01101010011001010110000101101110
En el estado S3 se realiza la operación de división para determinar M.
158
011000010111001101100001011011100111101001100001
Del ejemplo anterior sabemos que para realizar la operación de división se
requieren varios periodos de Clock pero no lo indicamos en este diagrama
de flujo.
01101010011001010110000101101110
En el circuito Procesador de Datos necesitamos un registro que almacenará la
suma de todos los números. Para que el sistema sea más simple, asumimos que la
suma puede ser representada con n bits sin sobrecarga. La salida de este registro
es a su vez una de las entradas del sumador. También necesitamos un mux2a1 en
la entrada del registro.
Este mux nos permitirá poner el registro en 0 en el estado inicial.
El sumador, recibe el dato del registro de suma en una de sus entradas, y en la
otra entrada recibe datos desde k registros que tienen almacenados los números.
Una de las maneras para seleccionar los datos de los registros, es utilizando un
bloque de n MUX k-a-1, cuya salida estará conectada con la entrada del sumador.
Las líneas de selección de éste MUX pueden ser controlados por un contador.
Para realizar la operación de división podemos utilizar el circuito Divisor diseñado
en el ejemplo anterior.
Para simplificar el diseño asumimos que k = 4, pero la misma estructura puede
ser utilizada para cualquier cantidad de números.
159
011000010111001101100001011011100111101001100001
Procesador de Datos
01101010011001010110000101101110
160
011000010111001101100001011011100111101001100001
Los números que deben almacenarse en los registros (R0,….., Rk-1)

entran por la misma entrada Data y se guardan en aquel registro cuya entrada de
01101010011001010110000101101110
habilitación En esté activada por la salida de un Decodificador n a 2n .
Las entradas al decodificador se representan por las señales RAdd.
Cuando el sumador termina de sumar todos los números y las salidas del
ContadorDown llegan a 0, una puerta NOR genera la salida z = 1. En este
momento, el circuito Divisor debe dividir la suma de todos los números para la
cantidad de números.
Por tanto, la entrada DataA del Divisor, se conecta con la salida del registro
donde se almacena la suma de los números. La entrada Data B del Divisor debe
recibir la cantidad de números k.
Cuando el circuito Divisor termina la operación de división genera la salida zz y el
controlador debe generar la salida Done.
El Promedio M será mostrado por las salidas Q (Cociente) y R (Resto) del circuito
Divisor.
161
011000010111001101100001011011100111101001100001
Diagrama ASM del controlador
01101010011001010110000101101110
162
011000010111001101100001011011100111101001100001
En el estado S1 se cargan los registros (R0,….., Rk-1) por medio de algún
control externo. Por lo tanto, en S1 solo se debe cargar el ContadorDown
con el número k-1 (EC, LC) y se debe habilitar el registro de suma (ES) para
cargarlo con 0’s.
01101010011001010110000101101110
Cuando Start = 1 el circuito Controlador va al estado S2 donde se genera la señal
ES y Ssel=1 para que el registro Sum puede cargar la suma al final de éste estado
(S2). Aquí mismo se pregunta por el valor de z. Si z = 0, se genera la salida
condicional EC para que el contador se decremente.
Si z = 1 significa que el contador llego a 0 y todos los números han sido sumados.
El circuito Controlador pasa al estado S3 donde se genera la salida LA.
La señal LA sirve para cargar el dato resultado de la suma y el número k en el
circuito Divisor. Luego, el Controlador pasa al estado S4 y genera la señal Div que
activa la entrada Start del Divisor.
Cuando la operación de división termina y por tanto el Divisor genera la salida zz
(Done del Divisor), el Controlador pasa al estado S5. En este momento, el valor
de M aparece en las salidas Q y R.
La señal Div (Start para el circuito Divisor) debe ser mantenida en el estado S5
para impedir que el Divisor reinicie (encere) sus registros y se borren los
resultados. También en este estado se genera la salida Done del circuito
Generador del Numero Promedio. 163
011000010111001101100001011011100111101001100001
Código VHDL para el circuito Controlador del Generador de Número
Promedio.
01101010011001010110000101101110
164
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
USO DE MEMORIAS RAM
Para un número k grande de registros, es preferible utilizar una memoria
SRAM en lugar de usar k registros.
Las herramientas CAD usualmente proporcionan módulos predefinidos que
representan SRAM.
El editor gráfico de Max+plusII proporciona algunos módulos de SRAM.
Seleccionaremos el módulo : lpm_ram_dq.
165
011000010111001101100001011011100111101001100001
La memoria SRAM a utilizar tiene una entrada/salida de datos de 8 bits, una
entrada de direcciones de 4 bits y la señal de control we. La memoria
entonces es de 24 x 8.
01101010011001010110000101101110
Al ser asincrónica, cuando We=1, el dato presente en la entrada DATA se escribe
en la dirección presente en la entrada ADDRESS.
Cuando We=0 el dato de la dirección que está en la entrada ADDRESS se lee en la
salida Q.
Los subcircuitos a utilizar son los mismos que el diseño original, esto es:
Bloque de multiplexores 2 a 1, Registro de sostenimiento, sumador, contador down (hacia
abajo), circuito divisor y circuito controlador.
El controlador debe ser modificado para soportar el proceso de escritura y lectura de la
memoria.
166
011000010111001101100001011011100111101001100001
Diagrama ASM modificado para el Controlador
Los estados S1, S2 y
01101010011001010110000101101110
S3 son para el ingreso
de datos a la memoria
SRAM.
Si write=1 escribimos
un dato en la dirección
n-1. Cuando write=0
nuevamente, el
contador se
decrementa, y luego se
pregunta si ya fue
usado el último dato de
la memoria o si se
activó la señal start
para empezar el
cálculo del promedio
igual que antes.
167
011000010111001101100001011011100111101001100001
Código VHDL del Controlador
01101010011001010110000101101110
168
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Usaremos los diseños elaborados en los ejemplos anteriores. Se debe agregar una
bloque para el BUS de MUX 2 a 1.
En el Editor Grafico realizaremos la implementación del circuito Generador de
Numero Promedio utilizando todos los componentes necesarios, anteriores y
nuevos. 169
011000010111001101100001011011100111101001100001
Partición funcional en el editor gráfico
01101010011001010110000101101110
170
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
171
011000010111001101100001011011100111101001100001
01101010011001010110000101101110
Taller:
SISTEMA DIGITAL DETECTOR DE
INTERSECCIÓN DE CONJUNTOS
172
011000010111001101100001011011100111101001100001
5.) Diseñar un SISTEMA DIGITAL DETECTOR DE INTERSECCIÓN DE CONJUNTOS,
el mismo permite el ingreso de dos conjuntos A y B en forma secuencial (byte a
byte), luego detecte los números en común entre los conjuntos A y B ingresados.
01101010011001010110000101101110
• U: Conjunto de números de 8 bits (0 - 255).
• A: Conjunto de números de 8 bits, con un
número de elementos ≤ 255.
• B: Conjunto de números de 8 bits, con un
número de elementos ≤ 255.
• AᴖB: Números en común de 8 bits delos
conjuntos A y B.
SEÑALES:
• InNúmero.- Es una señal de 8 bits que el usuario usa para ingresar números uno a
uno.
• IngresoA.- Señal que permite al usuario hacer el ingreso de número a número como
elemento del conjunto A. (Asuma que el número está presente en la entrada
InNúmero).
• IngresoB.- Señal que permite al usuario hacer el ingreso de número a número como
elemento del conjunto B. (Asuma que el número está presente en la entrada
InNúmero). 173
011000010111001101100001011011100111101001100001
• LedIngreso.- Led indicador que todavía el usuario puede ingresar números.
Este led puede apagarse debido a que el usuario presiona la tecla FinIngreso o
debido a que el usuario ingresó el número máximo de elementos en cada
01101010011001010110000101101110
conjunto (A, B).
• Fin Ingreso.- Esta señal que el usuario puede usar para indicar a la MSS que ya
no desea ingresar más elementos en los conjuntos A y B.
• Start.- Luego de ingresar correctamente los elementos en cada conjunto el
usuario deberá presionar la tecla Start para empezar a trabajar.
• OK.- Este led indica que la MSS terminó de encontrar los elementos de la
intersección entre los conjuntos A y B.
• AᴖB.- Esta señal de 8 bits de salida muestra número a número con un intervalo
de 1segundo cada uno de los elementos de la intersección entre los conjuntos
A y B. Luego que el sistema termina de mostrar todos los elementos de la
intersección, la MSS regresa al estado inicial.
PRESENTAR:
a) Hacer la partición funcional del sistema completo: Mss, Ram, Msi, etc.
b) Diagrama ASM del controlador.
c) Código VHDL del sistema completo en Quartus.
RECURSOS: https://goo.gl/lhtWFn
174
011000010111001101100001011011100111101001100001
NOTA:
El pseudocódigo para el ingreso de los El pseudocódigo para la búsqueda de
datos es el siguiente: elementos es el siguiente:
01101010011001010110000101101110
i=0; #eA=i;
j=0; #eB=j;
While(FinIngreso=0){ i=0;
LedIngreso=1; k=0;
If (IngresoA=1 and i≤255){ While(i ≤ #eA){
RAMA(i)=InNumero; j=0;
i=i+1; while(j ≤ #eB){
} if(RAMA(i)=RAMB(j){
If (IngresoB=1 and j≤255){ RAMAᴖB(k)<=RAMA(i);
RAMB(j)=InNumero; k=k+1;
j=j+1; }
} j=j+1;
if(i=255 and j=255){break;} }
} i=i+1;
-- i representa el número de elementos en conjunto }
A, y j representa el número de elementos en B.
175

Diseño Formal Sistemas Digitales

Cargado por

Información del documento

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

Diseño Formal Sistemas Digitales

Cargado por

Copyright:

Formatos disponibles

011000010111001101100001011011100111101001100001

En esta unidad se presenta una metodología formal para diseñar sistemas

Se muestra la forma de modelar el sistema usando un lenguaje de descripción de

Las especificaciones del Sistema Digital a desarrollar, nos indican de forma

Lo aprendido en el capítulo anterior, nos sugiere utilizar un controlador MSS para

Un Sistema Digital puede ser dividido en dos partes principales llamados

El Procesador de Datos es usado para almacenar y manipular datos y para

El circuito Controlador es una MSS que controla la operación de Procesador de

Datos Procesador de Datos (Bloques MSI) Datos

Datos Procesador de Datos (Bloques MSI) Datos

Codificador BCD a 7 Segmentos: Convertidor o Codificador

Diagrama de bloques general de un Sistema Digital.

RAMA(i)=InNumero; En este caso luego de la validación, de forma

Datos Procesador de Datos Datos

Luego de estructurar la Partición Funcional se debe decidir que tipo de descripción se

Un subcircuito o subsistema puede ser representado con un solo componente (registro,

La declaración de entity puede incluir también la keyword generic. Mediante VHDL, la

La declaración architecture describe el funcionamiento interno de una entity. VHDL

VHDL soporta tres tipos diferentes de descripción de architecture (o niveles de

• Descripción estructural (nivel lógico de abstracción) en la que se

Nota: el operador <= indica asignación a señal.

Se puede también utilizar declaraciones concurrentes condicionales when – else.

En la declaración with – select – when se evalúa la expresión que acompaña a la

La barra “ | ” tiene el mismo significado que el operador lógico or.

Dentro de la arquitectura (architecture) aparece un proceso (process) que es la

La declaración process puede ser usada tanto en la descripción de circuitos

Los tres tipos de descripción de un Sistema Digital en VHDL pueden mezclarse en

Si ya tenemos estructurada la Partición Funcional, se puede adoptar un modelo

El Diseño top-down comprende la construcción de cada subcircuito o subsistema

Si En=0 : El dispositivo mantiene el último valor en la salida

En el estado Tb el Controlador genera la salida incondicional EnReg que permitirá

Puesto que para manejar el registro_i_d y el contador_up, se emplea la misma

En el mismo instante de tiempo el Controlador preguntara si el Dato de 8 bits

Si este bit es un 1 el Controlador debe generar la salida condicional de EnCnt que

Si el Dato no tiene ni un 1, entonces, el Controlador va al estado Tc, genera la

Se desea diseñar un circuito Multiplicador de dos números binarios sin signo,

En el Procesador de Datos debemos usar un registro de desplazamiento

También necesitamos un registro de desplazamiento de izquierda a derecha de n

El sumador debe ser de 2n bits también y necesitamos un registro de

Inicialmente el registro P debe estar en 0. Ya que no podemos usar Resetn

Diseñar un circuito Divisor de dos números binarios sin signo de n bits.

A continuación se muestra un ejemplo de una división manual en decimal y en

El circuito debe desplazar a la izquierda los dígitos del registro Dividiendo A

Inicialmente el Resto R debe ser cero. En R se van ingresando uno a uno

Si Start = 0, y si externamente se habilita la señal LdA, se carga el valor del

Si las operaciones que se realizan en los estados S2 y S3 se ejecutarán en un solo

Para realizar las dos operaciones en el mismo ciclo de Clock, necesitaremos un

La idea es tener en R el valor del resto actual (del último desplazamiento) y al

Si se quiere dividir 13 para 5:

En el mismo estado, el registro Resto R y el flip-flop D se cargan con 0

Cuando se activa la entrada externa Start = 1, entonces, estando todavía en el

Cuando llegue el flanco de subida del Clock se produce el desplazamiento de A/Q

Cuando el contador que estaba cargado con n -1 llegue a 0, Cig0 = 1 y el

En el estado S3, se genera la salida Done, se espera que Start se desactive y se

En la librería work ya tenemos todos los componentes necesarios para el Procesador de

En este ejemplo nuestra trama de datos de 12 bits llamada Data_In es

Partición Funcional Data_In

Q1(2-0) Qcont “0011” “1100”

Diseñar un circuito Ordenador de Números: Dados k números de n-bits cada uno

El estado S3 se utiliza para inicializar el contador Cj con el valor i+1.

Los estados S6 y S7 se utilizan para intercambiar los contenidos de los registros Ri

Si Cj ≠ k-1 (que representa el ultimo registro), el circuito regresa de S8 a S4 y

Si Cj = k-1 y Ci ≠ k-2 (que representa el penúltimo registro), entonces el circuito

Hay varias maneras de implementar el Procesador de Datos.