Project 2

HalfAdder

CHIP HalfAdder {
    IN a, b;    // 1-bit inputs
    OUT sum,    // Right bit of a + b 
        carry;  // Left bit of a + b

    PARTS:
    Xor(a=a,b=b,out=sum);
    And(a=a,b=b,out=carry);
}

FullAdder

CHIP FullAdder {
    IN a, b, c;  // 1-bit inputs
    OUT sum,     // Right bit of a + b + c
        carry;   // Left bit of a + b + c

    PARTS:
    HalfAdder(a=a,b=b,sum=s1,carry=c1);
    HalfAdder(a=s1,b=c,sum=sum,carry=c2);
    Or(a=c1,b=c2,out=carry);
    //And(a=a,b=b,out=c1);
    //Xor(a=a,b=b,out=b1);
    //And(a=b1,b=c,out=c2);
    //Xor(a=c,b=b1,out=sum);
    //Or(a=c1,b=c2,out=carry);
}

Add16

4-bit adder

CHIP Add16 {
    IN a[16], b[16];
    OUT out[16];

    PARTS:
    HalfAdder(a=a[0],b=b[0],carry=c0,sum=out[0]);
    FullAdder(a=a[1],b=b[1],c=c0,carry=c1,sum=out[1]);
    FullAdder(a=a[2],b=b[2],c=c1,carry=c2,sum=out[2]);
    FullAdder(a=a[3],b=b[3],c=c2,carry=c3,sum=out[3]);
    FullAdder(a=a[4],b=b[4],c=c3,carry=c4,sum=out[4]);
    FullAdder(a=a[5],b=b[5],c=c4,carry=c5,sum=out[5]);
    FullAdder(a=a[6],b=b[6],c=c5,carry=c6,sum=out[6]);
    FullAdder(a=a[7],b=b[7],c=c6,carry=c7,sum=out[7]);
    FullAdder(a=a[8],b=b[8],c=c7,carry=c8,sum=out[8]);
    FullAdder(a=a[9],b=b[9],c=c8,carry=c9,sum=out[9]);
    FullAdder(a=a[10],b=b[10],c=c9,carry=c10,sum=out[10]);
    FullAdder(a=a[11],b=b[11],c=c10,carry=c11,sum=out[11]);
    FullAdder(a=a[12],b=b[12],c=c11,carry=c12,sum=out[12]);
    FullAdder(a=a[13],b=b[13],c=c12,carry=c13,sum=out[13]);
    FullAdder(a=a[14],b=b[14],c=c13,carry=c14,sum=out[14]);
    FullAdder(a=a[15],b=b[15],c=c14,carry=c15,sum=out[15]);
}

Inc16

4-bit incrementer

CHIP Inc16 {
    IN in[16];
    OUT out[16];

    PARTS:
    Add16(a=in,b[0]=true,out=out);
}

ALU

CHIP ALU {
    IN  
        x[16], y[16],  // 16-bit inputs        
        zx, // zero the x input?
        nx, // negate the x input?
        zy, // zero the y input?
        ny, // negate the y input?
        f,  // compute out = x + y (if 1) or x & y (if 0)
        no; // negate the out output?

    OUT 
        out[16], // 16-bit output
        zr, // 1 if (out == 0), 0 otherwise
        ng; // 1 if (out < 0),  0 otherwise

    PARTS:
    //zx.nx
    Mux16(a=x,b=false,sel=zx,out=mzx);
    Not16(in=mzx,out=nzx);
    Mux16(a=mzx,b=nzx,sel=nx,out=mnx);

    //zy.ny
    Mux16(a=y,b=false,sel=zy,out=mzy);
    Not16(in=mzy,out=nzy);
    Mux16(a=mzy,b=nzy,sel=ny,out=mny);

    Add16(a=mnx,b=mny,out=xaddy);
    And16(a=mnx,b=mny,out=xandy);

    //f.no
    Mux16(a=xandy,b=xaddy,sel=f,out=mf);
    Not16(in=mf,out=nf);
    Mux16(a=mf,b=nf,sel=no,out=mno);

    //zr
    And16(a=mno,b=mno,out[0..7]=out1,out[8..15]=out2);
    Or8Way(in=out1,out=out11);
    Or8Way(in=out2,out=out22);
    Or(a=out11,b=out22,out=out12);
    Not(in=out12,out=zr);

    //ng
    And16(a=mno,b=mno,out[15]=ng);

    //out
    And16(a=mno,b=mno,out=out);
}