NAND y NOR

01 · Punto de partida

AND y OR con bolita mandan

Si cada puerta fuera un objeto distinto, una placa necesitaría chips de AND, de OR, de NOT y de lo que se te ocurra. Pero resulta que alcanza con una sola. Una puerta que puede, combinada con copias de sí misma, imitar a todas las demás se llama universal, y la NAND y la NOR lo son.

• ¿Qué tablas tienen NAND y NOR, y por qué son «las naturales» del CMOS?
• ¿Cómo se hace NOT, AND, OR y XOR solo con NAND? ¿Y solo con NOR?
• ¿Cómo se lee una red de NAND como si fuera AND y OR?
• ¿El 74HC00 y el 74HC02 comparten pines?
• ¿Cuándo conviene usar una pieza universal y cuándo no?

02 · NAND

Solo el 11 da 0

NAND significa NOT-AND: es un AND seguido de una inversión. Su salida vale 0 únicamente cuando todas las entradas valen 1; en cualquier otro caso vale 1. Se escribe Y = ~(A·B). En el símbolo es un AND con la bolita en la salida.

Por qué es natural en CMOS

Una NAND CMOS lleva solo 4 transistores: dos PMOS en paralelo arriba y dos NMOS en serie abajo. Un AND necesita 6, porque es una NAND más un inversor. Es decir: en silicio la puerta «con bolita» es la barata, y la «sin bolita» es la cara.

Por qué NAND y no NOR

Una NOR CMOS tiene dos PMOS en serie, y los transistores PMOS son más lentos que los NMOS. Por eso, en igualdad de condiciones, la NAND es más rápida y más compacta que la NOR, y es la puerta preferida cuando hay que elegir.

Cómo se lee

Dos lecturas equivalentes (De Morgan): «no todas son 1» o «alguna es 0». Es la puerta que dice «hay una falla» cuando falta alguna condición.

Una historia

Su operación se conoce también como «trazo de Sheffer», por el lógico que en 1913 demostró que una sola operación basta para expresar toda la lógica proposicional.

03 · NOR

Solo el 00 da 1

NOR significa NOT-OR. Su salida vale 1 únicamente cuando todas las entradas valen 0. Se escribe Y = ~(A+B). Es el dual exacto de la NAND: lo mismo, con todo cambiado de signo.

04 · Universalidad

Todo con una pieza

¿Por qué alcanza una sola? Porque cualquier función se puede escribir con NOT, AND y OR (es la suma de productos del Tema 6). Si demostrás que NAND construye esas tres, construye todo. Y las construye así:

Con NOR el esquema es el espejo: la receta es la misma intercambiando los papeles de AND y OR (dualidad, Tema 8).

05 · De Morgan en el plano

La red de dos niveles

Las leyes de De Morgan dicen cómo cambia una puerta al mover las bolitas de lugar. Son dos reglas simétricas:

Gráficamente: un NAND es un OR con bolitas en las entradas, y un NOR es un AND con bolitas en las entradas. Una bolita en la salida de una puerta, empujada hacia adelante, se convierte en una bolita en la entrada de la siguiente y cambia la puerta de AND a OR (o al revés).

El truco: AND-OR se convierte en NAND-NAND

La suma de productos (Tema 6) es naturalmente una red de dos niveles: AND adentro, OR afuera. Si dibujás una bolita en la salida de cada AND y otra en cada entrada del OR final, se cancelan de a pares (dos inversiones se anulan) y el OR con bolitas en las entradas es exactamente una NAND. Resultado: la misma función con puertas NAND en los dos niveles.

Mismo resultado, un solo tipo de chip y menos retardo, porque cada NAND es más rápida que un AND. Es exactamente lo que hacen las herramientas de síntesis cuando mapean un diseño a una biblioteca de puertas: reescriben todo con la pieza más barata.

Receta

Partí de la suma de productos. Cada producto pasa a una NAND (con sus entradas negadas donde la variable aparece negada). La suma final también es una NAND que junta todas las salidas.

Entradas negadas

Si un producto lleva ~A, necesitás un inversor para A (que se obtiene con una NAND de entradas unidas). Se comparte con todas las puertas que lo usen.

Dual con NOR

El producto de sumas (con maxterms) se convierte igual en una red NOR-NOR.

06 · Chips reales

74HC00, 74HC02 y compañía

El 00 y el 02 no se parecen

A pesar de ser duales, el 74HC00 y el 74HC02 no tienen el mismo mapa de pines. En el 00 cada puerta tiene sus entradas primero y la salida después (A, B, Y); en el 02 la salida va primero (Y, A, B). Conectar uno donde iba el otro cortocircuita salidas con entradas o con alimentación.

Salidas en el 00 y en el 02

En el 74HC00 las salidas están en los pines 3, 6, 8 y 11. En el 74HC02, en los pines 1, 4, 10 y 13. Confirmalo en la hoja de datos del fabricante antes de cablear.

Entradas y puertas sin usar

Una entrada sobrante de una NAND se ata a 1 (el neutro del AND); una de una NOR, a 0. Y una puerta entera sin usar no se deja al aire: sus entradas se atan a GND o VCC para que no oscile ni consuma.

NOT con una NAND

Hay dos formas de hacer un inversor con una NAND: unir las dos entradas (carga el cable de A con el doble de capacidad) o atar una a 1 y usar la otra (mejor). Con una NOR, igual: una entrada a 0.

Dos NAND cruzadas: una memoria

Si la salida de cada NAND se conecta a una entrada de la otra, el lazo guarda un bit. Es el latch SR con entradas activas en bajo (~S, ~R): la célula básica de la memoria, y la razón por la que el 74HC132 (con Schmitt) se usa para limpiar los rebotes de un botón (Tema 11).

07 · Simulador

Laboratorio: constructor

Elegí con qué pieza construir (NAND o NOR) y qué puerta querés armar. El simulador dibuja la red de puertas, calcula el valor de cada cable para las entradas A y B que fijes y compara el resultado con la puerta real. Contá cuántas piezas hacen falta.

• Cuadros: cada una es una puerta NAND o NOR de la pieza elegida, con el valor de su salida. Las entradas unidas a una misma fuente (como en un NOT) se dibujan con dos cables.
• Cables amarillos y turquesa: amarillo = 1, turquesa = 0.
• Resultados: salida de la red, salida esperada, cantidad de puertas (y chips) y si coinciden.

Recorrido guiado (7 minutos)

1. 1
   Mirá la red inicial: XOR con 4 NAND.

   Una NAND recibe A y B; dos más reciben cada entrada junto con esa salida; la cuarta junta las dos. Con A = 1 y B = 0 los valores fluyen hasta la salida: 1.

2. 2
   Apretá «Verificar las 4 filas».

   La firma obtenida es 0110: la del XOR. Cuatro piezas iguales, una puerta distinta de la pieza base. Eso es universalidad.

3. 3
   Elegí NOT.

   Una sola NAND con las dos entradas unidas: ~(A·A) = ~A. Mirá cómo A llega por dos cables a la misma puerta.

4. 4
   Elegí AND y después OR.

   AND cuesta 2 piezas (la NAND y un inversor). OR cuesta 3: invertir A, invertir B y juntarlas. Mirá cómo OR gasta más: por eso no es la puerta natural del silicio.

5. 5
   Cambiá a «Construir con NOR».

   Los costos se invierten: OR ahora cuesta 2 y AND cuesta 3. Es la dualidad del Tema 8: lo que era barato con una pieza es caro con la otra.

6. 6
   Con NOR elegí XNOR y después XOR.

   La misma red de 4 puertas da XNOR; el XOR necesita una quinta pieza como inversor. Con NAND era al revés.

7. 7
   Con NAND, pedí NOR; con NOR, pedí NAND.

   Cuestan 4 piezas cada una: construir la puerta «opuesta» a la pieza que tenés es casi lo más caro que se puede pedir (solo el XNOR con NAND o el XOR con NOR, con 5, cuestan más).

Preguntas para pensar

1. Recorré las 4 filas del XOR con NAND. ¿Alguna falla? ¿Qué demuestra?
2. Elegí OR con NAND y A = 0, B = 0. ¿Cuánto vale cada cable? ¿Cuántas piezas trabajan?
3. ¿Qué puerta cuesta 3 piezas con NAND y 2 con NOR? ¿Y al revés?
4. ¿Cuántas piezas necesitaría un XOR si solo tuvieras NAND y quisieras ahorrar una puerta? ¿Se puede?

08 · Universalidad en código

Construir todo con NAND (y con NOR)

Los bloques muestran las dos puertas, construyen NOT, AND, OR, XOR y XNOR desde una sola primitiva contando cuántas veces se la usa, repiten la prueba con NOR, convierten una suma de productos en una red NAND-NAND y arman una memoria con dos NAND cruzadas.

Paso 1: las dos puertas y sus firmas

def nand_(a, b):
    return 1 - (a & b)


def nor_(a, b):
    return 1 - (a | b)


filas = [(a, b) for a in (0, 1) for b in (0, 1)]
print("NAND:", "".join(str(nand_(a, b)) for a, b in filas))
print("NOR: ", "".join(str(nor_(a, b)) for a, b in filas))
print("AND: ", "".join(str(a & b) for a, b in filas))
print("OR:  ", "".join(str(a | b) for a, b in filas))

NAND: 1110. NOR: 1000. Cada una es el complemento bit a bit de AND (0001) y OR (0111).

Paso 2: todo desde NAND, contando piezas

usos = 0


def nand_(a, b):
    global usos
    usos += 1
    return 1 - (a & b)


def not_(a):
    return nand_(a, a)


def and_(a, b):
    return not_(nand_(a, b))


def or_(a, b):
    return nand_(not_(a), not_(b))


def nor_(a, b):
    return not_(or_(a, b))


def xor_(a, b):
    n1 = nand_(a, b)
    return nand_(nand_(a, n1), nand_(b, n1))


def xnor_(a, b):
    return not_(xor_(a, b))


REF = {
    "NOT": (lambda a, b: not_(a), lambda a, b: 1 - a),
    "AND": (and_, lambda a, b: a & b),
    "OR": (or_, lambda a, b: a | b),
    "NOR": (nor_, lambda a, b: 1 - (a | b)),
    "XOR": (xor_, lambda a, b: a ^ b),
    "XNOR": (xnor_, lambda a, b: 1 - (a ^ b)),
}
filas = [(a, b) for a in (0, 1) for b in (0, 1)]
for nombre, (construida, real) in REF.items():
    usos = 0
    firma = "".join(str(construida(a, b)) for a, b in filas)
    piezas = usos // 4
    ok = all(construida(a, b) == real(a, b) for a, b in filas)
    print(f"{nombre:<5} firma {firma}  {piezas} NAND  {'ok' if ok else 'FALLA'}")

NOT 1, AND 2, OR 3, NOR 4, XOR 4, XNOR 5. Cada fila se evalúa 4 veces, por eso se divide el conteo entre 4. La universalidad queda verificada por tabla.

Paso 3: lo mismo con NOR (el dual)

usos = 0


def nor_(a, b):
    global usos
    usos += 1
    return 1 - (a | b)


def not_(a):
    return nor_(a, a)


def or_(a, b):
    return not_(nor_(a, b))


def and_(a, b):
    return nor_(not_(a), not_(b))


def nand_(a, b):
    return not_(and_(a, b))


def xnor_(a, b):
    n1 = nor_(a, b)
    return nor_(nor_(a, n1), nor_(b, n1))


def xor_(a, b):
    return not_(xnor_(a, b))


REF = {
    "NOT": (lambda a, b: not_(a), lambda a, b: 1 - a),
    "OR": (or_, lambda a, b: a | b),
    "AND": (and_, lambda a, b: a & b),
    "NAND": (nand_, lambda a, b: 1 - (a & b)),
    "XNOR": (xnor_, lambda a, b: 1 - (a ^ b)),
    "XOR": (xor_, lambda a, b: a ^ b),
}
filas = [(a, b) for a in (0, 1) for b in (0, 1)]
for nombre, (construida, real) in REF.items():
    usos = 0
    firma = "".join(str(construida(a, b)) for a, b in filas)
    ok = all(construida(a, b) == real(a, b) for a, b in filas)
    print(f"{nombre:<5} firma {firma}  {usos // 4} NOR  {'ok' if ok else 'FALLA'}")

NOT 1, OR 2, AND 3, NAND 4, XNOR 4, XOR 5: los costos de NAND, con los papeles de AND y OR intercambiados.

Paso 4: de suma de productos a NAND-NAND

from itertools import product


def dos_niveles(productos):
    # cada producto es una lista de literales (indice_de_variable, valor_requerido)
    def f(*bits):
        nivel1 = [1 - int(all(bits[i] == v for i, v in p)) for p in productos]
        return 1 - int(all(nivel1))        # NAND final
    return f


mayoria = lambda a, b, c: int(a + b + c >= 2)

canonica = [[(0, 0), (1, 1), (2, 1)], [(0, 1), (1, 0), (2, 1)],
            [(0, 1), (1, 1), (2, 0)], [(0, 1), (1, 1), (2, 1)]]
simplificada = [[(0, 1), (1, 1)], [(0, 1), (2, 1)], [(1, 1), (2, 1)]]

for nombre, prods in (("canónica      Σm(3,5,6,7)", canonica), ("simplificada  AB+AC+BC", simplificada)):
    f = dos_niveles(prods)
    ok = all(f(*b) == mayoria(*b) for b in product((0, 1), repeat=3))
    entradas = sum(len(p) for p in prods)
    print(f"{nombre}: {len(prods)} NAND de nivel 1 + 1 NAND final = {len(prods) + 1} puertas, {entradas} entradas de producto, {'ok' if ok else 'FALLA'}")

Las dos redes dan la mayoría de 3. La simplificada usa 4 puertas (tres NAND de dos entradas y una de tres); la canónica, 5 (cuatro de tres entradas y una de cuatro), y además necesitaría inversores para las variables negadas, que el modelo resuelve con bits[i] == v. Simplificar primero ahorra puertas y chips.

Paso 5: dos NAND cruzadas, un latch SR

def nand_(a, b):
    return 1 - (a & b)


def paso(s_n, r_n, q, qn):
    for _ in range(4):               # dejar que la red se asiente
        q = nand_(s_n, qn)
        qn = nand_(r_n, q)
    return q, qn


q, qn = 0, 1
print("~S ~R |  Q ~Q")
for s_n, r_n in ((1, 1), (0, 1), (1, 1), (1, 0), (1, 1), (0, 0), (1, 1)):
    q, qn = paso(s_n, r_n, q, qn)
    nota = {(0, 1): "set", (1, 0): "reset", (1, 1): "mantiene", (0, 0): "PROHIBIDO"}[(s_n, r_n)]
    print(f" {s_n}   {r_n}  |  {q}  {qn}   {nota}")

Con (0, 1) la memoria vale 1 (set); con (1, 0) vale 0 (reset); con (1, 1) recuerda. Con (0, 0) las dos salidas valen 1, y al soltar ambas a la vez el resultado depende de cuál NAND es un poco más rápida: en el chip real es impredecible (este modelo elige uno).

09 · Analogía de programador

Una primitiva, todo lo demás

La NAND es al hardware lo que una instrucción mínima es a un procesador teórico: con una sola operación y suficiente paciencia, hacés todo. La idea es la misma que la de un lenguaje con un único operador.

1. 1
   NAND = el !(a && b) del que sale todo.

   Como en software, !a se reescribe como !(a && a). Lo curioso es que, en silicio, eso es lo barato.

2. 2
   Universal = completo, no óptimo.

   Podés escribir cualquier programa con una sola instrucción, pero no querés. Lo mismo vale para un circuito: reducir los tipos de piezas tiene un costo en cantidad de piezas.

3. 3
   Pinout ≠ función.

   Como una API cuya firma reordenó los argumentos: misma función, otro mapa. Se lee la hoja de datos, no se asume.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios universales

Ejercicio 1: OR con tres NAND

Dibujá A → NOT, B → NOT y una NAND final. Escribí la función y verificá las cuatro filas a mano y con el simulador.

Ejercicio 2: XNOR con NAND

Partí del XOR de 4 NAND y agregá lo mínimo para obtener la igualdad. ¿Qué tabla sale? ¿Cuántas piezas?

Ejercicio 3: stock mínimo

Solo con 74HC00 (4 NAND por chip) querés armar 2 NOT, 1 AND, 1 OR y 1 XOR. ¿Cuántas NAND y cuántos chips hacen falta?

Ejercicio 4: dos niveles

Implementá Y = A·B + C·D usando solo 74HC00. ¿Cuántas NAND y cuántos chips? Compará con la versión AND-OR.

Ejercicio 5: la mayoría con NAND

Armá la mayoría de 3 (AB + AC + BC) con NAND. ¿Qué chips usás si tenés un 74HC00 y un 74HC10 (tres NAND de tres entradas)? ¿Y si solo tenés 74HC00?

Ejercicio 6: el latch

Con el latch de dos NAND (entradas activas en bajo ~S y ~R) aplicás la secuencia (0,1), (1,1), (1,0), (1,1). ¿Cuánto vale Q después de cada paso? ¿Por qué (0,0) está prohibida? Verificá con el Paso 5.

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 10?

Podés avanzar si sos capaz de responder esto sin mirar:

• Escribir las firmas de NAND y NOR y decir qué las distingue de AND y OR.
• Dibujar un NOT, un AND y un OR usando solo NAND.
• Enunciar las dos leyes de De Morgan sin equivocar el OR por el AND.
• Convertir Y = A·B + C·D en una red NAND-NAND.
• Decir en qué pines están las salidas de un 74HC00 y de un 74HC02.
• Explicar por qué universal no es sinónimo de óptimo.

Con AND, OR, NOT, NAND y NOR ya construís cualquier función. Falta una puerta de uso muy frecuente que no sale barata de ninguna de ellas: en el próximo tema, XOR y XNOR, las puertas de la diferencia y la igualdad.