Wie kann ich die Ausgabe Flaggen für ALU in „Nand zu Tetris“ Kurs?

Question

Auch wenn ich diese Hausaufgaben markiert, es ist eigentlich für einen Kurs, die ich kostenlos auf meinem eigenen tue. Wie auch immer, ist der Kurs „Von Nand zu Tetris“ und ich bin der Hoffnung, jemand hier den Kurs gesehen oder getroffen hat, so kann ich etwas Hilfe bekommen. Ich bin in der Phase, wo ich mit der mitgelieferten hdl Sprache der ALU bin Gebäude. Mein Problem ist, dass ich nicht meinen Chip richtig zu kompilieren bekommen. Ich erhalte Fehler, wenn ich versuche, die Ausgabe Flags für die ALU einzustellen. Ich glaube, das Problem ist, dass ich keine Zwischengröße SUBSCRIPT kann, da, wenn ich versuche nur die Flaggen auf wahr oder falsch basierend Einstellung auf einige Zufallsvariablen (zB einem Eingangs-Flag), ich habe nicht die Fehler. Ich weiß, dass das Problem nicht mit den Chips, die ich zu verwenden Ich versuche, da ich alle eingebauten Chips verwende.

Hier ist mein ALU-Chip so weit:

/**
 * The ALU.  Computes a pre-defined set of functions out = f(x,y)
 * where x and y are two 16-bit inputs. The function f is selected 
 * by a set of 6 control bits denoted zx, nx, zy, ny, f, no.
 * The ALU operation can be described using the following pseudocode:
 *     if zx=1 set x = 0       // 16-bit zero constant
 *     if nx=1 set x = !x      // Bit-wise negation
 *     if zy=1 set y = 0       // 16-bit zero constant
 *     if ny=1 set y = !y      // Bit-wise negation
 *     if f=1  set out = x + y // Integer 2's complement addition
 *     else    set out = x & y // Bit-wise And
 *     if no=1 set out = !out  // Bit-wise negation
 *
 * In addition to computing out, the ALU computes two 1-bit outputs:
 *     if out=0 set zr = 1 else zr = 0 // 16-bit equality comparison
 *     if out<0 set ng = 1 else ng = 0 // 2's complement comparison
 */

CHIP ALU {

IN  // 16-bit inputs:
    x[16], y[16],
    // Control bits:
    zx, // Zero the x input
    nx, // Negate the x input
    zy, // Zero the y input
    ny, // Negate the y input
    f,  // Function code: 1 for add, 0 for and
    no; // Negate the out output

OUT // 16-bit output
    out[16],

    // ALU output flags
    zr, // 1 if out=0, 0 otherwise
    ng; // 1 if out<0, 0 otherwise

PARTS:
// Zero the x input
Mux16( a=x, b=false, sel=zx, out=x2 );

// Zero the y input
Mux16( a=y, b=false, sel=zy, out=y2 );

// Negate the x input
Not16( in=x, out=notx );
Mux16( a=x, b=notx, sel=nx, out=x3 );

// Negate the y input
Not16( in=y, out=noty );
Mux16( a=y, b=noty, sel=ny, out=y3 );

// Perform f
Add16( a=x3, b=y3, out=addout );
And16( a=x3, b=y3, out=andout );
Mux16( a=andout, b=addout, sel=f, out=preout );

// Negate the output
Not16( in=preout, out=notpreout );
Mux16( a=preout, b=notpreout, sel=no, out=out );

// zr flag
Or8way( in=out[0..7], out=zr1 );   // PROBLEM SHOWS UP HERE
Or8way( in=out[8..15], out=zr2 );
Or( a=zr1, b=zr2, out=zr );

// ng flag
Not( in=out[15], out=ng );

}

Also das Problem tritt auf, wenn ich versuche, eine indizierte Version von ‚out‘ zu senden, um den Or8Way Chip. Ich habe versucht, eine andere Variable als ‚out‘ verwenden, aber mit dem gleichen Problem. Dann las ich, dass Sie nicht in der Lage sind Zwischenvariablen SUBSCRIPT. Ich dachte, vielleicht, wenn ich die Zwischenvariable zu einem anderen Chip gesendet, und das Chip indizierte es, würde es das Problem lösen, aber es hat den gleichen Fehler. Leider kann ich glaube einfach nicht von einer Art, die zr und ng Flags zu setzen, ohne eine Zwischengröße Indizierung, also bin ich wirklich fest!

Nur damit Sie wissen, wenn ich die problematischen Zeilen mit folgenden ersetzen, wird es kompilieren (aber nicht die richtigen Ergebnisse liefern, da ich einige zufällige Eingabe nur bin mit):

// zr flag
Not( in=zx, out=zr );

// ng flag
Not( in=zx, out=ng );

Wer irgendwelche Ideen?

Edit: Hier ist der Anhang des Buches für den Kurs die angibt, wie die hdl funktioniert. Blick speziell auf Abschnitt 5, die über Busse spricht und sagt: „Ein interner Stift (wie v oben) kann nicht indexiert werden“

Edit: ist der genaue Fehler erhalte ich: "Reihe 68, kann nicht Tor der Ausgangs-Pin zu einem Teil verbinden". Die Fehlermeldung ist verwirrend Art aber, da dies nicht das eigentliche Problem zu sein scheint. Wenn ich einfach ersetzen "Or8way (in = out [0..7], out = zr1);" mit "Or8way (in = false, out = ZR1);" es wird diesen Fehler nicht erzeugen, das, was mich führen wird in der Anlage zu suchen und finden, dass das aus variabel, da sie als Zwischen abgeleitet wurden, nicht indexiert werden.

Answer 1

Die Lösung als Pax wurde vorgeschlagen eine Zwischengröße als Eingabe zu einem anderen Chip, wie Or16Way zu verwenden. Hier ist der Code, nachdem ich das Problem behoben und auf Fehler:

CHIP ALU {

IN  // 16-bit inputs:
    x[16], y[16],
    // Control bits:
    zx, // Zero the x input
    nx, // Negate the x input
    zy, // Zero the y input
    ny, // Negate the y input
    f,  // Function code: 1 for add, 0 for and
    no; // Negate the out output

OUT // 16-bit output
    out[16],

    // ALU output flags
    zr, // 1 if out=0, 0 otherwise
    ng; // 1 if out<0, 0 otherwise

PARTS:
// Zero the x input
Mux16( a=x, b=false, sel=zx, out=x2 );

// Zero the y input
Mux16( a=y, b=false, sel=zy, out=y2 );

// Negate the x input
Not16( in=x2, out=notx );
Mux16( a=x2, b=notx, sel=nx, out=x3 );

// Negate the y input
Not16( in=y2, out=noty );
Mux16( a=y2, b=noty, sel=ny, out=y3 );

// Perform f
Add16( a=x3, b=y3, out=addout );
And16( a=x3, b=y3, out=andout );
Mux16( a=andout, b=addout, sel=f, out=preout );

// Negate the output
Not16( in=preout, out=notpreout );
Mux16( a=preout, b=notpreout, sel=no, out=preout2 );

// zr flag
Or16Way( in=preout2, out=notzr );
Not( in=notzr, out=zr );

// ng flag
And16( a=preout2, b=true, out[15]=ng );

// Get final output
And16( a=preout2, b=preout2, out=out );
}

Answer 2

Für alle Interessierten, die Lösung der Emulator unterstützt, ist mehrere Ausgänge zu verwenden So etwas wie:

Mux16( a=preout, b=notpreout, sel=no, out=out,out=preout2,out[15]=ng);

Answer 3

Dies ist, wie ich die ALU tat:

CHIP ALU {
IN  // 16-bit inputs:
    x[16], y[16],
    // Control bits:
    zx, // Zero the x input
    nx, // Negate the x input
    zy, // Zero the y input
    ny, // Negate the y input
    f,  // Function code: 1 for add, 0 for and
    no; // Negate the out output
OUT // 16-bit output
    out[16],
    // ALU output flags
    zr, // 1 if out=0, 0 otherwise
    ng; // 1 if out<0, 0 otherwise
PARTS:      
    Mux16(a=x, b=false, sel=zx, out=M16x);
    Not16(in=M16x, out=Nx);
    Mux16(a=M16x, b=Nx, sel=nx, out=M16M16x);

    Mux16(a=y, b=false, sel=zy, out=M16y);
    Not16(in=M16y, out=Ny);
    Mux16(a=M16y, b=Ny, sel=ny, out=M16M16y);

    And16(a=M16M16x, b=M16M16y, out=And16);
    Add16(a=M16M16x, b=M16M16y, out=Add16);
    Mux16(a=And16, b=Add16, sel=f, out=F16);

    Not16(in=F16, out=NF16);
    Mux16(a=F16, b=NF16, sel=no, out=out, out[15]=ng, out[0..7]=zout1, out[8..15]=zout2);

    Or8Way(in=zout1, out=zr1);
    Or8Way(in=zout2, out=zr2);
    Or(a=zr1, b=zr2, out=zr3);
    Not(in=zr3, out=zr);
}

Answer 4

Haben Sie versucht:

// zr flag
Or8way(
    in[0]=out[ 0], in[1]=out[ 1], in[2]=out[ 2], in[3]=out[ 3],
    in[4]=out[ 4], in[5]=out[ 5], in[6]=out[ 6], in[7]=out[ 7],
    out=zr1);
Or8way(
    in[0]=out[ 8], in[1]=out[ 9], in[2]=out[10], in[3]=out[11],
    in[4]=out[12], in[5]=out[13], in[6]=out[14], in[7]=out[15],
    out=zr2);
Or( a=zr1, b=zr2, out=zr );

Ich weiß nicht, ob dies funktionieren wird, aber es scheint Sinn aus der Betrachtung dieses Dokument zu machen hier .

Ich würde denken, auch zweimal über out als Variablennamen verwenden, da es verwirrend versucht, den Unterschied zwischen dem, um herauszufinden, und dem Schlüsselwort out (wie in „out=...“).

Nach Ihrer bearbeiten, wenn Sie Zwischenwerte nicht Index, dann scheint es, werden Sie über einen separaten „Chip“ wie IsZero16 implementieren müssen, die einen 16-Bit-Wert als Eingabe wird (Ihre Zwischen out) und zurück ein Bit, das anzeigt seine Null-ness, die Sie in zr laden können. Oder Sie könnten einen IsZero8 Chip machen, aber man müsste dann nennen sie es zwei Stufen, wie Sie gerade mit Or8Way tun.

Dies scheint eine gültige Lösung, da Sie können Index der Eingangswerte auf einem Chip.

Und gerade in dem Fehler suchen, kann dies ein anderes Problem auf die sein, die Sie vorschlagen. Der Ausdruck „Can not Tor der Ausgangs-Pin zu einem Teil verbinden“ würde für mich bedeuten, dass Sie nicht in der Lage sind, Signale von dem Ausgangsparameter Verarbeitungsbereich zu verbinden, wieder in den Chips. Das macht Sinn von einem elektrischen Standpunkt aus.

Sie finden können Sie die Ausgabe in eine temporäre Variable zu speichern haben und dass sowohl auf Satz verwenden zr und out (da, sobald die Signale „gesendet“ wurden auf die Chips Ausgangs-Pins, sie nicht mehr verfügbar sein).

Können wir versuchen:

CHIP SetFlags16 {
    IN  inpval[16];
    OUT zflag,nflag;
    PARTS:
        Or8way(in=inpval[0.. 7],out=zr0);
        Or8way(in=inpval[8..15],out=zr1);
        Or(a=zr0,b=zr1,out=zflag);
        Not(in=inpval[15],out=nflag);
}

und dann, in der ALU-Chip, verwenden Sie diese am Ende:

// Negate the output
Not16( in=preout, out=notpreout );
Mux16( a=preout, b=notpreout, sel=no, out=tempout );

// flags
SetFlags16(inpval=tempout,zflag=zr,nflag=ng);

// Transfer tempout to out (may be a better way).
Or16(a=tempout,b=tempout,out=out);

Answer 5

Hier ist man auch mit einem neuen Chip, aber es fühlt sich sauberer

/**
 * Negator16 - negates the input 16-bit value if the selection flag is lit
 */
CHIP Negator16 {
  IN sel,in[16];
  OUT out[16];

  PARTS:
  Not16(in=in, out=negateIn);
  Mux16(a=in, b=negateIn, sel=sel, out=out);
}

CHIP ALU {
  // IN and OUT go here...
  PARTS:
  //Zero x and y if needed
  Mux16(a=x, b[0..15]=false, sel=zx, out=x1);
  Mux16(a=y, b[0..15]=false, sel=zy, out=y1);

  //Create x1 and y1 negations if needed
  Negator16(in=x1, sel=nx, out=x2);
  Negator16(in=y1, sel=ny, out=y2);

  //Create x&y and x+y
  And16(a=x2, b=y2, out=andXY);
  Add16(a=x2, b=y2, out=addXY);

  //Choose between And/Add according to selection
  Mux16(a=andXY, b=addXY, sel=f, out=res);

  // negate if needed and also set negative flag
  Negator16(in=res, sel=no, out=res1, out=out, out[15]=ng);

  // set zero flag (or all bits and negate)
  Or16Way(in=res1, out=nzr);
  Not(in=nzr, out=zr);
}