283 lines
5.6 KiB
Plaintext
283 lines
5.6 KiB
Plaintext
|
# logiteca
|
||
|
|
||
|
compendio de circuitos lógicos que pueden implementarse en las {danzas compuertas}.
|
||
|
|
||
|
material de referencia para las {las danzas}
|
||
|
|
||
|
# 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
|
||
|
```
|