Proyecto: calculadora

01 · Especificación

Dos dígitos, un resultado

Igual que en la cerradura, primero el contrato. La calculadora:

• Entradas: dos dígitos decimales A y B de 0 a 9, cada uno en cuatro interruptores (código BCD, Tema 5). Lo ideal serían dos ruedas BCD de 0 a 9; con un DIP de 4 posiciones por dígito, pueden llegar combinaciones que no son dígitos (10 a 15).
• Salida: la suma A + B, de 0 a 18, en dos dígitos de siete segmentos (Tema 21). Sin ceros a la izquierda: 7 + 2 se ve «9», no «09».
• Operandos inválidos: si un dígito vale más de 9, el display se apaga y un LED rojo avisa. Nunca se muestra un número equivocado sin avisar.
• Alimentación: 5 V, serie 74HC, desacople y pull-downs como en el Tema 29.

• ¿Por qué un sumador binario no alcanza para mostrar una suma decimal?
• ¿Qué hay que corregir y cuándo?
• ¿Cómo se muestran dos cifras y se apaga el cero de la izquierda?
• ¿Qué debe hacer el circuito si un operando no es un dígito?
• ¿Cuántos chips y cuánta corriente hacen falta?
• ¿Qué casos borde hay que probar a mano?

02 · El problema decimal

El sumador piensa en base 16

Un sumador de 4 bits (Tema 24) entrega una suma Z de 4 bits y un acarreo C. Es aritmética módulo 16: el acarreo sale cuando la suma llega a 16. Pero un dígito decimal «se pasa» al llegar a 10. Entre 10 y 15 el sumador todavía no llevó nada, aunque en decimal ya habría que llevar uno. Tabla de lo que pasa:

Por ejemplo, 7 + 5 = 12: Z = 1100 (que se ve como un 12, pero no es un dígito BCD). Si le sumamos 0110 (6): 1100 + 0110 = 1 0010. El nibble bajo, 0010, es el 2 de «12»; el 1 que salió de más es justo la decena. Sumar 6 le «regala» al binario los 6 valores que se saltea el BCD (los códigos 10 a 15), y el acarreo del nibble pasa a valer 10.

Por qué esta condición

La suma vale 10 o más en dos casos: hubo acarreo (C = 1, suma de 16 a 18) o el nibble Z está entre 1010 y 1111. Esos códigos son los que tienen Z3 = 1 y alguno de Z2 o Z1 en 1 (1000 y 1001 son los dígitos 8 y 9: no se tocan).

Por qué sumar 6 y no otro número

16 − 10 = 6. Es la distancia entre dónde desborda el binario y dónde desborda el decimal. Se suma exactamente esa diferencia para que el desborde caiga en el lugar correcto.

K es el dígito de las decenas

Con operandos de 0 a 9 la suma llega a 18: las decenas son 0 o 1. K vale 1 exactamente cuando la suma es 10 o más, así que K es el dígito de la izquierda; no hace falta calcular nada más.

Es un sumador BCD

Este esquema (sumar en binario, detectar el desborde decimal, sumar 6) es el clásico sumador BCD de una década. Encadenando décadas con K como acarreo se suman números de varias cifras (Ejercicio 3).

03 · Diseño

Bloques, ecuaciones y conexionado

La segunda entrada del 283 n.º 2

Los bits B3..B0 del segundo sumador valen 0, K, K, 0: es decir, 0000 o 0110. Entonces U = Z cuando K = 0 y U = Z + 6 cuando K = 1. Un mismo chip suma «nada» o «seis» según K.

Supresión del cero a la izquierda

El decodificador de decenas recibe 0000 o 0001, pero el 0 no se quiere ver. Su entrada ~BI (apagado, activa en bajo) se conecta directamente a K: con K = 0 el dígito se apaga; con K = 1 muestra el «1». Es el blanking del Tema 21, ahora con un fin útil.

Pines de control del 4511

~LT (prueba de lámpara) va a +5 V; LE (latch) va a masa para que las salidas sigan a las entradas. No se dejan al aire (Tema 29). En las unidades, ~BI va a la señal de «operandos válidos» (siguiente sección). Un 4511 apaga solo los códigos 1010 a 1111, que no pueden aparecer en las unidades si los operandos son válidos.

Display de cátodo común

Los dos dígitos son de cátodo común, con una resistencia por segmento (Tema 21): 680 Ω da 4,4 mA por segmento, una corriente razonable para un pin HC. El 4511 entrega la corriente (salidas activas en alto).

Los 283 y los pines

Cada 283 conecta A3..A0 y B3..B0 a sus entradas, S3..S0 a las salidas, el acarreo de entrada a masa (Cin = 0) y Vcc/GND con 100 nF pegado. Los números de pin exactos, en la hoja de datos del fabricante; lo importante acá es la lógica de la conexión.

04 · Entradas inválidas

Fallar con ruido, no en silencio

Un DIP de cuatro posiciones tiene 16 combinaciones y solo diez son dígitos. Para A o B entre 10 y 15 el circuito, sin protección, seguirá sumando y mostrará algo. Las consecuencias, calculadas con el gemelo digital:

Es un fallo silencioso: la calculadora «responde» con seguridad un número equivocado. Es el peor tipo de falla, porque nadie sabe que hay que desconfiar (el Tema 30 lo llamó fail-closed). La detección es barata: un operando es inválido si el bit 3 está en 1 y alguno de los bits 2 o 1 también:

Qué cuesta

Dos OR, dos AND y un NOR (cinco puertas en tres chips que ya están en la placa o cuestan centavos). Es una versión chica del comparador «mayor que 9» del Tema 25.

Qué hace ERR_n

Vale 1 si todo está bien y 0 si algún operando es inválido. Va al ~BI del decodificador de unidades (apaga el dígito) y, junto con K, al ~BI del de decenas (K · ERR_n). Con ERR_n = 0 el display queda en blanco.

El LED de error

Se conecta de +5 V a ERR_n a través de 1 kΩ: se enciende cuando ERR_n baja a 0 (la compuerta absorbe unos 3 mA, dentro de lo que garantiza el HC; Tema 30).

Alternativa de hardware

Reemplazar el DIP por ruedas BCD hace imposible el error de entrada: cada rueda solo da 0 a 9. Pero el diseño sigue sin protegerse de un cable suelto o de una rueda mal armada; la detección es defensa en profundidad.

05 · Materiales y consumo

Lista de compras y presupuesto de corriente

Son 7 chips con detección de errores (6 sin ella: se saca el 74HC02 y el ~BI de decenas va directo a K). Todas las puertas sobrantes llevan sus entradas a masa, como en el Tema 29.

La corriente depende de qué número se muestra: cada segmento encendido cuesta lo mismo. El peor caso entre 0 y 18 es la suma «18» (un «1» más un «8»: 9 segmentos, 39,7 mA con 680 Ω) y, con los ocho interruptores cerrados (8 × 0,5 mA = 4 mA), el total ronda 44 mA. Con 2000 mAh de pilas serían unas 46 horas: es un proyecto de banco, no de batería.

06 · Puesta en marcha

Orden de pruebas y casos borde

Con 7 chips, probar al final es una receta para no saber dónde está el error. Se prueba por etapas, y en cada una se mide el nodo intermedio, no solo el display:

1. Alimentación y reposo

5 V en cada chip, con el 100 nF puesto. Con A = B = 0000: Z = 0000, K = 0, display de unidades en «0», decenas apagadas, LED de error apagado.

2. El primer sumador solo

Con el segundo todavía sin conectar: A = 0011, B = 0100 debe dar Z = 0111, C = 0. Probar algunas sumas y también un acarreo: 8 + 8 debe dar Z = 0000, C = 1.

3. La señal K

Medir K con sumas de 0 a 18: debe valer 0 hasta 9 y 1 desde 10. El borde es el caso crítico: 4 + 5 = 9 (K = 0) y 5 + 5 = 10 (K = 1).

4. El segundo sumador

Con K = 1: U = Z + 0110. Comprobar 5 + 5: Z = 1010, U = 0000. Y 9 + 9: Z = 0010, U = 1000.

5. Los displays

Recorrer los diez dígitos en las unidades. Probar 1 (dos segmentos) y 8 (siete): el 8 no debe verse más opaco que el 1.

6. Entradas inválidas

Poner A = 1100: el display se apaga y el LED rojo se enciende. Repetir con B = 1111 y con A = 1010: todas deben avisar. Con 1001 (el 9) no debe avisar.

7. Toda la matriz

Anotar las 100 combinaciones válidas contra una tabla hecha en Python (Paso 3). Son 100 pruebas, pero se hacen en media hora.

Sospechoso: 8 + 8

Es el caso que corrige por acarreo (C = 1) y no por el rango de Z. Si da «10» en lugar de «16», K no está recibiendo C.

Sospechoso: 5 + 5

Es el primero que corrige. Si muestra «16», la corrección suma de más; si muestra «A» o nada, K no activó.

Rebotes y destellos

Al mover los interruptores, el display pasa por números intermedios durante unos cientos de nanosegundos (hazards de función, Tema 28): no se ven. Si la calculadora se usara para accionar algo, se leería con un pulsador, como en la cerradura; acá basta con que el LE del 4511 pueda congelar la lectura.

07 · Simulador

Laboratorio: la calculadora con display

El simulador reproduce el circuito etapa por etapa: los dígitos A y B de 0 a 15, el primer sumador (Z y C), la señal de corrección K, el segundo sumador (U) y los dos displays de siete segmentos que dibuja el 4511. El interruptor «Detección de errores» agrega o saca la protección contra operandos inválidos.

• Deslizadores A y B: de 0 a 15; los valores de 10 a 15 no son dígitos y sirven para ver qué pasa.
• Display: dos dígitos de siete segmentos. El cero de la izquierda está apagado y los códigos mayores de 9 los apaga el 4511.
• Resultados: Z con su acarreo, K, la lectura del display y un veredicto: correcto, error avisado o fallo silencioso.

Recorrido guiado (10 minutos)

1. 1
   Mirá el estado inicial: 7 + 5.

   El primer sumador entrega Z = 1100 (12 en binario). K vale 1 porque Z3 = 1 y Z2 = 1. El segundo sumador hace 1100 + 0110 = 1 0010: unidades 0010 y el display dice 12.

2. 2
   Bajá B a 2 (7 + 2).

   Z = 1001 (9). K = 0: no se corrige, el segundo sumador suma 0000 y las decenas se apagan. El display dice «9», no «09».

3. 3
   Subí B a 3 (7 + 3 = 10).

   Es el primer caso corregido: Z = 1010, K = 1, U = 0000. El display pasa de «9» a «10»: aparece la decena.

4. 4
   Probá 8 + 8.

   Z = 0000 pero C = 1: el sumador desbordó. K se activa por el acarreo (no por el rango de Z) y U = 0110. Display 16.

5. 5
   Probá 9 + 9.

   El máximo: Z = 0010, C = 1, K = 1, U = 1000. Display 18. Es el número que más segmentos enciende (9).

6. 6
   Subí A a 10 con la detección activada.

   Display apagado y ERR encendido. A = 1010 no es un dígito: el circuito se niega a mostrar nada.

7. 7
   Pasá a «Sin detección» con el mismo A = 10.

   Ahora el display muestra algo. Con B = 0 dice «10» (coincide por casualidad); con otros valores puede dar un número que no es la suma de dos dígitos, sin ninguna señal.

8. 8
   Probá 15 + 15 sin detección.

   La suma real es 30, pero el circuito muestra «14» sin avisar. Es el fallo silencioso: la calculadora «responde» con seguridad.

9. 9
   Buscá un caso con el display apagado sin detección.

   Por ejemplo, 15 + 6 (suma 21): Z = 0101, C = 1, K = 1 y las unidades salen 1011 (mayor de 9), así que el 4511 las apaga. Es un apagado casual y no un diseño: no avisa ni distingue de otros casos.

10. 10
    Volvé a activar la detección y barrido rápido de A.

    Con A de 0 a 9, todo bien; con A de 10 a 15, siempre ERR. Los dígitos inválidos siempre se avisan, sin excepciones.

Preguntas para pensar

1. ¿Cuánto valen Z, C y K en 6 + 4? ¿Y en 6 + 3?
2. En 8 + 8, ¿por qué K vale 1 si Z vale 0000?
3. Con A = 10 y B = 0, sin detección, el display dice «10». ¿Es una suma correcta?
4. ¿Qué diferencia práctica hay entre «apagado por el 4511» y «apagado por la detección»?

08 · La calculadora en código

Gemelo digital, tabla de corrección, barrido, retardo y consumo

Los bloques modelan el circuito etapa por etapa: dos sumadores de 4 bits y la lógica de corrección; construyen la tabla de todas las sumas de 0 a 18 con K y el +6; barren los 256 pares de entrada para contar cuántos fallan sin detección; estiman el camino crítico y la cantidad de chips; y calculan la corriente de los segmentos según la resistencia y el número mostrado.

Paso 1: el gemelo digital con dos sumadores

def sum4(a, b, cin=0):
    t = a + b + cin                                   # 74HC283: 4 bits + acarreo
    return t & 0xF, t >> 4


def calculadora(a, b):
    z, c = sum4(a, b)                                 # sumador 1: A + B
    z3, z2, z1 = (z >> 3) & 1, (z >> 2) & 1, (z >> 1) & 1
    k = c | (z3 & (z2 | z1))                          # suma >= 10: hay que corregir
    u, _ = sum4(z, 0b0110 if k else 0)                # sumador 2: Z + 6K
    return k, u


for a, b in ((3, 4), (7, 5), (9, 9), (0, 0), (8, 8)):
    k, u = calculadora(a, b)
    print(f"{a} + {b}: Z = {(a + b) & 15:04b} C = {(a + b) >> 4} -> K = {k}, unidades = {u:04b} ({u}) -> display {'' if not k else k}{u}   (esperado {a + b})")

Las cinco sumas coinciden con el resultado esperado. En 7 + 5, Z = 1100 con K = 1 produce unidades 0010 y el display «12»; en 8 + 8, Z = 0000 pero C = 1 activa K y las unidades salen 0110 («16»); en 9 + 9, Z = 0010, C = 1 y unidades 1000 («18»).

Paso 2: la tabla de corrección de 0 a 18

def sum4(a, b, cin=0):
    t = a + b + cin
    return t & 0xF, t >> 4


def correccion(valor):
    z, c = valor & 0xF, valor >> 4
    z3, z2, z1 = (z >> 3) & 1, (z >> 2) & 1, (z >> 1) & 1
    k = c | (z3 & (z2 | z1))
    u, _ = sum4(z, 0b0110 if k else 0)
    return z, c, k, u


print("suma   Z     C  K   Z+6K   unidades  display")
bien = True
for v in range(19):
    z, c, k, u = correccion(v)
    print(f"{v:4d}  {z:04b}  {c}  {k}   {z + 6 * k:5d}   {u:04b} ({u})    {10 * k + u}")
    bien = bien and (10 * k + u == v)
print()
print("todas las sumas 0..18 correctas:", bien, "| se suma 6 porque 16 - 10 = 6: el acarreo binario (16) vale 10 en decimal")

Las 19 filas salen correctas. K vale 0 de 0 a 9 y 1 de 10 a 18; de 10 a 15 el sumador no tiene acarreo pero la corrección suma 6 y desborda el nibble (el 16 de Z + 6 se descarta, quedando las unidades); de 16 a 18 el acarreo ya está y Z + 6 no desborda. La constante 6 es la diferencia 16 − 10.

Paso 3: barrido de los 256 pares, con y sin detección

def sum4(a, b, cin=0):
    t = a + b + cin
    return t & 0xF, t >> 4


def maquina(a, b, con_deteccion=True):
    z, c = sum4(a, b)
    z3, z2, z1 = (z >> 3) & 1, (z >> 2) & 1, (z >> 1) & 1
    k = c | (z3 & (z2 | z1))
    u, _ = sum4(z, 0b0110 if k else 0)
    ea = ((a >> 3) & 1) & (((a >> 2) & 1) | ((a >> 1) & 1))
    eb = ((b >> 3) & 1) & (((b >> 2) & 1) | ((b >> 1) & 1))
    err = ea | eb
    ok = 0 if (err and con_deteccion) else 1          # ~BI de los decodificadores
    unidades = u if (ok and u <= 9) else None         # el 4511 apaga 10..15
    decenas = 1 if (k and ok) else 0
    return decenas, unidades, err


validos_ok = 0
for a in range(10):
    for b in range(10):
        d, u, e = maquina(a, b)
        validos_ok += (10 * d + u == a + b and e == 0)
print(f"pares validos (0-9 + 0-9): {validos_ok} de 100 correctos")

invalidos = [(a, b) for a in range(16) for b in range(16) if a > 9 or b > 9]
print(f"pares invalidos: {len(invalidos)} de 256")
con = sum(1 for a, b in invalidos if maquina(a, b, True)[1] is None and maquina(a, b, True)[2] == 1)
print(f"  con deteccion: {con} apagan el display y encienden ERR")

sin_aviso = [(a, b) for a, b in invalidos if maquina(a, b, False)[1] is not None]
mal = [(a, b) for a, b in sin_aviso if 10 * maquina(a, b, False)[0] + maquina(a, b, False)[1] != a + b]
print(f"  sin deteccion: {len(sin_aviso)} muestran un numero sin aviso; {len(mal)} de ellos con un valor distinto de A + B")
for a, b in ((15, 15), (12, 3), (10, 0)):
    d, u, e = maquina(a, b, False)
    print(f"    {a:2d} + {b:2d} = {a + b:2d}: sin deteccion muestra {'' if not d else d}{u}")

Los 100 pares válidos dan el resultado correcto. De los 156 pares inválidos, la detección apaga el display y enciende ERR en los 156. Sin detección, 105 muestran un número sin aviso (en los otros 51 el 4511 apaga el display por casualidad) y 15 de esos muestran un valor distinto de A + B: 15 + 15 muestra «14» en lugar de 30.

Paso 4: camino crítico y cantidad de chips

TPD_NS = {"283": 30, "compuerta": 10, "4511": 40}      # orientativo, confirmar en la hoja de datos
camino = [("283 #1 (A+B)", "283"), ("OR (Z2+Z1)", "compuerta"), ("AND con Z3", "compuerta"),
          ("OR con C -> K", "compuerta"), ("283 #2 (Z+6K)", "283"), ("4511 (decodifica)", "4511")]
total = 0
print("camino critico (orientativo, 5 V):")
for nombre, tipo in camino:
    total += TPD_NS[tipo]
    print(f"  {nombre:20s} {TPD_NS[tipo]:3d} ns   acumulado {total:3d} ns")
print(f"retardo total ~ {total} ns: millones de veces menos que el tiempo que tarda un ojo en ver el cambio")
print()
chips = {"74HC283": 2, "74HC4511": 2, "74HC08": 1, "74HC32": 1, "74HC02": 1}
print("chips con deteccion de error:", sum(chips.values()), chips)
print("chips sin deteccion:", sum(chips.values()) - 1, "(sin el 74HC02; el BI de decenas es K)")
puertas = {"AND": 4, "OR": 4, "NOR": 1}
print("puertas sueltas:", sum(puertas.values()), puertas, "+ 2 sumadores de 4 bits + 2 decodificadores")

El camino crítico tiene seis etapas y suma unos 130 ns (orientativos): para un ojo humano, instantáneo. Hacen falta 7 chips con detección de errores y 6 sin ella; las puertas sueltas son 9 (4 AND, 4 OR y 1 NOR). Para otra serie de chips los tiempos cambian: medilos en la hoja de datos.

Paso 5: corriente de los segmentos

VCC, V_SEG = 5.0, 2.0
SEGMENTOS = {0: 6, 1: 2, 2: 5, 3: 5, 4: 4, 5: 5, 6: 6, 7: 3, 8: 7, 9: 6}


def i_seg_ma(r_ohm):
    return (VCC - V_SEG) / r_ohm * 1000


print("R por segmento   I por segmento   peor digito (8)   limite de 50 mA por patita Vcc del chip")
for r in (220, 330, 470, 680, 1000):
    i = i_seg_ma(r)
    peor = 7 * i
    print(f"{r:10d} ohm   {i:10.1f} mA   {peor:10.1f} mA   {'se pasa' if peor > 50 else 'ok'}")
print()
r = 680
print(f"con {r} ohm: corriente del display segun el numero mostrado (decenas + unidades)")
for suma in (0, 1, 8, 11, 18):
    d, u = divmod(suma, 10)
    segs = SEGMENTOS[u] + (SEGMENTOS[d] if d else 0)
    print(f"  {suma:2d}: {segs:2d} segmentos -> {segs * i_seg_ma(r):5.1f} mA")
peor = max(SEGMENTOS[u] + (SEGMENTOS[1] if d else 0) for s in range(19) for d, u in [divmod(s, 10)])
i_pull = 8 * VCC / 10.0                                    # ocho interruptores cerrados con pull-down de 10k
total_ma = peor * i_seg_ma(r) + i_pull
print(f"peor caso entre 0..18: {peor} segmentos = {peor * i_seg_ma(r):.1f} mA; DIP: {i_pull:.1f} mA; total ~ {total_ma:.0f} mA")
print(f"con 2000 mAh: {2000 / total_ma:.0f} h")

Con 220 Ω un «8» pediría 95 mA (más de los 50 mA por patita de alimentación); con 680 Ω, 31 mA. Según el número mostrado la corriente va de 8,8 mA (el «1») a 39,7 mA (el «18»). Sumando 4 mA de los interruptores, el peor caso es de unos 44 mA: 46 horas con 2000 mAh.

09 · Analogía de programador

Pipeline, normalización y validación de entrada

1. 1
   La representación importa.

   El mismo número, doce, es 1100 en binario y 0001 0010 en BCD. Convertir entre representaciones es donde viven los bugs; acá se hace con una suma y una condición.

2. 2
   Validar en el borde.

   Un sistema serio no asume que la entrada cumple el contrato: lo comprueba. Cuesta cinco puertas y evita el peor tipo de falla, la que parece funcionar.

3. 3
   Probar los casos borde primero.

   Los errores viven en los bordes: 9 → 10, 15 → 16, 18. Una tabla de siete casos bien elegidos detecta más que cien sumas al azar.

Una diferencia con el software: en hardware, «agregar una excepción» no existe. Si un caso no está cubierto por una compuerta, el circuito hace algo igual. Cubrir los casos que no deberían ocurrir es parte del diseño, no un lujo.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de cálculo

Ejercicio 1: 7 + 8 a mano

Calculá Z, C, K, la segunda suma, las unidades y lo que muestra el display. Verificalo con el Paso 1.

Ejercicio 2: la condición de K

¿Por qué K = C + Z3·(Z2 + Z1) y no simplemente Z3 + C? ¿Qué casos distingue?

Ejercicio 3: dos décadas

Extendé la calculadora a números de dos cifras (0 a 99). ¿Qué hay que duplicar y cómo se conectan las décadas?

Ejercicio 4: contar los fallos silenciosos

Sin la detección, ¿cuántos pares de operandos producen un display encendido? ¿En cuántos el valor mostrado es distinto de A + B? Citá un ejemplo.

Ejercicio 5: presupuesto del display

Con 680 Ω el peor caso es de 44 mA. Si el proyecto fuera a pilas, ¿qué cambiarías para estirar la autonomía y cuánto ganarías?

Ejercicio 6: congelar la lectura

Querés que, al soltar un pulsador «HOLD», el display retenga el resultado aunque se muevan los interruptores. ¿Qué pin del 4511 lo permite?

12 · Síntesis

Ideas para recordar

¿Listo para el cierre?

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

• Explicar por qué se suma 6 y cuándo, con un ejemplo numérico.
• Escribir K y justificar cada término de su ecuación.
• Dibujar los bloques y decir qué recibe cada entrada del segundo sumador.
• Describir qué pasa con un operando inválido con y sin detección, y por qué lo segundo es peor.
• Dimensionar la resistencia de un segmento y calcular el consumo del peor número.
• Elegir los casos borde para probar el circuito armado.

Con la cerradura y la calculadora andando, el curso está completo. En el último tema hacemos el balance de todo lo recorrido: cierre y puente al curso 6, donde aparece lo que a este circuito le falta, la memoria.