nand2tetris projest 1

2018-08-20

  • Not
1
2
3
4
5
6
7
CHIP Not {
    IN in;
    OUT out;

    PARTS:
    Nand(a = in, b = in, out = out);
}

  • And

    1
    2
    3
    4
    5
    6
    7
     CHIP And {
    	 IN a, b;
    	 OUT out;
    	 PARTS:
    	 Nand(a = a, b = b, out = nandOut);
    	 Not(in = nandOut, out = out);
    }

  • Or

    • A or B = Not(Not(A) And Not(B))
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      CHIP Or {
      	IN a, b;
      	OUT out;
      	PARTS:
      	Not(in = a, out = nota);
      	Not(in = b, out = notb);
      	And(a = nota, b = notb, out = andOut);
      	Not(in = andOut, out = out);
      	
      }

  • Mux

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/** 
 * Multiplexor:
 * out = a if sel == 0
 *       b otherwise
 */

CHIP Mux {
	IN a, b, sel;
	OUT out;
	PARTS:
	Not(in = sel, out = notSel);
	And(a = a, b = notSel, out= aAndNotSel);
	And(a = sel, b = b, out = selAndb);
	Or(a = aAndNotSel, b = selAndb, out = out);
}

  • DMux

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
     * Demultiplexor:
     * {a, b} = {in, 0} if sel == 0
     *          {0, in} if sel == 1
     */

    CHIP DMux {
    	IN in, sel;
    	OUT a, b;
    	PARTS:
    	Not(in = sel, out = notSel);
    	And(a = in, b = notSel, out = a);
    	And(a = in, b = sel, out = b);
    }

  • Not16

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    /**
     * 16-bit Not:
     * for i=0..15: out[i] = not in[i]
     */

    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]);
    }

  • And16

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    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]);
    	   
    }

  • Or16

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    /**
     * 16-bit bitwise Or:
     * for i = 0..15 out[i] = (a[i] or b[i])
     */

     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]);
    }

  • Mux16

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    /**
     * 16-bit multiplexor: 
     * for i = 0..15 out[i] = a[i] if sel == 0 
     *                        b[i] if sel == 1
     */

    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]);
    }

  • Mux4Way16

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     * 4-way 16-bit multiplexor:
     * out = a if sel == 00
     *       b if sel == 01
     *       c if sel == 10
     *       d if sel == 11
     */

    CHIP Mux4Way16 {
    	IN a[16], b[16], c[16], d[16], sel[2];
    	OUT out[16];
    	PARTS:
    	Not(in = sel[0], out = notA);
    	Not(in = sel[1], out = notB);

    	And(a = sel[0], b = sel[1], out = aAndB);
    	And(a = notA, b = sel[1], out = notAandB);
    	And(a = sel[0], b = notB, out = aAndNotB);
    	And(a = notA, b = notB, out = notAandnotB);

    	Mux16(a[0..15] = false, b[0..15] = a, sel = notAandnotB, out = outA);
    	Mux16(a[0..15] = false, b[0..15] = b, sel = aAndNotB, out = outB);
    	Mux16(a[0..15] = false, b[0..15] = c, sel= notAandB, out = outC);
    	Mux16(a[0..15] = false, b[0..15] = d, sel= aAndB, out = outD);
    	
    	Or16(a[0..15] = outA, b[0..15] = outB, out = tempOut1);
    	Or16(a[0..15] = tempOut1, b[0..15] = outC, out = tempOut2);
    	Or16(a[0..15] = tempOut2, b[0..15] = outD, out = out);
    	
    	
    }

  • Mux8Way16

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     * 4-way 16-bit multiplexor:
     * out = a if sel == 00
     *       b if sel == 01
     *       c if sel == 10
     *       d if sel == 11
     */

    CHIP Mux4Way16 {
    	IN a[16], b[16], c[16], d[16], sel[2];
    	OUT out[16];
    	PARTS:
    	Not(in = sel[0], out = notA);
    	Not(in = sel[1], out = notB);

    	And(a = sel[0], b = sel[1], out = aAndB);
    	And(a = notA, b = sel[1], out = notAandB);
    	And(a = sel[0], b = notB, out = aAndNotB);
    	And(a = notA, b = notB, out = notAandnotB);

    	Mux16(a[0..15] = false, b[0..15] = a, sel = notAandnotB, out = outA);
    	Mux16(a[0..15] = false, b[0..15] = b, sel = aAndNotB, out = outB);
    	Mux16(a[0..15] = false, b[0..15] = c, sel= notAandB, out = outC);
    	Mux16(a[0..15] = false, b[0..15] = d, sel= aAndB, out = outD);
    	
    	Or16(a[0..15] = outA, b[0..15] = outB, out = tempOut1);
    	Or16(a[0..15] = tempOut1, b[0..15] = outC, out = tempOut2);
    	Or16(a[0..15] = tempOut2, b[0..15] = outD, out = out);
    	
    	
    }

  • DMux4way

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /**
     * 4-way demultiplexor:
     * {a, b, c, d} = {in, 0, 0, 0} if sel == 00
     *                {0, in, 0, 0} if sel == 01
     *                {0, 0, in, 0} if sel == 10
     *                {0, 0, 0, in} if sel == 11
     */

     CHIP DMux4Way {
    	 IN in, sel[2];
    	 OUT a, b, c, d;
    	 PARTS:
    	 DMux(in = in, sel = sel[1], a = outA, b = outB);
    	 DMux(in = outA, sel = sel[0], a = a, b = b);
    	 DMux(in = outB, sel = sel[0], a = c, b = d);
    	 
     }

  • DMux8Way

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
     * 8-way demultiplexor:
     * {a, b, c, d, e, f, g, h} = {in, 0, 0, 0, 0, 0, 0, 0} if sel == 000
     *                            {0, in, 0, 0, 0, 0, 0, 0} if sel == 001
     *                            etc.
     *                            {0, 0, 0, 0, 0, 0, 0, in} if sel == 111
     */

     CHIP DMux8Way {
    	 IN in, sel[3];
    	 OUT a, b, c, d, e, f, g, h;
    	 PARTS:
    	 DMux(in = in, sel = sel[2], a = partA, b = partB);
    	 DMux4Way(in = partA, sel[0..1] = sel[0..1], a = a, b = b, c = c, d = d);
    	 DMux4Way(in = partB, sel[0..1] = sel[0..1], a = e, b = f, c = g, d = h);
    }