Professional Documents
Culture Documents
MODULO
SISTEMAS DIGITALES BASICOS
miguelpintoaparicio@gmail.com
BUCARAMANGA
2006
INTRODUCCION
Este curso es un abre bocas al maravilloso mundo digital, y pretende dar una
formación básica a los futuros diseñadores digitales, que con dispositivos como
PLDs, FPGAs, DSPs, etc. podrán llevar a la vida real aquellas ideas que le
permitan interactuar al hombre con la máquina.
Para el desarrollo del curso es importante el papel que juegan los siguientes
recursos tecnológicos como medio activo, buscando la relación tutor-
estudiante:
0
an an −1.....a2 a1a0 = ∑ ai bi = anb n + an −1b n −1 + ... + a1b1 + a0b 0 (Ecuación No. 1)
i=n
Explicación
Tenemos el número 2197, el cual tiene el dígito 2 en la posición tres, el dígito 1
en la posición dos, el dígito 9 en la posición uno y el dígito 7 en la posición
cero; tenemos en cuenta que este número está representado en base 10, por lo
tanto, para expresarlo de forma numérica hacemos la sumatoria de cada dígito
multiplicado por la base elevada a la posición representativa del dígito en el
número. De esta manera tenemos que
Sistema Octal
El sistema octal tiene 8 dígitos para su numeración (0, 1, 2, 3, 4, 5, 6 y 7) por lo
cual se considera que su base es 8. Un procedimiento sencillo para pasar del
sistema decimal al octal es el siguiente:
Nota Importante:
Antes de continuar, tenemos que definir para este módulo (como es
acostumbrado en casi todos los textos) que cuando tengamos un número
representado, este debe ir acompañado de un subíndice que nos indique
el sistema numérico en el cual se está representando, es decir:
si el subíndice es 2, es porque es sistema Binario, ejemplo:
111012
si el subíndice es 8, es porque es sistema Octal, ejemplo:
56038
si el subíndice es 10, es porque es sistema Decimal, ejemplo:
985610
110 , 210 , 410 , 810 , 1610 , 3210 , 6410 , 12810 , 25610 , 51210 ,........
1.1.1 Definición
La suma binaria la definiremos de la siguiente manera:
Si adicionamos dos dígitos cuyos valores son cero, el resultado es cero.
Si adicionamos un dígito cuyo valor es uno con un dígito cuyo valor es
cero, su resultado es uno
Si adicionamos dos dígitos cuyos valores son unos, el resultado es cero,
pero generamos un dígito adicional que lo llamaremos acarreo y cuyo
valor es uno; el dígito de acarreo será un componente a adicionar a los
dígitos inmediatamente más significativos.
Procedimiento:
Primero que todo agrupamos los dos números binarios uno encima del
otro de tal manera que los dígitos de la misma posición se encuentre en
la misma columna o uno sobre el otro:
11010 2 +
010112
011010 2 +
0010112
1001012
Realicemos ahora la resta del número 11010 2 con el número 10112 :
Procedimiento:
Primero que todo agrupamos los dos números binarios uno encima del
otro de tal manera que los dígitos de la misma posición se encuentre en
la misma columna o uno sobre el otro:
11010 2 −
010112
011010 2 −
0010112
0011112
1.2 Multiplicación y división
De similar manera a la suma y resta de números binarios, la multiplicación y
división de números binarios mantiene los mismos procedimientos que en el
sistema decimal.
1.2.1. Definición
La multiplicación binaria la definiremos de la siguiente manera:
Si multiplicamos dos dígitos cuyos valores son 0 su resultado es 0.
Si multiplicamos un dígito cuyo valor es 0 con un dígito cuyo valor es 1,
su resultado es 0.
Si multiplicamos dos dígitos cuyos valores son 1 su resultado es 1.
Si multiplicamos un número de varios dígitos con otro de varios dígitos el
proceso es similar al que realizamos con números decimales (ver
sección 1.2.2.)
Procedimiento:
Primero que todo agrupamos los dos números binarios uno encima del
otro de tal manera que los dígitos de la misma posición se encuentre en
la misma columna o uno sobre el otro:
Procedimiento:
Primero que todo agrupamos los dos números binarios de la misma
manera que cuando realizamos una división en el sistema decimal:
Aún nos falta por bajar un dígito del dividendo, pero el número que se
forma no es mayor que el divisor, así que agregamos un cero al número
de la zona de resultado:
EJERCICIOS:
Cada entrada o salida del circuito digital representa un dígito binario, por lo
tanto, estos se conocen como bit, del término inglés BInary DigiT. Por lo cual,
se acostumbra a hablar de un circuito digital de n bits de entrada o n bits de
salida. En la figura No. 1 tenemos el ejemplo de la representación de un circuito
digital de 3 bits de entrada y 5 bits de salida:
Figura No. 1
Circuito Digital de 3 bits de entrada y 5 bits de salida
2.1.1 Definición
Una compuerta lógica es aquel circuito digital que tiene la capacidad de aplicar
un proceso interno a sus n bits de entrada, que cumple con alguna de las
operaciones definidas en el Álgebra de Boole, y que cuyos resultados son
manifiestos en sus bits de salida. En la figura No. 2 podemos observar las
operaciones del Algebra de Boole, sus tablas de verdad y representación
gráfica.
Figura No. 2 Propiedades del Algebra de Boole:
Tablas y representación gráfica
2.1.2 Aplicaciones de las Compuertas
Las compuertas lógicas digitales son implementadas para representar las
funciones booleanas que representan los sistemas digitales, y que permiten
realizar algún tipo de aplicación como control de un proceso industrial,
operaciones aritméticas (sumas, restas, multiplicaciones y divisiones de
números binarios), etc.
2.2.1 Definición
Los circuitos digitales implementados con la lógica Transistor–Transistor son
conocidos como circuitos integrados TTL (sigla del término en inglés,
Transistor-Transistor Logic), y todo circuito integrado que contenga cualquier
tipo de compuerta lógica que se genere con este tipo de circuito lógico se
relaciona con la Familia TTL.
2.2.2 Características
Los circuitos integrados de la Familia TTL se alimentan con 5V con una
variación aceptable de ± 0.25V y funcionan adecuadamente en
temperaturas ambientales entre los 0° a 70° C.
La Familia TTL configura la zona de voltaje para definir el “0” entre 0V y
0.8V, y para definir el “1” entre 2.4V y 5.0V.
La velocidad de cambio de estado lógico del bit de salida a razón del
cambio lógico de los bits de entrada alcanza en algunas versiones de la
familia hasta 250 Mhz, claro está que esto incrementa el consumo de
potencia del circuito integrado
Cuando una de las entradas del circuito lógico no se conecta sino que se
deja al aire, el sistema lo toma como un “1”; pero es recomendable
conectar la entrada por medio de una resistencia de 1kΩ a 5V para
garantizar el estado del mismo.
La Familia TTL tiene un limitante en cuanto al número de compuertas
que se pueden interconectar entre sí (fan out), esta característica está
impuesta por la capacidad de corriente que puede suministrar o recibir.
La familia TTL también se clasifica dependiendo del tipo de salida con que
cuenta:
Salida TTL con colector abierto.
Salida TTL de tres estados.
2.3.1 Definición
Se denominan circuitos integrados de la Familia CMOS a aquellos en los
cuales se ha implementado la lógica booleana por medio de circuitos lógicos
CMOS.
2.3.2 Características
Los circuitos integrados de la Familia CMOS se alimentan con valores
entre 3V y 18V (claro que las series más nuevas definen su rango de
alimentación entre 2V y 6V), y los estados lógicos “1” y “0” se definen
en los rangos Vcc-0.7Vcc y 0.3Vcc-0V, respectivamente.
Estos integrados son especialmente susceptibles a daños por carga
electrostática, aunque las últimas generaciones de CI CMOS vienen
protegidos contra estas descargas.
INVESTIGACION:
3). Qué otros tipos de lógicas circuitales se han implementado para poder
implementar las operaciones booleanas?
4). Investigue cuáles son los circuitos integrados más comúnmente usados y
qué características poseen.
3. PRINCIPIOS DE DISEÑO DE LOGICA COMBINACIONAL
3.1.1 Definición
Señal lógica: Es el estado que se registra en los bits de entrada o salida de
un circuito combinacional; se han definido el estado “1” o ALTO y el estado “0”
o BAJO. En el álgebra de Boole una variable simbólica (por ejemplo X) será
quien represente la señal lógica en un bit de entrada.
AND: Para una multiplicación lógica tenemos que si las entradas son X y Y, su
representación algebraica sería F = X ⋅ Y , en donde el punto de multiplicación
(⋅) indica una operación AND o multiplicación lógica (Ver figura No. 2) y cuyo
resultado sólo es “1” cuando todas las entradas son “1”.
OR: una suma lógica u operación OR, la cual se representa por medio de un
signo más ( F = X + Y ), tiene como salida “0” si y solamente si todas las
entradas son “0” (Ver figura No. 2).
X +Y = Y + X X ⋅Y = Y ⋅ X (ecuación No. 3)
X + (Y ⋅ Z ) = ( X + Y ) ⋅ ( X + Z ) (ecuación No. 4)
X ⋅ (Y + Z ) = ( X ⋅ Y ) + ( X ⋅ Z ) (ecuación No. 5)
3. las operaciones OR y AND son asociativas:
( X + Y ) + Z = X + (Y + Z ) = X + Y + Z (ecuación No. 6)
( X ⋅ Y ) ⋅ Z = X ⋅ (Y ⋅ Z ) = X ⋅ Y ⋅ Z (ecuación No. 7)
___ ___
f ( X , Y , Z ,...) = [ X + f (0, Y , Z ,...)] ⋅ X + f (1, Y , Z ,...) = X ⋅ f(1, Y, Z,...) + X ⋅ f (0, Y , Z ,...)
Procedimiento:
1. Tomaremos el término de la izquierda del igual, y por medio de la
propiedad distributiva (Ec. No. 5) eliminaremos el paréntesis:
___
X ⋅Y + Y ⋅Y = X ⋅Y
___
2. Si observamos el segundo término del lado izquierdo del igual ( Y ⋅ Y ),
notaremos que están cumpliendo la propiedad del complemento para la
multiplicación lógica, por lo tanto el resultado de este término es “0”:
X ⋅Y + 0 = X ⋅Y
X ⋅Y = X ⋅Y
__________ ____
Aplique el Teorema de Morgan en A ⋅ (B + C)
Procedimiento:
1. El Teorema de Morgan dice que toda variable es reemplazada por su
complemento, las operaciones AND y OR son reemplazadas por su inverso
(OR y AND) (Ver ecuaciones No. 12 y 13). Inicialmente colocaremos los
complementos de A y del término que va entre paréntesis, y la operación
inversa de la multiplicación lógica, lo cual nos da:
__________ ____ ___ _________
A ⋅ (B + C) = A + (B + C) =
2. Ahora, el término entre paréntesis está negado, cuando aplicamos la
negación los términos B y C son reemplazados por sus complementos y la
operación de la suma lógica se reemplaza por la multiplicación lógica:
__________ ____ ___ _________ ___ ___ ___
A ⋅ (B + C) = A + (B + C) = A + B ⋅ C
Por lo tanto
______________ ___ ___ ___
A ⋅ (B + C) = A + B ⋅ C
3.2 ANALISIS Y SINTESIS DE CIRCUITOS COMBINACIONALES
Ahora si estamos capacitados para entender cómo las formas canónicas son
empleadas para deducir expresiones lógicas que describen un circuito lógico a
partir de la tabla de verdad correspondiente. La primera forma canónica es la
Suma Canónica de la función lógica, la cual es la suma de los mintérminos
correspondientes a las filas de la tabla de verdad en las cuales los resultados
sean un “1”, como ejemplo, la suma canónica de la tabla de verdad de la figura
No. 8 es
F = XY
___ ___
F = ( X + Y )( X + Y )( X + Y )
De similar manera, se propone al estudiante representar toda la tabla de
verdad en la expresión resultante para confirmar que cumple con las
condiciones de la tabla.
___ ___
F = ( X + Y )( X + Y )( X + Y )
Procedimiento:
1. Hemos dicho que las operaciones OR y AND son asociativas (Ver Ecuación.
No. 7), por lo tanto, agruparemos los dos primeros maxtérminos como sigue:
___ ___
F = [( X + Y )( X + Y )]( X + Y )
6. Ahora, una variable que es sumada con un “1” y con su complemento nos
da la misma variable, por lo cual
___
F = [ XY ]( X + Y )
___
F = XY ( X + Y )
F = XY
Esta es una de las causas por las cuáles la minimización es una de las mejores
herramientas para optimizar el circuito lógico diseñado, de tal manera, que la
expresión final sea la de menor número y tamaño de compuertas electrónicas
necesarias para construirla. Los medios que tenemos para optimizar una
expresión booleana son:
Procedimiento:
1). Podemos aplicar la ley asociativa de la suma lógica para los dos últimos
términos así
___ ___
F = X Z + ( XY + X Y Z )
___
3). Para el término (Y + Y Z ) aplicamos la ley distributiva según la Ecuación
___
No. 4, de tal forma que obtenemos (Y + Y ) ⋅ (Y + Z ) , y como para la suma de
complementos se cumple que es igual a “1” tendríamos (1) ⋅ (Y + Z ) = (Y + Z ) ,
así que reemplazando en la expresión:
___
F = X Z + X (Y + Z )
Lo que nos falta es relacionar cada línea de la tabla de verdad con cada cuadro
del Mapa de Karnaugh. Para hacerlo, lo que hacemos es analizar cada una de
las intersecciones entre las filas y las columnas, por ejemplo, la fila dos y la
columna tres en la Figura No. 13 es la intersección entre el término 01 y el
término 11, lo que nos indica que debe ser el término de la expresión
correspondiente a F(X,Y,Z,W) = F(0,1,1,1); de similar manera, la intersección
entre la fila tres y la columna cuatro es el término de la expresión
correspondiente a F(X,Y,Z,W) = F(1,1,1,0). En otras palabras cada cuadro del
mapa de Karnaugh tiene un mintérmino correspondiente en la tabla de verdad;
y en cada cuadro se colocará el resultado esperado para cada uno de ellos. Es
importante tener en cuenta que existen columnas y filas adyacentes en el mapa
de Karnaugh en las cuales una de las variables es “1” y no varía, esto lo
podemos observar en la figura No. 14.
Figura No. 13 Mapa de Karnaugh para una expresión de 4 variables
Procedimiento:
1. Identificamos que es una tabla de verdad con tres variables, por lo tanto,
necesitaremos un mapa con dos filas y cuatro columnas como la
observada en el Item b) de la figura No. 14.
2. Cada uno de los mintérminos de la tabla de verdad será relacionada con
cada uno de los cuadros del mapa de Karnaugh, por lo cual, en cada
cuadro relacionado colocaremos los resultados esperados según la tabla
de verdad:
EJERCICIOS:
1+ 0 = 1+1 = 1⋅ 0 = 1 ⋅1 =
X +0= Y +1 = X ⋅0 = X+X =
___ ___
Z ⋅Z = X+X = X⋅X = X + X ⋅Y = 0
Y (Y + X ) = X + XY + Y =
__________ _________
b). ( XY + ZW ) ⋅ V =
7). Investigue cómo se trabajan los mapas de Karnaugh para cinco o más
variables.
En la tabla anterior, usted podrá notar que para los valores binarios del 1010 2 al
11112 el sistema tiene unas salidas activadas (segmentos), esas salidas a qué
información en conjunto corresponde?. Como ejercicio práctico, encuentre la
mínima expresión lógica para cada una de las salidas (segmentos) y realice el
circuito lógico correspondiente al conversor BCD – Siete Segmentos.
4.2.1 Definición
Un codificador es aquel circuito lógico que hace la conversión de un código a
otro código; algunos de estos códigos son el GRAY; el código de Caracteres;
los códigos para acciones, condiciones y estados (empleado en la
comunicación del teclado con el PC); los códigos para detectar y corregir
errores; códigos Bidimensionales; códigos para la transmisión y el
almacenamiento de Datos en Serie (NRZI, BPRZ, AMI; etc.)
2 F (0,1,2,3,4,5,6,7,8,9) = 5 + 6 + 7 + 8 + 9
4 F (0,1,2,3,4,5,6,7,8,9) = 4 + 6 + 7 + 8 + 9
2 F (0,1,2,3,4,5,6,7,8,9) = 2 + 3 + 5 + 8 + 9
1 F (0,1,2,3,4,5,6,7,8,9) = 1 + 3 + 5 + 7 + 9
4.3 Multiplexores
En muchas situaciones de la vida nos hemos visto obligados a hacer fila y
esperar nuestro turno, en algunos de esos casos, son varias las filas que
esperan a que un solo funcionario sea el que les atienda, y en esos casos, el
funcionario decide a cual de las filas empieza a atender. Una situación similar
se presenta en los dispositivos electrónicos, por ejemplo un bus de transmisión
de Datos, al que muchos dispositivos desean acceder pero deben esperar su
turno para hacerlo.
4.3.1 Definición
Un multiplexor es un conmutador digital; es el encargado de encauzar datos de
una fuente entre n fuentes posibles, a una sola salida.
4.4.1 Definición
La operación XOR algunas veces se reconoce por el símbolo “ ⊕ ” y se define
como
___ ___
X ⊕Y = X Y + X Y
4.5.1 Definición
Un Comparador es un circuito lógico que compara dos palabras binarias
indicando si son iguales o no.
4.6.1 Definición
Un sumador es el circuito encargado de realizar la operación de la suma
aritmética a dos números binarios.
4.7.1 Definición
El circuito de Resta es aquel que realiza la operación de sustraer entre dos
valores binarios.
D = B 0 ⊕ B1 ⊕ P
___ ___
Psal = B0 B1 + B0 P + B1.P
4.8.1 Definición
La unidad Aritmética y Lógica (ALU) es un circuito combinacional especializado
en el desarrollo de operaciones aritméticas y lógicas diferentes a dos valores
binarios dados; la selección del tipo de operación requerido se realiza por
medio de las entradas destinadas para este fin. Por lo tanto, este tipo de
circuito tiene las entradas para los dos valores binarios y entradas adicionales
para especificar el tipo de operación a realizar.
4.9.1 Definición
Un multiplicador combinacional es un circuito lógico con una tabla de verdad
que expresa el producto de dos palabras de entrada de n bits como una función
combinacional.
c0 = a0b0
c1 = a0b1 ⊕ a1b1
c 2 = a1b1 ⊕ (( a 0 b1 )( a1b0 ))
c3 = (a1b1 )(a0b1 )(a1b0 )
Ejercicios:
1). Diseñe un decodificador de 3 a 8 para decodificar un código Gray.
5.1.1 Definición
Una memoria ROM es un circuito combinacional con n entradas y b salidas, en
donde las entradas se conocen como entradas de Dirección y tradicionalmente
por el término en inglés Address cada una de ellas se les llama A0 , A1 , …,
An−1 ; las salidas se conocen como Salidas de Datos y a cada una de ellas se
les llama D0 , D1 , …, Db −1 .
5.1.3 Aplicaciones
Como se había comentado antes, una memoria ROM puede almacenar la
relación establecida en una tabla de verdad y por lo tanto, con un solo CI se
puede reemplazar el número necesario de compuertas discretas para construir
el circuito lógico que represente esa tabla de verdad. Por lo tanto, se puede
construir una memoria ROM para almacenar cualquier tabla de verdad que
satisfaga la cantidad de entradas y salidas requeridas para la misma.
Figura No. 28 Estructura básica de una ROM de 2 n xb
5.2.1 Definición
Un PLD combinacional es cualquier dispositivo lógico cuya función es
especificada por el usuario final después de ser fabricado el dispositivo. Otro
nombre con el cual se conoce este tipo de dispositivo es PLA (de las siglas de
Programmable Logic Array) , también conocido como un arreglo lógico
programable.
5.2.2 Circuito Básico de Funcionamiento
Un ejemplo de un Arreglo Lógico Programable puede ser como el de la figura
No. 30, en donde se tiene un dispositivo AND-OR de dos niveles combinacional
que puede programarse de tal forma que se pueda aplicar una expresión lógica
de suma de mintérminos; el procedimiento de la programación consiste en
dañar los fusibles que se colocan antes de la compuerta AND, de tal manera
que quedan funcionando sólo los que estén relacionados con los mintérminos
seleccionados.
5.2.3 Aplicaciones
En algunos casos, los PLAs o PLDs se emplean como memorias ROM; como
se había planteado, una memoria ROM se puede representar con una tabla de
verdad en donde las entradas identifican la dirección de memoria y las salidas
indicarían el valor almacenado en esa posición de memoria, ahora, si esta tabla
de verdad la representamos con varias expresiones de suma de mintérminos y
estas expresiones se programan en un PLA, podemos obtener una memoria
ROM implementada con este tipo de dispositivos.
5.3.1 Definición
Una memoria RAM es un dispositivo semiconductor que puede ser leído o
escrito por una unidad central de procesamiento u otros dispositivos, y es
empleado para el almacenamiento de datos.
5.3.3 Aplicaciones
La memoria RAM es una memoria volátil ampliamente usada en computadores
para mantener información de datos y programas temporalmente.
Investigación:
LU, Mi (2004). Arithmetic and logic in computer systems. John Wiley and Sons,
Inc Publication.
LENGUAJE VHDL
Como la salida del sistema está representada por una expresión lógica, esta
expresión lógica nos indica la manera como se compone el sistema en
pequeñas partes o sub-módulos. Cada uno de estos sub-módulos son
conocidos como instancias o casos (instance), y los puertos de estas
instancias son interconectados por señales (signals). Como ejemplo, podemos
observar en la figura No. 33 las instancias que conformarían la representación
estructural de la figura No. 32. Téngase en cuenta que cada una de las
instancias A, B y C pueden estar compuestas a su vez por otro tipo de
instancias.
Para el caso de diseñar sistemas electrónicos con el lenguaje VHDL, los pasos
anteriores se realizan en paralelo, es decir, la descripción del comportamiento,
la descripción estructural y la simulación se realizan a la par, lo que nos permite
obtener al final un listado de interconexiones que al ser implementada se
obtiene un CI con las características deseadas.
LYBRARY nombre_de_la_librería;
USE nombre_de_la_librería.nombre_del_paquete.partes_del_paquete;
ENTITY nombre_de_la_entidad IS
PORT (
Nombre_del_puerto : modo_de_funcionamiento tipo_de_señal;
Nombre_del_puerto : modo_de_funcionamiento tipo_de_señal;
. . . . . );
END nombre_de_la_entidad;
Para cada puerto, se tiene la posibilidad de indicar qué tipo de señal manejará,
es decir, si será un bit (BIT), un estado lógico (STD_LOGIC), un entero
(INTEGER), etc.
Tomemos como ejemplo el código que describe una compuerta OR, cuyas
entradas se llaman A y B, y su salida C:
ENTITY compuerta_OR IS
PORT(A, B : IN BIT;
C : OUT BIT);
END compuerta_OR ;
En el mismo caso que del nombre de la entidad, puede ser cualquier nombre
de la arquitectura excepto las palabras reservadas por el lenguaje VHDL. En la
parte de las declaraciones, la cual es opcional, se realiza una declaración de
las señales y constantes presentes en el sistema. En la parte del código se
incorpora la descripción del comportamiento lógico del sistema. Continuemos
con el ejemplo de la compuerta OR, en cuyo caso el código correspondiente en
la sección de arquitectura sería:
1.4.1 Comentarios
Los comentarios en el lenguaje VHDL comienzan con dos guiones seguidos (--)
y representa como comentario toda la escritura que sigue a los guiones hasta
el final del renglón correspondiente. Los comentarios los puede emplear el
programador como instrumento de explicación o aclaración con relación a
alguna parte del programa desarrollado.
1.4.2 identificadores
Los identificadores son las palabras reservadas por el lenguaje y los nombres
definidos por el programador (variables, señales, rutinas, etc). Estos
identificadores se deben establecer de la siguiente manera:
Ejemplos:
0 1 123_456_789 852E6 --enteros literales
0.0 0.5 2.756_45 12.4E-9 --reales literales
Ejemplos:
2#1100_0100# 16#C4# 4#301#E1 -- el número entero 196
2#1.1111_1111_111#E+11 16#F.FF#E2 -- el número real 4095.0
1.4.4 Caracteres
En algunos casos, se necesitará tener el código ASCII de algunos caracteres
como el valor de una variable, para tal caso, al asignar el valor del carácter es
necesario colocarlo entre comillas sencillas, ejemplos:
B”110110101”
O”134” --el número equivalente sería B”001_011_100”
X”65” --el número equivalente sería B”0110_0101”
1.4.7 Operadores
El lenguaje VHDL tiene pre-establecido las siguientes clases de operadores:
Operadores de Asignación:
Son usados para asignar valores a las señales, variables y constantes.
Ellos son:
Operadores lógicos:
Son usados para ejecutar operaciones lógicas, pero los objetos deben
ser de tipo BIT, STD_LOGIC, o STD_ULOGIC; los operadores lógicos
son:
o NOT
o AND
o NAND
o OR
o NOR
o XOR
o XNOR
Operadores aritméticos:
Son usados para realizar operaciones aritméticas; los datos deben ser
de tipo INTEGER, SIGNED, UNSIGNED y REAL. Los operadores son:
+ suma
- resta
* multiplicación
/ división
** exponenciación
MOD módulo
REM Residuo
ABS valor absoluto
** Exponencial
o = igual a
o /= no es igual a
o < menor que
o > mayor que
o <= menor o igual que
o >= mayor o igual que
Operadores de desplazamiento
Son usados para realizar desplazamientos de datos. Los operadores de
desplazamiento son:
SLL desplazamiento lógico a la izquierda –las posiciones
a la derecha del dato son reemplazadas por ‘0’
SRL desplazamiento lógico a la derecha –las posiciones a
la izquierda del dato son reemplazadas por ‘0’
SLA desplazamiento aritmético a la izquierda --conserva
el signo, es decir mantiene el valor del bit más significativo
SRA desplazamiento aritmético a la derecha --conserva
el signo del bit más significativo.
ROL rotación a la izquierda
ROR rotación a la derecha
1.4.8 Instrucción IF
La instrucción IF permite seleccionar la ejecución de un código en dependencia
de una o más condiciones. Las líneas de códigos para esta instrucción son:
IF condición THEN
Secuencia_de_instrucción --si cumple la condición se realiza la instrucción
ELSIF condición THEN
Secuencias_de_instrucción
ELSE
Secuencia_de_instrucción --en el caso que no se cumpla, se realiza esta
END IF;
CASE expresión_condicional IS
Instrucción_alternativa_en_caso_de cumplirse_la_condición
END CASE;
Nombre_del_LOOP :
WHILE condición LOOP
Secuencia_de_instrucciones
END LOOP nombre_del_loop ;
1.4.11 Instrucción NULL
La instrucción NULL no tiene ningún efecto sobre el programa, indica que en
ciertos casos no se realiza nada, es muy empleada como instrucción en
algunas selecciones de la instrucción CASE.
ASSERT condición
REPORT expresión
SEVERITY expresión ;
Como se observó en los ejemplos del capítulo anterior, en las secciones del
código relacionado con la entidad y la arquitectura del mismo, es donde se
establecen los diferentes bloques e interrelaciones de los mismos; se
establecen la funcionalidad de los puertos y sus modos de trabajo (IN, OUT,
etc.)
2.2 OBJETOS
Constante (constant)
Señal (signal)
Variable (variable)
Archivo (file)
Cada uno de estos objetos debe declararse dentro del código VHDL ya sea
como una declaración (en la sección de arquitectura), como parte de un lazo de
control o decisión, como el parámetro de un sub-programa, o como puerto de
entrada o salida de un bloque.
2.2.1 Constante
Es un objeto cuyo valor asignado no cambia, es estático. Para declarar una
constante se siguen las siguientes líneas de comando:
Ejemplo:
CONSTANT cambio : INTEGER := 4;
En donde se declara una constante llamada cambio cuyo valor será el entero 4.
2.2.2 Variable
Es un objeto de cualquier tipo que es comúnmente usado como una memoria
temporal, y cuyo valor es fácilmente cambiado o alterado según los
requerimientos del código empleado. Para declarar una variable se sigue la
siguiente línea de comando:
2.2.3 Señal
Se llama señal a la interconexión existente entre los puertos presentes en el
sistema electrónico que se diseña, por lo cual, una señal represente el cable
que se usaría para la interconexión o el nivel de voltaje presente en el mismo.
También permite establecer un control temporizado e indicar retardos. Las
señales son comúnmente declaradas en la sección de arquitectura, pero su
comportamiento está relacionado con el modo declarado para el puerto que se
relacione con la señal, es decir:
Escalar (scalar)
Compuesto (composite)
De acceso o de entrada (access)
De archivo (file)
2.3.1.1 Tipo Escalar
Existen cuatro tipos de objetos escalares:
2.3.1.5 Subtipos
Un subtipo es un tipo con una limitación al rango de valores original; la
preferencia de generar un subtipo y no un nuevo tipo de objeto se deriva de la
facilidad con la cual el subtipo hereda todas las cualidades del tipo original,
claro está con las limitaciones impuestas en la nueva definición. Ejemplo de
definición de subtipos:
Entidad:
ENTITY identificador IS
GENERIC Listado_general_componentes
PORT Listado_general_de_puertos
BEGIN
Instrucciones_entidad
END identificador ;
Arquitectura:
Declaración_de_señales ::=
SIGNAL lista_de_identificadores : subtipos clase_de_señal :=
expresión ;
Declaración_de_componentes ::=
COMPONENT identificador
Descripción_del_componente
END identificador;
Configuración_y_uso
BEGIN
Instrucciones
END identificador ;
GENERIC define y declara propiedades o constantes del módulo que están
siendo declaradas en la Entidad.
PORT Define las entradas y salidas del módulo que se está definiendo.
2.5.3 BLOCK
La funcionalidad de este condicional es la de crear subdivisiones de
condicionales de ejecución dentro de una misma entidad. La estructura básica
de este condicional es:
nombre_del_bloque:
BLOCK Expresión IS
Declaraciones_opcionales
BEGIN
Sentencias_condicionales
END BLOCK nombre_del_bloque;
CAPITULO 3
3.1 MULTIPLEXORES 4 A 1
Recordemos la tabla lógica del multiplexor 4 a 1 vista anteriormente:
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------------------------------
ENTITY multiplexor_4_a_1 IS
PORT ( D3, D2, D1, D0 : IN BIT;
direccion : IN STD_LOGIC_VECTOR ( 1 DOWNTO 0) ;
Salida : OUT BIT );
END multiplexor_4_a_1 ;
-----------------------------------------------------------------------------
ARCHITECTURE ejemplo OF multiplexor_4_a_1 IS
BEGIN
PROCESS ( D3, D2, D1, D0, direccion, salida)
BEGIN
IF ( direccion = “00” ) THEN
Salida <= D0;
ELSIF ( direccion = “01”) THEN
Salida <= D1;
ELSE (direccion = “10”) THEN
Salida <= D2;
ELSE
Salida <= D3;
END IF;
END PROCESS ;
END ejemplo ;
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------------------------------
ENTITY multiplexor_4_a_1 IS
PORT ( D3, D2, D1, D0, A1, A0: IN STD_LOGIC;
Salida : OUT STD_LOGIC );
END multiplexor_4_a_1 ;
-----------------------------------------------------------------------------
ARCHITECTURE ejemplo_lógico OF multiplexor_4_a_1 IS
BEGIN
Salida <= (D0 AND NOT A1 AND NOT A0) OR
(D1 AND NOT A1 AND A0) OR
(D2 AND A1 AND NOT A0) OR
(D3 AND A1 AND A0);
END ejemplo_lógico ;
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------------------------------
ENTITY multiplexor_4_a_1 IS
PORT ( D3, D2, D1, D0: IN STD_LOGIC;
Dirección: IN STD_LOGIC_VECTOR (1 DOWNTO 0);
Salida : OUT STD_LOGIC );
END multiplexor_4_a_1 ;
-----------------------------------------------------------------------------
ARCHITECTURE ejemplo_when OF multiplexor_4_a_1 IS
BEGIN
Salida <= D0 WHEN dirección=”00” ELSE
D1 WHEN dirección=”01” ELSE
D2 WHEN dirección=”10” ELSE
D3;
END ejemplo_when ;
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------------------------------
ENTITY multiplexor_4_a_1 IS
PORT ( D3, D2, D1, D0: IN STD_LOGIC;
Dirección: IN STD_LOGIC_VECTOR (1 DOWNTO 0);
Salida : OUT STD_LOGIC );
END multiplexor_4_a_1 ;
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------------------------------
ENTITY siete_segmentos IS
PORT ( entrada : IN BIT_VECTOR ( 3 DOWNTO 0) ;
Salida : OUT BIT_VECTOR (6 DOWNTO 0) );
END siete_segmentos ;
-----------------------------------------------------------------------------
ARCHITECTURE siete_segmentos OF siete_segmentos IS
BEGIN
PROCESS (entrada)
BEGIN
CASE entrada IS
WHEN “0000” => salida <= “1111110”;
WHEN “0001” => salida <= “0110000”;
WHEN “0010” => salida <= “1101100”;
WHEN “0011” => salida <= “1111001”;
WHEN “0100” => salida <= “0110011”;
WHEN “0101” => salida <= “1011011”;
WHEN “0110” => salida <= “0011111”;
WHEN “0111” => salida <= “1110000”;
WHEN “1000” => salida <= “1111111”;
WHEN “1001” => salida <= “1110011”;
WHEN “1010” => salida <= “1110111”;
WHEN “1011” => salida <= “0011111”;
WHEN “1100” => salida <= “1001110”;
WHEN “1101” => salida <= “0111101”;
WHEN “1110” => salida <= “1001111”;
WHEN “1111” => salida <= “1000111”;
END CASE;
END PROCESS;
END siete_segmentos;
-----------------------------------------------------------------------------
Ejercicios:
4.1 SUMADORES
Recordemos el sumador de dos bits con acarreo de entrada de la figura No. 24
b), el cual se representa en la figura No. 35. El código VHDL para este
sumador sería:
ENTITY sumador IS
PORT (B0, B1, A: IN BIT;
Resultado, Acarreo_de_Salida: OUT BIT;
END sumador;
---------------------------------------------------------------------
ARCHITECTURE dataflow OF sumador IS
BEGIN
Resultado <= B0 XOR B1 XOR A;
Acarreo_de_Salida <= (B0 AND B1) OR (B0 AND A) OR (B1 AND A);
END dataflow
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
-----------------------------------------------------------------------------
ENTITY cerradura IS
PORT ( SIGNAL teclas : IN STD_LOGIC_VECTOR (3 DOWNTO 0);
SIGNAL clear, chequear: IN STD_LOGIC;
SIGNAL puerta : OUT STD_LOGIC_VECTOR(0 TO 1) );
END cerradura ;
-----------------------------------------------------------------------------
ARCHITECTURE logica_cerradura OF cerradura IS
TYPE decodificador IS (RESET, PRIMER_NUMERO, ESPERA_PRIMER,
SECUNDO_NUMERO, ESPERA_SEGUNDO, TERCER_NUMERO,
ESPERA_TERCER, CUARTO_NUMERO);
SIGNAL estado_presente : decodificador;
BEGIN
Salida_seleccionada : PROCESS(estado_presente)
BEGIN
CASE estado_presente IS
WHEN RESET => puerta <= “10”;
WHEN PRIMER_NUMERO SEGUNDO_NUMERO
TERCER_NUMERO CUARTO_NUMERO => puerta
<= “01”;
WHEN OTHERS => puerta <= “11”;
END CASE;
END PROCESS;
Salida_seleccionada : PROCESS
VARIABLE proximo_estado: decodificador;
BEGIN
WAIT UNTIL ( chequear’EVENT AND chequear=’1’);
Proximo_estado := estado_presente;
IF clear=’0’ THEN
Proximo_estado := RESET;
ELSE
CASE estado_presente IS
WHEN RESET =>
CASE teclas IS
WHEN “0001” => proximo_estado :=
primer_numero;
WHEN OTHERS => NULL;
END CASE;
WHEN primer_numero =>
CASE teclas IS
WHEN “0010” => proximo_estado :=
Segundo_numero;
WHEN “0001” => proximo_estado :=
Espera_primer;
WHEN OTHERS => proximo_estado :=
RESET;
END CASE;
WHEN espera_primer =>
CASE teclas IS
WHEN “0010” => proximo_estado :=
Segundo_numero;
WHEN “0001” => NULL;
WHEN OTHERS => proximo_estado :=
RESET;
END CASE;
WHEN segundo_numero =>
CASE teclas IS
WHEN “0011” => proximo_estado :=
tercer_numero;
WHEN “0010” => proximo_estado :=
Espera_segundo;
WHEN OTHERS => proximo_estado :=
RESET;
END CASE;
WHEN espera_segundo =>
CASE teclas IS
WHEN “0011” => proximo_estado :=
tercer_numero;
WHEN “0010” => NULL;
WHEN OTHERS => proximo_estado :=
RESET;
END CASE;
WHEN tercer_numero =>
CASE teclas IS
WHEN “0100” => proximo_estado :=
cuarto_numero;
WHEN “0011” => proximo_estado :=
Espera_tercer;
WHEN OTHERS => proximo_estado :=
RESET;
END CASE;
WHEN espera_tercero =>
CASE teclas IS
WHEN “0100” => proximo_estado :=
cuarto_numero;
WHEN “0011” => NULL;
WHEN OTHERS => proximo_estado :=
RESET;
END CASE;
WHEN cuarto_numero =>
CASE teclas(0) IS
WHEN ‘0’ => proximo_estado :=
RESET;
WHEN OTHERS => NULL;
END CASE;
WHEN OTHERS => NULL;
END CASE;
END IF;
Estado_presente <= proximo_estado;
END PROCESS;
END logica_cerradura;
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all; --este paquete se empleará para el tipo XOIZ
USE dzx.logic_utils.all; --este paquete se empleará para el tipo XOIZ_VECTOR
USE work.control_logic.rnd_gen; --es un generador de secuencias randómico
-----------------------------------------------------------------------------
ENTITY generador IS
PORT ( CLK, RESET : IN XOIZ;
BUS_EXT : OUT XOIZ_VECTOR (3 DOWNTO 0)) ;
END generador ;
-----------------------------------------------------------------------------
ARCHITECTURE ejemplo OF generador IS
SINAL REG_RANDOM : XOIZ_VECTOR(REG_RANDOM’range);
BEGIN
WAIT UNTIL (CLK=’0’ AND CLK’event);
IF RESET = ‘1’ THEN
VRANDOM_REG := REG_RANDOM; --se emplea el último patrón
ELSE
FOR k IN REG_RANDOM’range LOOP
IF k=REG_RANDOM’left THEN
VRANDOM_REG(k) := ‘1’;
ELSE
VRANDOM_REG(k) := ‘0’;
END IF;
END LOOP;
END IF;
RND_GEN(VRANDOM_GEN); --se genera nuevo patrón
REG_RANDOM <= VRANDOM_REG;
END PROCESS
BUS_EXT <= REG_RANDOM;
END
Resultado <= a * b;
END ejemplo ;
-----------------------------------------------------------------------------
BIBLIOGRAFIA