NOT, buffer y tri-estado

01 · Punto de partida

Una entrada, tres superpoderes

¿Para qué querrías una puerta con una sola entrada? Parece que no hace nada: lo que entra, sale. Pero resuelve tres problemas que aparecen en cuanto conectás algo real: la señal viene al revés de lo que necesitás, el pin no tiene fuerza para manejar lo que le colgaste, o demasiados chips quieren hablar por el mismo cable.

• ¿Qué hace la bolita en un símbolo lógico y por qué aparece en tantos lados?
• ¿Cuándo un buffer salva un diseño si no cambia el valor de la señal?
• ¿Qué es el estado Z y por qué no es lo mismo que 0?
• ¿Cómo comparten un cable varios chips sin destruirse?
• ¿Qué significa que una señal sea «activa en bajo»?

02 · NOT

El que dice que no

El inversor es la puerta más simple: su salida es el opuesto de su entrada. Su tabla de verdad, de dos filas, ya la conocés del Tema 6: es la función de una variable con firma 10.

En el símbolo, el inversor es un triángulo con una bolita en la punta de salida. El chip estándar es el 74HC04: seis inversores independientes en 14 pines (12 de señal, más VCC y GND). Es uno de los circuitos integrados más baratos que existen.

Cómo es por dentro

En CMOS (Tema 3) es un transistor PMOS arriba y uno NMOS abajo, con las compuertas unidas. Con entrada en 1 conduce el de abajo y la salida va a masa; con entrada en 0 conduce el de arriba y la salida va a VCC. Nunca conducen los dos a la vez (salvo un instante al conmutar), por eso consume casi nada en reposo.

Retardo

La salida no cambia al instante: tarda un tiempo de propagación (en la familia HC, unos pocos a decenas de nanosegundos según la alimentación; mirá el datasheet). Ese retardo, que parece un detalle, es el que dará problemas en el Tema 28 (glitches) y el que se aprovecha para armar osciladores.

Doble inversión

Dos NOT en serie devuelven el valor original pero con un poco de retardo y con la señal regenerada. Un buffer no inversor se construye internamente así: dos inversores seguidos.

Entradas sin usar

De los seis inversores del 74HC04, los que no uses no se dejan al aire: una entrada CMOS flotante puede oscilar y hacer consumir al chip. Se conectan a GND (o a VCC). Es una de las reglas de oro del Tema 29.

Dos inversores en lazo: una memoria

Hay un truco notable que vas a usar en el curso siguiente. Si conectás la salida de un inversor a la entrada de otro y la salida de este a la entrada del primero, el lazo tiene dos estados estables (01 y 10) y se queda en el que lo dejaste. Es la célula de una memoria SRAM: dos NOT cruzados guardan un bit. Con tres inversores en lazo, en cambio, nunca se estabiliza: oscila. Es un oscilador de anillo, y se usa en el interior de los chips para medir velocidad. La regla: cantidad par de inversiones, estable; impar, oscila.

03 · La bolita

Activo en alto y activo en bajo

La bolita no es propiedad del inversor: es el símbolo de «negar» y puede aparecer en cualquier pin de cualquier símbolo. Una bolita en una entrada significa que esa entrada se activa con 0; una bolita en una salida significa que la salida está invertida.

Hay dos formas de nombrar la misma señal: OE con una barra encima, /OE, ~OE, nOE o OE#. Todas dicen «Output Enable, se habilita con 0». Cuando una señal está activa en bajo, su nombre describe lo que hace cuando es verdadera, no su nivel de voltaje: ~CS = 0 significa «chip seleccionado».

04 · Buffer

El que repite fuerte

El buffer (o búfer) es un triángulo sin bolita: su salida es igual a su entrada, Y = A. Lógicamente no hace nada. Físicamente, hace tres cosas muy valiosas.

Corriente (drive)

Un pin lógico entrega unos pocos miliamperios. Para encender un LED o varias cargas hace falta más. El buffer recibe la señal con una entrada que casi no consume y la entrega con una salida diseñada para manejar más corriente. El pin decide; el buffer ejecuta.

Fan-out

Cuántas entradas cuelgan de una misma salida. Las entradas CMOS casi no consumen corriente continua, pero cada una tiene capacidad (unos picofaradios) que la salida debe cargar y descargar. Con muchas entradas la señal se vuelve lenta; un buffer reparte la carga. Es la razón por la que los relojes llegan a todos lados a través de buffers.

Aislamiento

Un buffer separa una etapa de otra: lo que pase aguas abajo (un cortocircuito, una carga pesada) no llega al origen de la señal.

Adaptación de nivel

Algunos buffers sirven como traductores entre tensiones. Por ejemplo, el 74HC4050, alimentado a 3,3 V, acepta entradas de 5 V y entrega salidas de 3,3 V: se usa para pasar señales de un sistema de 5 V a uno de 3,3 V sin dañar el pin más débil. (Siempre consultá en el datasheet la tensión máxima permitida de entrada.)

05 · Tri-estado

El que sabe callar

Un buffer tri-estado (three-state) agrega una entrada de habilitación (enable). Con el enable activo se comporta como un buffer normal: la salida copia la entrada. Con el enable inactivo, la salida se desconecta: no es ni 0 ni 1, es como si el cable no existiera. Ese tercer estado se llama alta impedancia o Z.

Z no es 0 ni 1

Un driver en 0 tira la línea a masa con fuerza; un driver en Z no tira de ningún lado. Una línea que nadie maneja flota: su voltaje lo decide el ruido, la humedad o lo que toque, y un receptor puede leer 0 o 1 al azar (e incluso consumir de más).

No es lógica ternaria

No hay tres valores lógicos. Hay dos valores más la ausencia de driver. El diseño sigue siendo binario, y lo que llega a un receptor siempre tiene que ser 0 o 1.

Enable activo en alto o en bajo

Los chips reales usan las dos: el 74HC126 habilita con 1 y el 74HC125 con 0 (su pin se llama ~OE). La bolita del enable en el símbolo lo dice.

Los chips que vas a ver

74HC125/126: cuatro buffers tri-estado independientes. 74HC244: ocho buffers en dos grupos de cuatro, cada grupo con su ~OE. 74HC245: ocho transceptores bidireccionales (pin DIR para elegir el sentido, ~OE para soltar el bus).

06 · Buses

Compartir un cable sin chocar

Un bus es un conjunto de cables compartido por varios dispositivos (memorias, periféricos, procesador). Si cada dispositivo tuviera sus propios cables al procesador, el cableado crecería sin límite. Con un bus, todos se conectan en paralelo a las mismas líneas y por turnos, uno solo habla mientras los demás están en Z.

Lo que el procesador lee en el bus depende de cuántos drivers estén activos:

Contención: la regla de oro

Cuando un driver intenta poner 1 (tirar a VCC) y otro intenta poner 0 (tirar a masa) en la misma línea, cada uno pelea contra el otro por el cable. Como las salidas CMOS son casi cortocircuitos hacia sus rieles, circula una corriente grande entre ambas, el voltaje de la línea queda en un valor intermedio inválido y los chips se calientan. Dura lo que dura el choque; si es sostenido, puede dañarlos.

• Un solo enable activo por vez. La lógica que genera los enables (un decodificador, Tema 20) tiene que garantizar exclusión mutua.
• Apagar antes de encender. Los chips tardan un tiempo en abrir su salida (enable time) y otro en cerrarla (disable time). Si un chip se cierra justo cuando otro se abre, hay una ventana de solape. Se deja un breve tiempo muerto entre turnos, y en el diseño se verifica en el datasheet que el cierre sea más rápido que la apertura.
• Pull para el reposo. Una resistencia de 4,7 k a 10 k a VCC (pull-up) o a GND (pull-down) define el valor de la línea cuando nadie habla. Sin ella, el bus flota entre turnos.
• «Dicen lo mismo» no es excusa. Dos drivers en 1 no chocan hoy; pero un pequeño retardo entre ambos o una variación mínima en una transición los enfrenta por nanosegundos. Se diseña para que no pase nunca.

Otra forma de compartir: drenador abierto

Algunos buses (I²C es el ejemplo clásico) evitan el problema de raíz con salidas de drenador abierto (open-drain). Cada dispositivo solo puede hacer dos cosas: tirar la línea a 0 o soltarla (Z). El 1 lo pone siempre una resistencia de pull-up compartida. Como nadie empuja hacia arriba, no hay choque posible: si uno tira a 0, gana el 0. El resultado es un AND cableado: la línea vale 1 solo si todos sueltan.

07 · Simulador

Laboratorio: un bus, tres drivers

El simulador conecta tres buffers tri-estado a una misma línea de bus. Cada driver tiene su dato (D) y su enable (EN). Podés cambiar la polaridad del enable y la resistencia de pull, y el laboratorio te dice qué valor tiene el bus, quiénes están hablando y si hay un choque.

• Cables amarillos o turquesa: un driver que habla (amarillo = 1, turquesa = 0). Un cable gris discontinuo es un driver en Z.
• Bolita en el enable: aparece cuando el enable es activo en bajo.
• Cables rojos: contención. Dos drivers en desacuerdo.
• Resistencia a la derecha: el pull que define el reposo del bus (si lo hay).

Recorrido guiado (6 minutos)

1. 1
   Mirá el estado inicial.

   Solo habla D1 (EN1 = 1) con un 1: el bus vale 1 y los otros dos cables aparecen grises, en Z. D2 y D3 tienen datos distintos, pero no se oyen.

2. 2
   Pasá por «Turno de D2» y «Turno de D3».

   El bus toma el valor del que habla (0 y 1). Es un bus compartido: un cable, tres dueños por turnos.

3. 3
   Apretá «Nadie habla» con pull-up y después con pull-down.

   El bus queda en 1 y luego en 0: manda la resistencia. Con «Sin pull», el bus flota y el simulador lo marca como indefinido.

4. 4
   Apretá «Choque (D1 y D2)».

   Dos drivers con 1 y 0 se enfrentan: el bus pasa a X y los cables se ponen rojos. En un circuito real, esto es corriente de cortocircuito entre dos salidas.

5. 5
   Con el choque armado, cambiá D2 a 1.

   Los dos dicen lo mismo y el bus vale 1, pero el estado sigue avisando que hay varios hablando. Funciona hoy, pero está prohibido.

6. 6
   Cambiá la polaridad a «activo en bajo».

   Los botones EN se invierten solos para que sigan hablando los mismos drivers: ahora habla el que tiene EN = 0. Aparece la bolita en el triángulo. Mismo comportamiento, otra convención.

Preguntas para pensar

1. Con nadie hablando y pull-up, ¿qué lee un receptor? ¿Y qué pasa si un segundo bus idéntico no tiene pull?
2. ¿Qué combinación de datos hace que dos drivers hablando no choquen? ¿Por qué igual conviene evitarla?
3. Con enable activo en bajo, ¿qué valor de EN deja callado a un driver?
4. ¿Cuántos drivers pueden estar hablando a la vez en un diseño correcto?

08 · Puertas de una entrada en código

Negar, copiar, callar y compartir

Estos bloques modelan las tres puertas, resuelven un bus compartido, simulan un procesador que lee de varios dispositivos, detectan un error clásico de temporización en los enables, comparan tri-estado con drenador abierto y muestran por qué dos inversores en lazo memorizan y tres oscilan.

Paso 1: las tres puertas y sus tablas

def not_(a):
    return 1 - a


def buf(a):
    return a


def tri(a, en):
    return a if en else "Z"


print("A | NOT BUF")
for a in (0, 1):
    print(a, "|", not_(a), "  ", buf(a))

print("doble NOT == buffer:", all(not_(not_(a)) == buf(a) for a in (0, 1)))
print("EN A | Y")
for en in (0, 1):
    for a in (0, 1):
        print(en, " ", a, "|", tri(a, en))

NOT: 0→1 y 1→0. Dos NOT en serie reproducen al buffer. El tri-estado devuelve Z siempre que EN = 0, sin importar A.

Paso 2: resolver un bus con varios drivers

def tri(a, en):
    return a if en else "Z"


def bus(drivers, pull=None):
    activos = [d for d in drivers if d != "Z"]
    if not activos:
        return pull if pull is not None else "?"
    if len(set(activos)) > 1:
        return "X"
    return activos[0]


casos = {
    "nadie habla, pull-up": ([tri(1, 0), tri(0, 0), tri(1, 0)], 1),
    "nadie habla, sin pull": ([tri(1, 0), tri(0, 0), tri(1, 0)], None),
    "habla D1 = 1": ([tri(1, 1), tri(0, 0), tri(1, 0)], 1),
    "hablan D1 = 1 y D2 = 0": ([tri(1, 1), tri(0, 1), tri(1, 0)], 1),
    "hablan dos con el mismo 1": ([tri(1, 1), tri(1, 1), "Z"], 1),
}
for nombre, (drv, pull) in casos.items():
    hablan = sum(d != "Z" for d in drv)
    print(f"{nombre:<28} -> {bus(drv, pull)}   ({hablan} hablando)")

Sin nadie hablando manda el pull (1) o queda «?» si no lo hay. Con valores opuestos aparece X. El último caso da 1, pero hay dos hablando: funciona hoy y está prohibido.

Paso 3: un procesador que lee de cuatro dispositivos

def decodificador(direccion, n):
    return [1 if i == direccion else 0 for i in range(n)]


def leer_bus(direccion, datos, pull=0xFF):
    ens = decodificador(direccion, len(datos))
    drivers = [d if en else "Z" for d, en in zip(datos, ens)]
    activos = [d for d in drivers if d != "Z"]
    return activos[0] if len(activos) == 1 else pull


datos = [0x3C, 0xA5, 0x00, 0x7E]
for d in range(5):
    print(f"dir {d}: EN={decodificador(d, 4)}  bus=0x{leer_bus(d, datos):02X}")

Cada dirección activa un solo enable y el dato correspondiente aparece en el bus. La dirección 4 no tiene dispositivo: nadie habla y los pull-up dejan 0xFF (por eso leer memoria inexistente suele dar todos unos).

Paso 4: el bug del solape de enables

def revisar(nombre, secuencia):
    print(nombre)
    for t, en in enumerate(secuencia):
        n = sum(en)
        estado = "libre" if n == 0 else "ok" if n == 1 else "CHOQUE"
        print(f"  t={t} EN={en} -> {estado}")


# primero se enciende el nuevo, después se apaga el viejo: hay un instante con dos
mal = [[1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 1, 1], [0, 0, 1]]
# se apaga el viejo, se deja un tiempo muerto, se enciende el nuevo
bien = [[1, 0, 0], [0, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 1]]

revisar("cambio de turno sin tiempo muerto:", mal)
revisar("apagar antes de encender:", bien)

La primera secuencia choca en t=1 y t=3. La segunda pasa por «libre» entre dos turnos. Es el mismo problema que ves al manejar un bus con pines de un micro: primero soltar, después tomar.

Paso 5: tri-estado frente a drenador abierto, y un pin de micro

def open_drain(*salidas):
    # 0 = tira a masa, 1 = suelta (Z); el pull-up pone el 1
    return 0 if 0 in salidas else 1


print("drenador abierto (AND cableado):")
for combo in ((1, 1, 1), (1, 0, 1), (0, 0, 1), (0, 0, 0)):
    print(" ", combo, "->", open_drain(*combo))


class Pin:
    def __init__(self):
        self.modo = "INPUT"
        self.nivel = 0

    def salida(self):
        return self.nivel if self.modo == "OUTPUT" else "Z"


p1, p2 = Pin(), Pin()
p1.modo, p1.nivel = "OUTPUT", 1
print("p1 OUTPUT=1, p2 INPUT:", [p1.salida(), p2.salida()])
p2.modo, p2.nivel = "OUTPUT", 0
print("p1 OUTPUT=1, p2 OUTPUT=0:", [p1.salida(), p2.salida()], "-> contención")

En drenador abierto no existe el choque: cualquier 0 gana y el resultado es el AND de todas las salidas. Un pin en INPUT es Z; dos pines en OUTPUT con valores distintos sobre el mismo cable chocan.

Paso 6: inversores en lazo, memoria y oscilador

def anillo(n, pasos=12, inicio=0):
    s = [inicio] * n
    traza = []
    for t in range(pasos):
        i = t % n
        s[i] = 1 - s[i - 1]          # cada inversor mira al anterior
        traza.append("".join(map(str, s)))
    estable = len(set(traza[-n:])) == 1
    print(f"{n} NOT:", " ".join(traza), "->", "estable (memoria)" if estable else "oscila")


for n in (2, 3, 4, 5):
    anillo(n)

Con 2 y 4 inversores el lazo queda fijo: guarda un bit. Con 3 y 5 no se estabiliza nunca: oscila. Par = memoria, impar = oscilador.

09 · Analogía de programador

Negación, proxy y exclusión mutua

Las tres puertas tienen un equivalente directo en el código que ya escribís. La tercera, además, trae un problema clásico de concurrencia.

1. 1
   NOT = !.

   Niega un booleano en silicio. Y, igual que !!a devuelve a, dos NOT en serie son un buffer (con un poco de retardo).

2. 2
   Buffer = proxy de corriente.

   Repite sin cambiar el valor. Lo que cambia es quién pone la energía: el origen decide, el buffer ejecuta.

3. 3
   Tri-estado = mutex de hardware.

   Para pasar la palabra se cierra el enable de uno antes de abrir el del siguiente. Y, como en un programa concurrente, el error aparece en el instante de transición, no en el estado estable.

La diferencia con el software es la gravedad de la carrera: en un programa, dos hilos que escriben a la vez dejan un dato corrupto; en un bus, dos drivers que escriben a la vez dejan además un chip caliente.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de una entrada

Ejercicio 1: LED al revés

Un sensor activo en bajo (0 = alarma) debe encender un LED rojo (caída de unos 2 V) con un 74HC04 alimentado a 5 V. Dibujá la cadena, la tabla de verdad y calculá la resistencia para unos 4 mA, que es lo que suelen entregar estas salidas.

Ejercicio 2: bus de dos

Dos 74HC125 (enable activo en bajo) comparten un bus con pull-up de 10 k. Una señal de selección S decide quién habla: con S = 0 habla el primero y con S = 1 el segundo. ¿Cómo se conectan los ~OE? ¿Qué lee el bus si ambos están deshabilitados? ¿Hay algún riesgo cuando S cambia?

Ejercicio 3: contar inversores

Un 74HC04 trae seis NOT. ¿Cuántos chips hacen falta para invertir 4 señales de enable y 2 LED activos en bajo? ¿Qué se hace con los inversores que sobren en otros diseños?

Ejercicio 4: potencia de un pin

Un pin de microcontrolador soporta 20 mA. ¿Cuántos LEDs de 8 mA entran en un pin? Y si querés manejar 20 de esos LEDs a la vez desde una sola señal, ¿cuántos canales de un buffer de 24 mA por salida necesitás?

Ejercicio 5: encontrar el choque

Tres dispositivos comparten un bus y su software genera esta secuencia de enables (activos en alto): [1,0,0], [1,1,0], [0,1,0], [0,1,1], [0,0,1]. ¿En qué pasos hay contención? Reescribila para evitarla.

Ejercicio 6: anillos de inversores

Predecí qué hace un lazo de 2, 3 y 4 inversores y verificá con anillo(). ¿Qué regla general deducís?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 8?

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

• Dibujar el símbolo del NOT, del buffer y del tri-estado con enable activo en bajo.
• Decir qué significa que una señal se llame ~CS.
• Explicar por qué un buffer no cambia el valor pero sí cambia lo que se puede conectar.
• Describir qué lee un receptor cuando todos los drivers de un bus están en Z, con y sin pull.
• Dar la regla para evitar contención al cambiar de dispositivo en un bus.
• Comparar tri-estado con drenador abierto en una frase.

Con una entrada ya podés invertir, reforzar y compartir. Ahora dos entradas: en el próximo tema, AND y OR, las puertas que combinan decisiones.