De las puertas lógicas al sumador

Las computadoras no «saben sumar»: solo apilan bloques de puertas lógicas capa por capa. En esta lección construiremos con nuestras propias manos un circuito capaz de sumar usando puertas XOR, AND y OR, desde el semisumador hasta el sumador completo y luego hasta el sumador de 4 bits, nivel por nivel.


La suma en la vida cotidiana: la lección de la suma en columna

Recuerda el proceso de sumar en papel. Calcula37 + 58:

Primero suma las unidades:7 + 8 = 15, escribe5,acarreo 1。

Luego suma las decenas:3 + 5 + acarreo 1 = 9, escribe9, el resultado es95。

Este proceso revela tres puntos clave:

1. Cálculo dígito a dígito: cada dígito solo se preocupa por sus dos sumandos y por el acarreo proveniente del dígito inferior.

2. Propagación del acarreo: el dígito inferior puede generar un acarreo al terminar de sumar, y ese acarreo debe transmitirse al dígito superior.

3. El dígito menos significativo es especial: el dígito menos significativo no tiene acarreo de entrada de un dígito inferior; solo necesita procesar los dos sumandos.

La computadora también sigue esta idea: divide un gran problema (suma de varios bits) en muchos problemas pequeños (suma de 1 bit) y los resuelve uno a uno.

Semisumador: la suma de 1 bit del bit menos significativo

El bit menos significativo no tiene entrada de acarreo; solo necesita sumar dos números binarios de 1 bit. El circuito que puede manejar esta situación se llamaSemisumador (Half Adder)。

El semisumador tiene dos entradas A y B, y dos salidas:Bit de suma (Sum)yAcarreo (Carry)。

Tabla de verdad del semisumador:

ABSum (suma)Carry (acarreo)
0000
0110
1010
1101

Observando la tabla de verdad, aparece una asombrosa coincidencia:

Sum = A XOR BCuando A y B son diferentes, Sum=1; cuando son iguales, Sum=0 — esta es exactamente la tabla de verdad de la puerta XOR.

Carry = A AND BSolo cuando ambas entradas son 1 se genera acarreo — esta es exactamente la tabla de verdad de la puerta AND.

El semisumador solo necesita1 puerta XOR + 1 puerta ANDpara implementarse. El propio George Boole seguramente nunca imaginó que el sistema algebraico que inventó se convertiría un día en la base matemática del sumador.

Sumador completo: la suma completa que maneja el acarreo

El semisumador tiene un defecto fatal:no puede recibir el acarreo proveniente del bit inferiorExcepto el bit menos significativo, cada bit debe manejar tres números: A, B y el acarreo de entrada Cin proveniente del bit inferior.

El circuito que puede procesar al mismo tiempo dos sumandos y una entrada de acarreo se llamaSumador completo (Full Adder)。

Tabla de verdad del sumador completo:

ABCinSumCout
00000
00110
01010
01101
10010
10101
11001
11111

Un diseño ingenioso:con dos semisumadores se puede construir un sumador completo。

Primer paso: el semisumador 1 procesa A y B, obteniendo la suma intermedia S1 y el acarreo C1.

Segundo paso: el semisumador 2 procesa S1 y Cin, obteniendo la suma final Sum y el acarreo C2.

Tercer paso: acarreo finalCout = C1 OR C2(si cualquiera de los semisumadores genera acarreo, la salida final es acarreo).

Estructura del circuito del sumador completo:2 semisumadores + 1 puerta OR.Apilando capas, cada semisumador internamente es XOR + AND. Esta idea de construcción jerárquica recorre toda la arquitectura de las computadoras.

Sumadores completos en cascada: sumador de acarreo ondulante de 4 bits

Con el sumador completo, la suma de múltiples bits es simple:conectar varios sumadores completos en serie, conectando la salida de acarreo del bit inferior con la entrada de acarreo del bit superior.。

Una estructura en cascada de un sumador de 4 bits:

Bit 0 (el menos significativo): el sumador completo procesa A0 y B0, con acarreo de entrada = 0, y produce la suma S0 y el acarreo C0.

Bit 1: el sumador completo procesa A1 y B1, con acarreo de entrada = C0, y produce la suma S1 y el acarreo C1.

Bit 2: el sumador completo procesa A2 y B2, con acarreo de entrada = C1, y produce la suma S2 y el acarreo C2.

Bit 3 (el más significativo): el sumador completo procesa A3 y B3, con acarreo de entrada = C2, y produce la suma S3 y el acarreo C3 (acarreo final).

El acarreo, como una onda, se propaga nivel a nivel desde el bit inferior hasta el bit superior; por lo tanto, esta estructura se llamaSumador de acarreo ondulante (Ripple Carry Adder)。

El sumador de acarreo ondulante es simple e intuitivo, pero tiene un cuello de botella de rendimiento: en el peor caso, el acarreo debe propagarse desde el bit 0 hasta el bit más alto, atravesando la latencia de N sumadores completos. Las CPU modernas utilizan técnicas como el acarreo anticipado (Carry Lookahead) para optimizarlo, pero comprender el acarreo ondulante es el prerrequisito para entender todas las optimizaciones de sumadores.

Demostración de código Python

Ejemplo

# ============================================
# Lección 8: De las puertas lógicas al sumador - Demostración en Python
# Serie de tutoriales de ejemplo
# ============================================

def half_adder(a, b):
    """
Semisumador: suma dos números binarios de 1 bit sin considerar la entrada de acarreo.

Parámetros:
a, b: cada uno vale 0 o 1

Retorna:
(sum_bit, carry_out): bit de suma y acarreo de salida

Implementación circuital:
sum_bit = a XOR b (puerta XOR)
carry_out = a AND b (puerta AND)
    """

    sum_bit = a ^ b      # XOR: iguales da 0, diferentes da 1
    carry_out = a & b    # AND: solo hay acarreo cuando ambos son 1
    return sum_bit, carry_out


def full_adder(a, b, carry_in):
    """
Sumador completo: suma dos números binarios de 1 bit considerando la entrada de acarreo.

Parámetros:
a, b, carry_in: cada uno vale 0 o 1

Retorna:
(sum_bit, carry_out): bit de suma y acarreo de salida

Truco de implementación: usar dos semisumadores en cascada:
Primer paso: half_adder(a, b) → (s1, c1)
Segundo paso: half_adder(s1, carry_in) → (sum_bit, c2)
Acarreo final: carry_out = c1 OR c2
    """

    s1, c1 = half_adder(a, b)
    sum_bit, c2 = half_adder(s1, carry_in)
    carry_out = c1 | c2   # Puerta OR: si cualquiera genera acarreo, al final hay acarreo
    return sum_bit, carry_out


def adder_4bit(a_bits, b_bits):
    """
Sumador de acarreo ondulante de 4 bits: 4 sumadores completos en cascada.

Parámetros:
a_bits: lista binaria de 4 bits, a_bits
b_bits: lista binaria de 4 bits, b_bits

Retorna:
(sum_bits, final_carry): suma de 4 bits (bit menos significativo primero) y acarreo final

Imprime el proceso completo de propagación del acarreo, mostrando cómo funciona el acarreo ondulante.
    """

    carry_in = 0
    sum_bits = []

    print("=" * 55)
    print(" Sumador de acarreo ondulante de 4 bits —— proceso de propagación de acarreo")
    print("=" * 55)
    # Mostrar con el bit más significativo primero, para facilitar la lectura
    print(f" Sumando A: {list(reversed(a_bits))} (bit más significativo primero)")
    print(f" Sumando B: {list(reversed(b_bits))} (bit más significativo primero)")
    print()

    for i in range(4):
        s, carry_out = full_adder(a_bits[i], b_bits[i], carry_in)
        sum_bits.append(s)

        print(f" [bit {i}] (el bit menos significativo es el bit 0)")
        print(f" Entrada: A[{i}]={a_bits[i]}, B[{i}]={b_bits[i]}, acarreo de entrada={carry_in}")
        print(f" Salida: bit de suma={s}, acarreo de salida={carry_out}")

        if carry_out:
            print(f" >> ¡Se ha generado acarreo! Carry={carry_out} se transmitirá al bit {i+1}")

        carry_in = carry_out  # El acarreo actual se convierte en el acarreo de entrada del siguiente bit
        print()

    print(f" Resultado del cálculo: {list(reversed(sum_bits))} (bit más significativo primero)")
    print(f" Acarreo final: {carry_in}")
    print("=" * 55)

    return sum_bits, carry_in


def decimal_to_4bit(n):
    """Convierte un número decimal de 0 a 15 en una lista binaria de 4 bits (bit menos significativo primero)"""
    return [(n >> i) & 1 for i in range(4)]


def bits_to_decimal(bits):
    """Convierte una lista de bits binarios (bit menos significativo primero) en un entero decimal"""
    return sum(bit * (2 ** i) for i, bit in enumerate(bits))


# ============================================
# Casos de prueba
# ============================================

print(">>> Prueba del semisumador de ejemplo <<<")
for a in (0, 1):
    for b in (0, 1):
        s, c = half_adder(a, b)
        print(f"  half_adder({a}, {b}) => sum={s}, carry={c}")
print()

print(">>> Prueba del sumador completo de ejemplo <<<")
test_cases = [
    (0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1),
    (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)
]
for a, b, cin in test_cases:
    s, c = full_adder(a, b, cin)
    print(f"  full_adder({a}, {b}, carry_in={cin}) => sum={s}, carry={c}")
print()

print(">>> Prueba del sumador de 4 bits de ejemplo: 7 + 5 <<<")
a_dec, b_dec = 7, 5
a_bits = decimal_to_4bit(a_dec)
b_bits = decimal_to_4bit(b_dec)
result_bits, final_carry = adder_4bit(a_bits, b_bits)
result_dec = bits_to_decimal(result_bits)
print(f" Esperado: {a_dec} + {b_dec} = {a_dec + b_dec}")
print(f" Resultado: {result_dec} (acarreo={final_carry})")
print(f" Verificación ejemplo: {'¡Aprobado!' if result_dec == a_dec + b_dec else '¡Fallido!'}")
print()

print(">>> Prueba adicional de ejemplo: 10 + 6 (posible desbordamiento) <<<")
a_bits2 = decimal_to_4bit(10)
b_bits2 = decimal_to_4bit(6)
result_bits2, carry2 = adder_4bit(a_bits2, b_bits2)
result_dec2 = bits_to_decimal(result_bits2)
full_result = result_dec2 + (carry2 * 16)
print(f" Esperado: 10 + 6 = 16")
print(f" Resultado de 4 bits: {result_dec2}, acarreo: {carry2}, valor completo de 5 bits: {full_result}")
print(f" Verificación ejemplo: {'¡Aprobado!' if full_result == 16 else '¡Fallido!'}")

Ejecuta el código y observa cómo se propaga el acarreo entre cada bit: primero se calcula el bit menos significativo; una vez generado el acarreo, se transmite al siguiente bit; el siguiente bit se calcula y, al generar su acarreo, lo transmite hacia adelante. De ahí proviene el nombre de «acarreo ondulante» (ripple carry).


Demostración interactiva: animación del sumador de 4 bits en cascada (demostración de propagación de acarreo de ejemplo)

A continuación se simula un sumador de acarreo ondulante (ripple carry) de 4 bits utilizando únicamente div+SVG.Haz clic en el botón para demostrar paso a paso cómo el acarreo se transmite desde el bit 0 (el menos significativo) hasta el bit 3 (el más significativo), o también puedes usar «Demostración automática» para ver el proceso completo.

Sumador de acarreo ondulante de 4 bits — animación de propagación de acarreo

Entrada A (bit más significativo primero)
Sumando A (bit más significativo primero)
Sumando B (bit más significativo primero)
4 sumadores completos en cascada (ordenados de mayor a menor: FA3 ← FA2 ← FA1 ← FA0)
Sumador completo #3 (bit más significativo)
A=0 B=0
Acarreo de entrada Cin=0
Suma Sum=?
Acarreo de salida Cout=?
←
Sumador completo #2
A=0 B=0
Acarreo de entrada Cin=0
Suma Sum=?
Acarreo de salida Cout=?
←
Sumador completo #1
A=0 B=0
Acarreo de entrada Cin=0
Suma Sum=?
Acarreo de salida Cout=?
←
Sumador completo #0 (bit menos significativo)
A=0 B=0
Acarreo de entrada Cin=0
Suma Sum=?
Acarreo de salida Cout=?
Botones de control
Resultado del cálculo: -
Haz clic en «Siguiente paso» para comenzar la demostración de la propagación del acarreo
Otras extensiones