Proyecto: cerradura digital

01 · Especificación

Código 1010 o nada

Antes de dibujar una sola compuerta se escribe qué tiene que hacer el sistema, igual que en software se escribe primero el contrato. Nuestra cerradura:

• Entradas: un DIP switch de cuatro posiciones, S3 (el más significativo) a S0.
• Secreto: el código 1010, cableado en el circuito.
• Salidas: un LED verde («abre») que se enciende solo con el código exacto y un LED rojo («cerrado») en todos los demás casos.
• Seguridad ante fallas: si algo se rompe, se afloja o se saca del zócalo, el sistema debe quedar cerrado, nunca abierto por accidente.
• Alimentación: 5 V, dos chips de la serie 74HC (Tema 12).

• ¿Qué ecuación abre la cerradura y por qué es tan chica?
• ¿Conviene comparar con XNOR o con AND más inversores?
• ¿Qué va conectado a cada pin?
• ¿Cuánto consume y cómo se baja?
• ¿Qué significa «a prueba de fallas» y cómo se logra con una resistencia?
• ¿Por qué el verde puede destellar al mover los interruptores y cómo lo evita un pulsador ENTER?

02 · Diseño

De la tabla a la ecuación

Se empieza como siempre (Tema 6): la tabla de verdad. Con cuatro entradas hay 16 filas y la salida E vale 1 en una sola, la del código 1010 (el número 10).

Una función con un solo 1 en la tabla es un mintérmino (Tema 13): un producto en el que aparecen las cuatro variables, directas si el bit del código es 1 y negadas si es 0. No hay nada que simplificar con un mapa de Karnaugh (Tema 16): un solo 1 no se agrupa con ningún vecino.

Por qué es una igualdad

E vale 1 exactamente cuando cada bit de la entrada coincide con el bit del secreto. Es el comparador del Tema 25, con la ventaja de que un lado es constante y por eso no hace falta una puerta por bit.

Qué hace cada negación

Un bit del secreto en 0 se compara con ~S: ~S vale 1 justamente cuando S vale 0. Un bit del secreto en 1 se compara con S directamente. Así, todos los términos valen 1 solo si todas las posiciones coinciden.

Qué hace el rojo

El rojo es el complemento de E: se enciende en todo caso que no sea la clave. Es la lógica de «negar por defecto»: la cerradura está cerrada salvo que algo demuestre lo contrario.

Cantidad de negaciones

Hay una por cada cero del secreto. Con 1010 son dos (S2 y S0). Con 1111 no haría falta ninguna; con 0000 harían falta cuatro.

03 · Alternativas

Tres formas de comparar

El mismo circuito se puede armar de varias maneras y la elección depende de qué se necesita. Se comparan por cantidad de puertas y por flexibilidad:

XOR como detector de diferencias

A xor B vale 1 cuando los bits difieren (Tema 10). Si se hace XOR bit a bit entre el intento y el secreto, el resultado es 0000 exactamente cuando coinciden. Entonces basta un NOR de 4 entradas (vale 1 cuando todas valen 0) para obtener «igual».

Contra una constante, menos es más

Si el secreto no cambia, un XOR por bit es un desperdicio: con el secreto fijo, el XOR contra 1 es una conexión directa y contra 0 es un inversor. Por eso la versión fija usa solo dos NOT.

Cuándo conviene la configurable

Cuando el código lo tiene que poder cambiar el usuario. A cambio de más puertas y un segundo DIP, que además es la parte más débil: cualquiera ve cuál es el código mirando los interruptores.

04 · Esquema

Conexionado pin a pin

Con dos chips de 14 pines, cada conexión se puede escribir en una lista. Es el equivalente de un archivo de configuración: si está claro, el montaje sale a la primera.

El DIP

Cada interruptor lleva una de sus patas a +5 V y la otra a la entrada y a una resistencia de 10 kΩ hacia masa (pull-down, Tema 11). Cerrado: la entrada ve 5 V. Abierto: la resistencia la mantiene en 0 V. Sin ella, abierto significa «flotante».

Los LED

Cada uno con una resistencia de 1 kΩ en serie: a 5 V y con una caída de unos 2 V, circulan unos 3 mA (Tema 29), que es visible y está dentro de lo que entrega una salida HC.

Fail-closed de verdad

El pull-down de 10 kΩ en E obliga a 0 si el 74HC21 se saca o se rompe: el rojo queda encendido. Y una resistencia de 100 kΩ a masa en los cables ~S2 y ~S0 evita que se lean como «1» flotante si se retira el 74HC04.

Versión con ENTER

Un pulsador a +5 V con 10 kΩ a masa, filtrado con 1 µF (constante de tiempo de 10 ms) y limpiado por un inversor Schmitt 74HC14 (Tema 11) entra a un AND de 2 entradas junto con E: E_final = E · ENTER. Los LED y el actuador se manejan con E_final.

Salida hacia una cerradura real

Un pin HC entrega pocos mA: una cerradura eléctrica o un relé se maneja con un transistor y un diodo de rueda libre en la bobina, nunca directamente desde la compuerta (Tema 29). Con un 100 nF más en la zona de carga para que el pico no reinicie la lógica.

05 · Materiales y consumo

Lista de compras y presupuesto de corriente

El consumo se calcula con el método del Tema 29: se suma lo que toma cada cosa en el peor caso. Los chips casi no consumen; mandan los interruptores cerrados (5 V sobre 10 kΩ son 0,5 mA cada uno) y el LED encendido (3 mA).

Las cinco reglas del Tema 29 aplicadas aquí: Vcc estable de 5 V; desacople de 100 nF por chip; sin flotantes (pull-downs, entradas sobrantes a GND); sin peleas de salidas (cada salida maneja solo su carga); temperatura sin problema (unos mW).

06 · Puesta en marcha

Orden de pruebas y fallas conocidas

Armar todo y encender es la forma más cara de probar. Se prueba por capas, de la alimentación hacia la lógica, y en cada paso se sabe qué se espera.

1. Rieles y reposo

Medir 5 V entre los pines 14 y 7 de cada chip con todo conectado. Con el DIP en 0000: E = 0, rojo encendido, verde apagado. Si el verde prende, revisar el AND y las conexiones a masa.

2. Cada interruptor

Mover S0 a S3 de a uno y medir en el pin de cada entrada: 0 V o 5 V francos, nunca un valor intermedio. Un valor a mitad de camino indica un pull-down que no tira (flotante).

3. Los inversores

Con S2 = 0, ~S2 debe valer 5 V; con S2 = 1, 0 V. Lo mismo para S0. Si un inversor no responde, mirar su alimentación.

4. Los 16 códigos

Recorrer 0000 a 1111 y anotar: solo 1010 da verde. Es la prueba exhaustiva del Tema 6, posible porque son 16 casos. Anotar: abre 1 de 16.

5. Fail-closed

Con 1010 puesto, sacar el 74HC21 del zócalo: debe quedar el rojo encendido y el verde apagado. Repetir sacando el 74HC04. Si el verde llega a prender, falta un pull-down.

6. Mover el DIP con calma y con prisa

Pasar de 1000 a 1011 mirando el verde. Con un osciloscopio o un LED con memoria se ve que puede destellar al pasar por 1010 (más abajo). Con ENTER, este caso desaparece.

El destello del verde: un hazard de función

Cuando se mueven dos interruptores «a la vez», nunca cambian exactamente al mismo tiempo: la entrada pasa por un código intermedio. Es el hazard de función del Tema 28. Si ese código intermedio es 1010, la salida E sube un instante y baja. Por ejemplo, de 1000 a 1011 hay que cambiar S1 y S0: si cambia primero S1, la entrada vale 1010 y el verde destella. No hay ningún término de consenso que lo evite, porque en ese instante la entrada vale la clave.

En una cerradura con un LED es una curiosidad; en una cerradura real que actúa sobre un cerrojo, sería una puerta abierta por accidente. La solución, como en el Tema 28, es no leer la salida mientras las entradas se mueven: el código se evalúa solo cuando se aprieta ENTER.

07 · Simulador

Laboratorio: la cerradura con compuertas

El simulador dibuja el circuito con sus compuertas y colorea cada cable según su valor lógico: verde lima para 1, gris para 0. Podés elegir entre dos montajes —el fijo (AND-4 e inversores, secreto 1010) y el configurable (XNOR bit a bit, con un segundo DIP para el secreto)— y entre disparo libre (la salida sigue a las entradas) o con ENTER (solo se evalúa al apretarlo).

• Interruptores: los botones S3 a S0 cambian el código de entrada; C3 a C0 cambian el secreto (en el montaje configurable).
• Resultados: el valor de E, el veredicto, la cantidad de puertas del montaje elegido y los intentos con sus fallos.
• Intentos: en disparo libre cuenta cada cambio de código; con ENTER, cada vez que se aprieta.

Recorrido guiado (10 minutos)

1. 1
   Mirá el estado inicial: 1010, montaje fijo.

   S3 y S1 pasan directo; S2 y S0 pasan por un inversor, así que los cuatro cables que llegan al AND valen 1. E = 1, el verde prende y el rojo no.

2. 2
   Cambiá S0 a 1 (código 1011).

   El inversor de S0 entrega 0 y el AND pierde una entrada: E = 0. Un solo bit distinto alcanza para cerrar.

3. 3
   Recorré a mano otros cuatro o cinco códigos.

   Solo 1010 pone los cuatro cables en 1. El contador de intentos sube y los fallos también.

4. 4
   Pasá a «Configurable (XNOR)».

   Aparece la fila del secreto (C3 a C0). Cada fila tiene un XNOR que vale 1 cuando el bit de entrada coincide con el del secreto. La cantidad de puertas sube de 4 a 6.

5. 5
   Poné el secreto en 0110 y la entrada en 0110.

   Los cuatro XNOR valen 1 y el AND abre. Cambiar un bit de cualquiera de los dos lados cierra.

6. 6
   Secreto y entrada iguales sea cual sea el valor.

   Probá 0000 contra 0000 o 1111 contra 1111: abre también. El comparador es genérico; la versión fija era la barata.

7. 7
   Activá «Con ENTER» y dejá el código correcto.

   El AND de ENTER aparece al final: aunque E valga 1, la salida sigue en 0 hasta que se apriete. El verde no se enciende solo.

8. 8
   Apretá ENTER con el código correcto.

   E_final = E · ENTER vale 1 un momento: el verde prende y suma un intento acertado. Con un código incorrecto suma un fallo.

9. 9
   Con ENTER, cambiá los interruptores sin apretar.

   El rojo sigue fijo y los intentos no suben: mover el DIP ya no cuenta como probar un código, y lo que se ve en el camino no importa.

10. 10
    Contá los fallos para abrir por fuerza bruta.

    Probando códigos distintos, el peor caso son 15 fallos y el intento 16 abre. En un proyecto real habría un bloqueo después de unos pocos.

Preguntas para pensar

1. Con el montaje fijo, probá 1000 y 1011. ¿Cuánto vale E en cada caso y qué bit falla?
2. ¿Cuántos de los 16 códigos abren? ¿Qué implica para la seguridad?
3. En el montaje configurable con secreto 0110, ¿cuántas puertas hay y qué entrada abre?
4. Con ENTER, ¿qué diferencia hay entre dejar 1010 puesto y apretar?

08 · La cerradura en código

Gemelo digital, ataque, destellos, variantes y consumo

Los bloques reproducen el circuito en Python, para probarlo antes de armarlo: la tabla de las 16 combinaciones a nivel de compuertas, qué tan rápido cae una cerradura según los bits que tenga, cuántos movimientos de interruptor pueden destellar el verde, cuántas puertas cuesta cada variante y cuánto dura una batería con cada elección de resistencias.

Paso 1: el gemelo digital con compuertas

NOT = lambda a: 1 - a
AND4 = lambda a, b, c, d: a & b & c & d


def cerradura(s3, s2, s1, s0):
    e = AND4(s3, NOT(s2), s1, NOT(s0))           # HC04 (2 NOT) + HC21 (1 AND-4)
    rojo = NOT(e)                                # tercer NOT del HC04
    return e, rojo


print("S3 S2 S1 S0 | E  verde  rojo")
abren = []
for n in range(16):
    s3, s2, s1, s0 = (n >> 3) & 1, (n >> 2) & 1, (n >> 1) & 1, n & 1
    e, rojo = cerradura(s3, s2, s1, s0)
    print(f" {s3}  {s2}  {s1}  {s0}  | {e}   {'ON ' if e else 'off'}   {'ON ' if rojo else 'off'}")
    if e:
        abren.append(f"{s3}{s2}{s1}{s0}")
print()
print("abren:", abren, "->", len(abren), "de 16")
print("mintermino:", "m10 = S3 * ~S2 * S1 * ~S0  (1010 binario = 10)")

La tabla completa confirma la especificación: solo la fila 1010 pone E en 1 (verde encendido, rojo apagado); las otras 15 dejan el rojo encendido. Es la prueba exhaustiva del paso 4 de la puesta en marcha, hecha antes de tocar el protoboard.

Paso 2: fuerza bruta y cuántos bits hacen falta

print("bits   combinaciones   peor caso a 1 intento/s   azar con 3 intentos")
for bits in (4, 8, 12, 16, 32):
    comb = 2 ** bits
    peor_s = comb
    if peor_s < 120:
        t = f"{peor_s} s"
    elif peor_s < 7200:
        t = f"{peor_s/60:.0f} min"
    elif peor_s < 172800:
        t = f"{peor_s/3600:.1f} h"
    else:
        t = f"{peor_s/86400:.0f} dias"
    print(f"{bits:4d}   {comb:13d}   {t:>22s}   {min(1, 3/comb):17.4%}")
print()
print("con bloqueo de 30 s tras cada 3 fallos, 4 bits (16 codigos):")
fallos = 15
espera = (fallos // 3) * 30
print(f"  peor caso: {fallos} fallos + {fallos//3} bloqueos = {fallos + espera} s")

Con 4 bits se prueban todas las combinaciones en 16 segundos y se acierta al azar con 3 intentos el 18,75 % de las veces. Con 16 bits son 18 horas a un intento por segundo; con 32, 49 710 días. Un bloqueo de 30 s cada 3 fallos lleva el peor caso de 4 bits de 16 s a 165 s: ayuda, pero con 16 códigos sigue siendo un juguete.

Paso 3: cuántos movimientos pueden destellar el verde

from itertools import permutations

SECRETO = 0b1010


def intermedias(a, b):
    cambian = [i for i in range(4) if ((a ^ b) >> i) & 1]
    vistas = set()
    for orden in permutations(cambian):
        x = a
        for i in orden[:-1]:
            x ^= 1 << i
            vistas.add(x)
    return vistas


pares = [(a, b) for a in range(16) for b in range(16) if a != b and b != SECRETO and a != SECRETO]
con_destello = [(a, b) for a, b in pares if SECRETO in intermedias(a, b)]
print(f"transiciones entre codigos distintos de 1010: {len(pares)}")
print(f"las que pueden dar un destello verde en el camino: {len(con_destello)}")
for a, b in ((0b1000, 0b1011), (0b1110, 0b1011), (0b0000, 0b1111), (0b0001, 0b1001)):
    print(f"  {a:04b} -> {b:04b}: puede pasar por 1010? {SECRETO in intermedias(a, b)}")
print()
print("el pulsador ENTER lo evita: la cerradura solo se evalua al apretar, con el codigo ya asentado")

De 210 transiciones entre códigos distintos de 1010, 50 pueden pasar por 1010 en el camino (casi una de cada cuatro). De 1000 a 1011, de 1110 a 1011 y de 0000 a 1111 es posible; de 0001 a 1001 (un solo bit cambia) no. Mover varios interruptores a la vez es un hazard de función, y se arregla leyendo solo al apretar ENTER.

Paso 4: cuánto cuesta cada variante

def fijo(codigo):
    unos = bin(codigo).count("1")
    return {"NOT para entradas": 4 - unos, "AND-4": 1, "rojo (NOT)": 1}


def configurable():
    return {"XOR (HC86)": 4, "NOR-4 (HC4002)": 1, "rojo (otro NOR del HC4002)": 1}


for nombre, cod in (("1010", 0b1010), ("1111", 0b1111), ("0000", 0b0000)):
    d = fijo(cod)
    print(f"fijo {nombre}: {d} -> {sum(d.values())} puertas")
d = configurable()
print(f"configurable: {d} -> {sum(d.values())} puertas, 2 DIP")
print()
secret, intento = 0b0110, 0b0110
difiere = secret ^ intento
print("comparador por XOR: bits distintos =", f"{difiere:04b}", "-> abre" if difiere == 0 else "-> cerrado")
for intento in (0b0110, 0b0111, 0b1110):
    difiere = secret ^ intento
    print(f"  secreto {secret:04b} intento {intento:04b}: XOR = {difiere:04b} -> NOR4 = {int(difiere == 0)}")

La versión fija de 1010 tiene 4 puertas (2 NOT de entrada, el AND-4 y el NOT del rojo); la de 1111 solo 2, y la de 0000 llega a 6. La configurable tiene siempre 6 más un segundo DIP. El XOR entre intento y secreto da 0000 solo cuando coinciden, y un NOR de 4 entradas lo convierte en «igual».

Paso 5: presupuesto de corriente y autonomía

VCC = 5.0


def presupuesto(r_pull_k=10.0, r_led_k=1.0, v_led=2.0, interruptores_cerrados=4, chips=2, i_chip_ua=5.0):
    i_sw = interruptores_cerrados * VCC / r_pull_k             # mA
    i_led = (VCC - v_led) / r_led_k                            # mA, un solo LED a la vez
    i_ics = chips * i_chip_ua / 1000                           # mA
    return i_sw, i_led, i_ics


def autonomia_h(i_ma, mah=2000.0):
    return mah / i_ma


print("diseno                      I switches  I LED   I chips   total     autonomia")
for nombre, kw in (("base: pull 10k, LED 1k", {}),
                   ("pull 100k", {"r_pull_k": 100.0}),
                   ("pull 100k, LED 4,7k", {"r_pull_k": 100.0, "r_led_k": 4.7}),
                   ("DIP todo abierto (0000)", {"interruptores_cerrados": 0})):
    a, b, c = presupuesto(**kw)
    tot = a + b + c
    h = autonomia_h(tot)
    print(f"{nombre:26s} {a:7.2f} mA {b:6.2f} {c:8.3f}  {tot:6.2f} mA  {h:7.0f} h ({h/24:.0f} d)")
print()
r_led = (VCC - 2.0) / 0.004
print(f"R minima para 4 mA por pin: {r_led:.0f} ohm -> usamos 1 kohm: {(VCC-2.0)/1.0:.1f} mA (margen bajo el limite del HC)")

El diseño base toma unos 5 mA (con los cuatro interruptores cerrados) y 2000 mAh duran 17 días. Con pull-downs de 100 kΩ pasa a 3,2 mA y con un LED de 4,7 kΩ a 0,85 mA: 98 días. La resistencia mínima para no pasar de 4 mA por pin es de 750 Ω; con 1 kΩ quedan 3 mA, dentro del límite.

09 · Analogía de programador

Allowlist, deny-by-default y commit

1. 1
   Especificar antes de construir.

   La tabla de verdad es el contrato: 16 filas, una vale 1. Todo lo demás se verifica contra ella, igual que un test contra una especificación.

2. 2
   El estado seguro por defecto es una decisión de diseño.

   No sale solo: hay que agregar los pull-downs que lo garantizan. Es el equivalente de decidir qué hace el sistema cuando se cae un servicio.

3. 3
   Separar «preparar» de «confirmar».

   Mover el DIP es editar un borrador; ENTER es el commit. Mientras se edita, el estado intermedio no tiene por qué producir efectos.

Una diferencia con el software: acá no se puede «parchear» una cerradura desplegada. Un error de diseño que se descubre después implica abrir la caja, y por eso se prueba todo antes y se piensan las fallas de antemano.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de cerradura

Ejercicio 1: otro código

Cambiá el secreto a 0110. Escribí la ecuación, indicá cuántos inversores y en qué entradas hacen falta, y qué pines del 74HC21 cambian. Verificalo con el Paso 1.

Ejercicio 2: código configurable

Diseñá la versión con un segundo DIP para el secreto usando 74HC86 y 74HC4002. ¿Cuántos chips y cuántas puertas? ¿Cuál es la ventaja y cuál el problema?

Ejercicio 3: el pulsador ENTER

Agregá un pulsador ENTER para que la cerradura solo abra al apretarlo. ¿Qué compuerta hace falta? ¿Por qué RC y Schmitt? Con 10 kΩ y 1 µF, ¿cuánto vale la constante de tiempo y para qué sirve?

Ejercicio 4: ¿puede destellar?

¿Puede el verde destellar al pasar de 1000 a 1011? ¿Y de 0001 a 1001? Dá una regla general para saber si una transición puede pasar por el secreto.

Ejercicio 5: un LED para los dos colores

Con un 74HC20 (doble NAND de 4 entradas) en lugar del AND-4, el rojo sale directo de la compuerta. ¿Cómo se conectan los dos LED a la misma salida para ahorrar el tercer inversor?

Ejercicio 6: presupuesto de pilas

Con las pilas de 2000 mAh, una cerradura con pull-down de 100 kΩ y LED de 4,7 kΩ toma 0,85 mA. ¿Cuánto dura? ¿Qué cambiarías para que dure un año?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 31?

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

• Escribir la ecuación de apertura para cualquier código de 4 bits y decir cuántos inversores hacen falta.
• Elegir entre AND con inversores, XNOR y un comparador integrado según si el código cambia.
• Conectar de memoria los pines relevantes del 74HC21 y del 74HC04 de este montaje.
• Calcular el consumo y la autonomía con la resistencia del LED y del pull-down.
• Explicar por qué el verde puede destellar al mover el DIP y cómo lo soluciona ENTER.
• Nombrar tres puntos donde la cerradura es insegura aun cuando la lógica es correcta.

Con una cerradura completa, el siguiente paso es cambiar de problema: en el próximo tema armamos una calculadora de 4 bits con sumador, display de siete segmentos y las mismas prácticas de este proyecto.