AND y OR

01 · Punto de partida

Todos o alguno

Una caja fuerte con dos llaves se abre solo si las dos giran. Una alarma con dos sensores suena si cualquiera de los dos detecta algo. Son dos maneras de combinar dos condiciones, y casi todas las reglas del mundo son variantes de ellas: «mayor de edad y con entrada», «efectivo o tarjeta». En lógica digital se llaman AND y OR.

• ¿Qué fila da 1 en cada una y qué valor «manda» en cada caso?
• ¿Qué reglas permiten simplificar expresiones con AND y OR?
• ¿Qué se hace con las entradas que sobran (o que faltan)?
• ¿Cómo se arma un AND o un OR de muchas entradas?
• ¿Qué chips son y cómo se conectan?

02 · AND

Todos, sin excepción

La salida de un AND vale 1 solo cuando todas sus entradas valen 1. Se escribe Y = A·B (o A∧B, o simplemente AB). En el símbolo es una D: entradas por el lado plano, salida por el lado curvo.

Interruptores en serie

La imagen física: la corriente llega a la lámpara solo si todos los interruptores del camino están cerrados. Un solo interruptor abierto corta todo.

El 0 domina

Con un 0 en cualquier entrada, la salida es 0 sin importar el resto: A·0 = 0. Es el elemento absorbente del AND. Por eso sirve para «vetar»: un permiso, una guarda, un interlock.

El 1 no molesta

Un 1 en una entrada no altera nada: A·1 = A. Es el elemento neutro del AND. Una entrada AND que no vas a usar se ata a 1 y la puerta queda reducida a un buffer de la otra entrada.

AND como multiplicación

Con bits, 0·0 = 0, 0·1 = 0, 1·0 = 0 y 1·1 = 1: es exactamente la multiplicación de un bit por otro. Por eso la notación A·B.

03 · OR

Alguno alcanza

La salida de un OR vale 1 cuando al menos una de sus entradas vale 1. Se escribe Y = A+B (o A∨B). El símbolo tiene la espalda curva y termina en punta, y el chip estándar es el 74HC32.

Interruptores en paralelo

La corriente llega a la lámpara si algún camino tiene su interruptor cerrado. Abrir uno solo no apaga nada mientras otro siga cerrado.

El 1 domina

Con un 1 en cualquier entrada, la salida es 1: A+1 = 1. Es el elemento absorbente del OR. Sirve para «forzar» o para reunir alarmas: cualquiera dispara.

El 0 no molesta

A+0 = A. Es el elemento neutro del OR: una entrada OR sin usar se ata a 0.

1 + 1 = 1

Ojo, programador: el OR no suma, une. Si ambas condiciones se cumplen, el resultado es «sí», no «dos». Sumar con acarreo es otra cosa (Tema 23).

04 · Reglas que valen siempre

Un álgebra con diez reglas

AND y OR cumplen un conjunto de identidades que valen para cualquier valor de las entradas. Cada una se demuestra con una tabla de verdad (con tres variables, ocho filas). Te servirán para simplificar circuitos en los Temas 13 a 16.

Dualidad

Si en una regla intercambiás AND por OR y 0 por 1, obtenés otra regla válida. Por eso las columnas son espejo una de la otra. Es la razón por la que todo lo que aprendés de AND vale (al revés) para OR.

La distributiva es doble

En el álgebra común solo la multiplicación se distribuye sobre la suma. En lógica, las dos se distribuyen una sobre otra: A+(B·C) = (A+B)·(A+C) es cierta, y no lo es en aritmética.

Para qué sirven

Para achicar circuitos. Por ejemplo, A+A·B parece pedir dos puertas, pero por absorción es simplemente A: ninguna puerta. Menos puertas es menos costo, menos consumo y menos retardo.

05 · Más y menos entradas

Entradas sobrantes y puertas anchas

Cuando sobra una entrada

Si usás un AND de 3 entradas pero tenés solo dos señales, o una puerta de las que vienen cuatro en el chip tiene una entrada de más, esa entrada no se deja al aire: una entrada CMOS flotante puede oscilar, consumir de más o producir salidas erráticas (Temas 3 y 7). Se ata a un valor que no altere la función, y ese valor es el elemento neutro.

También se puede duplicar una entrada usada (A·A = A, A+A = A), pero eso carga el cable de A con una entrada más; ata a VCC o a GND siempre que puedas.

Cuando hacen falta más entradas

Existen puertas AND y OR de 3, 4 y hasta 8 entradas en un solo chip. Si no tenés la que necesitás, la asociatividad te deja armarla con puertas de dos entradas, en forma de árbol: A·B·C·D = (A·B)·(C·D).

Para N entradas hacen falta N − 1 puertas y la señal atraviesa ⌈log₂ N⌉ niveles. Esa profundidad importa porque cada nivel suma retardo: la salida de un AND de 16 entradas en árbol de dos entradas llega después que la de un AND de 4.

06 · Chips reales

74HC08, 74HC32 y compañía

En la serie 74HC (Tema 12), cada chip de puertas trae varias idénticas e independientes, y el patrón de pines es siempre el mismo.

Alimentación primero

Antes de cablear señales: pin 14 a VCC, pin 7 a GND, y un capacitor cerámico de 100 nF lo más cerca posible entre los dos (Tema 29). Sin alimentación, el chip no funciona, o peor, se alimenta a través de las entradas.

Retardo

Un AND o un OR de la familia HC tarda del orden de diez nanosegundos en responder (ver el datasheet para el valor a tu tensión). Lógicamente es instantáneo; físicamente, no.

Entradas de botones

Un pulsador conectado directamente a una entrada deja la entrada flotante cuando está suelto. Necesita una resistencia de pull-down (10 kΩ a masa) o de pull-up (Tema 11).

07 · Simulador

Laboratorio: serie y paralelo

El simulador dibuja el circuito eléctrico equivalente: una fuente, de 2 a 4 interruptores y una lámpara. En AND los interruptores están en serie; en OR, en paralelo. Cerrá y abrí interruptores y mirá por dónde pasa la corriente y cuándo se enciende la lámpara.

• Cables amarillos: tienen corriente. Los grises no llegan a ningún lado.
• Interruptor abierto: la cuchilla levantada, en naranja. El primero abierto corta una cadena en serie.
• Resultados: el valor de Y, la fila de la tabla, qué entrada domina y cuántas filas de la tabla dan 1.

Recorrido guiado (6 minutos)

1. 1
   Mirá el estado inicial: AND con A = 1 y B = 1.

   Los dos interruptores están cerrados, la corriente atraviesa el circuito en serie y la lámpara enciende: es la única fila de la tabla del AND con salida 1.

2. 2
   Abrí B.

   El cable posterior al interruptor abierto queda gris y la lámpara se apaga. En AND, un solo 0 domina y el simulador lo señala.

3. 3
   Cambiá a OR sin tocar los interruptores.

   Con A = 1 y B = 0 en paralelo, el camino de A conduce y la lámpara enciende. Mismas entradas, decisión opuesta.

4. 4
   Apretá «Todos en 0» en OR.

   Es la única fila del OR con salida 0. Mirá la última tarjeta: tres de cuatro filas dan 1 (con 4 entradas, 15 de 16).

5. 5
   Pasá a 4 entradas y recorré la tabla con «Siguiente fila».

   Son 16 filas. En AND, solo la última (1111) enciende la lámpara; en OR, solo la primera (0000) la deja apagada. Cuantas más entradas, más raro es que un AND dé 1 y más raro que un OR dé 0.

6. 6
   Fijá todas las entradas menos A en el valor neutro.

   En AND, poné B, C y D en 1; en OR, en 0. La lámpara sigue a A: la puerta se comporta como un buffer, igual que una puerta con entradas sobrantes bien atadas.

Preguntas para pensar

1. En AND con A = 1, B = 0, ¿cuánto vale Y y quién domina? Pasá a OR sin tocar A ni B: ¿qué cambia?
2. ¿Qué combinación da 0 en OR? ¿Cuál da 1 en AND? ¿Cuántas hay con 4 entradas?
3. Si B queda fija en 1, ¿qué puerta se vuelve un buffer de A? ¿Y si B queda fija en 0?
4. Con 3 entradas, ¿cuántas filas de la tabla de un AND dan 1? ¿Y de un OR?

08 · AND y OR en código

Modelar, demostrar y medir

Los siguientes bloques modelan las puertas de N entradas, demuestran las reglas del apartado 04 recorriendo todas las filas, muestran el AND y el OR como máscaras de bits, calculan el tamaño y la profundidad de un árbol de puertas, enseñan un glitch real al usar un AND como compuerta de reloj y extraen los minterms de una función AND-OR.

Paso 1: AND y OR de N entradas

from itertools import product


def and_(*xs):
    return int(all(xs))


def or_(*xs):
    return int(any(xs))


for n in (2, 3, 4):
    filas = list(product((0, 1), repeat=n))
    unos_and = sum(and_(*f) for f in filas)
    unos_or = sum(or_(*f) for f in filas)
    print(f"{n} entradas: {len(filas):>2} filas | AND da 1 en {unos_and} | OR da 1 en {unos_or}")

print("AND:", [and_(a, b) for a in (0, 1) for b in (0, 1)])
print("OR: ", [or_(a, b) for a in (0, 1) for b in (0, 1)])
print("AND-3 con un 0:", and_(1, 0, 1), "  OR-3 con un 1:", or_(0, 1, 0))

AND: [0, 0, 0, 1]. OR: [0, 1, 1, 1]. Con N entradas, el AND da 1 en una sola fila y el OR da 1 en todas menos una.

Paso 2: demostrar las reglas, fila por fila

from itertools import product

REGLAS = {
    "neutro AND   A·1 = A":       (lambda a, b, c: a & 1,        lambda a, b, c: a),
    "neutro OR    A+0 = A":       (lambda a, b, c: a | 0,        lambda a, b, c: a),
    "absorbente   A·0 = 0":       (lambda a, b, c: a & 0,        lambda a, b, c: 0),
    "absorbente   A+1 = 1":       (lambda a, b, c: a | 1,        lambda a, b, c: 1),
    "idempotente  A·A = A":       (lambda a, b, c: a & a,        lambda a, b, c: a),
    "complemento  A·~A = 0":      (lambda a, b, c: a & (1 - a),  lambda a, b, c: 0),
    "complemento  A+~A = 1":      (lambda a, b, c: a | (1 - a),  lambda a, b, c: 1),
    "asociativa   (A·B)·C":       (lambda a, b, c: (a & b) & c,  lambda a, b, c: a & (b & c)),
    "distributiva A·(B+C)":       (lambda a, b, c: a & (b | c),  lambda a, b, c: (a & b) | (a & c)),
    "distributiva A+(B·C)":       (lambda a, b, c: a | (b & c),  lambda a, b, c: (a | b) & (a | c)),
    "absorción    A+A·B = A":    (lambda a, b, c: a | (a & b),  lambda a, b, c: a),
    "absorción    A·(A+B) = A":  (lambda a, b, c: a & (a | b),  lambda a, b, c: a),
    "falsa:       A+B = A·B":     (lambda a, b, c: a | b,        lambda a, b, c: a & b),
}

for nombre, (izq, der) in REGLAS.items():
    ok = all(izq(*f) == der(*f) for f in product((0, 1), repeat=3))
    print(f"{'vale' if ok else 'FALLA'}  {nombre}")

Las doce reglas valen en las 8 filas; la última es una trampa y falla. Probar con tabla completa es una demostración, no una intuición.

Paso 3: AND y OR como máscaras de bits

LEER, ESCRIBIR, EJECUTAR = 0b100, 0b010, 0b001


def tiene_todos(permisos, requeridos):
    return (permisos & requeridos) == requeridos     # AND bit a bit: «todos»


def tiene_alguno(permisos, requeridos):
    return (permisos & requeridos) != 0              # AND + «distinto de cero»: «alguno»


p = LEER | ESCRIBIR                                   # OR enciende bits: 0b110
print(f"permisos = {p:03b}")
print("todos {leer, escribir}:  ", tiene_todos(p, LEER | ESCRIBIR))
print("todos {leer, ejecutar}:  ", tiene_todos(p, LEER | EJECUTAR))
print("alguno {escribir, ejecutar}:", tiene_alguno(p, ESCRIBIR | EJECUTAR))
print("alguno {ejecutar}:       ", tiene_alguno(p, EJECUTAR))

x = 0b10110101
print(f"x & 0x0F = {x & 0x0F:08b}   x | 0x80 = {x | 0x80:08b}")

El OR enciende bits y el AND los filtra (Tema 4). «Todos» compara el AND con la máscara; «alguno» pregunta si el AND quedó distinto de cero. Fijate en los paréntesis: en Python, == se evalúa antes que &.

Paso 4: árbol de puertas de dos entradas

def arbol(n):
    puertas, nivel, profundidad = 0, n, 0
    while nivel > 1:
        pares = nivel // 2
        puertas += pares
        nivel = pares + nivel % 2
        profundidad += 1
    return puertas, profundidad


TPD = 10   # ns por puerta, supuesto
for n in (2, 3, 4, 5, 6, 8, 16):
    puertas, prof = arbol(n)
    chips = -(-puertas // 4)
    print(f"{n:>2} entradas: {puertas:>2} puertas, {prof} niveles, {chips} chip(s) 74HC08, retardo ≈ {prof * TPD} ns")

Siempre N − 1 puertas. La profundidad crece con el logaritmo: duplicar las entradas agrega un solo nivel de retardo.

Paso 5: un AND como compuerta de reloj (y su glitch)

from itertools import groupby

CLK = "0011001100110011"      # cada carácter es un instante; cada semiperíodo dura 2
EN = "0001111111111111"       # EN sube cuando CLK ya está en 1
Y = "".join(str(int(c) & int(e)) for c, e in zip(CLK, EN))

print("CLK", CLK)
print("EN ", EN)
print("Y  ", Y)

anchos = [len(list(g)) for k, g in groupby(Y) if k == "1"]
print("anchos de los pulsos de Y:", anchos)
for a in anchos:
    if a < 2:
        print(f"  pulso de {a} instante: más corto que el normal (runt)")

Con EN = 0, la salida del AND se queda en 0. Pero cuando EN sube en medio de un pulso de reloj, aparece un pulso recortado de 1 instante que un contador conectado a Y contaría como un pulso entero. El Tema 28 explica cómo evitarlo.

Paso 6: una función AND-OR y sus minterms

from itertools import product


def riego(m, a, s):
    # bomba si modo manual, o (modo automático y suelo seco)
    return m | (a & s)


mins = []
print("M A S | Y")
for i, (m, a, s) in enumerate(product((0, 1), repeat=3)):
    y = riego(m, a, s)
    print(m, a, s, "|", y, f"  fila {i}")
    if y:
        mins.append(i)
print("Y = Σm(" + ", ".join(map(str, mins)) + ")")

Σm(3, 4, 5, 6, 7): cinco filas de ocho. Las filas con M = 1 (4 a 7) dan 1 sin importar el resto; la fila 3 es la de A·S con M apagado.

09 · Analogía de programador

&& y || con pines

AND y OR son tus && y ||, con una diferencia de fondo: el hardware no evalúa «de izquierda a derecha» ni se detiene en el primer valor decisivo. Las dos entradas llegan a la vez y la salida responde a ambas en paralelo.

1. 1
   AND = && de permisos.

   Todos los chequeos en verde, o no pasa. Un solo rojo vetá la acción.

2. 2
   OR = || de causas.

   Alcanza con una causa. Es la forma de reunir avisos en un solo indicador.

3. 3
   Dominancia = cortocircuito, sin el corto.

   El 0 en un AND y el 1 en un OR deciden el resultado sin importar el resto, igual que false && x y true || x. En software el compilador se ahorra evaluar x; en hardware, x se calcula igual, pero no cambia nada.

La consecuencia práctica: en un circuito el orden de las entradas no importa, ni hay que cuidar que la segunda condición dependa de la primera (como en p != NULL && p->x). Si una de las entradas puede tener un valor inválido, eso hay que resolverlo antes de la puerta.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de todos y alguno

Ejercicio 1: riego automático

Una bomba debe funcionar si (modo automático Y suelo seco) O modo manual. Escribí la función, la tabla de 8 filas y los minterms. Verificá con riego().

Ejercicio 2: enable con AND

Una señal de reloj CLK debe llegar a un contador solo cuando EN = 1. ¿Qué puerta usás? ¿Qué sale con EN = 0? ¿Qué riesgo hay si EN cambia en cualquier momento?

Ejercicio 3: montar un AND-OR

Armá en un protoboard un 74HC08 y un 74HC32 con dos pulsadores con pull-down (10 kΩ a masa) y un LED con su resistencia. Medí las cuatro filas de cada puerta. ¿Alguna difiere de 0001 y 0111? Si es así, ¿qué revisás?

Ejercicio 4: la entrada que sobra

Tenés un 74HC11 (tres AND de tres entradas) y un 74HC4075 (tres OR de tres entradas), pero en tu diseño cada puerta recibe solo dos señales. ¿A qué conectás la tercera entrada en cada caso? ¿Y si por error conectás la del AND a masa?

Ejercicio 5: un AND de 6 entradas

Necesitás un AND de 6 señales y solo tenés 74HC08 (cuatro AND de dos entradas). ¿Cuántas puertas, cuántos niveles y cuántos chips? ¿Cuál es el retardo si cada puerta tarda 10 ns? Verificá con arbol(6).

Ejercicio 6: permisos como bits

Un usuario tiene permisos 0b110 (leer y escribir). ¿Tiene todos los de {leer, escribir}? ¿Tiene alguno de {escribir, ejecutar}? ¿Cómo le agregás «ejecutar»? ¿Cómo le sacás «escribir»?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 9?

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

• Escribir de memoria las firmas de AND y OR (0001 y 0111).
• Decir qué valor domina en cada puerta y cuál es neutro.
• Indicar a qué se conecta una entrada sobrante de un AND y de un OR.
• Calcular cuántas puertas de dos entradas hacen falta para un AND de 8.
• Simplificar A + A·B con la regla de absorción.
• Explicar la diferencia entre & y && en términos de puertas.

Con AND, OR y NOT ya podés construir cualquier función. Pero hay dos puertas que lo hacen solas, más baratas y más rápidas: en el próximo tema, NAND y NOR.