path: root/src/logiteca.gmo

# logiteca

compendio de circuitos lógicos que pueden implementarse en las {danzas compuertas}.

material de referencia para las {compudanzas}

# acerca de

este es un compendio de circuitos lógicos que pueden implementarse en las {danzas compuertas}.

están descritos en *verilog*, un lenguaje descriptor de hardware. esto con la idea de estandarizarlos, de facilitar simularlos e implementarlos en otros materiales, y de indicar su cualidad de *red abstracta*.

utilizamos el lenguaje a nivel de {compuertas} lógicas solamente: cada compuerta se expresa como una función (`and()`, `not()`, `or()`, `nor()`, `nand()`, etc) donde el primer argumento es el nombre de la *salida* de la compuerta, y el o los otros argumentos son los nombres de las *entradas*.

el número de participantes asignado por circuito está contado como el *número de entradas* más el *número de compuertas*, donde alguna(s) de ella(s) incluyen las compuertas cuyas salidas son también la(s) del circuito. si se tienen más participantes, se pueden agregar el *número de salidas*: persona(s) que copien el resultado de la compuerta correspondiente.

# multiplicador de 1 bit

circuito que multiplica a dos números de 1 bit y da el resultado en 1 bit.

## multiplicador de 1 bit con compuertas habituales (3 o 4 participantes)

```
// multiplicador construido con compuertas habituales
// entradas (2): a,b
// salidas (1): r (resultado)
// compuertas (1): 1 de 2 entradas

module multiplicador( a, b, r);

input wire a, b;
output wire r;

and C1(r, a, b);

endmodule
```

## multiplicador de 1 bit con nor (5 o 6 participantes)

```
// multiplicador construido con nor's
// entradas (2): a,b
// salidas (1): r (resultado)
// compuertas (3): 2 de 1 y 1 de 2 entradas

module multiplicador( a, b, r);

input wire a, b;
output wire r;
wire p1,p2;

// negadas
nor C1(p1, a);
nor C2(p2, b);

// resultado
nor C3(r, p1, p2);

endmodule
```

# contadores

circuitos que incrementan 1 al número binario colocado en la entrada, con el mismo número de bits a la entrada que a la salida.

si la salida se "conecta" a la entrada, entonces con cada paso se obtiene el
número siguiente en la secuencia, es decir se "cuenta".

al llegar al último número, se regresa a 0.

## contador de 2 bits con compuertas habituales (4 o 6 participantes)

```
// contador de 2 bits con compuertas habituales
// entradas (2): a, b
// salidas (2):  x, y
// compuertas (2): 1 de 1 y 1 de 2 entradas

module contador(a, b, x, y);

input wire a,b; 
output wire x,y;

not C1(y, b);
xor C2(x, a,b);

endmodule
```

## contador de 2 bits con nor (7 o 9 participantes)

```
// contador de 2 bits con nor 
// entradas (2): a, b
// salidas (2):  x, y
// compuertas (5): 2 de 1 y 3 de 2 entradas

module contador(a, b, x, y);

input wire a,b; 
output wire x,y;
wire p1, p2, p3;

// negaciones
nor C1(y, b);
nor C2(p1, a);

// para x
nor C3(p2, a,b);
nor C4(p3, y,p1);
nor C5(x, p2,p3);

endmodule
```


## contador de 3 bits con nor (13 o 16 participantes)

```
// contador de 3 bits con compuertas habituales
// entradas (3): a, b, c
// salidas (3):  x, y, z
// compuertas (10): 3 de 1, 4 de 2, 3 de 3 entradas

module contador(a, b, c,  x, y, z);

input wire a,b,c; 
output wire x,y,z;
wire p1, p2, p3, p4, p5, p6, p7;

// negaciones
nor C1(p1, a);
nor C2(p2, b);
nor C3(z, c);

// para y
nor C4(p3, b,c);
nor C5(p4, p2,z);
nor C6(y, p3,p4);

// para x
nor C7(p5, a,b);
nor C8(p6, p1, p2, z);
nor C9(p7, a, p2, c);
nor C10(x, p5, p6, p7);

endmodule
```


# half adder

circuito que suma dos bits y da el resultado en dos bits (resultado y *carry*)

## half adder con compuertas habituales (4 o 6 participantes)

```
// half adder construido con compuertas habituales
// entradas (2): a,b
// salidas (2): r, c (resultado, carry)
// compuertas (2): 2 de 2 entradas

module halfadder( a, b, r, c);

input wire a, b;
output wire r,c;

// carry
and C1(c, a, b);

// resultado
xor C2(r, a, b);

endmodule
```

## half adder usando nor (7 o 9 participantes)

```
// half adder construido usando nor's
// entradas (2): a,b
// salidas (2): r, c (resultado, carry)
// compuertas (5): 2 de 1 y 3 de 2 entradas

module halfadder( a, b, r, c);

input wire a, b;
output wire r,c;
wire p1,p2,p3;

// negadas
nor C1(p1, a);
nor C2(p2, b);

// carry
nor C3(c, p1, p2);

// resultado
nor C4(p3, a, b);
nor C5(r, c, p3);

endmodule
```


# full adder

circuito que suma tres bits y da el resultado en dos bits (resultado y *carry*).

## full adder con compuertas habituales (14 o 16 participantes)

```
// full adder construido con compuertas habituales
// entradas (3): a, b, c
// salidas (2): carry, r (resultado)
// compuertas (11): 2 de 1 y 9 de 2 entradas

module fulladder( a, b, c, r, carry);

input wire a, b, c;
output wire r, carry;
wire p1, p2, p3, p4, p5, p6, p7, p8, p9;

// negadas
not C1(p1, a);
not C2(p3, p2);

// diferencias b,c
xor C3(p2, b, c);
or C4(p4, b, c);
and C5(p5, b, c);

// armado de resultado
and C6(p6,  p1, p2);
and C7(p7,  a, p3);
or C8(r, 	 p6, p7);

// armado de carry
and C9(p8,  p1, p5);
and C10(p9,  a, p4);
or C11(carry,   p8, p9);

endmodule
```

## full adder usando nor (15 o 17 participantes)

```
// full adder construido usando nor's
// entradas (3): a, b, c
// salidas (2): carry, r (resultado)
// compuertas (12): 3 de 1, 3 de 2, 4 de 3 y 1 de 4 entradas

module fulladder( a, b, c, r, carry);

input wire a, b, c;
output wire r, carry;
wire p1, p2, p3, p4, p5, p6, p7, p8, p9, p10;

// negadas
nor C1(p1, a); 
nor C2(p2, b);
nor C3(p3, c);

// pa'l carry
nor C4(p4, a, b);
nor C5(p5, a, c);
nor C6(p6, b, c);

// pa resultado
nor C7(p7, a, b , c);
nor C8(p8, p1, b, p3);
nor C9(p9, a, p2, p3);
nor C10(p10, p1, p2, c);

// salidas
nor C11(carry, p4, p5, p6);
nor C12(r, p7, p8, p9, p10);

endmodule
```



## llegan aquí
=> ./danzas_compuertas.gmi {danzas compuertas}
=> ./coloring_computers.gmi {coloring computers}