Semisumador y sumador

Tablas de verdad y funciones lógicas para sumar bits: primero con entradas A y B, después con dos números de 2 bits AB y CD.

Entrega en tu sitio

Crea en EMP la carpeta 4_semisumador_y_sumador con un index.html (tablas, explicación y código). Ahí dentro puedes meter también el .ino.

1 · Semisumador (entradas A y B)

El semisumador suma dos bits y genera suma S y acarreo C. No tiene entrada de acarreo previo.

A, B — bits a sumar.
S — bit de suma (A XOR B).
C — acarreo de salida (A AND B).

Funciones:

S = A ⊕ B = A·B̄ + Ā·B C = A · B

Dec	A	B	Ssuma	Cacarreo

Pulsa las celdas de S y C para rellenar en clase. Solución: S = A⊕B · C = A·B.

2 · Sumador completo (A, B y Cin)

El sumador completo suma tres bits: A, B y el acarreo de entrada Cin (aquí usamos la entrada C del Arduino como Cin). Genera suma S y acarreo de salida Cout.

A, B — bits a sumar.
C (Cin) — acarreo de una etapa anterior.
S — bit de suma.
Cout — acarreo hacia la etapa siguiente.

Funciones:

S = A ⊕ B ⊕ Cin Cout = A·B + A·Cin + B·Cin

Equivalente: un sumador completo = dos semisumadores + una OR del acarreo.

Dec	A	B	Cinentrada C	Ssuma	Coutacarreo

8 filas (A B Cin). La entrada D del Arduino no se usa en este apartado.

3 · Sumador de 2 bits (AB + CD)

Ahora A y B forman el primer número de 2 bits y C y D el segundo:

X = AB — A bit de más peso, B bit de menos peso → valor decimal 0…3.
Y = CD — C bit de más peso, D bit de menos peso → valor decimal 0…3.
Resultado X + Y → 0…6, hace falta 3 bits: Cout · S1 · S0.

Estructura (como dos etapas de sumador):

LSB: semisumador de B y D → S0 y acarreo interno.
MSB: sumador completo de A, C y el acarreo interno → S1 y Cout.

Funciones por bit:

S0 = B ⊕ D C0 = B · D S1 = A ⊕ C ⊕ C0 Cout = A·C + A·C0 + C·C0

Dec	AX₁	BX₀	CY₁	DY₀	XAB	YCD	X+Y	Cout	S1	S0

16 filas. X = 2A+B · Y = 2C+D · resultado en Cout·S1·S0 (binario).

4 · Programa Arduino

Cableado como en puertasLogicas: entradas I[] = {28, 26, 24, 22} → A, B, C, D.

LED 13 / 12 — Semisumador A,B → S y C.
LED 11 / 10 — Sumador completo A,B,Cin(C) → S y Cout.
LED 9 / 8 / 7 — Sumador AB+CD → Cout, S1, S0.

Las tres funciones se calculan a la vez; los LEDs no se pisan entre sí.

const int O[] = { 13, 12, 11, 10, 9, 8, 7, 6, 5 };
const int nO = 9;
const int I[] = { 28, 26, 24, 22 };
const int nI = 4;
bool A, B, C, D;

bool S_semi, C_semi;           // semisumador A,B
bool S_sum, Cout_sum;          // sumador completo A,B,C
bool S0, S1, Cout2, C0;        // sumador 2 bits AB+CD

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < nO; i++) pinMode(O[i], OUTPUT);
  for (int i = 0; i < nI; i++) pinMode(I[i], INPUT);
}

void loop() {
  A = digitalRead(I[0]);  // 28
  B = digitalRead(I[1]);  // 26
  C = digitalRead(I[2]);  // 24 · Cin / MSB de Y
  D = digitalRead(I[3]);  // 22 · LSB de Y

  // Semisumador A + B  → LED 13 (S), LED 12 (C)
  S_semi = A * !B + !A * B;
  C_semi = A * B;
  digitalWrite(O[0], S_semi);
  digitalWrite(O[1], C_semi);

  // Sumador completo A + B + Cin(C)  → LED 11 (S), LED 10 (Cout)
  S_sum = A * !B * !C + !A * B * !C + !A * !B * C + A * B * C;
  Cout_sum = A * B + A * C + B * C;
  digitalWrite(O[2], S_sum);
  digitalWrite(O[3], Cout_sum);

  // Sumador 2 bits X=AB + Y=CD  → LED 9 (Cout), 8 (S1), 7 (S0)
  S0 = B * !D + !B * D;
  C0 = B * D;
  S1 = A * !C * !C0 + !A * C * !C0 + !A * !C * C0 + A * C * C0;
  Cout2 = A * C + A * C0 + C * C0;
  digitalWrite(O[4], Cout2);
  digitalWrite(O[5], S1);
  digitalWrite(O[6], S0);

  mostrarMonitor();
}

void mostrarMonitor() {
  Serial.print("ABCD=");
  Serial.print(A); Serial.print(B); Serial.print(C); Serial.print(D);
  Serial.print(" | semi S="); Serial.print(S_semi);
  Serial.print(" C="); Serial.print(C_semi);
  Serial.print(" | full S="); Serial.print(S_sum);
  Serial.print(" Cout="); Serial.print(Cout_sum);
  Serial.print(" | 2b ");
  Serial.print(Cout2); Serial.print(S1); Serial.println(S0);
}