NAND2Tetris:带你从零开始手搓计算机之项目1

NAND2Tetris:带你从零开始手搓计算机之项目1——搭建逻辑门

---

总述

第一个项目总而言之还是非常地简单，就是要求大家在只拥有与非门的基础上搭建15个比较基础的逻辑门。

在之前我们学习逻辑门(包括与门、非门、或门),我们还是习惯于把这些内容以原子化的方式看待，缺少了对其逻辑关联的分析和了解。其实本质上，这些门不是相互独立和割裂的，你可以根据与非门搭建一个非门，你可以根据与非门、非门搭建好一个与门…在这个项目里，通过对不同逻辑门的搭建，你会深刻地发现门与门实际上是相互关联、相互成全的！

同时，不管是在数字电路还是数字逻辑设计这类的课程中，我们都会讨论布尔表达式、真值表这些内容。通过这个项目，你会发现，先写好并化简表达式再来用代码搭建逻辑门，是一件事半功倍的事情。

总之，15个逻辑门的搭建是我们迈出从零开始搭建计算机的第一步，因为一台再精密的机器，不过也只是由最基本的逻辑门搭建起来的罢。

以下是我自己实现的逻辑门代码，并非最优解，供参考。关键的思路和要素我会写在注释里。

Not

/**
 * Not gate:
 * if (in) out = 0, else out = 1
 */
CHIP Not {
    IN in;
    OUT out;

    PARTS:
    Nand(a = in , b = in , out = out);
}

And

/**
 * And gate:
 * if (a and b) out = 1, else out = 0 
 */
CHIP And {
    IN a, b;
    OUT out;
    
    PARTS:
    Nand(a = a, b = b, out = nandout);
    Not(in = nandout , out = out);

}

Or

/**
 * Or gate:
 * if (a or b) out = 1, else out = 0 
 */
CHIP Or {
    IN a, b;
    OUT out;

    PARTS:
    Not(in = a, out = nanda);
    Not(in = b,out = nandb);
    Nand(a = nanda, b = nandb, out = out);
}

Xor

/**
 * Exclusive-or gate:
 * if ((a and Not(b)) or (Not(a) and b)) out = 1, else out = 0
 */
CHIP Xor {
    IN a, b;
    OUT out;

    PARTS:
    Not(in = a, out = nanda);
    Not(in = b, out = nandb);
    And(a = a,b = nandb, out = anandb);
    And(a = nanda, b = b, out = bnanda);
    Or(a = anandb , b=bnanda , out=out);
}

Mux

/** 
 * Multiplexor:
 * if (sel = 0) out = a, else out = b
 */
CHIP Mux {
    IN a, b, sel;
    OUT out;
//我们通过什么方式去实现选择，这是一件非常值得考虑的事情。最重要的一件事情就是谁和1进行与运算就是他本身！
// out = (a AND (NOT sel)) OR (b AND sel)
    PARTS:
    Not(in = sel, out = notsel);
    And(a = a, b = notsel, out = aandnotsel);
    And(a = b, b = sel, out = bandsel);
    Or(a = aandnotsel, b = bandsel, out = out);
}

DMux

/**
 * Demultiplexor:
 * [a, b] = [in, 0] if sel = 0
 *          [0, in] if sel = 1
 */
CHIP DMux {
    IN in, sel;
    OUT a, b;

    PARTS:
    Not(in = sel, out = notsel);
    And(a = in, b = notsel, out = a);
    And(a = in, b = sel, out = b);
}

Not16

/**
 * 16-bit Not gate:
 * for i = 0, ..., 15:
 * out[i] = Not(a[i])
 */
CHIP Not16 {
    IN in[16];
    OUT out[16];

    PARTS:
    // 为每个位使用单独的 Not 门
    Not(in=in[0], out=out[0]);
    Not(in=in[1], out=out[1]);
    Not(in=in[2], out=out[2]);
    Not(in=in[3], out=out[3]);
    Not(in=in[4], out=out[4]);
    Not(in=in[5], out=out[5]);
    Not(in=in[6], out=out[6]);
    Not(in=in[7], out=out[7]);
    Not(in=in[8], out=out[8]);
    Not(in=in[9], out=out[9]);
    Not(in=in[10], out=out[10]);
    Not(in=in[11], out=out[11]);
    Not(in=in[12], out=out[12]);
    Not(in=in[13], out=out[13]);
    Not(in=in[14], out=out[14]);
    Not(in=in[15], out=out[15]);
}

And16

/**
 * 16-bit And gate:
 * for i = 0, ..., 15:
 * out[i] = a[i] And b[i] 
 */
CHIP And16 {
    IN a[16], b[16];
    OUT out[16];

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

Or16

/**
 * 16-bit Or gate:
 * for i = 0, ..., 15:
 * out[i] = a[i] Or b[i] 
 */
CHIP Or16 {
    IN a[16], b[16];
    OUT out[16];

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

Mux16

/**
 * 16-bit multiplexor: 
 * for i = 0, ..., 15:
 * if (sel = 0) out[i] = a[i], else out[i] = b[i]
 */
CHIP Mux16 {
    IN a[16], b[16], sel;  // 16 位输入 a 和 b，1 位选择信号 sel
    OUT out[16];           // 16 位输出 out

    PARTS:
    // 为每个位使用单独的 Mux 门
    Mux(a=a[0], b=b[0], sel=sel, out=out[0]);
    Mux(a=a[1], b=b[1], sel=sel, out=out[1]);
    Mux(a=a[2], b=b[2], sel=sel, out=out[2]);
    Mux(a=a[3], b=b[3], sel=sel, out=out[3]);
    Mux(a=a[4], b=b[4], sel=sel, out=out[4]);
    Mux(a=a[5], b=b[5], sel=sel, out=out[5]);
    Mux(a=a[6], b=b[6], sel=sel, out=out[6]);
    Mux(a=a[7], b=b[7], sel=sel, out=out[7]);
    Mux(a=a[8], b=b[8], sel=sel, out=out[8]);
    Mux(a=a[9], b=b[9], sel=sel, out=out[9]);
    Mux(a=a[10], b=b[10], sel=sel, out=out[10]);
    Mux(a=a[11], b=b[11], sel=sel, out=out[11]);
    Mux(a=a[12], b=b[12], sel=sel, out=out[12]);
    Mux(a=a[13], b=b[13], sel=sel, out=out[13]);
    Mux(a=a[14], b=b[14], sel=sel, out=out[14]);
    Mux(a=a[15], b=b[15], sel=sel, out=out[15]);
}

Or8way

/**
 * 8-way Or gate: 
 * out = in[0] Or in[1] Or ... Or in[7]
 */
CHIP Or8Way {
    IN in[8];
    OUT out;

    PARTS:
    Or(a = in[0], b = in[1], out = out0);
    Or(a = out0, b = in[2], out = out1);
    Or(a = out1, b = in[3], out = out2);
    Or(a = out2, b = in[4], out = out3);
    Or(a = out3, b = in[5], out = out4);
    Or(a = out4, b = in[6], out = out5);
    Or(a = out5, b = in[7], out = out);
}

Mux4Way16

/**
 * 4-way 16-bit multiplexor:
 * out = a if sel = 00
 *       b if sel = 01
 *       c if sel = 10
 *       d if sel = 11
 */
// 这个代码的实现比较巧妙，其实四路十六位多路选择器就是用两个二路的多路选择器来实现的。
CHIP Mux4Way16 {
    IN a[16], b[16], c[16], d[16], sel[2];
    OUT out[16];

    PARTS:
    // Select between a and b based on sel[0]
    Mux16(a=a, b=b, sel=sel[0], out=outAB);
    // Select between c and d based on sel[0]
    Mux16(a=c, b=d, sel=sel[0], out=outCD);
    // Final selection between outAB and outCD based on sel[1]
    Mux16(a=outAB, b=outCD, sel=sel[1], out=out);
}

Mux8Way16

/**
 * 8-way 16-bit multiplexor:
 * out = a if sel = 000
 *       b if sel = 001
 *       c if sel = 010
 *       d if sel = 011
 *       e if sel = 100
 *       f if sel = 101
 *       g if sel = 110
 *       h if sel = 111
 */
CHIP Mux8Way16 {
    IN a[16], b[16], c[16], d[16],
       e[16], f[16], g[16], h[16],
       sel[3];
    OUT out[16];

    PARTS:
    Mux4Way16(a=a, b=b, c=c, d=d, sel=sel[0..1], out=outab);
    Mux4Way16(a=e , b=f , c=g , d=h , sel=sel[0..1] , out=outcd);
    Mux16(a=outab, b=outcd, sel=sel[2], out = out);
}

DMux4Way

/**
 * 4-way demultiplexor:
 * [a, b, c, d] = [in, 0, 0, 0] if sel = 00
 *                [0, in, 0, 0] if sel = 01
 *                [0, 0, in, 0] if sel = 10
 *                [0, 0, 0, in] if sel = 11
 */
 // 高位选择，自顶向下
CHIP DMux4Way {
    IN in, sel[2];
    OUT a, b, c, d;

    PARTS:
    // 第一步：使用第一个 DMux 根据 sel[1] 拆分为 in1 和 in2
    DMux(in=in, sel=sel[1], a=in1, b=in2);

    // 第二步：根据 sel[0] 对 in1 进行进一步拆分为 a 和 b
    DMux(in=in1, sel=sel[0], a=a, b=b);

    // 第二步：根据 sel[0] 对 in2 进行进一步拆分为 c 和 d
    DMux(in=in2, sel=sel[0], a=c, b=d);
}

DMux8Way

/**
 * 8-way demultiplexor:
 * [a, b, c, d, e, f, g, h] = [in, 0,  0,  0,  0,  0,  0,  0] if sel = 000
 *                            [0, in,  0,  0,  0,  0,  0,  0] if sel = 001
 *                            [0,  0, in,  0,  0,  0,  0,  0] if sel = 010
 *                            [0,  0,  0, in,  0,  0,  0,  0] if sel = 011
 *                            [0,  0,  0,  0, in,  0,  0,  0] if sel = 100
 *                            [0,  0,  0,  0,  0, in,  0,  0] if sel = 101
 *                            [0,  0,  0,  0,  0,  0, in,  0] if sel = 110
 *                            [0,  0,  0,  0,  0,  0,  0, in] if sel = 111
 */
CHIP DMux8Way {
    IN in, sel[3];
    OUT a, b, c, d, e, f, g, h;

    PARTS:
    // 第一步：使用 DMux 根据 sel[2] 将信号拆分为两部分
    DMux(in=in, sel=sel[2], a=in1, b=in2);

    // 第二步：对 in1 使用 DMux4Way 进一步根据 sel[1:0] 拆分为 a, b, c, d
    DMux4Way(in=in1, sel=sel[0..1], a=a, b=b, c=c, d=d);

    // 第二步：对 in2 使用 DMux4Way 进一步根据 sel[1:0] 拆分为 e, f, g, h
    DMux4Way(in=in2, sel=sel[0..1], a=e, b=f, c=g, d=h);
}

-------------本文结束感谢您的阅读-------------

本文作者： Arua
本文链接： https://blog.visionary-5.top/2024/10/18/NAND2Tetris%E2%80%94%E2%80%94project1/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！

赏

如果给你带来一点启发，可以请我喝一杯下午茶吗？

支付宝