Lógica Combinacional
En este apartado se incluyen algunos módulos básicos de circuitos combinacionales:
Salida código exceso-3
La salida código exceso-3 es un código de 4 bits que se obtiene sumando 3 al número decimal que se quiere codificar.
Esta tabla de verdad muestra la relación entre los BCD o Binary Coded Decimals y la salida código exceso-3:
Entrada BCD
| \(A\) | \(B\) | \(C\) | \(D\) |
|---|---|---|---|
| \(0\) | \(0\) | \(0\) | \(0\) |
| \(0\) | \(0\) | \(0\) | \(1\) |
| \(0\) | \(0\) | \(1\) | \(0\) |
| \(0\) | \(0\) | \(1\) | \(1\) |
| \(0\) | \(1\) | \(0\) | \(0\) |
| \(0\) | \(1\) | \(0\) | \(1\) |
| \(0\) | \(1\) | \(1\) | \(0\) |
| \(0\) | \(1\) | \(1\) | \(1\) |
| \(1\) | \(0\) | \(0\) | \(0\) |
| \(1\) | \(0\) | \(0\) | \(1\) |
Salida código exceso-3
| \(w\) | \(x\) | \(y\) | \(z\) |
|---|---|---|---|
| \(0\) | \(0\) | \(1\) | \(1\) |
| \(0\) | \(1\) | \(0\) | \(0\) |
| \(0\) | \(1\) | \(0\) | \(1\) |
| \(0\) | \(1\) | \(1\) | \(0\) |
| \(0\) | \(1\) | \(1\) | \(1\) |
| \(1\) | \(0\) | \(0\) | \(0\) |
| \(1\) | \(0\) | \(0\) | \(1\) |
| \(1\) | \(0\) | \(1\) | \(0\) |
| \(1\) | \(0\) | \(1\) | \(1\) |
| \(1\) | \(1\) | \(0\) | \(0\) |
Luego es posible hacer un mapa de Karnaugh para las salidas/funciones \(x, y , z, w\)
Es importante mencionar que los BCD posibles son 10, cualquier entrada \(BCD > 9 \; \lor \; BCD < (1001)_2\) no es posible (valor indiferente marcado con \(X\)).
En este mapa se pueden ver las salidas \(z, y\).
De esta forma transformarlas en un diagrama lógico ahora es más sencillo (faltarían ver las salidas \(w, x\)).
Sumadores
Semisumador
Un semisumador es un circuito que suma dos bits de entrada \(x\) y \(y\) y produce dos salidas: la suma \(S\) y el acarreo \(C\).
La tabla de verdad de un semisumador es la siguiente:
| \(x\) | \(y\) | \(S\) | \(C\) |
|---|---|---|---|
| \(0\) | \(0\) | \(0\) | \(0\) |
| \(0\) | \(1\) | \(1\) | \(0\) |
| \(1\) | \(0\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(0\) | \(1\) |
Su diagrama es el siguiente:
Donde \(\;S = x \oplus y, \; C = xy\)
Sumador completo
Un sumador completo tiene tres entradas: dos bits \(x\) y \(y\) y un acarreo de entrada \(z\). Produce dos salidas: la suma \(S\) y el acarreo de salida \(C\).
La tabla de verdad de un sumador completo es la siguiente:
| \(x\) | \(y\) | \(z\) | \(C\) | \(S\) |
|---|---|---|---|---|
| \(0\) | \(0\) | \(0\) | \(0\) | \(0\) |
| \(0\) | \(0\) | \(1\) | \(0\) | \(1\) |
| \(0\) | \(1\) | \(0\) | \(0\) | \(1\) |
| \(0\) | \(1\) | \(1\) | \(1\) | \(0\) |
| \(1\) | \(0\) | \(0\) | \(0\) | \(1\) |
| \(1\) | \(0\) | \(1\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(0\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(1\) | \(1\) | \(1\) |
Su diagrama es el siguiente:
Donde \(\;S = z \oplus (x \oplus y), \; C = z(xy + x'y) + xy\)
Sumador binario
Un sumador binario es un circuito que suma dos números binarios. El mismo se compone de distintos sumadores completos (dependiendo de la cantidad de bits de los números a sumar).
Si tomamos por ejemplo, la suma de los números de cuatro bits \(A, B\) debemos sumar cada \(A_i\) con \(B_i\) y el acarreo de la suma anterior:
\[\begin{align} &\quad \; \\ &\quad \quad C_3 C_2 C_1 C_0 \\ &\quad \quad A_3 A_2 A_1 A_0 \\ &+ \;\;\; B_3 B_2 B_1 B_0 \\ &\quad \;\; \overline{C_4 S_3 S_2 S_1 S_0} \\ \end{align} \]
Uno de los problemas que radican en este sumador es que, al ser un proceso en cascada, su velocidad depende del cálculo de los acarreos.
La forma de resolver este problema es paralelizando el proceso, obteniendo los acarreos anticipadamente.
Acarreo anticipado
El acarreo anticipado es un método que permite calcular los acarreos de un sumador binario de forma paralela.
Observando el diagrama del sumador completo:
Mediante las variables binarias:
\[\begin{align} P_i &= A_i \oplus B_i \\ G_i &= A_iB_i \\ \end{align} \]Expresamos la suma y el acarreo como:
\[\begin{align} S_i &= P_i \oplus C_i \\ C_{i+1} &= G_i + P_iC_i \\ \end{align} \]Los acarreos serían:
\[\begin{align} &C_0 \\ &C_1 = G_0 + P_0C_0 \\ &C_2 = G_1 + P_1C_1 = G_1 + P_1(G_0 + P_0C_0) \\ &C_3 = G_2 + P_2C_2 = G_2 + P_2(G_1 + P_1(G_0 + P_0C_0)) \\ \end{align} \]Un diagrama lógico de un acarreo anticipado sería:
Multiplicador binario
Un multiplicador binario es un circuito que realiza la multiplicación de dos números binarios.
Si queremos multiplicar dos números de dos bits \(A, B\) seguimos de la siguiente manera:
\[\begin{align} &\quad \quad \quad \quad \quad \quad \; B_1 \quad \quad \quad B_0 \\ &\quad \quad \quad \quad \quad \times \; \; A_1 \quad \quad \quad A_0 \\ &+ \quad \quad \quad \quad \quad \overline{A_0 B_1 \quad A_0 B_0} \\ &\quad \quad \;\;\; A_1 B_1 \quad A_1 B_0 \\ &\overline{C_3 \quad \quad C_2 \quad \quad C_1 \quad \quad C_0} \\ \end{align} \]Aplicado a un diagrama lógico:
Decodificadores
Los decodificadores son circuitos combinacionales que dadas \(n\) variables de entrada generan \(2^n\) salidas (minitérminos).
Este sería un diagrama lógico de un decodificador de \(3\) a \(8\).
Los decodificadores pueden tener una entrada de habilitación (\(E\)) la cual determina si el decodificador funciona o no.
\(E=1 \implies\) decodificador activo por alto funciona y activo por bajo no funciona.
\(E=0 \implies\) decodificador activo por bajo funciona y activo por alto no funciona.
Ejemplo: los siguientes diagramas de bloque,
La tabla de verdad del primer decodificador (activo por alto) sería:
| \(E\) | \(A_1\) | \(A_0\) |
|---|---|---|
| \(1\) | \(0\) | \(0\) |
| \(1\) | \(0\) | \(1\) |
| \(1\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(1\) |
| \(0\) | \(X\) | \(X\) |
| \(Q_3\) | \(Q_2\) | \(Q_1\) | \(Q_0\) |
|---|---|---|---|
| \(0\) | \(0\) | \(0\) | \(1\) |
| \(0\) | \(0\) | \(1\) | \(0\) |
| \(0\) | \(1\) | \(0\) | \(0\) |
| \(1\) | \(0\) | \(0\) | \(0\) |
| \(0\) | \(0\) | \(0\) | \(0\) |
La tabla de verdad del segundo decodificador (activo por bajo) sería:
| \(E\) | \(A_1\) | \(A_0\) |
|---|---|---|
| \(0\) | \(0\) | \(0\) |
| \(0\) | \(0\) | \(1\) |
| \(0\) | \(1\) | \(0\) |
| \(0\) | \(1\) | \(1\) |
| \(1\) | \(X\) | \(X\) |
| \(Q_3\) | \(Q_2\) | \(Q_1\) | \(Q_0\) |
|---|---|---|---|
| \(1\) | \(1\) | \(1\) | \(0\) |
| \(1\) | \(1\) | \(0\) | \(1\) |
| \(1\) | \(0\) | \(1\) | \(1\) |
| \(0\) | \(1\) | \(1\) | \(1\) |
| \(1\) | \(1\) | \(1\) | \(1\) |
Multiplexores
Los multiplexores son circuitos que permiten seleccionar una de las \(2^n\) entradas en base a \(n\) entradas de selección \(S\) y enviarla a la salida.
Un multiplexor de \(2\) a \(1\) sería:
Si \(S = 0 \implies Y = I_0\)
Si \(S = 1 \implies Y = I_1\)
Ejemplo: tabla de verdad de multiplexor de 4 entradas
| \(S_1\) | \(S_0\) | \(Y\) |
|---|---|---|
| \(0\) | \(0\) | \(I_0\) |
| \(0\) | \(1\) | \(I_1\) |
| \(1\) | \(0\) | \(I_2\) |
| \(1\) | \(1\) | \(I_3\) |
Buffer triestado
Un buffer triestado posee una entrada, una salida y una entrada de control.
Si la entrada de control es \(0\) la salida es de alta impedancia, si es \(1\) la salida es igual a la entrada.
En otras palabras, dependiendo de la entrada de control la salida puede estar o no conectada.
Los multiplexores también pueden ser creados a partir de buffers triestado.
PLAs (Programmable Logic Arrays)
Un PLA es un circuito integrado que contiene una matriz de compuertas AND y OR que pueden ser programadas.
En lugar de poner distintas lineas correspondientes a varias entradas en una puerta AND, se pone una sola línea que y se marcan los valores que ingresen a ella (en la imagen, los círculos negros representan aquellos valores que sí están conectados a la compuerta correspondiente)
ROMs (Read-Only Memories)
Una ROM o memoria de solo lectura es un circuito integrado que almacena datos binarios de forma permanente. A diferencia de las PROMs (Programmable Read-Only Memories), las ROMs no pueden ser programadas por el usuario, ya que los datos son grabados durante el proceso de fabricación.
Un diagrama de bloque de una ROM sería:
En general una ROM de \(2^k \times n\) se compone de un decodificador interno de \(k \times 2^k\) y \(n\) compuertas OR (conectadas a cada salida del decodificador)
Ejemplo: ROM de \(32 \times 8\)
