Cierre y puente al curso 6

01 · Balance

Qué tenés ahora

Al empezar, un voltaje era una cantidad continua. Ahora es una decisión: por encima de un umbral vale 1 y por debajo vale 0, y con esa decisión se arma cualquier función que puedas escribir en una tabla. Recorriste 31 temas agrupados en cinco bloques y cerraste con dos proyectos que usan casi todo lo anterior.

• ¿Qué hizo cada bloque del curso y con qué «firma» se lo recuerda?
• ¿Cuál es el método que se repitió en cada diseño?
• ¿Qué sabés hacer ahora que antes no?
• ¿Qué errores clásicos ya reconocés y cómo se arreglan?
• ¿Qué hace imposible que un circuito combinacional recuerde algo?
• ¿Aprobás el examen final?

02 · El mapa

Los 31 temas en una tabla

Hilo 1: la tabla de verdad

Aparece en el Tema 6 y no se va más. Es la especificación, la prueba exhaustiva y la forma de comparar dos circuitos distintos que deberían hacer lo mismo.

Hilo 2: lo ideal frente a lo real

Cada bloque empieza con la versión de papel y termina con su cara física: niveles y márgenes (Tema 3), rebotes (Tema 11), fan-out y desacople (Temas 12 y 29), retardos y glitches (Tema 28).

Hilo 3: el costo

Menos puertas, menos chips, menos corriente. Simplificar (Temas 15 y 16) y bajar la tensión (Tema 29) son la misma idea con herramientas distintas.

Hilo 4: verificar todo

Con pocas variables se puede probar cada caso. Las pruebas exhaustivas de los proyectos (16 de 16, 100 de 100) son el hábito más valioso que te llevás.

03 · El método

Cinco pasos, de la idea al circuito verificado

Cada diseño del curso siguió la misma receta. Se ve mejor aplicada de principio a fin a un ejemplo chico: una votación 2 de 3 (la salida vale 1 si al menos dos de las tres entradas valen 1; ya apareció en el Tema 15).

1. 1
   Especificar.

   «Y vale 1 cuando al menos dos de A, B, C valen 1.» Sin ambigüedad: una frase que se puede convertir en tabla. Si hay casos que no pueden ocurrir, se anotan como «no importa».

2. 2
   Tabla de verdad.

   Ocho filas. Y vale 1 en 011, 101, 110 y 111: los minterms 3, 5, 6 y 7 (Tema 6).

3. 3
   Mínimo.

   En el mapa de Karnaugh (Tema 16) los cuatro unos forman tres grupos de dos: Y = AB + AC + BC. Es un caso donde la expresión canónica (cuatro productos de tres variables) se reduce a tres de dos.

4. 4
   Chips.

   Con la forma NAND-NAND (Tema 9) se usa solo NAND: tres NAND de dos entradas para los productos y un NAND de tres para la suma. Son un 74HC00 (se usan 3 de 4) y un 74HC10 (se usa 1 de 3): dos chips.

5. 5
   Verificar.

   Recorrer las ocho filas contra la especificación, en Python antes y en la mesa después. Si alguna falla, el error está en el paso anterior o en el cableado, y se sabe dónde buscar.

04 · Habilidades

Checklist de egreso

Si alguna de estas seis te suena a «más o menos», el examen final y los desafíos de abajo te dicen cuál repasar. No hace falta saber de memoria cada chip: hace falta saber qué buscar en la hoja de datos.

05 · Errores clásicos

Ya no te pasan (o los reconocés a tiempo)

Si te llevás una sola cosa de esta tabla: la mayoría de las fallas «misteriosas» de un circuito digital que debería andar son eléctricas (alimentación, entradas sin definir, rebotes), no lógicas.

06 · El puente

El primer circuito con memoria

Todo lo que construiste es combinacional: cada salida depende solo de las entradas actuales. Es el equivalente a una función pura, sin estado. Alcanza para decidir, calcular y mostrar, pero no para contar, recordar un código o esperar un evento: eso necesita que la salida dependa también de lo que pasó antes.

La sorpresa es lo poco que hace falta para lograrlo. Si se conecta la salida de una puerta a la entrada de otra y la salida de esa a la entrada de la primera, se forma un lazo realimentado que puede mantener un valor sin que nadie lo sostenga. Con dos puertas NOR se arma un latch SR, la unidad de memoria más chica:

La fila de arriba contradice todo lo que veníamos haciendo: con las mismas entradas (S = R = 0) la salida puede valer 0 o 1, según la historia. La tabla de verdad ya no alcanza, porque falta una columna: el estado previo. Probalo:

Qué probar

1. 1
   Poné S = 1, luego volvelo a 0.

   Q pasa a 1 y se queda en 1 aunque S ya no esté. Con S = R = 0 el circuito recuerda.

2. 2
   Poné R = 1 y luego volvelo a 0.

   Q pasa a 0 y se queda en 0. Mismas entradas (S = R = 0) que antes, otra salida: depende de la historia.

3. 3
   Poné S = R = 1 y soltá las dos.

   Q y ~Q valen 0 a la vez (el latch pierde su propiedad de ser complementario). Al soltarlas, se observa un paso (1, 1) y luego (0, 0): el lazo oscila. Con «Avanzar un paso de compuerta» se ve la oscilación paso a paso.

4. 4
   Salí de la oscilación con S o R.

   Poner un solo 1 (S o R) fuerza un estado válido. En el hardware real, la oscilación depende de cuál puerta es un poco más rápida: es impredecible. Por eso se prohíbe esa combinación.

Lo que cambia con la memoria

Hay estado. Una tabla de verdad se reemplaza por una tabla de estados y transiciones. El tiempo importa de otra manera: no solo cuánto tarda una salida en asentarse (Tema 28), sino cuándo se mira.

El reloj

Los latches sin control son difíciles de domar (la combinación prohibida, las carreras). La solución es un reloj que decide cuándo se escribe: así nacen el latch con enable, el flip-flop y todo el diseño síncrono que se anticipó en el Tema 28.

Lo que viene

Flip-flops D, T y JK; registros y registros de desplazamiento; contadores; máquinas de estados; y memorias RAM y ROM. Con eso, la cerradura recuerda un código ingresado en el tiempo, la calculadora acumula resultados y aparece el camino hacia un procesador.

Ya lo usaste sin saberlo

Un latch SR hecho con dos puertas era una de las tres soluciones del anti-rebote (Tema 11): el pulsador de dos posiciones «guarda» el último contacto y los rebotes no lo cambian.

07 · Examen final

Laboratorio: diez preguntas, una por idea

El examen tiene diez preguntas de opción múltiple, una por cada idea central del curso, y se corrige solo: al elegir una respuesta se muestra si es correcta, una explicación breve y el tema donde se estudió. Al final se calcula la nota y se listan los temas a repasar. Se puede reiniciar y repetir todas las veces que quieras; lo que importa es que, al terminar, puedas explicar cada respuesta.

08 · El curso en código

Un script con las firmas, el método, un autoexamen y el latch

Los bloques reúnen el curso en cuatro scripts: uno con la firma de cada bloque, el método aplicado de punta a punta a la votación 2 de 3, un autoexamen con assert y la simulación del latch SR con dos NOR, incluida la oscilación de la combinación prohibida.

Paso 1: las seis firmas del curso

from itertools import product

firmas = {}
firmas["AND"] = [a & b for a, b in product((0, 1), repeat=2)]
firmas["OR"] = [a | b for a, b in product((0, 1), repeat=2)]
firmas["NAND"] = [1 - (a & b) for a, b in product((0, 1), repeat=2)]
firmas["XOR"] = [a ^ b for a, b in product((0, 1), repeat=2)]

demorgan = all((1 - (a & b)) == ((1 - a) | (1 - b)) and (1 - (a | b)) == ((1 - a) & (1 - b))
               for a, b in product((0, 1), repeat=2))
mayoria = [n for n in range(8) if bin(n).count("1") >= 2]
z = (7 + 5) & 15
k = 1 if (7 + 5) >= 10 else 0
bcd = z + 6 * k

print("Bits       0xA5 =", 0xA5, "| en complemento a dos:", 0xA5 - 256)
print("Puertas   ", "  ".join(f"{n} {''.join(map(str, v))}" for n, v in firmas.items()))
print("Booleana   De Morgan en las 4 combinaciones:", demorgan)
print("Combin.    mayoria 2/3 (minterms):", mayoria, "| 7+5: Z =", f"{z:04b}", "-> +6 ->", f"{bcd & 15:04b}", "(decenas", k, ")")
print("Consumo    5 V -> 3,3 V gasta", round((5 / 3.3) ** 2, 2), "veces menos")
print("Proyectos  cerradura: 1 de 16 abre | calculadora: 100 de 100 validos correctos")

Cada bloque deja su número: 165 y −91; las firmas 0001, 0111, 1110 y 0110; De Morgan cierto en las cuatro combinaciones; los minterms 3, 5, 6 y 7 de la mayoría; 7 + 5 → 1100 → 0010 con decena 1; el ahorro de 2,3 veces al bajar de 5 a 3,3 V y los resultados de los dos proyectos.

Paso 2: el método, de punta a punta

from itertools import product

NAND = lambda *x: 1 - int(all(x))

spec = lambda a, b, c: int(a + b + c >= 2)                 # la especificacion: 2 de 3
tabla = {(a, b, c): spec(a, b, c) for a, b, c in product((0, 1), repeat=3)}
minterms = [a * 4 + b * 2 + c for (a, b, c), v in tabla.items() if v]
print("pasos 1 y 2 (spec y tabla): minterms de la salida =", minterms)

sop = lambda a, b, c: (a & b) | (a & c) | (b & c)           # paso 3: Karnaugh -> 3 grupos de 2
nand_nand = lambda a, b, c: NAND(NAND(a, b), NAND(a, c), NAND(b, c))   # paso 4: solo NAND


def verificar(f):
    return sum(1 for e, v in tabla.items() if f(*e) == v)


print("paso 3 (minimo): AB + AC + BC          ->", verificar(sop), "de 8 filas")
print("paso 4 (chips):  NAND-NAND             ->", verificar(nand_nand), "de 8 filas")
print()
print("costo: 3 NAND-2 + 1 NAND-3 = 4 puertas -> 74HC00 (usamos 3 de 4) + 74HC10 (usamos 1 de 3) = 2 chips")
print("paso 5 (verificacion total): las 8 filas coinciden con la especificacion:", verificar(nand_nand) == 8)

La especificación genera los minterms 3, 5, 6 y 7; tanto la suma de productos AB + AC + BC como su versión NAND-NAND coinciden con la especificación en las ocho filas. El costo es de cuatro puertas en dos chips (74HC00 y 74HC10). La verificación total es el último paso, no un adorno: si falla, el error está antes.

Paso 3: autoexamen con asserts

assert 0xA5 == 165 and 0xA5 - 256 == -91
assert [a ^ b for a in (0, 1) for b in (0, 1)] == [0, 1, 1, 0]
assert [1 - (a & b) for a in (0, 1) for b in (0, 1)] == [1, 1, 1, 0]
assert (5 + 3) == 0b1000
assert 0x25 == 37
assert ["ROM", "RAM", "UART", "GPIO"][0b10] == "UART"
assert 9600 // 10 == 960                                  # 8N1: 10 bits por byte
assert [n for n in range(8) if bin(n).count("1") >= 2] == [3, 5, 6, 7]
assert round((5 / 3.3) ** 2, 1) == 2.3
assert (0b1010 ^ 0b1010) == 0 and (0b1010 ^ 0b1011) != 0
print("APROBADO: nos vemos en el curso 6")

Las diez afirmaciones se cumplen y el script imprime «APROBADO». Cambiá cualquiera (por ejemplo, 165 por 166) y Python lanza un AssertionError con la línea que falló: un autoexamen que no se puede engañar.

Paso 4: el puente, un latch SR con dos NOR

NOR = lambda a, b: 1 - (a | b)


def paso(s, r, q, qn):
    return NOR(r, qn), NOR(s, q)                          # los dos NOR se actualizan a la vez


q, qn = 0, 1
secuencia = [("espera", 0, 0, 2), ("SET", 1, 0, 2), ("suelto", 0, 0, 2), ("RESET", 0, 1, 2),
             ("suelto", 0, 0, 2), ("S=R=1", 1, 1, 2), ("suelto 1", 0, 0, 1), ("suelto 2", 0, 0, 1),
             ("suelto 3", 0, 0, 1), ("suelto 4", 0, 0, 1)]
print("paso       S R |  Q ~Q")
for nombre, s, r, n in secuencia:
    for _ in range(n):                                    # cuantos pasos de compuerta se dejan correr
        q, qn = paso(s, r, q, qn)
    print(f"{nombre:9s}  {s} {r} |  {q}  {qn}")
print()
print("con S = R = 0 la salida vale 1 o 0 segun lo que paso antes: eso ya no es combinacional (hay memoria)")
print("S = R = 1 esta prohibida: al soltar las dos a la vez el lazo oscila (0,0) -> (1,1) -> (0,0) ...")

Tras SET, Q queda en 1 con S = R = 0; tras RESET, queda en 0 con las mismas entradas: eso es memoria. Con S = R = 1 ambas salidas valen 0 y, al soltar las dos a la vez, el modelo oscila (1, 1), (0, 0), (1, 1)… para siempre. En un chip real el lazo termina cayendo en uno de los dos estados de forma impredecible.

09 · Analogía de programador

Funciones puras y la caja de herramientas

1. 1
   Cada tema es una herramienta, no un dato.

   Una puerta, un teorema o un bloque MSI no se memorizan: se combinan. Lo que se recuerda es cuándo usar cada uno.

2. 2
   Programar ya te había enseñado a simplificar.

   Quitar un if redundante o factorizar una condición es la misma habilidad que agrupar unos en un mapa. El silicio solo le puso precio a cada puerta.

3. 3
   Lo combinacional no recuerda.

   Es la frontera natural del curso. Todo lo que hace falta para pasar de una función pura a un programa con estado es una forma de recordar: eso es lo que sigue.

La analogía tiene un límite honesto: en software un error de lógica se corrige y se vuelve a ejecutar. En hardware, los errores de lógica, los eléctricos y los de tiempo se confunden en el mismo síntoma, y la depuración se parece más a la de un sistema distribuido: hay que medir en muchos puntos.

10 · Comprensión

Confusiones frecuentes al terminar

11 · Práctica final

Desafíos de egreso

Desafío 1: diseño exprés

Votación 2 de 3 con NAND solamente. Escribí la ecuación, la forma NAND-NAND, la cantidad de puertas y los chips. ¿Qué pasa si solo tenés 74HC00?

Desafío 2: debug exprés

Un display con 7448 o 4511 muestra «8» fijo, sea cual sea el código de entrada. Tres causas, en orden, y cómo descartarlas.

Desafío 3: cazar al culpable

Un contador manual avanza de a 5 por cada pulsación. ¿Cuál es la causa y cuáles son tres remedios, en orden de preferencia?

Desafío 4: auditar una placa

Una placa se reinicia cada vez que se enciende un relé, y un integrado está tibio sin hacer nada. Aplicá el checklist: ¿qué dos sospechosos y qué se mide?

Desafío 5: una cerradura de 8 bits

Ampliás la cerradura a 8 bits. ¿Cuántas combinaciones tiene y qué chip podrías usar para comparar? ¿Es más segura?

Desafío 6: lo que le falta al contador

Querés un contador que avance cada vez que apretás un botón. Dibujalo con lo que sabés: ¿qué parte podés hacer con circuitos combinacionales y cuál no?

12 · Síntesis y ruta

Fin del curso 5

¿Listo para el curso 6?

El curso 6, Secuenciales y Memoria, agrega el reloj, el flip-flop, los registros, los contadores, las máquinas de estados y la memoria. Podés empezarlo si sos capaz de hacer esto sin mirar:

• Pasar una especificación a tabla de verdad y de ahí a una expresión mínima.
• Aplicar De Morgan y pasar de suma de productos a NAND-NAND.
• Armar y verificar un circuito de seis a diez puertas, probando todas las filas.
• Reconocer en el osciloscopio o en el comportamiento un rebote, un glitch, un flotante y un hundimiento de Vcc.
• Explicar con tus palabras por qué un circuito combinacional no puede recordar.
• Describir qué hace un latch SR y por qué S = R = 1 está prohibida.

Curso completo: 32 de 32 temas. Gracias por haber llegado contando en binario; nos vemos en el curso 6.