Operación de diseño lógico, ¿preguntas simples?

Ha pasado mucho tiempo desde que hice esto a lo largo.

La tabla de la verdad

El primer paso para aprender qué hacen estos circuitos es crear una tabla de verdad. Quizás ya sepa cómo hacerlo, pero no sabía que era el primer paso, en cualquier caso lo repasaremos. Trabajaré el primer circuito de ejemplo.

Haz columnas para cada una de tus entradas y salidas. A veces también es más fácil hacer columnas para valores intermedios, solo para ayudarlo a determinar los resultados finales. Tienes A, B y C como entradas, la salida del mux no está etiquetada, pero es la salida para este circuito.

+---+---+---+-----+
| A | B | C | Out |
+---+---+---+-----+

Ahora complete las entradas posibles. Solo querrá hacer esto para las tablas de verdad con menos de cuatro o cinco entradas, de lo contrario, se vuelven demasiado grandes. Siempre empiezo con la entrada que está más a la derecha y alterno entre escribir un 0 y un 1 al completar las filas. Hay tres entradas, lo que significa que hay ocho permutaciones posibles (2 ^ 3). Para la siguiente entrada a la derecha, complete alternando entre escribir dos 0 y dos 1 mientras completa las filas. La entrada final alterna entre escribir cuatro 0 y cuatro 1 al completar las filas. Así es como solía hacerlo; Encuentra tu mejor manera. Las filas solo cuentan en binario.

+---+---+---+-----+
| A | B | C | Out |
+---+---+---+-----+
| 0 | 0 | 0 |     |
+---+---+---+-----+        
| 0 | 0 | 1 |     |
+---+---+---+-----+
| 0 | 1 | 0 |     |
+---+---+---+-----+
| 0 | 1 | 1 |     |
+---+---+---+-----+
| 1 | 0 | 0 |     |
+---+---+---+-----+
| 1 | 0 | 1 |     |
+---+---+---+-----+
| 1 | 1 | 0 |     |
+---+---+---+-----+
| 1 | 1 | 1 |     |
+---+---+---+-----+

Ahora rellénalo con las cosas obvias primero. Por ejemplo, dado que A está controlando el mux, en cualquier momento es igual a 1, la salida es simplemente NO B. Eso se ocupa de la mitad inferior de la tabla.

Para la otra mitad, cuando A es 0, la salida es simplemente B y C.

+---+---+---+-----+
| A | B | C | Out |
+---+---+---+-----+
| 0 | 0 | 0 |  0  |
+---+---+---+-----+        
| 0 | 0 | 1 |  0  |
+---+---+---+-----+
| 0 | 1 | 0 |  0  |
+---+---+---+-----+
| 0 | 1 | 1 |  1  |
+---+---+---+-----+
| 1 | 0 | 0 |  1  |
+---+---+---+-----+
| 1 | 0 | 1 |  1  |
+---+---+---+-----+
| 1 | 1 | 0 |  0  |
+---+---+---+-----+
| 1 | 1 | 1 |  0  |
+---+---+---+-----+

La ecuación

Al verlo así por partes, lo que realmente estás haciendo es traducir el circuito en oraciones, esas oraciones se pueden describir con ecuaciones booleanas.

Las oraciones fueron:

Si A, entonces la salida NO es B.

Si NO es A, entonces la salida es B y C.

En términos de la salida, esto significa que la salida es verdadera cuando BYC es verdadera y NO A es verdadera o A es verdadera y NOT B es verdadera .

Por lo tanto, la ecuación es Salida = (~ A & (B & C)) | (A & ~ B).

Ese método puede ser demasiado difícil para usted al principio. El largo camino para la ecuación es escribir la ecuación para cada fila de la tabla de verdad y reducir la lógica con el álgebra booleana. Debes hacer eso una vez , luego aprender a dibujar un mapa de Karnaugh y escribir la ecuación de La lógica reducida producida por eso.

Derivar expresiones lógicas
Derivar una expresión lógica a partir de un circuito lógico dado implica rastrear la ruta desde la entrada hasta la salida y escribir expresiones lógicas intermedias a lo largo de la ruta. El proceso se ilustra en la siguiente figura.

Teniendoencuentaestaspuertassimples:

Una posible implementación del multiplexor es:

Unaposibleimplementacióndeldecodificadores:
>

Entonces, dependiendo del valor (1,0) de sus señales de entrada, A, B, C y utilizando las tablas de verdad, puede determinar fácilmente la salida.

La forma más rápida de llegar a una ecuación para cualquier problema como este es escribir una tabla de verdad y luego usar un K-Map para obtener una y / o ecuación.

enlace

Primer problema:

Tabla de la verdad

\ $ \ begin {array} {ccc | c} A & B & C & Out \\ \ hline 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 1 & 1 & 1 \\ 1 & 0 & 0 & 1 \\ 1 & 0 & 1 & 1 \\ 1 & 1 & 0 & 0 \\ 1 & 1 & 1 & 0 \\ \ end {array} \ $

K-Map

\ $ \ begin {array} {c | c} _ {AB} \ diagdown ^ C & 0 \ quad 1 \\ \ hline 00 & 0 \ quad 0 \\ 01 & 0 \ quad \ boxed 1 \\ 11 & 0 \ quad 0 \\ 10 & \ en caja {1 \ quad 1} \\ \ end {array} \ $

\ $ OUT = A \ overline B + \ overline ABC \ $