Hey WBahn! That was a while ago, but I think I remember what was going on.

Project 02 has two versions of the test script for the ALU: one with status bits, and one without. It is recommended to make the no-status bits ALU first, as it is less complicated and therefore easier to implement. I followed this advice, and commented out the zr and ng pins in my initial version.

I went on to finish the ALU by adding the status pins, but I forgot to uncomment out the zr pin:

// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/02/ALU.hdl
/**
* The ALU (Arithmetic Logic Unit).
* Computes one of the following functions:
* x+y, x-y, y-x, 0, 1, -1, x, y, -x, -y, !x, !y,
* x+1, y+1, x-1, y-1, x&y, x|y on two 16-bit inputs,
* according to 6 input bits denoted zx,nx,zy,ny,f,no.
* In addition, the ALU computes two 1-bit outputs:
* if the ALU output == 0, zr is set to 1; otherwise zr is set to 0;
* if the ALU output < 0, ng is set to 1; otherwise ng is set to 0.
*/
// Implementation: the ALU logic manipulates the x and y inputs
// and operates on the resulting values, as follows:
// if (zx == 1) set x = 0 // 16-bit constant
// if (nx == 1) set x = !x // bitwise not
// if (zy == 1) set y = 0 // 16-bit constant
// if (ny == 1) set y = !y // bitwise not
// if (f == 1) set out = x + y // integer 2's complement addition
// if (f == 0) set out = x & y // bitwise and
// if (no == 1) set out = !out // bitwise not
// if (out == 0) set zr = 1
// if (out < 0) set ng = 1
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:
// Put you code here:
Mux16(a=x,b=false,sel=zx,out=xOutz);
Not16(in=xOutz, out=notx);
Mux16(a=xOutz,b=notx,sel=nx,out=xOutn);
Mux16(a=y,b=false,sel=zy,out=yOutz);
Not16(in=yOutz, out=noty);
Mux16(a=yOutz,b=noty,sel=ny,out=yOutn);
And16(a=xOutn,b=yOutn,out=aNded);
Add16(a=xOutn,b=yOutn,out=aDded);
Mux16(a=aNded,b=aDded,sel=f,out=outf);
Not16(in=outf,out=notoutf);
Mux16(a=outf,
b=notoutf,
sel=no,
out=out,
out[15]=ng,
out[0..7]=lowbyte,
out[8..15]=highbyte);
Or8Way(in=lowbyte,out=lowbit);
Or8Way(in=highbyte,out=highbit);
Or(a=lowbit,b=highbit,out=notzr);
Not(in=notzr,out=zr);
}

This ALU will pass the full ALU.tst. The simulator treats the 'zr' pin that's attached to the last Not gate as an internal pin that isn't connected to anything else - a case of the system doing what it's supposed to to, but not what I meant it to do! The ALU.tst script checks the value coming off of the pin named 'zr' to make sure it's correct, but doesn't seem to have a way to check that the pin is an output pin.

This did not cause me too much trouble, but I was thinking it would be pretty annoying to have an error like this buried a few layers deep in a complex project where all the individual components test out OK, but connecting them together doesn't!