página de compuertas lógicas

6 files changed, 110 insertions, 4 deletions

diff --git a/src/actualizaciones.gmo b/src/actualizaciones.gmo
index 5975056..036a1dd 100644
--- a/src/actualizaciones.gmo
+++ b/src/actualizaciones.gmo
@@ -12,6 +12,7 @@ varias páginas nuevas:
 
 => ./apuntes.gmi {apuntes}
 => ./ciclo_de_memoria.gmi {ciclo de memoria}
+=> ./compuertas.gmi {compuertas}
 => ./danzas_compuertas.gmi {danzas compuertas}
 => ./non_e-computers.gmi {non e-computers}
 => ./terranova.gmi {terranova}
diff --git a/src/actualizaciones.xml b/src/actualizaciones.xml
index 5a77ffe..e0f25fc 100644
--- a/src/actualizaciones.xml
+++ b/src/actualizaciones.xml
@@ -15,7 +15,7 @@
 <updated>2021-05-21T12:00:00Z</updated>
 <link href='https://quesomango.neocities.org/actualizaciones.html#sjm-660d2' rel='alternate'/>
 <summary>
-	varias páginas nuevas: apuntes, ciclo de memoria, danzas compuertas, non e-computers, terranova, textos, the rite of computing
+	varias páginas nuevas: apuntes, ciclo de memoria, compuertas, danzas compuertas, non e-computers, terranova, textos, the rite of computing
 </summary>
 </entry>
 
diff --git a/src/compuertas.gmo b/src/compuertas.gmo
new file mode 100644
index 0000000..d18e778
--- /dev/null
+++ b/src/compuertas.gmo
@@ -0,0 +1,101 @@
+# compuertas lógicas
+
+las bases de los circuitos digitales.
+
+estos incluyen, claro está, a las {danzas compuertas}
+
+usamos la convención de utilizar dos valores posibles: 1 para denominar arriba, o verdadero, y 0 para denominar abajo, o falso.
+
+
+# una entrada
+
+## buffer
+
+la salida es igual a la entrada
+
+## NOT
+
+la salida es lo opuesto a la entrada. 
+
+también podríamos decir que la salida es lo que no es la entrada.
+
+
+# dos entradas
+
+con dos entradas binarias, hay cuatro posibles combinaciones.
+
+## AND
+
+la salida es verdadera únicamente cuando todas sus entradas son verdaderas.
+
+en cualquier otro caso, la salida es falsa.
+
+
+## OR
+
+la salida es verdadera cuando aunque sea una de sus entradas sea verdadera.
+
+únicamente cuando todas las entradas son falsas, su salida es falsa.
+
+
+## XOR
+
+la salida es verdadera cuando una y solo una de sus entradas sea verdadera.
+
+en cualquier otro caso, la salida es falsa.
+
+también la podemos describir así: la salida es verdadera cuando las entradas son diferentes, y es falsa cuando las entradas son iguales.
+
+
+## NOR 
+
+la salida es verdadera cuando ninguna de sus entradas es verdadera. 
+
+que es lo mismo que decir que su salida es verdadera cuando todas sus entradas son falsas.
+
+en cualquier otro caso, su salida es falsa.
+
+NOR es una de las compuertas universales: con ella se puede construir a todas las demás.
+
+esto se debe en parte a que NOR se convierte en NOT si sus dos entradas están conectadas como una sola.
+
+por otro lado, NOR es equivalente a negar con NOT la salida de una compuerta OR.
+
+por cómo funciona, también la podemos considerar como un AND que funciona con 0 en vez de con 1.
+
+
+## NAND
+
+la salida es verdadera cuando aunque sea una de sus entrada es falsa. 
+
+únicamente cuando todas sus entradas son verdaderas, su salida es falsa.
+
+NAND es la otra compuerta universal. esto se debe en parte a que se convierte en NOT si sus dos entradas están conectadas como una sola.
+
+por otro lado, NAND es equivalente a negar con NOT la salida de una compuerta AND.
+
+por cómo funciona, también la podemos considerar como un OR que funciona con 0 en vez de con 1.
+
+
+# más entradas
+
+todas las compuertas funcionan igual para más de dos entradas, excepto XOR.
+
+importante: AND y OR poseen la propiedad distributiva. 
+
+por ejemplo, un AND de tres entradas (a, b, c) es equivalente a un AND de dos entradas (a, b), con su salida (x) conectada a la entrada de otro AND de dos entradas (x, c)
+
+esto no sucede así ni en NOR ni en NAND. en su caso, hay que agregar un NOT entre las dos compuertas.
+
+
+# demorgan
+
+una compuerta AND es equivalente a una compuerta NOR con sus entradas negadas.
+
+una compuerta OR es equivalente a una compuerta NAND con sus entradas negadas.
+
+
+
+## llega(n) aquí
+=> ./danzas_compuertas.gmo {danzas compuertas}
+=> ./logiteca.gmi {logiteca}
diff --git a/src/danzas_compuertas.gmo b/src/danzas_compuertas.gmo
index 6e65a1d..0ffa062 100644
--- a/src/danzas_compuertas.gmo
+++ b/src/danzas_compuertas.gmo
@@ -8,12 +8,14 @@ tareas sencillas y divertidas (requeridas de atención y presencia) que combinad
 
 o se está de pie o se está en descanso.
 
-a cada quien se le asigna un rol (versión nor) 
+a cada quien se le asigna un rol:
 
 * simplemente decidir en qué posición colocarse
 * colocarse siempre en oposición a tal persona
 * o ponerse de pie solo cuando ni tal persona ni cual persona están de pie.
 
+(o alguna otra de las {compuertas} lógicas)
+
 la complejidad surge de quién ve a quién, quién depende de quién.
 
 cinco personas para multiplicar dos dígitos binarios... nada mal.
@@ -33,4 +35,5 @@ el resultado del full-adder está conectado a otro ciclo de memoria. todos los c
 
 ## llega(n) aquí
 => ./compudanzas.gmi {compudanzas}
+=> ./compuertas.gmi {compuertas}
 => ./logiteca.gmi {logiteca}
diff --git a/src/indice.gmo b/src/indice.gmo
index bb1bf6c..aa21967 100644
--- a/src/indice.gmo
+++ b/src/indice.gmo
@@ -7,6 +7,7 @@
 => ./ciclo_de_memoria.gmi {ciclo de memoria}
 => ./coloring_computers.gmi {coloring computers}
 => ./compudanzas.gmi {compudanzas}
+=> ./compuertas.gmi {compuertas}
 => ./danzas_compuertas.gmi {danzas compuertas}
 => ./danzasistemas-tag.gmi {danzasistemas-tag}
 => ./darena.gmi {darena}
diff --git a/src/logiteca.gmo b/src/logiteca.gmo
index 21b6b35..728359d 100644
--- a/src/logiteca.gmo
+++ b/src/logiteca.gmo
@@ -6,11 +6,11 @@ material de referencia para las {compudanzas}
 
 # acerca de
 
-este es un compendio de circuitos lógicos que pueden implementarse en las "danzas compuertas".
+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*.
+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.