Seeing red

[emjay]

You're looking for either an EDA or a schematic editor that;s compatible with your hdl file format.  Try TinyCad or KiCAD.  I use Eagle, but only out of habit and because I have the full suite.  EasyEDA runs in a browser tab......if that's your thing.  Pretty much all of the editors are cross platform.  

Just for what you want, KiCad (and it's user created libraries) is probably the way to go.  It has -alot- more functionality than just making symbol map schematics, though.

Thanks for that, Rhythm, but unfortunately they all look a bit too complicated for me. I was just hoping for simple diagrams of the top level chips used in a HDL definition of a single chip... just showing pins and their connections, coming out of boxes with the chip name on... just something simple like that. Whereas these programs are very intricate, very technical, and they deal with the electronics which I'm guessing I'm not going to learn about in this course? In other words this course is abstract regarding the physical implementation of the chips on real circuitboards? But thanks for those suggestions... maybe in the future   At the moment I'll just make do with pen and paper

Anyway, I've now done chapter two and its project, so if you're interested, this is my implementation of the specified ALU:

---

Code:

// 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=toamuxnx);
  
   Not16(in=toamuxnx,out=tobmuxnx);
   Mux16(a=toamuxnx,b=tobmuxnx,sel=nx,out=toxf);
  
   Mux16(a=y,b=false,sel=zy,out=toamuxny);
  
   Not16(in=toamuxny,out=tobmuxny);
   Mux16(a=toamuxny,b=tobmuxny,sel=ny,out=toyf);
  
   And16(a=toxf,b=toyf,out=toamuxf);
   Add16(a=toxf,b=toyf,out=tobmuxf);
   Mux16(a=toamuxf,b=tobmuxf,sel=f,out=toamuxno);
  
   Not16(in=toamuxno,out=tobmuxno);
   Mux16(a=toamuxno,b=tobmuxno,sel=no,out=out,out[0..7]=outor8w1,out[8..15]=outor8w2,out[15..15]=ng);
  
   Or8Way(in=outor8w1,out=outora);
   Or8Way(in=outor8w2,out=outorb);
   Or(a=outora,b=outorb,out=outtonot);
   Not(in=outtonot,out=zr);
}

---

What I'm liking about this particularly is that it's developing a whole new way of thinking... a whole new type of logic. In the sense that in traditional programming if you have branching statements... as in if... do this, else... do something else ...you can consider one or another branch a dead end. But here it's different... here there are no switches per se diverting the path of inputs based on flags (ie the control bits) - which tbh is what I assumed was happening before - rather everything is done in parallel... you can't just stop an output dead once you're finished with it, it has to go somewhere... so for instance in this ALU you have a control bit to negate the input, but to implement it you have to do (or I had to do) both whatever the case... so take the input and negate it down one path, and then feed both the both the negated and the non-negated paths into a Mux which outputs one or the other depending on the value of the control bit. So it's a very different type of logic than I'm used to but I'm really enjoying learning it  

On with the next chapter, Sequential Logic, and from the looks of it, that will be the one about making memories