Nand2Tetris — Kapitel 3

//1-Bit-Register [zitieren: 2]
//Eingabe: in, laden (1 Bit) [zitieren: 3]
//Ausgabe: out (1 Bit) [zitieren: 4]
//Aktion: Wenn die Last 1 ist (bestätigt), wird der Wert des Registers auf in [zitieren: 2] gesetzt.
//Andernfalls behält das Register seinen aktuellen Wert (wenn load(t) out(t+1) = in(t), sonst out(t+1) = out(t))[cite: 3].

CHIP Bit {
    IN in, load;
    OUT out;

    PARTS:
    Mux(a=DFFO , b=in , sel=load , out=MuxO );
    DFF(in=MuxO , out=DFFO, out=out );
}

//16-Bit-Programmzähler
//Eingabe: in[16], laden, inc, zurücksetzen [zitieren: 5]
//Ausgabe: out[16] [zitieren: 5]
//Funktionsweise: Bestimmt den Registerwert für den nächsten Taktzyklus entsprechend den Prioritäten der Reset-, Load- und Inc-Signale [zitieren: 6].

CHIP PC {
    IN in[16], load, inc, reset;
    OUT out[16];

    PARTS:
    Inc16(in=regOut, out=incOut);
    Mux16(a=regOut, b=incOut, sel=inc, out=mux1);

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

    Mux16(a=mux2, b=false, sel=reset, out=mux3);

    Register(in=mux3, load=true, out=regOut, out=out);
}

//16-Bit-Register [zitieren: 34]
//Eingabe: in[16], laden [zitieren: 35]
//Ausgabe: out[16] [zitieren: 36]
//Aktion: Wenn die Last 1 ist (bestätigt), wird der Wert des Registers auf in [zitieren: 34] gesetzt.
//Andernfalls behalten Sie den aktuellen Wert bei [zitieren: 35]. 16-Bit-Chips parallel geschaltet [zitieren: 36, 37, 38, 39, 40, 41].

CHIP Register {
    IN in[16], load;
    OUT out[16];

    PARTS:
    Bit(in=in[0] , load=load , out=out[0] );
    Bit(in=in[1] , load=load , out=out[1] );
    Bit(in=in[2] , load=load , out=out[2] );
    Bit(in=in[3] , load=load , out=out[3] );
    Bit(in=in[4] , load=load , out=out[4] );
    Bit(in=in[5] , load=load , out=out[5] );
    Bit(in=in[6] , load=load , out=out[6] );
    Bit(in=in[7] , load=load , out=out[7] );
    Bit(in=in[8] , load=load , out=out[8] );
    Bit(in=in[9] , load=load , out=out[9] );
    Bit(in=in[10] , load=load , out=out[10] );
    Bit(in=in[11] , load=load , out=out[11] );
    Bit(in=in[12] , load=load , out=out[12] );
    Bit(in=in[13] , load=load , out=out[13] );
    Bit(in=in[14] , load=load , out=out[14] );
    Bit(in=in[15] , load=load , out=out[15] );
}

//Speicher von acht 16-Bit-Registern [zitieren: 12]
//Eingabe: in[16], Laden, Adresse[3] [zitieren: 15]
//Ausgabe: out[16] [zitieren: 15]
//Aktion: Wenn die Last 1 ist, wird der Wert des anhand der Adresse ausgewählten Registers auf in [zitieren: 13] gesetzt.
//Andernfalls wird der Wert nicht geändert und der Wert des ausgewählten Registers an out ausgegeben [zitieren: 14].

CHIP RAM8 {
    IN in[16], load, address[3];
    OUT out[16];
    PARTS:
    DMux8Way(in=load, sel= address,
    a= Out0, b= Out1,
    c= Out2, d= Out3,
    e= Out4, f= Out5,
    g= Out6, h= Out7);
    Register(in=in , load=Out0 , out=R0 );
    Register(in=in , load=Out1 , out=R1 );
    Register(in=in , load=Out2 , out=R2 );
    Register(in=in , load=Out3 , out=R3 );
    Register(in=in , load=Out4 , out=R4 );
    Register(in=in , load=Out5 , out=R5 );
    Register(in=in , load=Out6 , out=R6 );
    Register(in=in , load=Out7 , out=R7 );
    Mux8Way16(
    a= R0, b= R1,
    c= R2, d= R3,
    e= R4, f= R5,
    g= R6, h= R7,
    sel= address, out=out);
}

//64 Wörter Speicher
//Eingabe: in[16], Laden, Adresse[6] [zitieren: 25]
//Ausgabe: out[16] [zitieren: 25]
//Funktionsweise: Kombination von 8 RAM8-Chips zu 64 Registern [zitieren: 26, 27, 28].

CHIP RAM64 {
    IN in[16], load, address[6];
    OUT out[16];
    PARTS:
    DMux8Way(in=load, sel=address[3..5], a=loadA, b=loadB, c=loadC, d=loadD, e=loadE, f=loadF, g=loadG, h=loadH);

    RAM8(in=in, load=loadA, address=address[0..2], out=outA);
    RAM8(in=in, load=loadB, address=address[0..2], out=outB);
    RAM8(in=in, load=loadC, address=address[0..2], out=outC);
    RAM8(in=in, load=loadD, address=address[0..2], out=outD);
    RAM8(in=in, load=loadE, address=address[0..2], out=outE);
    RAM8(in=in, load=loadF, address=address[0..2], out=outF);
    RAM8(in=in, load=loadG, address=address[0..2], out=outG);
    RAM8(in=in, load=loadH, address=address[0..2], out=outH);

    Mux8Way16(a=outA, b=outB, c=outC, d=outD, e=outE, f=outF, g=outG, h=outH, sel=address[3..5], out=out);
}

//Speicher für 512 Wörter
//Eingabe: in[16], Laden, Adresse[9] [zitieren: 29]
//Ausgabe: out[16] [zitieren: 29]
//Funktionsweise: 8 RAM64-Chips werden zu 512 Registern zusammengefasst [zitieren: 30, 31, 32].

CHIP RAM512 {
    IN in[16], load, address[9];
    OUT out[16];
    PARTS:
    DMux8Way(in=load, sel=address[6..8], a=loadA, b=loadB, c=loadC, d=loadD, e=loadE, f=loadF, g=loadG, h=loadH);

    RAM64(in=in, load=loadA, address=address[0..5], out=outA);
    RAM64(in=in, load=loadB, address=address[0..5], out=outB);
    RAM64(in=in, load=loadC, address=address[0..5], out=outC);
    RAM64(in=in, load=loadD, address=address[0..5], out=outD);
    RAM64(in=in, load=loadE, address=address[0..5], out=outE);
    RAM64(in=in, load=loadF, address=address[0..5], out=outF);
    RAM64(in=in, load=loadG, address=address[0..5], out=outG);
    RAM64(in=in, load=loadH, address=address[0..5], out=outH);

    Mux8Way16(a=outA, b=outB, c=outC, d=outD, e=outE, f=outF, g=outG, h=outH, sel=address[6..8], out=out);
}

//4K-Wortspeicher
//Eingabe: in[16], Laden, Adresse[12] [zitieren: 7]
//Ausgabe: out[16] [zitieren: 7]
//Funktionsweise: 8 RAM512-Chips werden zu 4096 Registern zusammengefasst [zitieren: 8, 9, 10].

CHIP RAM4K {
    IN in[16], load, address[12];
    OUT out[16];
    PARTS:
    DMux8Way(in=load, sel=address[9..11], a=loadA, b=loadB, c=loadC, d=loadD, e=loadE, f=loadF, g=loadG, h=loadH);

    RAM512(in=in, load=loadA, address=address[0..8], out=outA);
    RAM512(in=in, load=loadB, address=address[0..8], out=outB);
    RAM512(in=in, load=loadC, address=address[0..8], out=outC);
    RAM512(in=in, load=loadD, address=address[0..8], out=outD);
    RAM512(in=in, load=loadE, address=address[0..8], out=outE);
    RAM512(in=in, load=loadF, address=address[0..8], out=outF);
    RAM512(in=in, load=loadG, address=address[0..8], out=outG);
    RAM512(in=in, load=loadH, address=address[0..8], out=outH);

    Mux8Way16(a=outA, b=outB, c=outC, d=outD, e=outE, f=outF, g=outG, h=outH, sel=address[9..11], out=out);
}

//16K Wortspeicher
//Eingabe: in[16], Laden, Adresse[14] [zitieren: 22]
//Ausgabe: out[16] [zitieren: 22]
//Funktionsweise: Vier RAM4K-Chips werden mit DMux4Way und Mux4Way16 kombiniert, um 16384 Register zu konfigurieren [zitieren: 23, 24].

CHIP RAM16K {
    IN in[16], load, address[14];
    OUT out[16];
    PARTS:
    DMux4Way(in=load, sel=address[12..13], a=loadA, b=loadB, c=loadC, d=loadD);

    RAM4K(in=in, load=loadA, address=address[0..11], out=outA);
    RAM4K(in=in, load=loadB, address=address[0..11], out=outB);
    RAM4K(in=in, load=loadC, address=address[0..11], out=outC);
    RAM4K(in=in, load=loadD, address=address[0..11], out=outD);

    Mux4Way16(a=outA, b=outB, c=outC, d=outD, sel=address[12..13], out=out);
}