¿Cómo hacer un Mapa de Karnaugh con entradas de "no importa"?

Aquí se explica cómo crear el K-Map para la salida Q. Recuerde que debe hacer un Mapa de Karnaugh separado para cada una de las tres salidas.

inputs    output 
A B C D | Q
0 0 0 0 | x
0 0 0 1 | 0
0 0 1 x | 0
0 1 x x | 1
1 x x x | 1

1. %código%. Esta primera línea es estándar. El "no importa" es una salida. Simplemente coloque la "x" en el lugar apropiado.

Cuando una entrada es X (no importa), eso significa que la línea aplica ambos cuando la X se reemplaza por un 0 y por un 1.

Para su ejemplo, puede ampliar su primera tabla para que sea:

inputs    outputs 
A B C D | Q R S
0 0 0 0 | x x 0
0 0 0 1 | 0 0 1
0 0 1 0 | 0 1 1
0 0 1 1 | 0 1 1
0 1 0 0 | 1 0 1
0 1 0 1 | 1 0 1
0 1 1 0 | 1 0 1
0 1 1 1 | 1 0 1
1 0 0 0 | 1 1 1
(I'll leave the remaining 7 lines to you)

Una línea con 1 X se expandirá a 2 líneas, una línea con 2 X se expandirá a 4 líneas, ... (n X se expandirá a \ $ 2 ^ n \ $ líneas)

Con respecto a su pregunta sobre cómo marcar un no importa en un banco de pruebas (suponiendo que todavía esté hablando de entrada , no importa, no las salidas), debe hacer que su banco de pruebas pase a través de todas las combinaciones de entrada \ $ 2 ^ n \ $ como hicimos al ampliar la tabla anterior.

Como dijiste "no importa, no importa si es un 0 o un 1" . Entonces, si se dice que la salida correspondiente a la entrada "1x" es '1', entonces significa que la salida será '1' si el primer bit (MSB) es '1'. LSB puede ser '0' o '1'. En otras palabras, la salida será '1' tanto para "10" como para "11".

Un ejemplo más: si quiero escribir la tabla de verdad para el sistema, con 4 líneas de entrada, cuya salida será '1' si el último bit de la combinación de entrada (LSB) es '0', preferiré escribir :

input   output
--------------
xxx0       1
xxx1       0
-------------

en lugar de enumerar todas las 16 combinaciones. Porque esto es compacto.

Siempre que encuentre x en la secuencia de entrada, reemplace x con todas las combinaciones posibles. Algunos ejemplos se dan:

$$ \ begin {array} {rll} \ text {símbolo} & \ text {números equivalentes} & \ text {significado} \\ \ hline \ mathrm {\ color {red} {x}} & \ Rightarrow \ color {rojo} {0}, \ color {rojo} {1} & \ text {cualquier número de 1 bit} \\ \ mathrm {\ color {red} {xx}} & \ Rightarrow \ color {rojo} {00}, \ color {rojo} {01}, \ color {rojo} {10}, \ color {rojo} {11} & \ text {cualquier número de 2 bits} \\ \ mathrm {1 \ color {red} {x}} & \ Rightarrow 1 \ color {rojo} {0}, 1 \ color {rojo} {1} & \ text {cualquier número de 2 bits que comience con 1} \\ \ mathrm {\ color {red} {xx} 1} & \ Rightarrow \ color {rojo} {00} 1, \ color {rojo} {01} 1, \ color {rojo} {10} 1, \ color {rojo} {11} 1 & \ text {cualquier número de 3 bits terminando con 1} \\ \ mathrm {1 \ color {rojo} {x} 00} & \ Rightarrow 1 \ color {rojo} {0} 00,1 \ color {rojo} {1} 00 & \ text {cualquier 4 bits sin comenzar con 1 y terminando con 00} \\ \ hline \ end {array} $$

Al dibujar un mapa de Karnaugh, puede ser importante distinguir entre:

1. Casos en los que el circuito debe comportarse de manera idéntica cuando una entrada en particular es baja y estable cuando es alta.

2. Casos en los que el comportamiento del circuito no debería verse afectado por una entrada.

Los dos casos pueden parecer sinónimos, pero a veces puede haber una gran diferencia. Considera la tabla de verdad:

abc
00X -> 0
01X -> 1
1X0 -> 0
1X1 -> 1
X00 -> 0
X11 -> 1

Uno podría simplemente dibujar el circuito como una tabla de verdad:

   |00 01 11 10 bc
---+--------------
a=0| 0  0  1  1
a=1| 0  1  1  0

pero eso no daría todo el panorama, ya que eso haría Sugiera que el circuito podría implementarse como una suma de productos:

out=!a*b*!c + !a*b*c + a*!b*c + a*b*c

pero tal salida puede fallar brevemente cuando una entrada, incluso una que debería no tiene efecto - cambia de alto a bajo o viceversa. Por ejemplo, si las entradas cambian de 010 a 011, aunque la salida debería ser alto en ambos estados, puede haber un momento en el que ni! a b ! c ni ! a b c se registra como verdadero [ya que "c" no es estable alto y no es estable bajo]. Si una entrada realmente necesita ser "no importa", puede ser una buena idea dibujar un óvalo alrededor de los estados que deben comportarse como una unidad, y garantizar que se utiliza un solo término de producto para abarcar todos ellos.

Tenga en cuenta que, si bien dos términos de producto serían suficientes para manejar la tabla de verdad, garantizar que las transiciones en una entrada de "no importa" no afectarán a la salida requerirá la adición de una tercera. El hecho de no tener un término de producto que abarque uno de los óvalos rellenos puede llevar a lo que se denomina peligros lógicos. En algunos diseños no importan, pero en otros pueden ser mortales.