La compuerta AND es también conocida como “todo o nada”. En el Álgebra de Boole se representa por una multiplicación, por lo tanto para tener la salida en estado activo es necesario que sus entradas tengan un estado binario 1, al tener una entrada inactiva “0” su salida será 0.

Código:

CHIP And {

IN a, b;

OUT out;

PARTS:

Nand (a=a, b=b, out=nand1);

Nand (a=nand1, b=nand1, out=out);

}

El valor de salida de una compuerta NOT será 1 cuando su valor entrada sea 0 y será 0 cuando su valor de entrada sea 1. La siguiente figura interactiva muestra un diagrama de una compuerta NOT con su correspondiente tabla de verdad.

Código:

CHIP Not {

IN in;

OUT out;

PARTS:

Nand (a=in, b=in, out=out);

}

Esta compuerta permite que con cualquiera de sus entradas que este en estado binario 1, su salida pasara a un estado 1 también. No es necesario que todas sus entradas estén accionadas para conseguir un estado 1 a la salida pero tampoco causa algún inconveniente.

Código:

CHIP Or {

IN a, b;

OUT out;

PARTS:

Nand(a=a, b=a, out=nand1);

Nand(a=b, b=b, out=nand2);

Nand(a=nand1, b=nand2, out=out);

}

La puerta XOR, compuerta XOR u OR exclusiva es una puerta lógica digital que implementa el o exclusivo; es decir, una salida verdadera (1/HIGH) resulta si una, y solo una de las entradas a la puerta es verdadera. Si ambas entradas son falsas (0/LOW) o ambas son verdaderas, resulta en una salida falsa.

Código:

CHIP Xor {

IN a, b;

OUT out;

PARTS:

Nand(a=a, b=b, out=nand1);

Nand(a=a, b=nand1, out=nand2);

Nand(a=nand1, b=b, out=nand3);

Nand(a=nand2, b=nand3, out=out);

}

Un multiplexor ("Mux") tiene dos entradas de "datos" y una entrada de "selector". Si la entrada del selector es 0, el chip devuelve lo que obtiene de la primera entrada de datos, y si el selector es 1, el chip devuelve lo que obtiene de la segunda entrada de datos. Esta es una herramienta fundamental que le permite a la computadora "elegir" cuál de los dos posibles valores debe usar.

CHIP Mux {

IN a, b, sel;

OUT out;

PARTS:

// Put your code here:

Not (in=sel, out=notsel);

And (a=a, b=notsel, out=anda);

And (a=b, b=sel, out=andb);

Or (a=anda, b=andb, out=out);

}

Los DEMULTIPLEXORES realizan la función inversa a la del multiplexor, es decir, una señal de entrada única, es obtenida en uno de los N canales de salida. El conmutador ahora selecciona el canal de salida por donde estará presente el dato de entrada.

Código:

CHIP DMux {

IN in, sel;

OUT a, b;

PARTS:

Nand(a=sel, b=sel, out=nand1);

Nand(a=in, b=nand1, out=nand2);

Nand(a=sel, b=in, out=nand3);

Nand(a=nand2, b=nand2, out=a);

Nand(a=nand3, b=nand3, out=b);

}

Es un NOT que se repite o se implementa 16 veces.

Código:

CHIP Not16 {

IN in[16];

OUT out[16];

PARTS:

Not(in=in[0],out=out[0]);

Not(in=in[1],out=out[1]);

Not(in=in[2],out=out[2]);

Not(in=in[3],out=out[3]);

Not(in=in[4],out=out[4]);

Not(in=in[5],out=out[5]);

Not(in=in[6],out=out[6]);

Not(in=in[7],out=out[7]);

Not(in=in[8],out=out[8]);

Not(in=in[9],out=out[9]);

Not(in=in[10],out=out[10]);

Not(in=in[11],out=out[11]);

Not(in=in[12],out=out[12]);

Not(in=in[13],out=out[13]);

Not(in=in[14],out=out[14]);

Not(in=in[15],out=out[15]);

}

Es un AND que se repite o se implementa 16 veces.

Código:

Código:

CHIP And16 {

IN a[16], b[16];

OUT out[16];

PARTS:

And(a=a[0], b=b[0], out=out[0]);

And(a=a[1], b=b[1], out=out[1]);

And(a=a[2], b=b[2], out=out[2]);

And(a=a[3], b=b[3], out=out[3]);

And(a=a[4], b=b[4], out=out[4]);

And(a=a[5], b=b[5], out=out[5]);

And(a=a[6], b=b[6], out=out[6]);

And(a=a[7], b=b[7], out=out[7]);

And(a=a[8], b=b[8], out=out[8]);

And(a=a[9], b=b[9], out=out[9]);

And(a=a[10], b=b[10], out=out[10]);

And(a=a[11], b=b[11], out=out[11]);

And(a=a[12], b=b[12], out=out[12]);

And(a=a[13], b=b[13], out=out[13]);

And(a=a[14], b=b[14], out=out[14]);

And(a=a[15], b=b[15], out=out[15]);

}

Lo mismo ocurre con Or16, se aplica la compuerta Or 16 veces

Código:

CHIP Or16 {

IN a[16], b[16];

OUT out[16];

PARTS:

Or(a=a[0], b=b[0], out=out[0]);

Or(a=a[1], b=b[1], out=out[1]);

Or(a=a[2], b=b[2], out=out[2]);

Or(a=a[3], b=b[3], out=out[3]);

Or(a=a[4], b=b[4], out=out[4]);

Or(a=a[5], b=b[5], out=out[5]);

Or(a=a[6], b=b[6], out=out[6]);

Or(a=a[7], b=b[7], out=out[7]);

Or(a=a[8], b=b[8], out=out[8]);

Or(a=a[9], b=b[9], out=out[9]);

Or(a=a[10], b=b[10], out=out[10]);

Or(a=a[11], b=b[11], out=out[11]);

Or(a=a[12], b=b[12], out=out[12]);

Or(a=a[13], b=b[13], out=out[13]);

Or(a=a[14], b=b[14], out=out[14]);

Or(a=a[15], b=b[15], out=out[15]);

}

De igual manera, es el MUX implementado 16 veces.

Código:

CHIP Mux16 {

IN a[16], b[16], sel;

OUT out[16];

PARTS:

Mux(a=a[0], b=b[0], sel=sel, out=out[0]);

Mux(a=a[1], b=b[1], sel=sel, out=out[1]);

Mux(a=a[2], b=b[2], sel=sel, out=out[2]);

Mux(a=a[3], b=b[3], sel=sel, out=out[3]);

Mux(a=a[4], b=b[4], sel=sel, out=out[4]);

Mux(a=a[5], b=b[5], sel=sel, out=out[5]);

Mux(a=a[6], b=b[6], sel=sel, out=out[6]);

Mux(a=a[7], b=b[7], sel=sel, out=out[7]);

Mux(a=a[8], b=b[8], sel=sel, out=out[8]);

Mux(a=a[9], b=b[9], sel=sel, out=out[9]);

Mux(a=a[10], b=b[10], sel=sel, out=out[10]);

Mux(a=a[11], b=b[11], sel=sel, out=out[11]);

Mux(a=a[12], b=b[12], sel=sel, out=out[12]);

Mux(a=a[13], b=b[13], sel=sel, out=out[13]);

Mux(a=a[14], b=b[14], sel=sel, out=out[14]);

Mux(a=a[15], b=b[15], sel=sel, out=out[15]);

}

Or8Way tiene 8 entradas y mantendría una única salida.

Código:

CHIP Or8Way {

IN in[8];

OUT out;

PARTS:

Or(a=in[0], b=in[1], out=or1);

Or(a=or1, b=in[2], out=or2);

Or(a=or2, b=in[3], out=or3);

Or(a=or3, b=in[4], out=or4);

Or(a=or4, b=in[5], out=or5);

Or(a=or5, b=in[6], out=or6);

Or(a=or6, b=in[7], out=out);

}

Básicamente es un Mux de 4 entradas aplicado 16 veces.

Código:

CHIP Mux4Way16 {

IN a[16], b[16], c[16], d[16], sel[2];

OUT out[16];

PARTS:

Mux16(a=a, b=d, sel=sel[0], out=mux1);

Mux16(a=b, b=c, sel=sel[1], out=mux2);

Xor(a=sel[0], b=sel[1], out=muxsel);

Mux16(a=mux1, b=mux2, sel=muxsel, out=out);

}

La implementación que se realizó basa su funcionamiento en una idea parecida a la utilizada en la implementación del Mux4Way16 pero en este caso el problema es el inverso

Código:

CHIP DMux4Way {

IN in, sel[2];

OUT a, b, c, d;

PARTS:

Xor(a=sel[1], b=sel[0], out=xor1);

DMux(in=in, sel=xor1, a=dmuxsela, b=dmuxselb);

DMux(in=dmuxsela, sel=sel[1], a=a, b=d);

DMux(in=dmuxselb, sel=sel[0], a=c, b=b);

}

Como en la del Mux8Way16 se decidió usar 2 DMux4Way, un DMux16 y un Xor de 3 entradas para el manejar el selector.

Código:

CHIP DMux8Way {

IN in, sel[3];

OUT a, b, c, d, e, f, g, h;

PARTS:

Xor(a=sel[2], b=sel[1], out=xor1);

Xor(a=xor1, b=sel[0], out=xor2);

DMux(in=in, sel=xor2, a=dmuxa, b=dmuxb);

DMux4Way(in=dmuxa, sel=sel[1..2], a=a, b=d, c=f, d=g);

DMux4Way(in=dmuxb, sel=sel[0..1], a=e, b=b, c=c, d=h);

}