acomodando sitio

1 files changed, 284 insertions, 0 deletions

diff --git a/src/logiteca.gmo b/src/logiteca.gmo
new file mode 100644
index 0000000..70f9f08
--- /dev/null
+++ b/src/logiteca.gmo
@@ -0,0 +1,284 @@
+# 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
+```
+
+enlaza aquí {compudanzas}