# Building My Own CPU - Part 3: Just Like the Simulations (It Was Not Just Like The Simulations) / 构建我自己的 CPU - 第三部分：就像模拟中一样（才怪）

Table of Contents / 目录

*[Recap/Intro / 回顾与简介](#recapintro) *[So Much for “No Breadboards” / “不用面包板”的诺言破灭了](#so-much-for-no-breadboards) *[Custom PCBs from PCBWay / 来自 PCBWay 的定制 PCB](#custom-pcbs-from-pcbway) *[Real-World Demons (a.k.a. stuff Logisim didn’t warn me about) / 现实世界中的恶魔（也就是 Logisim 没有警告过我的那些事）](#real-world-demons) * [It Works! / 成功运行！](#it-works) *[“Build Techniques” / “构建技术”](#build-techniques) *[The Arduino Mega: World’s Most Overqualified ROM Loader / Arduino Mega：世界上大材小用的 ROM 加载器](#arduino-mega) *[Rolling My Own Toolchain / 打造我自己的工具链](#rolling-my-own-toolchain) *[So Is It Finished? / 那么它完成了吗？](#so-is-it-finished) *[What’s Next? / 下一步是什么？](#whats-next) * [Conclusion / 结论](#conclusion) *[Now Let’s Talk About PCBWay! / 现在我们来谈谈 PCBWay！](#now-lets-talk-about-pcbway) * [Thanks for Reading! / 感谢阅读！](#thanks-for-reading)

--- > ℹ️ **Info / 提示** > > Hello! This is the third part of the series about [WCPU-1](https://willwarren.com/tags/wcpu-1/), my homebrew 8-bit computer. > 你好！这是关于我的自制 8 位计算机 [WCPU-1](https://willwarren.com/tags/wcpu-1/) 系列文章的第三部分。 > > Check out [Part 1](/2025/04/29/building-my-own-cpu-wcpu-part-1) and[Part 2](/2025/08/14/building-my-own-cpu-wcpu-part-2-simulation)! > 欢迎阅读 [第 1 部分](/2025/04/29/building-my-own-cpu-wcpu-part-1) 和[第 2 部分](/2025/08/14/building-my-own-cpu-wcpu-part-2-simulation)！ ## Recap/Intro / 回顾与简介 Let’s just get this over with: 我们就直奔主题吧： ![A photo of the full build in a darkened room. A rat’s nest of wires cover a malevolent red glow as the computer works](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/cover.jpeg) *Don't look it directly in the eye! / 别直视它的眼睛！* So in [Part 2](/2025/08/14/building-my-own-cpu-wcpu-part-2-simulation) I simulated the whole design in Logisim-Evolution and tweaked it until I was happy. I was emboldened, and felt pretty confident that I wasn’t going to make any **Big Mistakes** with the real hardware… 在 [第 2 部分](/2025/08/14/building-my-own-cpu-wcpu-part-2-simulation) 中，我在 Logisim-Evolution 中模拟了整个设计并进行微调，直到自己满意为止。我胆子变大了，并且非常自信地认为我在实际硬件上不会犯任何**大错**…… ![“The ‘is this a pigeon’ meme but it says foreshadowing instead of pigeon”](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/is-this-a-foreshadowing.png) *Maybe... / 也许吧...* This post covers what actually happened when I started building the physical thing. Spoiler: it was humbling. There are backwards LEDs, floating address lines, cursed EEPROMs, and at one point I just learned to read binary by staring at some blinking lights because I’ve been too lazy or distracted to build an output register yet. 这篇文章记录了我开始构建实际物理硬件时到底发生了什么。剧透一下：它极其令人感到挫败。出现了装反的 LED、悬空的地址线、被诅咒的 EEPROM，甚至有一次我仅仅通过盯着闪烁的灯就学会了读二进制数，因为我太懒或者太分心，还没搭好一个输出寄存器。 This build of WCPU-1 should be seen as a *prototype* to validate the design and wiring before moving to the “real” PCB design. 这次构建的 WCPU-1 应该被看作是一个*原型*，用于在转入“真正的” PCB 设计之前验证设计和布线。 I’ve written this in a sort of “don’t make my mistakes, kid” war-story style, so it’s a little crazed at times and probably a little embarrassing, but here we are. 我用一种类似“孩子，别重蹈我的覆辙”的战场回忆录风格来写这篇文章，所以有时可能会显得有点抓狂，或许还有点尴尬，但我们还是走到了这一步。 Also it’s very, very long. Sorry. 另外，这篇文章非常、非常长。抱歉。 You already saw the “hero shot” of the build with all the red lights looking like something out of the Upside-Down, but here’s another shot in the light of day: 你已经看过了这张设备的“高光照片”，所有的红灯让它看起来像是《怪奇物语》里“逆世界（Upside-Down）”的东西，不过这里有一张它在白天的样子： ![](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/full-build.jpeg) ## So Much for “No Breadboards” / “不用面包板”的诺言破灭了 Of course, right out the gate I made some decisions which eventually felt like mistakes. 当然，一开始我就做出了一些后来感觉像是错误的决定。 With the schematics roughed out in KiCAD (mostly traced from my Logisim design, which worked shockingly well as a reference), I started ordering parts from Digikey. If you plan ahead you can hit the free shipping threshold, which I’m going to pretend was strategic and not just the result of buying way too many LEDs. 在 KiCAD 中画出大致的原理图后（主要是从我的 Logisim 设计中描绘过来的，事实证明它作为参考的效果惊人地好），我开始从 Digikey 订购零件。如果你提前规划，就能凑够免邮门槛，我打算假装这是我的策略，而不是因为买了太多 LED 的结果。 In my mind I was thinking that I want everything on the **final** build to be Surface Mount Technology (SMT) and so that’s pretty much what I ordered. I was going to make a few PCBs and connect them all together (how??) to experiment/validate ideas. But in the end there was so much rearranging that I decided to only create a couple of PCBs (more on that later) and do the rest breadboard style. Only you can’t put SMT chips into breadboards… 在我的设想中，我希望**最终**版本上的所有东西都采用表面贴装技术（SMT），所以我基本上订购的都是这类零件。我打算制作一些 PCB 并将它们连接在一起（怎么连？？）来实验和验证想法。但最后，因为有太多需要重新调整的地方，我决定只做几块 PCB（后文会详述），其余部分则用面包板搭建。只是，你没法把 SMT 芯片插进面包板里…… ![Photo of an IS62C256AL soldered onto an adapter board. The combined size is larger than the DIP package would have been.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/soldered-smt.jpeg) *The DIP version would have taken up less space too... / DIP 封装版本占用的空间甚至会更小……* So if I had to do this again, I would always order a bunch of SMT parts, but also 2-4 of the DIP version of the same chip from the same manufacturer for testing/validation. They are almost always available. If I’m going to end up using breadboards everywhere anyway, might as well just get DIP packages for the prototype. 所以如果让我重来一次，我依然会订购一堆 SMT 零件，但同时也会从同一制造商那里订购 2-4 个相同芯片的 DIP 版本用于测试和验证。它们几乎总是能买到。如果我最终还是要到处用面包板，倒不如在原型机上直接买 DIP 封装。 Adapter/breakout boards to the rescue. 好在转接板/分线板拯救了我。 ## Custom PCBs from PCBWay / 来自 PCBWay 的定制 PCB I ordered three custom PCBs for the first batch: 我为第一批订购了三块定制的 PCB： ### The EEPROM Programmer Board / EEPROM 编程器板 This was the first board I needed to have since without it I can’t program the microcode ROMs and nothing else will work. 这是我需要的第一块板子，因为没有它我就无法烧录微代码 ROM，其他一切也就无从谈起。 It’s a standalone tool that lives outside the computer. I put the EEPROM into the socket, and connect via serial to my laptop to upload the binary files. 它是一个存在于这台计算机之外的独立工具。我把 EEPROM 放入插座中，然后通过串口连接到我的笔记本电脑上传二进制文件。 ![Photo of the EEPROM programmer. An Arduino Nano clone can be seen on the left, and the socketed EEPROM is visible on the right.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/eeprom-programmer.jpeg) *It looks nice but will it work? / 看起来不错，但能用吗？* I had Claude Code help me design and implement a serial protocol for sending files over the wire and having them get written to the chip. This pairs with the microcoding system I created in python, which generates the binary files and then also connects to the serial port directly and uploads them. It’s pretty neat and allowed for pretty quick iteration! 我让 Claude Code 帮我设计并实现了一个串行协议，用于通过线路发送文件并将其写入芯片。这与我用 Python 编写的微代码系统相配合，该系统会生成二进制文件，然后直接连接到串口并上传它们。这非常简洁，也让我得以快速迭代！ #### Mistakes / 犯下的错误 The Arduino Nano (clone) on the board is connected to all the address and data lines via 2 shift registers. 板子上的 Arduino Nano（克隆版）通过 2 个移位寄存器连接到所有的地址和数据线。 ![](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/eeprom-programmer-schematic.png) But it’s also connected to the control pins (`OE`, `WE`, `CE`) via the shift registers!! That means the most significant three bits of the data being shifted out also control when and how the data is written. 但它**同样**也通过移位寄存器连接到了控制引脚（`OE`、`WE`、`CE`）！！这意味着移出的数据的最高三位也控制着数据何时写入以及如何写入。 This unfortunately limited the speed at which I could safely write to the EEPROMs. If I had those 3 pins just connected to free GPIOs on the Arduino, I could have used the Page Write capabilities of the chips, which allows for writes waaaay faster than one byte at a time. In my testing I could rewrite the entire 8KB EEPROM in about 80s one byte at a time, and in about 1.3s with page writes. 不幸的是，这限制了我能安全写入 EEPROM 的速度。如果我仅仅把这 3 个引脚连接到 Arduino 的空闲 GPIO 上，我就能使用芯片的页写入（Page Write）功能，它比逐字节写入要快得**多多多多**。在我的测试中，逐字节写入重写整个 8KB EEPROM 大约需要 80 秒，而使用页写入则只需要约 1.3 秒。 That said, in “slow mode” it did work on the first try, which is a win in my book. 尽管如此，在“慢速模式”下它一次就成功运行了，在我看来这已经算是一场胜利了。 ### The Generic Register Board / 通用寄存器板 This was probably my greatest success in this project so far. 这可能是我迄今为止在这个项目中最成功的部分。 I designed a generic register PCB which contained a `74HC377` octal D type flip flop (to hold the actual data) and a `74HC245` for its tristate bus connection. 我设计了一块通用寄存器 PCB，它包含一个 `74HC377` 八 D 型触发器（用于保存实际数据），以及一个用于三态总线连接的 `74HC245`。 This way I could just connect all the registers to the same bus, and differentiate them by which IN and OUT control lines they were connected to. Very tidy. 这样我就可以将所有寄存器连接到同一条总线上，并通过它们所连接的 IN 和 OUT 控制线来区分它们。非常整洁。 ![Photo of the generic Register PCB. It has 2 big-ish IC’s on it (the 74HC377 and the 74HC245) and 8 red LEDs](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/register-pcb.jpeg) *You can tell this is the instruction register because of the professional white marker usage / 从这专业的白色记号笔使用痕迹，你就能看出这是指令寄存器* Other than IN, OUT and power pins, the left set of 8 pins is the I/O connection to the `74HC245`. The right-hand set of pins is the output pins from the `74HC377`. Of course there are also many blinkenlights showing the internal state of the register. Super handy for debugging! 除了 IN、OUT 和电源引脚外，左边的一组 8 个引脚是连接到 `74HC245` 的 I/O 接口。右边的一组引脚是 `74HC377` 的输出引脚。当然，板子上还有许多闪烁的指示灯（blinkenlights）显示着寄存器的内部状态。对于调试来说超级方便！ #### A Note on the `74HC377` / 关于 `74HC377` 的说明 In future builds I would probably choose to work with the `74HC574` instead. The reason being that the ‘377 doesn’t have tristate outputs - so you require something like the ‘245 to connect to a shared data bus, adding 1 extra chip to your count. 在未来的版本中，我可能会选择使用 `74HC574`。原因在于 '377 没有三态输出——因此你需要像 '245 这样的元件来连接到共享数据总线，这给你的芯片总数增加了一个额外的负担。 The drawback of something like the ‘574 is that there’s no way to see the internal state without outputting it somewhere (like the bus). So for debugging and demonstrator type projects, the 377 is fine because you can connect it to some LEDs as I have done, and then into a bus transceiver, but if you just use the 574 in the exact same way, you ALSO have the option to reduce your chip count since you don’t need the `74HC245`. Drawback obviously being fewer blinkenlights. 像 '574 这样的芯片缺点是，如果不把它输出到某个地方（比如总线），你就没法看到它的内部状态。所以对于调试和演示类的项目来说，用 377 是可以的，因为你可以像我一样把它连接到一些 LED 上，然后再进入总线收发器。但如果你用完全相同的方式使用 574，你**同样**也可以选择减少芯片数量，因为你不再需要 `74HC245`。缺点很明显，就是可以闪烁的灯变少了。 This board worked perfectly first try and has been rock solid, btw. No big deal 💅. 顺便提一句，这块板子也是一次成功，并且一直非常稳定。小意思啦 💅。 ### The Control Module Board 😩 / 控制模块板 😩 This board is extremely simple. It just holds the 3x `AT28C64B` EEPROMs that generate the 24-bit control word. 这块板子极其简单。它仅仅放置了 3 块产生 24 位控制字的 `AT28C64B` EEPROM。 It takes addresses in, and poops out the microcode steps, asserting/deasserting control lines and driving the whole computer. Simple right? 它接收地址输入，然后“拉出”微代码步骤，拉高或拉低控制线，驱动整台计算机。很简单对吧？ I designed the schematic and the PCBs, sent them off to PCBWay and all was well! 我设计了原理图和 PCB，发给了 PCBWay，一切看起来都很美好！ Then a bunch of bad things happened: 紧接着一堆倒霉事发生了： * The boards were mis-shipped on the first attempt by PCBWay. I received some other random person’s PCBs. Got it re-made and re-shipped, not a huge deal (more on this below) *PCBWay 第一次把板子发错了。我收到了某个陌生人的 PCB。让他们重新制作并重新发货了，不是什么大问题（下面会详细说明）。* * I inverted `CE` in the schematic which is actually active-HIGH. So in the microcode ROM I have to invert it, again *我在原理图中反转了 `CE` 引脚，而它实际上是高电平有效（active-HIGH）的。所以我必须在微代码 ROM 里再次把它反转回来。* * Oh, and whoops, no decoupling capacitors anywhere. I bodged some in afterwards. *噢，哎呀，哪里都没有去耦电容。后来我飞线凑合加了一些。* * There was another massive design flaw: the Output Enable and Write Enable pins weren’t connected to anything at all! They were just floating and doing whatever they wanted, meaning that they were corrupting themselves continuously. I performed the world’s smallest bodge 6 times, and that issue was resolved *还有一个巨大的设计缺陷：输出使能（OE）和写使能（WE）引脚根本没有连接任何东西！它们处于悬空状态，随心所欲，这意味着它们在持续不断地损坏自身的数据。我飞了 6 根世界上最小的线（bodge），然后这个问题就解决了。* * I INSTALLED ALL 36 LEDs BACKWARDS. Every single one. I had to rotate them individually with my hot air station and tweezers. Very zen, but very, VERY tedious *我把所有的 36 个 LED 全都装反了。每一个都是。我不得不用热风枪和镊子一个个把它们转过来。非常考验禅意，但也非常、非常枯燥。* ![Photo of the completed control module PCB. Three EEPROMs in their sockets are visible, along with the 3 shift registers with their bodged decoupling capacitors. Some of the LEDs are glowing.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/control-logic-pcb.jpeg) *This PCB has been through it / 这块 PCB 真是历经沧桑* After all that, to my surprise, it worked perfectly. Or so I thought… (foreshadowing again!!!). 经历了这一切之后，让我惊讶的是它居然完美运作了。至少我是这么认为的……（又是伏笔！！！）。 To see my review of PCBWay’s services, scroll almost all the way to the bottom. 如果你想看我对 PCBWay 服务的评价，请滚动到文章的最底部。 ## Real-World Demons (a.k.a. stuff Logisim didn’t warn me about) / 现实世界中的恶魔（也就是 Logisim 没有警告过我的那些事） !["Just like the simulations" meme](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/just-like-the-simulations.png) **Spoiler**: It was ***NOT*** just like the simulations. **剧透**：它**根本不**像模拟里的那样。 ### 1. The Clock / 1. 时钟信号 I built my clock on some perfboard, with some little switches to choose between single step, adjustable 555, and a 1MHz crystal oscillator. 我在洞洞板（perfboard）上搭建了我的时钟模块，带有一些小开关，可以在单步执行、可调 555 定时器和 1MHz 晶体振荡器之间进行选择。 ![Photo of the clock. It is a messy build on perfboard/veroboard.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/clock.jpeg) *Photo from before it was assimilated / 融入系统前的遗照* This surprisingly actually works OK! I can basically go from ~0.5Hz to about 450Hz with the 555, and the single step button is nicely debounced with another 555 timer. 这块板子出人意料地好用！通过 555 定时器，我基本上能在约 0.5Hz 到大约 450Hz 之间调节，而单步按钮也用另一个 555 定时器做好了优秀的防抖处理。 One minor issue is that the switches to change between modes are not properly debounced and can cause the occasional glitch. A workaround is to just hold the computer in reset, choose the mode, and then take it out of reset. It’s only really an issue going to/from 1MHz mode. I’ll fix it in the real deal. 一个小问题是，用于在模式间切换的开关没有做适当的防抖，偶尔会导致故障（glitch）。变通的方法是，让计算机保持在复位状态，选择模式，然后再退出复位状态。这通常只有在切换到 1MHz 模式或从 1MHz 切出时才会出现问题。我会在最终版本中修复它。 #### Gross Edges / 糟糕的边沿 The clock module does not produce very nice edges. I eventually fixed this by routing the output into a Schmitt Inverter which has some built-in hysteresis and cleaned those edges right up. 这个时钟模块产生的边沿非常不干净。我最终通过将输出接入具有一定迟滞特性（hysteresis）的施密特反相器（Schmitt Inverter），把这些边沿整理得干干净净。 ![](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/gross-clock-edge.png) The yellow line here is the drooopy clock signal. This is a combination of poor power distribution and bad wiring. The blue line is an example of a downstream device spuriously going low at the wrong time because of the “falling edge” in the middle of the clock pulse. 这里的黄线是拖沓的时钟信号。这是糟糕的配电和不良布线共同造成的。蓝线是一个示例，显示了下游设备因为时钟脉冲中间出现的假“下降沿”，而在错误的时间被意外拉低。 So now the flow is from the clock module -> schmitt inverter (produces my `~CLK` signal) -> into another Schmitt inverter (produces my `CLK` signal). In later/better versions I will probably still use the Schmitt inverters because they sort of guarantee a level of edge quality that we want. 所以现在的流程是：从时钟模块出发 -> 进入施密特反相器（产生我的 `~CLK` 信号）-> 再进入另一个施密特反相器（产生我的 `CLK` 信号）。在后续更好版本的设计中，我可能仍会使用施密特反相器，因为它们在某种程度上保证了我们所需的边沿质量。 ### 2. Instruction Register, Flags and T-State Timing / 2. 指令寄存器、标志位与 T 状态时序 The Instruction Register, the Flags Register and the T-State counter all feed directly into the EEPROMs, and thus cause the control lines to change. If we are latching all registers on the rising edge of the `CLK` signal, that causes a problem. 指令寄存器、标志寄存器和 T 状态（T-State）计数器都直接将数据馈入 EEPROM 中，进而导致控制线发生变化。如果我们让所有寄存器都在 `CLK` 信号的上升沿锁存数据，这就会引发一个问题。 ![Crudely hand drawn timing diagram showing a pulsing CLK signal, and T and F signals which do not rise at the same time.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/quote-timing-diagram-unquote.png) *"Timing Diagram" / “时序图”* In this amazing diagram `T` is the t-state counter and `F` is the flags register, for example. 在这个令人惊叹的手绘图里，举例来说，`T` 是 T 状态计数器，`F` 是标志寄存器。 We want `T` AND `F` to change at the green line (or the blue line) NOT in the middle of an instruction happening. They need to change **together**. 我们希望 `T` 和 `F` 在绿线（或蓝线）处改变，而不是在指令执行的中间发生改变。它们需要**同时**改变。 If we could move `F` back, then that means the falling edge of `CLK` is where we do all the setup. `CLK` goes low. Chaos ensues. Control lines are asserted and deasserted. Data goes on the bus, sometimes from more than one place. In the distance, sirens. 如果我们能把 `F` 往后移，那就意味着在 `CLK` 的下降沿我们完成了所有的准备（setup）。`CLK` 变低电平。混乱随之而来。控制线被拉高和拉低。数据跑到总线上，有时还不止来自一个地方。远处仿佛传来了警笛声。 It should also be noted that the Instruction Register has the same issue! And we can’t just clock these registers with the `~CLK` signal since then they would be a whole cycle too late. 需要注意的是，指令寄存器也存在同样的问题！我们不能简单地用 `~CLK` 信号来驱动这些寄存器，因为那样它们会晚整整一个周期。 #### The Solution / 解决方案 To solve this, I tied the outputs of the Flags Register and Instruction Register into another `74HC377`, which was clocked with the rising edge of the `~CLK` signal (which is also the falling edge of the `CLK` signal). With the Output Enable pin tied low, the clock pin has all the control over when that value will emerge, and start controlling the EEPROMs. 为了解决这个问题，我把标志寄存器和指令寄存器的输出接入了另一个 `74HC377`，它由 `~CLK` 信号的上升沿（也就是 `CLK` 信号的下降沿）提供时钟。只要把输出使能（Output Enable）引脚拉低，时钟引脚就拥有了决定这个值何时显现并开始控制 EEPROM 的所有控制权。 Now, all the craziness of the setup time happens at once, and we don’t need to worry about control lines going nuts in the middle of an instruction. 现在，建立时间（setup time）带来的所有疯狂变动都会同时发生，我们不需要再担心控制线在指令执行中途发疯了。 ### 3. EEPROM Glitches / 3. EEPROM 故障尖峰（Glitch） The EEPROMs I’m using for the control module glitch a lot when the input address changes. Here’s a nice example - the yellow line is an address pin changing, and the blue line is the EEPROM glitching temporarily low for about 25ns. 我用于控制模块的 EEPROM 在输入地址改变时会出现很多毛刺故障。这是一个很好的例子——黄线是地址引脚在变化，蓝线是 EEPROM 出现约 25ns 的临时低电平毛刺。 ![](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/eeprom-glitch.jpeg) The datasheet for the AT28C64B actually covers this topic pretty well. Basically once the address pins change, for the next up-to-150ns, ANYTHING CAN HAPPEN. An output pin that was low can flicker high and then back low. High pins can do the opposite (like in my photo). It can start raining upwards, and hamburgers will eat people. Once the 150ns is over, everything is rock solid and stable. AT28C64B 的数据手册其实很好地涵盖了这个问题。基本上，一旦地址引脚发生改变，在接下来的长达 150ns 内，任何事情都有可能发生。一个原本是低电平的输出引脚可能会闪一下高电平然后又变回低电平。高电平的引脚也可能出现相反的情况（就像我照片里那样）。雨可能会往天上倒着下，汉堡会吃人。一旦 150ns 过去，一切就都坚如磐石，恢复稳定了。 Generally this is not a MASSIVE issue as long as your entire build is synchronous and you have separate phases for setup and latching, as I have explained above. Essentially, nothing is latching anything during this glitchy time anyway so it’s fine. Values on the bus are ignored. All is well… 通常来说，这算不上什么**大**问题，只要你的整个架构是同步的，并且正如我上面解释的，你有独立的建立（setup）和锁存（latching）相位。从本质上讲，在这个毛刺频发的时期，不管怎样都没有东西在锁存任何数据，所以没关系。总线上的值会被忽略。一切都好…… #### Even Worse Glitches? / 还有更糟的毛刺？ Now, given that I just said that glitches at address changes are a known and normal thing, why would THIS be happening? 🤔 既然我刚说了地址改变时的毛刺是已知且正常的现象，那为什么还会发生下面**这种**事呢？🤔 The blue line is one of the control lines coming out of the EEPROM. The yellow line is CLK. 蓝线是从 EEPROM 出来的一根控制线。黄线是 CLK。 ![Oscilloscope screenshot. It shows a square wave (the CLK signal) and another line that is erratically oscillating, rather than holding a specific level.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/eeprom-glitch-worse.png) And here again, you can see the `CLK` goes low, and the EEPROM just goes crazy, and not just for 150ns! It just keeps glitching for the whole low cycle, and then also at some random times. 再看这里，你可以看到 `CLK` 变低电平，EEPROM 直接发狂了，而且不止 150ns！它在整个低电平周期内都在持续产生毛刺，甚至在一些随机时间也会发作。 ![Oscilloscope screenshot. The glitches are worse now, and seemingly random](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/eeprom-glitch-worser.png) Here’s the weirdest example I was able to capture where one of the control lines was just oscillating forever. This was true even with the `CLK` halted etc. crazy stuff. 这是我能捕捉到的最诡异的例子，其中一根控制线干脆就开始无休止地振荡。即使在 `CLK` 暂停的情况下也是如此，太疯狂了。 ![Oscilloscope screenshot. Now the glitches are just perpetual, and not affected by the clock at all. Something is wrong.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/eeprom-glitch-even-woorrserr.png) **So what is to blame?** A bad solder connection 🤦🤦🤦 **那么罪魁祸首是谁呢？**是糟糕的焊接引脚 🤦🤦🤦 Yes. Not one, but TWO of the address lines had no continuity to not one, but two of the EEPROMs 🤦🤦🤦🤦🤦🤦🤦🤦 没错。不是一根，而是有**两根**地址线与不只一个，而是**两个** EEPROM 完全没有导通 🤦🤦🤦🤦🤦🤦🤦🤦 So those address lines were essentially floating, meaning that they are interpreted as just…whatever…at any time they felt like it. 所以那些地址线基本上是处于悬空状态的，这意味着它们在任何自己开心的时候，都会被随机解释成……随便什么鬼东西。 I resoldered those connections and it has been rock solid ever since 🙃 我重新焊接了这些连接点，从那以后它就稳如老狗了 🙃 I always, always, always do continuity checks after assembling PCBs, but this time I was so excited to get going that I didn’t do it, and it cost me probably multiple tens of hours debugging strange behaviour. Don’t be like me. 在组装完 PCB 之后，我总是、总是、总是会做导通测试，但这次我太兴奋了急着想让它跑起来，结果没做，这大概浪费了我好几十个小时去调试奇奇怪怪的行为。别像我一样。 Anyway… 不管怎样…… ### 4. RAM Timing / Bus Contention / Asynchronous Chaos / 4. RAM 时序 / 总线冲突 / 异步混乱 I was going to write a really long explanation of this, but instead I think I’ll just keep it short and sweet to save my sanity. 我本来打算对这个问题写一大段长篇大论的解释，但我想了想还是长话短说吧，为了保住我的理智。 Basically anything that was writing to RAM would sometimes work and sometimes not. This is becoming a theme! 简而言之，任何向 RAM 写入数据的操作都会时而成功，时而失败。这快成为本项目的主旋律了！ What I realized is now insanely obvious in hindsight, and I feel dumb for not realizing/solving sooner. 事后看来，我意识到的问题简直明显得离谱，我感觉自己太蠢了，竟然没有早点发现并解决它。 The RAM chip I’m using (`IS62C256AL`) is asynchronous, meaning it has no clock signal to tell it when to do things. If you want to get it to write whatever is on the bus to itself, you bring the `~WE` (write enable) pin low, then when you take it high again, the data is written. Nice. 我使用的 RAM 芯片（`IS62C256AL`）是异步的，意味着它没有时钟信号来告诉它何时该做事。如果你想让它把总线上的任何东西写入自己，你就把 `~WE`（写使能）引脚拉低，然后当你再次把它拉高时，数据就被写入了。很好。 In my design, the control signal `RI` (RAM IN) is wired directly to the `~WE` pin on the `IS62C256AL`. 在我的设计中，控制信号 `RI`（RAM 输入）直接连到了 `IS62C256AL` 的 `~WE` 引脚上。 Maybe you can see where this is going. The `RI` control signal is driven by our glitchy friends the EEPROMs. So naturally if `RI` glitches high-low-high or low-high-low or any other pattern, the RAM chip will store whatever is on it’s I/O pins at that instant. What is on it’s I/O pins at that instant is highly (astronomically) unlikely to be what you actually want at that instant. 也许你能猜到接下来会发生什么了。`RI` 控制信号是由我们那浑身毛刺的朋友——EEPROM 驱动的。因此，自然而然地，如果 `RI` 出现了高-低-高或低-高-低或其他任何模式的毛刺，RAM 芯片就会存储那一瞬间出现在它 I/O 引脚上的任何东西。而那一瞬间在它 I/O 引脚上的东西，极大概率（简直是天文概率）不是你那一瞬间真正想要的数据。 #### Solution / 解决方案 The solution is to “gate” the `RI` signal with our clock signal. That is to say, that the RAM should completely ignore `RI` until a time of our choosing. 解决方案是用我们的时钟信号对 `RI` 信号进行“门控（gate）”。也就是说，RAM 应该完全忽略 `RI`，直到我们选定的那个时刻。 In my design’s case, the time we choose is the rising edge of `CLK`. That is the time that we’ve chosen for all things to latch data, and RAM shouldn’t be any different. 在我的设计中，我们选择的时间是 `CLK` 的上升沿。这是我们为所有设备选择的锁存数据的时间，RAM 也不应该例外。 ![Timing diagram for writing to the IS62C256AL. It is a screenshot from the datasheet.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/ram-timing-diagram.png) The RAM commits data on the **rising edge of the active-low `~WE` signal**. That means we need to gate `RI` with `~CLK` so the write only completes at the correct time. That will produce a LOW signal (which starts the write process) only if `RI` AND `~CLK` are both low. Then when `~CLK` changes, `WE` will go high again, committing the write at the time we wanted. RAM 在**低电平有效的 `~WE` 信号的上升沿**提交数据。这意味着我们需要用 `~CLK` 门控 `RI`，这样写入操作就只会在正确的时间完成。只有当 `RI` 和 `~CLK` 均为低电平时，才会产生一个低电平信号（启动写入过程）。然后当 `~CLK` 改变时，`WE` 将再次变高，从而在我们需要的时间点提交写入。 **This fix solved the last problem that was plaguing the build.** **这个修复解决了困扰这次硬件组装的最后一个问题。** ## It Works! / 成功运行！ After finally fixing the RAM timing issue, everything finally clicked (clocked?) into place. 在终于解决 RAM 时序问题后，一切终于各就各位（或者说各合其时（clocked）？）了。 The computer runs. At 1 MHz. All tested programs execute correctly. It can run fine unattended for days at a time. 这台计算机跑起来了。以 1 MHz 的速度。所有测试的程序都能正确执行。它甚至可以在无人值守的情况下连续正常运行好几天。 23 instructions, 3 addressing modes, 256 bytes of RAM (for now). It’s Turing complete. 23 条指令，3 种寻址模式，256 字节的 RAM（目前）。它是图灵完备的。 Fibonacci, counting loops, conditional branching all working fine at full speed. 斐波那契数列、计数循环、条件分支，都在全速下运行良好。 I’ve gotta say the feeling of seeing the whole thing working perfectly, and handling anything you can throw at it is just amazing. It’s been a long road but I’ve learned a **LOT**. 我不得不说，看到整个系统完美运行，并且能处理你扔给它的任何任务，这种感觉真是太棒了。这是一段漫长的旅程，但我学到了**超级多**。 Check out this video of the wire jungle running the Fibonacci sequence (still with the temporary Arduino-based output register): 来看看这段视频吧，这堆飞线组成的丛林正在运行斐波那契数列（当时还在使用基于 Arduino 的临时输出寄存器）：

## “Build Techniques” / “构建技术” After fixing the timing issues and glitches, and the computer was finally stable, we get to another topic: how this thing was actually wired together. 在修复了时序问题和毛刺并且计算机终于稳定下来之后，我们来到了另一个话题：这玩意儿到底是怎么接线的。 I put the section title in quotes basically because there were no techniques. I just used solid core wire and joined things together with whatever length would reach. I was quite afraid this would limit the speed at which I could run the computer, but really it just meant I needed really good power connections throughout the build and a LOT of bulk and bypass capacitors (I used 1uF and 100nF respectively) 我给这节的标题打上引号，主要是因为压根儿没有什么技术可言。我只是用实芯线把东西连在一起，能碰到哪算哪长。我原本非常担心这会限制计算机运行的速度，但实际上它只意味着我在整个组装过程中需要非常好的电源连接，以及大量的大容量电容和旁路电容（我分别使用了 1uF 和 100nF）。 There is no organization, and no structure really, except a couple of co-located things. 除了几个摆在一起的东西之外，确实没有什么组织，也没有什么结构可言。 Here is a map of the thing, but be warned: this image may disturb you 😂 这里有一张这个设备的区域分布图，但警告你：这张图可能会让你感到不适 😂 ![A photo of the full build with various areas crudely circled in mspaint](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/full-build-map.jpeg) In this image you can see: 在这张图里你可以看到： * **CLK** (the clock / 时钟) * **~CLK** (actually just the schmitt triggers for the CLK / 实际上只是时钟的施密特触发器) * **CONTROL** (EEPROM-based control logic / 基于 EEPROM 的控制逻辑) * **PC** (Program counter / 程序计数器) * **T** (T-step counter / T 步计数器) * **BUS** (the bus / 总线) * **RAM+MAR** (RAM and Memory Address Regsister / RAM 和内存地址寄存器) * **1** (the ALU, not sure why I put 1. There is also the zero detect logic and its bus transceiver / 算术逻辑单元 (ALU)，不知道我为什么标个 1。这里还有零检测逻辑及其总线收发器) * **FLAGS** (The flags register / 标志寄存器) * **IR** (Instruction Register / 指令寄存器) * **IF** (the 74HC377 that gates IR and FLAGS to the correct `~CLK` phase / 将 IR 和 FLAGS 选通到正确 `~CLK` 相位的 74HC377) * **X**,**A** (registers / 寄存器) * **B** (the B register plus all the XOR gates used for the SUB instruction / B 寄存器以及用于 SUB 指令的所有异或门) I will say that it all came together quite quickly because I wasn’t cutting, stripping, and bending a zillion little wires to the perfect length. 我得说，组装起来相当快，因为我没有把成千上万根小电线剪裁、剥皮并弯折到完美的长度。 For me personally, I feel like I know the design inside and out, so troubleshooting is not a problem. But if you are new or learning, I would **NOT** recommend the “bundle of airwires” approach. 对我个人而言，我觉得自己对这个设计了如指掌，所以排除故障不是问题。但如果你是新手或正在学习，我**绝不**推荐这种“一大束飞线（airwires）”的搭建方法。 Each wire is also basically a capacitor, so if there is contact resistance from crappy breadboards for example, you’ve created a nice little RC filter which will slow down your nice sharp signal edges into loong slow curves instead. So **beware**! And scope everything with the oscilloscope if you can! 每一根导线本质上也相当于一个电容，因此如果存在比如来自劣质面包板的接触电阻，你就等于制造了一个不错的小 RC 滤波器，它会将你漂亮锐利的信号边沿减缓成漫长的缓坡。所以**要当心**！如果可以的话，用示波器检查所有的东西！ ## The Arduino Mega: World’s Most Overqualified ROM Loader / Arduino Mega：世界上大材小用的 ROM 加载器 Using DIP switches to load a program into RAM got very old very quickly. Since this machine has 256 usable bytes of RAM, the programs can get kind of long. 用 DIP 拨码开关把程序加载到 RAM 里这事儿很快就让人厌烦了。既然这台机器有 256 字节的可用 RAM，程序可能会变得相当长。 Instead I sort of hacked an Arduino Mega into the middle of it. 作为替代，我半黑客式地把一块 Arduino Mega 塞进了系统中间。 It’s directly connected to the bus and some of the control lines (`RESET`, `II`, `RI`, `MI`, `CLK`). 它直接连接到总线和一些控制线（`RESET`、`II`、`RI`、`MI`、`CLK`）上。 I also route the `CLK` line via a little SPDT switch which controls whether `CLK` comes from the actual clock, or from the Arduino. 我还通过一个小小的单刀双掷（SPDT）开关来布线 `CLK`，它控制着 `CLK` 是来自实际的时钟模块还是来自 Arduino。 ![](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/arduino-mega.jpeg) On boot, the Arduino pulls reset low, then shoves bytes into RAM one by one, pulsing `CLK` as it goes, and then releases the reset line and sets all the control line connections to “INPUT” (which makes them High-Z, effectively unplugging them from the circuit). 启动时，Arduino 会拉低复位线，然后将字节逐个塞入 RAM，同时发送 `CLK` 脉冲，接着释放复位线并将所有控制线连接设置为“输入（INPUT）”（这会让它们变成高阻态 High-Z，实际上等同于将它们从电路中拔出）。 So the process to load the program is: 因此，加载程序的流程如下： * Switch the `CLK` line to the Arduino *将 `CLK` 线路切换到 Arduino* * Power up the WCPU-1 if it isn’t yet *给 WCPU-1 上电（如果还没开机的话）* * Press the reset button on the Arduino *按下 Arduino 上的复位按钮* * The Arduino stuffs the program into RAM in about 10ms *Arduino 在大约 10 毫秒内将程序塞入 RAM* * Hold down the WCPU-1 reset button *按住 WCPU-1 的复位按钮* * Switch the `CLK` back to the real clock *将 `CLK` 切换回真正的时钟模块* * Let go of the reset button *松开复位按钮* This didn’t always work very well, and honestly it is a **huge hack**. The logic levels on the control lines are all over the place because the EEPROMs are also trying to drive the lines. 这并不总是很管用，老实说，这简直是个**巨大的糊弄（hack）**。控制线上的逻辑电平到处乱跳，因为 EEPROM 同样也试图在驱动这些线。 In practice, this bus fighting originally prevented the Arduino from writing to RAM at all. So in the image above you might see a thing marked LOAD that is just a `74HC245` on its own whose Output Enable pin is controlled by the Arduino. 在实际操作中，这种总线竞争（bus fighting）一开始导致 Arduino 根本无法向 RAM 写入数据。所以在上图中你可能会看到一个标有 LOAD 的东西，它只是一个单独的 `74HC245`，它的输出使能引脚由 Arduino 控制。 In this way, the Arduino can cut the EEPROM off from the `RI` line temporarily while it’s working, and then it relinquishes it back again afterwards. None of the other control signals seemed to care about the Arduino, but `RI` is incredibly sensitive. 通过这种方式，Arduino 在工作时可以暂时切断 EEPROM 与 `RI` 线的连接，然后再将其交还回去。其他控制信号似乎都不在乎 Arduino 的干扰，但 `RI` 却极其敏感。 The proper way to do this would probably be to wire the `OE` pin of all the control logic EEPROMs up to the Arduino, then you could effectively “unplug” the whole module from the computer while the Arduino loader did its thing. Unfortunately for me, I didn’t break out the `OE` pin on my Control Module PCB! 正确的做法可能是将所有控制逻辑 EEPROM 的 `OE` 引脚连接到 Arduino，这样在 Arduino 加载器工作时，你就可以有效地将整个模块从计算机中“拔出”。但很不幸，我在我的控制模块 PCB 上没有把 `OE` 引脚引出！ #### The “real” solution / “真正”的解决方案 My goal here is to remove the Arduino completely. I will divide the addressable RAM into 2x 128-byte blocks with the first being wired to (another) EEPROM. 我现在的目标是彻底移除 Arduino。我会将可寻址的 RAM 分为两个 128 字节的块，并将第一个块连接到（另一个）EEPROM。 Then the program can just live in the EEPROM permanently, and on boot the program will already be there. 这样，程序就可以永久地留在 EEPROM 中，开机时程序就已经在那里了。 I really want WCPU-1 to be a sort of one-board demonstrator. As such its only going to run *relatively* basic programs so I’m OK with the loss of RAM. 我真的希望 WCPU-1 成为一块单板展示机。正因如此，它只会运行*相对*基础的程序，所以失去一半的 RAM 对我来说也是可以接受的。 --- ## Rolling My Own Toolchain / 打造我自己的工具链 OK the Arduino is putting programs into RAM for now. But what are those programs? How do they work? How am I writing the code? How do I generate the microcode images for the glitchy EEPROMs? 好了，现在 Arduino 正在把程序放入 RAM 中。但这些程序是什么？它们是如何工作的？我是怎么写代码的？我该如何为那些充满毛刺的 EEPROM 生成微代码镜像？ Well I’m glad you asked. 很高兴你问了。 ### The Microcode Generator / 微代码生成器 It’s just a very simple Python script that builds a big array and dumps it into three binary files (`rom0.bin`, `rom1.bin`, `rom2.bin`), one for each EEPROM. Each EEPROM is responsible for 8 control signals. ROM2 has a few unused ones at the end which I could use for new functionality in future. 它只是一个非常简单的 Python 脚本，构建了一个巨大的数组，并将其导出到三个二进制文件中（`rom0.bin`、`rom1.bin`、`rom2.bin`），每个文件对应一个 EEPROM。每个 EEPROM 负责 8 个控制信号。ROM2 的末尾还有几个未使用的信号，我以后可以用它们来实现新功能。 Each instruction is defined as a list of control signal combinations per T-step. For example NOP is just `[CO | MI, RO | II | CE, N]`. It reads a bit like pseudocode for what the hardware should do at any given time. 每条指令都被定义为每个 T 步（T-step）的控制信号组合列表。例如 NOP 就是 `[CO | MI, RO | II | CE, N]`。它读起来有点像伪代码，描述了硬件在任何给定时间应该做什么。 A tricky part is conditional instructions. I apply a mask to the Flag bits so the same opcode can have completely different microcode depending on which flags are set. JC (jump if carry) literally has two different sequences baked into the image. One of them loads the new address into the PC, and one just skips past the operand. 棘手的部分是条件指令。我对标志位（Flag bits）应用了一个掩码，这样相同的操作码就可以根据设置的标志位不同，产生完全不同的微代码。比如 JC（进位则跳转，jump if carry）实际上在镜像中烧录了两种不同的序列。其中一个序列将新地址加载到 PC 中，而另一个则直接跳过操作数。 The EEPROMs have 13 total address lines and I laid them out like this: EEPROM 总共有 13 根地址线，我是这样安排它们的： ```text SZC IIIIII TTTT ``` `SZC` are the **Sign**, **Zero**, and **Carry** flags. The `I`’s are the 6 bits of the current instruction, and the `T`’s are the 4 bits of t-state. So I can have 64 different instructions each with up to 16 microcode steps. Maybe overkill. `SZC` 分别是**符号**（Sign）、**零**（Zero）和**进位**（Carry）标志。`I` 是当前指令的 6 位，而 `T` 是 T 状态的 4 位。所以我可以有 64 种不同的指令，每种指令最多可以有 16 个微代码步骤。可能有点杀鸡用牛刀了。 ### The Instruction Set / 指令集 I decided to keep it simple, since I’m not planning on adding a crazy amount of capabilities and I expect the programs in WCPU to be relatively simple. I have space for 64 different opcodes and at the moment I have 23. 我决定保持简单，因为我没打算添加疯狂的功能数量，并且我预计 WCPU 中的程序会相对简单。我有 64 个不同操作码的空间，目前我使用了 23 个。 Despite the simplicity you can find some pretty creative ways to use these instructions to make cool programs. There is also immediate and absolute addressing modes for many instructions. Meaning they can operate on either a provided literal value like `5` or a value fetched from elsewhere in memory like `$AA`. 尽管很简单，你还是能找到一些非常有创意的方式来使用这些指令编写酷炫的程序。许多指令还具有立即寻址和绝对寻址模式。这意味着它们既可以操作提供的字面值（如 `5`），也可以操作从内存其他位置获取的值（如 `$AA`）。 Check it out! 来看看吧！ | Opcode / 操作码 | Mnemonic / 助记符 | Operand / 操作数 | Description / 描述 | Flags / 标志位 | Microsteps / 微步数 | |---|---|---|---|---|---| | `0x00` | `NOP` | — | No operation
*无操作* | — | 3 | | `0x01` | `HLT` | — | Halt the CPU
*停止 CPU* | — | 1 | | `0x02` | `OUT` | — | Output register A to display
*输出寄存器 A 到显示器* | — | 3 | | `0x04` | `ADD` | imm | A = A + immediate
*A = A + 立即数* | C, Z, S | 5 | | `0x05` | `ADD` | abs | A = A + [address]
*A = A + [地址]* | C, Z, S | 6 | | `0x06` | `SUB` | imm | A = A - immediate
*A = A - 立即数* | C, Z, S | 5 | | `0x07` | `SUB` | abs | A = A -[address]
*A = A - [地址]* | C, Z, S | 6 | | `0x08` | `CMP` | imm | Set flags from A - immediate (discard result)
*根据 A - 立即数设置标志位，抛弃计算结果* | C, Z, S | 5 | | `0x09` | `CMP` | abs | Set flags from A - [address] (discard result)
*根据 A - [地址]设置标志位，抛弃计算结果* | C, Z, S | 6 | | `0x14` | `LDA` | imm | Load immediate into A
*将立即数加载到 A* | — | 4 | | `0x15` | `LDA` | abs | Load [address] into A
*将 [地址] 的值加载到 A* | — | 5 | | `0x16` | `LDB` | imm | Load immediate into B
*将立即数加载到 B* | — | 4 | | `0x17` | `LDB` | abs | Load[address] into B
*将 [地址] 的值加载到 B* | — | 5 | | `0x18` | `LDX` | imm | Load immediate into X
*将立即数加载到 X* | — | 4 | | `0x19` | `LDX` | abs | Load [address] into X
*将 [地址] 的值加载到 X* | — | 5 | | `0x20` | `STA` | abs | Store A to [address]
*将 A 存储到 [地址]* | — | 5 | | `0x21` | `STB` | abs | Store B to [address] *(not yet in hardware, not sure if I care)*
*将 B 存储到 [地址]（硬件尚未实现，不确定我是否在乎）* | — | — | | `0x22` | `STX` | abs | Store X to [address]
*将 X 存储到 [地址]* | — | 5 | | `0x30` | `JMP` | abs | Unconditional jump
*无条件跳转* | — | 4 | | `0x33` | `JC` | abs | Jump if Carry = 1
*如果进位 = 1 则跳转* | — | 4 | | `0x34` | `JNC` | abs | Jump if Carry = 0
*如果进位 = 0 则跳转* | — | 4 | | `0x35` | `JZ` | abs | Jump if Zero = 1
*如果为零 = 1 则跳转* | — | 4 | | `0x36` | `JNZ` | abs | Jump if Zero = 0
*如果不为零 = 0 则跳转* | — | 4 | | `0x37` | `JS` | abs | Jump if Sign = 1
*如果符号位 = 1 则跳转* | — | 4 | | `0x38` | `JNS` | abs | Jump if Sign = 0
*如果符号位 = 0 则跳转* | — | 4 | ### The Assembler (`wcasm`) / 汇编器 (`wcasm`) It’s all well and good having an instruction set, but you still have to write code like this: 拥有指令集固然很好，但你仍然得像这样写代码： ```text 0x14 0x01 0x04 0x01 0x02 0x30 0x02 ``` That is just not fun at all. 这真的一点也不好玩。 You know what is MORE fun? 你知道什么**更**好玩吗？ ![A screenshot of Neovim with Will’s amazing theme applied. It shows some 6502-ish assembly code, nicely syntax highlighted. The code shown calculates the Fibonacci sequence in a loop.](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/nvim-w-files.png) Custom syntax highlighting, comments, “variables”, and being able to write code in a nice ergonomic way. 自定义语法高亮、注释、“变量”，以及能够以一种符合人体工程学的舒适方式编写代码。 To turn this cool custom-syntax-highlighted `.w` file into the more boring format that the computer understands, we need an assembler. 要将这个酷炫且具有自定义语法高亮的 `.w` 文件转换成计算机能理解的更无聊的格式，我们需要一个汇编器。 Full disclaimer I did get some help from my buddy Claude Code to get through some of the boilerplate and minutiae of the coding that I generally don’t enjoy. It also created all the syntax highlighting config for my neovim setup (which you can find [here](https://github.com/phybros/kickstart.nvim/commit/55f3fc7627b2ace3cf016c5a2cbb68b53df051df)!) 在此声明，我确实从我的好兄弟 Claude Code 那里得到了一些帮助，帮我解决了一些我通常不喜欢的样板代码和枯燥细节。它还为我的 neovim 环境创建了所有的语法高亮配置（你可以在[这里](https://github.com/phybros/kickstart.nvim/commit/55f3fc7627b2ace3cf016c5a2cbb68b53df051df)找到它！） I wrote `wcasm` in Python and it takes in my `.w` files and outputs raw binary files, and also just prints out all the machine code (lol) which I can copy paste into the Arduino sketch in order to have it run on the computer. In future I will take these binary files and send them to an EEPROM via the EEPROM Programmer described earlier. 我用 Python 编写了 `wcasm`，它接收我的 `.w` 文件并输出原始的二进制文件，同时也会打印出所有的机器码（哈哈），我可以将其复制粘贴到 Arduino 项目中，以便在计算机上运行它。未来，我将把这些二进制文件通过前面描述的 EEPROM 编程器直接发送到 EEPROM 中。 I used 6502-ish syntax and wanted comments and variables and that makes it way easier to write more complex programs without losing your mind. 我使用了类似 6502 的语法，并且加入了注释和变量功能，这让编写更复杂的程序变得容易得多，免得你为此抓狂。 The assembler uses the syntax to figure out which actual opcode you wanted. For example `lda #5` is a “load A register with 5” which is opcode 0x14. Similarly `lda $e1` would load A with the value stored in RAM at address `e1`. 该汇编器根据语法来推断你实际想要哪个操作码。例如，`lda #5` 的意思是“将 5 加载到 A 寄存器”，也就是操作码 0x14。类似地，`lda $e1` 则会将 RAM 中地址为 `e1` 的值加载到 A。 It does two passes, the first one removes comments and whitespace, and records the locations of all the labels (like `loop:` above). The second pass converts all the opcodes and replaces variables and labels with real addresses. 它会进行两次遍历（two passes），第一遍移除注释和空白字符，并记录所有标签（例如上面的 `loop:`）的位置。第二遍转换所有的操作码，并将变量和标签替换为真实的地址。 ### The Full Pipeline / 完整的工作流 Worth spelling out end to end because although it is janky, it is still very satisfying: 值得把整个端到端的流程梳理一遍，因为虽然它有些简陋，但依然非常令人满足： 1. Write assembly in a `.w` file *在 `.w` 文件中编写汇编代码* 2. `wcasm.py` assembles it into a raw `.bin` *`wcasm.py` 将其汇编成原始的 `.bin` 文件* 3. The machine code gets embedded in the Arduino sketch *机器码被嵌入到 Arduino 代码（sketch）中* 4. Upload the sketch to the Arduino with the `CLK` in “Arduino mode” *在 `CLK` 处于“Arduino 模式”下，将代码上传到 Arduino* 5. Arduino loads the program into RAM, releases reset *Arduino 将程序加载到 RAM，并释放复位* 6. Switch the `CLK` back to Clock, and the CPU runs the program! *将 `CLK` 切换回时钟模块，CPU 开始运行程序！* It’s a lot of steps, but each one is dead simple and individually testable. In future of course, the Arduino will be gone, and wcasm will be enhanced to send the binary straight to the EEPROM via serial. 步骤很多，但每一步都极其简单且可以单独测试。当然，未来 Arduino 将会被移除，wcasm 也会被增强，以便通过串口将二进制文件直接发送到 EEPROM。 Also lots of other ways to make it nicer in future, but I might save that for `WCPU-2` 😉. 未来还有许多其他方法可以让它变得更好，但我可能要把这些留给 `WCPU-2` 了 😉。 ## So Is It Finished? / 那么它完成了吗？ ![](/2026/03/12/building-my-own-cpu-part-3-from-simulation-to-hardware/no.png) Nope. There are a few big things missing before I’d want to call this “finished”. There are a ton of tiny little things too but I will just list the biggest missing items. 没有。在我打算称其为“完成”之前，还有几个大项缺失。当然还有一大堆小问题，但我只列出最大的那些未完成项。 ### No Output (lol!) / 没有输出设备（哈哈！） Yes, probably one of the most visible and important components is missing. 是的，也许是最显眼、最重要的组件缺失了。 Yes, the computer works. No, it cannot display anything. 是的，计算机能工作。不，它什么也显示不了。 I had been using a second Arduino with an OLED screen (see video above) to pretend to be the output register for a while, but eventually I just watched the A register like some sort of maniac. 我曾有一段时间用第二块带 OLED 屏幕的 Arduino（见上面的视频）来伪装输出寄存器，但最后我就像个疯子一样纯靠盯着 A 寄存器的灯看。 I sort of learned how to read binary at a glance from doing this, which is kind of hilarious. 正因为这样，我甚至学会了一眼读出二进制，这有点搞笑。 What a dumb thing to not build. 没建这玩意儿真是件蠢事。 ### The Arduino Loader Situation + RAM Split / Arduino 加载器的现状 + RAM 拆分 I explained this pretty well up above, but just to recap, I want to get rid of any Arduinos in the build and rely on discrete logic and EEPROMs instead, and make the whole thing self-contained and self-managing. 128 bytes of RAM and 128 of ROM. Turn the machine on and it runs, easy! 我在上面已经解释得很清楚了，但简单回顾一下：我想去掉组装件里的所有 Arduino，转而依靠分立逻辑和 EEPROM，让整个系统自成一体并实现自我管理。128 字节的 RAM 和 128 字节的 ROM。机器一开机就能运行，很简单！ ### No HLT / 没有停机（HLT）指令 Not sure why I never wired this up, but there we go. I just need to `AND` the incoming clock signal with the `~HLT` signal and that should do the trick! Right?! 不知道为什么我一直没有把这个连上，但事实就是如此。我只需要把输入的时钟信号与 `~HLT` 信号进行一次“与（AND）”运算就可以了！对吧？！ ### Power-On/Reset / 上电/复位 Without the Arduino loader I’m gonna need a way to set the `IR`, Flags, `PC` and T-State to a known state before starting to execute the code from ROM. There are a few decent IC’s around that can help with this that I’ve heard of, but I haven’t done much research yet. 没有了 Arduino 加载器，我就需要一种方法在开始执行 ROM 中的代码之前，将 `IR`、标志位、`PC` 和 T 状态设置到一个已知的状态。我听说市面上有一些不错的 IC 可以帮忙解决这个问题，但我还没有做太多研究。 ### Replace Sign Flag with Overflow Flag / 将符号标志位替换为溢出标志位 Currently the most-significant-bit (MSB) of the last ALU result is latched in as the sign flag, which works, but I don’t really care about it that much. 目前，上一次 ALU 结果的最高有效位（MSB）被锁存为符号标志位，这行得通，但我真的不是特别在乎它。 I kind of think that an overflow flag (`V`) would be better and more useful. Then you could see if your ALU result went out of a representable range. It takes a couple more gates to implement but it’s not too bad. 我倒是觉得溢出标志位（`V`）会更好也更有用。这样你就可以看到 ALU 的结果是否超出了可表示的范围。实现它需要多用几个逻辑门，但也不算太糟。 ### Better Clock / 更好的时钟模块 Not having debouncing between speed modes is a big bummer, so I’d like to fix that before I finish the final PCB design. Speaking of… 在速度模式之间切换时没有防抖确实是个大遗憾，所以我想在完成最终 PCB 设计之前修复这个问题。说到这个…… ### The “Final” PCB / “最终版” PCB I’d like to get this all onto one self-contained PCB. I want it to be very “LED-forward” and be really interactive and tactile. Maybe I’ll even frame it or put it on my nightstand, who knows? 我想把所有的东西都集成到一块独立完整的 PCB 上。我希望它充满“LED感”，具有极强的交互性和触感。也许我还会把它装裱起来或者放在我的床头柜上，谁知道呢？ ## What’s Next? / 下一步是什么？ You can expect a Part 4 where hopefully I will have addressed all the missing features and components, and built the first and hopefully final version of the definitive WCPU-1 PCB. 大家可以期待第 4 部分，希望到那时我已经解决了所有缺失的功能和组件，并构建出第一个且希望是最终决定版的 WCPU-1 PCB。 After that…WCPU-2 of course! I have a really long wishlist of things for WCPU-2 including but not limited to: 在这之后……当然是 WCPU-2！我为 WCPU-2 列了一个长长的愿望清单，包括但不限于： * Separate buses: 16 bit address bus, 8 bit data bus *分离式总线：16 位地址总线，8 位数据总线* * 16 bit stack pointer and program counter *16 位栈指针和程序计数器* * More capable ALU: AND/OR/NAND/NOR/NOT/XOR/SHL/SHR etc *功能更强大的 ALU：与/或/与非/或非/非/异或/左移/右移等等* * much much more…… *还有许多许多……* I want to graduate into “real computer” territory and that makes me insanely excited. 我想毕业进入“真正的计算机”领域，这让我感到无比兴奋。 ### Open Sourcing / 开源计划 I will be sharing everything on my [Github](https://github.com/phybros), but not yet. 我将在我的[Github](https://github.com/phybros) 上分享一切，但不是现在。 The project is currently an incomprehensible mess of files in about 12 different folders strewn across 2 different computers 😭 目前这个项目是一堆难以理解的杂乱文件，分散在大约 12 个不同的文件夹里，且散落在 2 台不同的电脑上 😭 But yes I do plan to open source the entire thing, including the toolchain, full PCB design files, and BOM so you can get your own made and program it easily, should you want to. 但是的，我确实计划把所有东西开源，包括工具链、完整的 PCB 设计文件以及物料清单（BOM），这样如果你愿意的话，就可以轻松地制造并烧录你自己的版本。 ## Conclusion / 结论 This project has been a really long time in the works, and required a huge amount of mental energy. Sometimes I just sat there thinking about clock phases for ages, or wondered about EEPROM glitches in the shower like a totally normal person. 这个项目已经进行了很长一段时间，耗费了大量的精神能量。有时候我只是坐在那里，满脑子都是时钟相位，想上大半天；或者在洗澡的时候琢磨 EEPROM 的毛刺问题，就像一个“完全正常的普通人”一样。 A project like this is potentially a huge rabbit hole. The hardest part is knowing when to stop adding features. I came super close to adding a stack and stack pointer to WCPU-1, but in the end I feel like then I’d want to have more RAM, maybe banking, and then GPIO etc etc etc it just never ends. So knowing where to cut it off is a good idea. Keep that scope creep to a minimum! 像这样的项目很可能是一个巨大的兔子洞。最难的部分是知道何时停止添加功能。我差点就给 WCPU-1 添加栈和栈指针了，但最终我觉得那样一来我又会想要更多的 RAM，也许还要存储体切换（banking），然后是 GPIO 等等等等，这就没完没了了。所以知道在哪里适可而止是个好主意。把需求蔓延（scope creep）降到最低！ I learned an astronomical amount via this project and it’s been super rewarding so far, and I think it will continue to be ☺️. 通过这个项目我学到了海量的知识，到目前为止都觉得极具成就感，而且我相信这种感觉还会持续下去 ☺️。 For the next project, before buying a bunch of things or building another huge jungle of wires in service of WCPU-2, I’m going to have a look at FPGA development, and try to build the WCPU-1 on there. From there hopefully I can use it to rapidly prototype WCPU-2 and get the design totally finalized before getting into real components. 对于下一个项目，在为 WCPU-2 购买一堆东西或搭建另一个巨大的飞线丛林之前，我打算去看看 FPGA 开发，并尝试在那里构建 WCPU-1。希望藉此我能用它来快速搭建 WCPU-2 的原型，并在进入实际购买元件阶段之前彻底敲定设计。 ## Now Let’s Talk About PCBWay! / 现在我们来谈谈 PCBWay！ > ℹ️ **Info / 提示** > > **Disclosure**: [PCBWay](https://pcbway.com) reached out to sponsor this project. They provided the PCB fabrication and shipping for the boards described in this section for free. However, they wanted me to be as honest as possible. > **披露**：[PCBWay](https://pcbway.com) 主动联系赞助了这个项目。他们免费为本节描述的板子提供了 PCB 制造和运输服务。不过，他们希望我尽可能地诚实评价。 > > All opinions, mistakes, and backwards LEDs are my own. > 所有观点、错误以及装反的 LED 均属于我自己。 ### The Good / 优点 The PCBs themselves are of a great quality. Really nice finish, clear silkscreen, quick turnaround. All the things I expected. The major errors on the EEPROM board were totally my fault. The fabricated boards were exactly what I designed. PCB 本身的质量非常好。出色的表面处理，清晰的丝印，极快的交付速度。所有我期望的东西都满足了。EEPROM 板子上的重大错误完全是我自己的责任。制造出来的板子和我设计的完全一样。 The interactions with customer service were fast and clear, and they made things happen quickly. 与客户服务的沟通快速且清晰，他们让事情迅速得到推进。 ### The Less Good / 缺点 The Register and EEPROM Programmer boards arrived in a box with someone else’s PCBs instead of my Control Module boards which set me back a few days. 寄存器板和 EEPROM 编程器板在到达时，盒子里装的是别人的 PCB，而不是我的控制模块板，这让我耽误了几天。[PCBWay](https://pcbway.com) offered to remake and re-send the boards at no charge, which was awesome! They were incredibly proactive about this as soon as I reported the issue, and began the manufacturing of a new batch immediately. The new boards were in my hands 3 days after emailing them about the problem.[PCBWay](https://pcbway.com) 主动提出免费重新制作并补发板子，这太棒了！在我报告问题后，他们极其积极主动地处理了此事，并立即开始了新一批的生产。在给他们发邮件反映问题后的 3 天内，新板子就已经交到了我的手上。 I had to pay import duties a second time, which was a bummer, but I let customer service know and they credited that amount back to my [PCBWay](https://pcbway.com) account immediately, which was amazing. 我不得不第二次支付进口关税，这让人有点郁闷，但我通知了客服，他们立刻把这笔钱退回到了我的 [PCBWay](https://pcbway.com) 账户里，这真是太棒了。 ### Conclusion / 结论 PCBWay’s PCB fabrication service is generally awesome. I would recommend to anyone who is doing low volume hobby stuff with just a few caveats listed above. The shipping error that bit me is not common, I just got unlucky. PCBWay 的 PCB 制造服务总体来说非常出色。我会向任何做小批量爱好项目的人推荐它，只需注意上面列出的几点。坑了我的发货错误并不常见，我只是运气不好而已。 ## Thanks for Reading! / 感谢阅读！ I can’t believe you read this all the way to the end! 真不敢相信你居然把它一直读到了最后！ See you in part 4 😎 第 4 部分见 😎