Files
R8Forge/docs/hardware.md
T
dsh 1e7acc018e hardware: the 74LS machine gets a period bill of materials, and a mechanics plan
Two things: the TTL build is now the main target (Tang Nano looks too modern), and
the packer learned the format that makes the TTL build simple.

Format: r8forge_tape_pack --eprom writes one byte per instruction with the opcode
in the low three bits.  Then ip is the EPROM address and D2..D0 are the opcode --
no shift register, no 16 bit window, no decoder.  It wastes five bits per
instruction, and a 27C512 is exactly 64K, which is the historical instruction
budget: the 8 bit calculator (51378) and the flagship (43676) both fit.  Both
formats live in the same .r8t trailer now (format byte 1 = packed, 2 = one byte
per instruction), decode dispatches on it, and the test runs both and requires
the same output and step count.

Carrier: 74LS DIPs on a green board, 27C512 in a socket with its quartz window,
6116 SRAM, 74LS299 for the rotate, 6850 ACIA for serial, 74LS47 and four seven
segment displays on the panel, 1 MHz can oscillator.  About 31 to 40 chips, 400
to 700 CNY, a few weeks.  The FPGA stays as a bench-only stepping stone.

hardware/mechanics.md: where mechanics actually pays.  The program must stay
electronic (130 metres of paper tape for the calculator), and 512 relays for the
data ring are out, but the pointer is worth it -- > and < are 71 to 73 percent of
all steps, so a 64 position ratchet or uniselector makes the machine physically
walk the ring.  Also listed: an electromagnetic step counter (10 to 20 Hz, so
only in single step mode, with a clutch for free running), a paper tape punch or
plotter for output, a tape/card reader or plain keypad for input, and a hand crank
as the clock.  The rule that keeps this safe: mechanics only ever sit on sensor
and actuator pins and never in the logic path, and the handshake just stops the
sequencer while something moves -- since nothing in the ISA can observe time,
slower is not different.  A relay-only machine is priced honestly too: 60 to 120
relays, 10 to 50 Hz, hello in 10 to 40 seconds, the calculator in four hours, so
that one is an exhibit.

Also fixed: the synthesised macro fallback file name now carries a per-run token.
When the system temp directory is not writable every r8asm falls back to the same
working directory, so parallel ctest runs could write and import the same file --
which showed up as a random one-test failure in 0.39 seconds and nothing else.
2026-11-20 16:35:02 +08:00

25 KiB
Raw Blame History

ROT-8 硬件:从规格到一台机器

软件这边已经到"四份虚拟机互为对拍 + 穷举测试全绿"的程度,造硬件最大的好处是有黄金模型: 每一条纸带、每一步的 ip/dp/cell 值都能先算出来,硬件只要逐步对上就行。这份文档是设计稿, 不是承诺;先把"机器要满足什么"和"预算多少"钉死,再挑载体。

已定的两件事:物理机做 8 位 cell(11 位格子的一半是"数位语义"、一半是邪门,物理上 一个字节最好摆:,/. 天生就是一个字符); 载体的挑选见 §5,还没定。

1. 硬件的判据只有一条:状态序列

ISA 里没有任何东西能看见时间:没有计数器、没有中断、没有 ,/. 的时序语义(, 阻塞、 . 立刻)。所以硬件只要满足

第 n 条指令执行后,ip、dp、环里的每个 cell、输出流 与软件模型完全一致

就等于"同一台机器",几拍一条指令、内存多慢、能不能流水,全都不影响语义(只影响快慢)。 这条自由是造机器的关键:微码状态机、慢速内存、甚至转鼓,都是合法实现。

2. 机器规格(从 SPEC.md §1 翻成硬件需求)

存储组织是严格哈佛的:程序存储器与数据存储器是两个空间、两片器件、互不可达。 这不是架构偏好,是 ISA 保证的 —— 8 条指令里没有任何一条能读写程序存储器:>/< 只动 dp(数据环),+/- 只改当前格,[/] 只读一下当前格的最低位居中判断,,/. 只碰数据格的 I/O。ip 只有两条通路:顺序 +1,和括号跳转。所以没有自修改代码、没有 "数据当指令执行"、也就没有混在一起的隐患。另外两边的回绕语义也不同:程序纸带是 线性的(ip 走到头就停机),数据是环(dp 模 N 回绕)。

项 值 硬件含义
指令 8 条:> < + - [ ] , . 3 bit 操作码,程序存储器只读(见上:ISA 不可写)
程序 线性执行,ip 从 0 加到尾,到尾停机 程序计数器 = 程序存储器地址;没有别的跳转,只有 [/] 改 ip;不回绕
数据 64 格 × 8 bit,复位全 0,dp 初始 0 独立的一片存储器,64 字节;dp 是 6 位计数器,回绕免费(见 §3 的实测:程序峰值 51 格)
> / < dp = (dp ± 1) mod N 6 位计数器,加/减 1 自然回绕,不需要比较器
+ 整格右旋(bit0 补到最高位) 没有 ALU:8 bit 移位 + 回填(74HC299 一片,FPGA 里是接线)
- 翻最低位 一个 XOR 门
[ (biz) 最低位 = 0 → 跳到配对 ] 之后 前向扫描(或循环栈,见 §4)
] (rnz) 最低位 = 1 → 跳回配对 [(它要重跑) 后向扫描(或循环栈,见 §4)
, 整字节写入输入字符 阻塞到有字符;EOF 读成 0(见 §8)。8 位下"整格"就是"整个字节",没有截断问题
. 输出整格 8 位 = 串行 ASCII 的低 7 位(bit 7 留给校验/停止位,默认关);库里的数字都是 ≤ 57,bit 7 恒 0
停机 ip 走完纸带 一个 halt 触发器

括号扫描的确切边界(照 ROT-8-viz/src/rot8.c 的 rot8_biz/rot8_rnz,别按常识猜):

biz, 最低位 == 0:  ip++ ; 深度=0
                    while 深度 != 0 or 当前 != rnz:
                        当前 == biz ? 深度++ : (当前 == rnz ? 深度-- : 跳过)
                        ip++
                    ; 出循环时 ip 停在那个 rnz 上,主循环的 ip++ 越过它
rnz, 最低位 == 1:  ip-- ; 深度=0
                    while 深度 != 0 or 当前 != biz:
                        当前 == rnz ? 深度++ : (当前 == biz ? 深度-- : 跳过)
                        ip--
                    ip--            ; 让主循环的 ip++ 把它指回那个 biz

两条容易写错的:[ 是"跳到 ] 后面"(差一就变成死循环);] 是"跳回 [ 本身",让 [ 重新测试(不是 [ 的后面)。硬件里就是两个方向的扫描状态机 + 一个 5 bit 深度计数器 (库里最深的嵌套不到 16 层)。

3. 预算:现在的纸带要多大

一条指令 3 bit,8 条挤 3 字节;数据 64 格(-DR8FORGE_MEMORY_CELLS=64)。11/16/32 位那几行留着对照。

程序 8 位指令数 ROM (3 bit/条) 11 位指令数 16 位 32 位
examples/full_add.r8asm 95 36 B 95 95 95
examples/hello.r8asm 577 217 B 727 — —
examples/term.r8asm 16 414 6.2 KB 21 721 — —
examples/signed_demo.r8asm 37 511 14.1 KB 52 983 — —
asm/test.r8asm(全家桶) 43 676 16.4 KB 62 351 — —
examples/calc.r8asm 51 378 19.3 KB 73 624 112 802 336 304

三个直接结论:

  1. 选 8 位顺手把 ip 预算的问题解决了:8 位计算器是 51 378 条,重新回到 65536 以内 (11 位那版 73 624 已经越过了历史 INS_SIZE)。16 位 ip 就够装,做成 20 位只是留余量。
  2. 数据 RAM 就是 64 字节:一片 6116(2K×8)里塞 32 台都没问题;dp 6 位,回绕免费。
  3. 32 位那版(126 KB)不进硬件:它超过常见小 FPGA 的片上 BRAM(Tang Nano 9K ≈ 58 KB、 iCE40 UP5K ≈ 15 KB)。8 位物理机要跑的就是上表那五条。

环取 64 格(-DR8FORGE_MEMORY_CELLS=64)。脚本遍历每条纸带的 >/< 记峰值 ('<'@0 全为 0,说明没有靠回绕的写法):calc 51、hello 49、signed_demo 34、 term 27 —— 64 格装得下所有程序;只有 asm/test.r8asm 自检铺到 155(它把每个宏的格子块 并排铺开,是自检不是程序)。实测:64 / 128 格下整轮自检 8/8 通过(11 位);物理机那套 8 位 + 64 格下 ctest -L widthfree 5/5 通过,计算器纸带与 259 格版逐字节相同、 会话步数也相同(166 348)。选环的规则见 SPEC §1.2:≥ 程序碰到的最高格号 + 1 (碰到 ≥ 环大小的地址会被折回去,输出可能不变、步数会变)。

4. 微架构

        ┌──────────────┐   3 bit    ┌───────────────┐
        │ tape ROM     │──opcode──▶│ 解码/微序列   │── we, we_dp, dp±, scan ──┐
        │ (ip → 指令)  │            │ (2~4 拍/指令) │                          │
        └──────▲───────┘            └───────▲───────┘                          ▼
               │ ip                          │ 状态                     ┌──────────┐
        ┌──────┴───────┐            ┌────────┴────────┐                 │ 数据 RAM │
        │ ip 计数器    │◀──扫描单元──│ 括号扫描 (深度) │                 │  64 × 8  │
        │ 16~20 bit    │   ±1/扫描  └─────────────────┘                 └────┬─────┘
        └──────────────┘                     │ dp (6 bit, 自然回绕)          │
                                    ┌────────┴────────┐                      │
                                    │ dp 计数器        │──────── 地址 ────────┘
                                    │ (6 位, 回绕免费) │
                                    └─────────────────┘
  • 数据通路只有三件:右旋({cell[0], cell[7:1]})、翻 bit0、取 bit0。没有加法器、 没有比较器、没有立即数。8 位整条数据通路就是一片 74HC299 + 一个 XOR + 一根测试线。
  • 一条指令 2~4 拍:FETCH → DECODE → EXEC(→ 扫描) → ip++。1 MHz 时钟、4 拍/指令 = 250 k 指令/秒 → 8 位计算器一次会话(实测 166 348 步)≈ 0.7 s;10 MHz 就是 0.07 s。 8 位全家桶 asm/test.r8asm 实测 99 824 步、52 个 OUT。
  • 括号扫描的两种实现(语义等价,四份 VM 的步数口径不变,因为扫描不计步数):
    1. 扫描式(照 §2 的伪码):[ 且最低位=0 时前向扫到配对的 ] 之后,] 且最低位=1 时后向扫回配对的 [。需要介质能反向迭代。
    2. 循环栈式(就地执行时用这个):[ 且最低位=1 时把 ip 压进一个 5 bit 深度的小栈; ] 时总是弹一格 —— 弹出来的位置就是配对的 [,若最低位=1 就跳回去([ 会重跑), 否则继续往下。[ 且最低位=0 时仍然前向扫描(这一段本来就只往前)。不需要反向迭代, 连"往回扫"都省了;代价是一个 5 bit 的 LIFO(TTL 里 2~3 片 74HC273/244 + 一个指针, FPGA 里几行)。为什么不是可选优化:扫描式每扫一条花一个时钟,而计算器的主 loop 几乎包住整条纸带(51 378 条),] 每轮后向扫描就是 51 k 个时钟 —— 1 MHz 下 51 ms, 每读一个字符都付一次;栈式是 O(1)。前提是纸带的括号良构(汇编器会保证;不平衡的 ] 在扫描式里是"扫到纸带外面",在栈式里是"空栈弹出"→ 定义成停机即可)。
  • +/- 的读改写:单口 RAM 也能做(一拍读、一拍写),要求"同一格内完成",因为 语义里没有别的指令能插进来。
  • ip 与 dp 都从 0 起,数据 RAM 复位清零(用 FPGA 的初始化或 TTL 的复位清零脚)。
  • 停机:ip == 长度 → halt,时钟门控;前面板一个"运行/单步/复位"三档开关。
  • 步数计数器:软件口径的"步"就是指令数,硬件加一个只读的 32 位计数器即可(面板显示, 或 UART 报 steps=N),方便和 tape_run 的步数逐位对上。

5. 载体三档

取向:越复古越好 —— 面板、器件、封装都要 1980 年代那味,所以 B(74LS + EPROM + 数码管 面板)是主目标;A 只当"先把逻辑跑通"的跳板(Tang Nano 那种指甲盖板子长得太现代,真要 做板就用 74LS 分立件 + 绿色 PCB + 大号丝印)。

B'. 分立 74LS 机器(主目标,博物馆档)

按 8 位 / 64 格、一条指令一个字节(低 3 位是操作码)算 —— 这个格式让线路简单一大截: ip 直接当 EPROM 地址,取出的字节 D2..D0 就是操作码,不需要移位寄存器、不需要 16 位 窗口、不需要查表。代价是每条指令浪费 5 bit,而 27C512 正好 64K 字节,正好等于项目 历史上那条 INS_SIZE = 65536 的预算 —— 8 位计算器(51 378 条)和全家桶(43 676 条)都装得下 ✓。

部件 选型 片数 年代感
程序 ROM 27C512(64K×8,UV 擦除窗口)一条指令一字节 1 石英窗 + 紫外线擦除,最有味
ip 计数器 74LS161 ×4(16 位,接 EPROM 的 A0..A15) 4
数据 RAM 6116(2K×8)—— 只用 64 字节 1 1980 年代的 SRAM
数据寄存器 + 右旋 74LS299(8 位通用移位寄存器,右旋 / 保持) 1
dp 计数器 74LS161 ×2(6 位,回绕免费) 2
循环栈 74LS670(4×4 寄存器堆)×2 + 74LS161 当栈指针(8 深够用) 3
控制/微码 28C64 微码 ROM ×1 + 74LS161 微序列计数器 + 74LS138 译码 3 微码控制,8086 同代做法
串口 6850 ACIA + 74LS4060(分频出 9600 baud) 2 8080 时代的经典 ACIA
面板 74LS47 ×4(七段译码)+ 4 位数码管 + LED(指令/ip/dp)+ 拨动开关 + 大红按钮 6~8 前面板就是"机器"的脸
胶合 74LS00/04/08/32/244/245 6~9
时钟/复位 1 MHz 罐头晶振(或 74LS04 + 2 MHz 晶体 ÷2)+ 74LS14 + RC 2
合计 3140 片,¥400~700 5 V 2 A,绿色 PCB,全 DIP 插座

速度:12 MHz、约 4 拍/指令 → 0.250.5 M 指令/秒;8 位计算器一次会话(166 k 步)0.4~0.7 s ✓。 工作量:几周(面包板先通,再画 PCB;面板可以最后做)。

面板(这才是"8086 那种"的来源):4 位数码管显示当前格(十六进制),一排 8 个 LED 显示 当前指令,一排 16 个 LED 显示 ip 低 16 位(或 4 位数码管显示 ip),一排 6 个 LED 显示 dp,外加 RUN / STEP / RESET 三个带灯按钮和一个 8 位拨码当"输入字节"。外壳用 铝型材/亚克力开窗都行,丝印上写满信号名。

A. FPGA(跳板,不是终态)

项 选择
板子 任意(Tang Nano 9K 一类,¥100 上下)——只用来先把逻辑跑通,外形不讲究
能跑 8 位全家桶(16.4 KB)✓、8 位计算器(19.3 KB)✓
工具 Gowin IDE 或 yosys + nextpnr-gowin
速度 50 MHz / 2~4 拍 ≈ 10 M 指令/秒
价值 hardware/rot8.v 已经在它上面验证过逻辑;烧上去只是看灯,最终机器是 B'

C. 机电(艺术品档,另外的野心)

  • 数据环做转鼓:8 条磁道 × 64 格、一个读头 + 一个写头(写头在下游一格处)。 >/< 的"访问"就是等下一个格脉冲;+/- 在读到写头之间的那一格时间里改好写回, 所以每条指令 ≈ 一格时间。3000 rpm、64 格/圈 → 312 µs/格 → 166 k 步 ≈ 52 s(环小了每圈格子少,鼓要转快点才追得上:10000 rpm → 16 s)。 代价是机加工(或找一个旧磁鼓/软盘改)。
  • 程序做纸带:3 bit 数据 + 1 孔同步,2.54 mm 孔距。hello(727 条)≈ 1.8 m ✓; 计算器(51 378 条)≈ 130 m ✗ —— 所以纸带只适合演示级小程序,大纸带还是进 EPROM。
  • 也可以只做"面板 + 真 I/O"的半机电:MCU 跑 ISA,面板是真按键/LED/数码管。
A FPGA 跳板 B' 分立 74LS C 机电
上手时间 一个周末 几周 几个月起
成本 ¥100~300 ¥400~700 ¥1000+ + 机加工
速度 ~10 M 指令/秒 0.25~0.5 M 40~45 k
能跑 8 位全家桶/计算器 ✓ ✓ ✓(慢,但够:一次会话 ~20 s)
复古程度 ✗ ✓✓(DIP、UV EPROM、数码管、拨码) ✓✓✓
可改 ISA/调试 改一行重烧 换 EPROM(擦 20 分钟,仪式感) 换凸轮/继电器

建议:A 先做(一周内能跑真纸带),B 作为"正式机器"的目标(A 的 RTL 状态机原样翻成 微码表,接口和时序都不变),C 当展示件。8 位让 B 的片数掉到 20~28 片、C 的鼓只要 8 条磁道。

6. 前面板

  • ip(16 bit)、dp(6 bit)、当前格(8 bit)各一排 LED;一条"纸带定位"进度条。
  • 8 个指令灯:当前指令亮一个。
  • 64 格用 8×8 LED 矩阵或 128×64 OLED 画成圆环,dp 指的那格高亮(和 viz 一个样子)。
  • 三个按键:单步 / 运行·暂停 / 复位;一个"输入"按键(按一下给 , 喂一个字符)。
  • UART:一个终端窗口就是"键盘 + 打字机",计算器直接在上面用(8 位下打出来就是 046 这种)。

7. 验证方案(这是软件层白送的大礼)

  1. 打包器:新工具 r8forge tape pack <x.r8asm> -o x.bin,按 3 bit 小端打包(8 条指令 3 字节)。 同时给 r8forge_tape_run 加一个 .bin 载入路径 —— 打包器对不对,用现有四份 VM 一比就知道。
  2. RTL 仿真对拍:同一份 .bin 在 Verilog testbench 里跑完,比较 (ip, dp, 环里的 cell, OUT 流, steps) 与 tape_run 的终态;再抽几条 tape 逐步比。
  3. 单步对拍(上板之后):tape_run --trace 导出每步状态,面板单步一遍对照 (M1 阶段就靠这个把接线错误抓出来)。
  4. 里程碑(数字都按 8 位实测):
    内容 验收
    ✅ M0 打包器 + RTL 仿真 做完(2026-11,iverilog 14):hello 417 步、term(喂 lhi)17 643 步、calc(喂 12 34 + .)166 741 步、全家桶 100 142 步 —— RTL 的 OUT 流与步数和 tape_run --loop-stack --retest 逐字节一致;ctest -R rtl_sim 固化
    M1 上板,面板 + 单步 单步跑 hello,OUT 与仿真逐字符一致
    M2 UART + 连续运行 asm/test.r8asm 跑完:93 个 OUT、步数 = 100 142(--retest 口径;软硬件都已对上,等真板子)
    M3 交互 终端里把计算器会话打出来(12 34 + . → 046,166 741 步 —— 仿真里已经做到)
    M4 加宽到 11 位(可选) 换一份 ROM 跑 asm/test.r8asm:步数 = 202 159 —— 证明"宽度是构建参数、不是运行时状态"

8. 动手前必须先定下来的语义(软件里已经定了,硬件要照抄)

  1. , 是阻塞的。derive/tape_run 用 -i 预装输入、读空后给 0;viz 的串行模式 是真的 getchar() 阻塞,EOF 给 0。硬件取后者:UART RX 等到一个字节再继续; EOF 是一个显式事件(终端发 0x04,或面板上的"EOF"键),此时读入 0 —— 否则交互时每个空读都会把程序送去退出。
  2. . 只做一种输出:8 位下就是把低 7 位当字符发给串口(bit 7 留给校验/停止位,默认关)。 W < 8 的"打十进制"是 viz 的兼容行为,物理机不需要。
  3. , 写整格:8 位下就是"把收到的字节写进那一格"(2026-11 改过的语义:整格写入, 不是只写低 7 位)。要复刻 7E1 帧就把 bit 7 填成校验、bit 8 填停止位,默认不填。
  4. [/] 的扫描边界照 §2 那两段伪码,尤其 ] 要跳回 [ 本身。
  5. 宽度是构建参数,不是运行时状态:同一份纸带只对一个宽度成立(库宏按 _CELL_SIZE 展开)。 物理机是 8 位;要跑 11 位那套就换 ROM + 换 RAM/寄存器宽度(M4 可选)。

9. 待定 / 下一步

  • 已定:位宽 = 8、环 = 64 格;因此数据 RAM 64 字节、./, 就是字节 I/O、8 位计算器 51 378 条 (回到 65536 以内)、全家桶 99 824 步。

  • 选哪一档(A / B / C)—— 还没定,影响后面所有细节。

  • 程序介质 —— 还没定。功能上要求很低:ip 只会 ±1 和"括号扫描",扫描本身也是 一步一步走的,所以任何能正向/反向迭代的介质都够(这就是"纸带"这个词的字面意思); 再进一步,] 的跳回可以用循环栈消掉:[ 且最低位=1 时把 ip 压栈,] 且最低位=1 时弹栈并回到那个位置,[ 且最低位=0 时仍然前向扫描 —— 与 §2 的伪码语义等价(扫描不 计入步数,所以四份虚拟机的步数口径不变),这样连反向迭代都不需要了。

    真正的差别在速度:我们程序的运行时循环非常"长" —— 计算器的主 loop 几乎包住整条 纸带(51 378 条),所以每读一个字符就要把整条纸带走一遍。按介质速度算:

    介质 每字符要走的 51k 条 结论
    纸带读取器(50~300 字符/秒) 170~1000 s 只适合 hello 这种几百条的演示(577 条 ≈ 2 s)
    音频卡带(1200 baud ≈ 400 字符/秒) ~130 s 同上
    磁带/软盘级(30~500 k 字符/秒) 0.1~1.7 s ✓ 能用
    移位寄存器环(1 MHz,一条/拍) 51 ms ✓ 但要 153 kbit 的移位寄存器 ✗ 贵
    RAM / BRAM + ip 计数器 0(随机访问) ✓✓ 最省事

    所以:功能上"纸带"完全成立,速度上我们的程序不允许机械纸带(除非改写程序让循环变短, 而库的做法恰好相反:%rep 把软件循环展开成了长直线代码)。实用结论——

    介质 谁用 访问方式 说明
    FPGA 内部 BRAM A 随机 镜像跟 bitstream 一起烧进去,不需要任何外部芯片;8 位全家桶 16.4 KB,Tang Nano 9K 的 58 KB 装得下
    并行 flash / EEPROM(29C010、39SF010、28C256…) B 随机(地址总线) 一片就是"纸带":地址给出 ip 那个字节,取低 3 bit;70~150 ns,配 1 MHz 时钟宽裕
    串行 SPI NOR flash A/B 只能前向 配循环栈可以直连执行(] 不回头),但每轮仍要顺序流过整条纸带 ✗ 慢;现实做法是启动时整条拷进 RAM
    纸带 / 卡带 / 转鼓 C、演示 正/反向 演示级:hello 577 条可以,计算器 5 万条不行
  • 要不要"纸带"这个物理形态:演示级纸带(≤ ~2000 条,2.54 mm 孔距约 5 m)可以做, 大程序进 ROM(8 位全家桶 16.4 KB)。

程序存储器:与数据环分开(哈佛),两种装法都行

约束只有一条:程序和数据不共享存储空间(§2 已经说明这是 ISA 保证的)。至于程序那一侧 用什么,自由:

装法 1:就地 ROM(卡带) ip 直接当程序存储器的地址,取出的字节里切 3 bit 就是操作码。并行 flash / EEPROM (28C256、29C010、39SF010)接法是 15~17 根地址线 + 8 根数据线,零胶合逻辑; 28C256(32 KB,DIP-28,5 V,150 ns)装得下计算器(19.3 KB)+ 终端(6.2 KB)+ 监控程序。 芯片插在宽体座上就是"卡带":拔下来用 CH341A 重写。没有 loader、没有程序 RAM、没有启动步骤。

装法 2:板上程序 RAM + 一次性装入(你说的那种) 程序存储器换成一片独立的 RAM/BRAM(62256、或 FPGA 的 BRAM),复位时由一小段 boot 逻辑从任意小介质(串行 flash、microSD、UART、甚至一块 24C512 EEPROM)把镜像搬进去, 之后就地执行、随机访问。好处:换纸带不用烧片、不用拔芯片;代价:多一个 boot 状态机 (FPGA 里几十行状态机,TTL 里一片小 AVR/CPLD)和那片程序 RAM。 注意它不是"数据 RAM":程序 RAM 只有 boot 能写,ISA 依然碰不到它(哈佛不变),所以 "混在一起"的担心不成立 —— 它只是"程序空间换了种器件"。

两种装法的取舍:

装法 1(就地 ROM) 装法 2(程序 RAM + 装入)
器件 1 片并行 flash/EEPROM 1 片程序 RAM + 1 片小 flash/SD + boot 逻辑
换带 拔芯片 / 烧录器 重新装入(按键或上电自动)
启动步骤 无 有(毫秒级)
ISA 能写到程序空间吗 不能(没有那条指令) 不能(boot 之后 RAM 只读)
随机访问 ✓ ✓
适合 TTL 复古机 FPGA、想频繁换纸带的机器

就地执行时扫描是花时间的(每条扫描指令一个时钟)。计算器的主 loop 几乎包住整条纸带 (51 378 条),] 真去后向扫描每轮就是 51 k 个时钟(1 MHz 下 51 ms,每读一个字符都付一次)。 所以 §4 的循环栈式括号实现是标配:] 只弹栈、不扫描 → O(1)。

不能就地寻址的介质(机械纸带、只能串行读的 SPI flash、软盘)只配当"装法 2 的源": 它们通过 boot 逻辑进程序 RAM,之后机器照常随机访问。按面积看这些源:

介质 尺寸 容量/速度 接口
并行 EEPROM / flash(28C256、29C010、39SF010) DIP-28,宽体座 32 KB~128 KB;150 ns 地址 + 数据总线,零胶合(装法 1 本体)
FPGA 内部 BRAM 片上 58 KB(Tang Nano 9K) bitstream 初始化(装法 1/2 皆可)
microSD 15×11 mm 任意;SPI 几百 KB/s SPI 4 线(装法 2 的源)
串行 SPI NOR(25Q64) 8 pin,10×10 mm 8 MB SPI(装法 2 的源;也常当配置片)
信用片大小穿孔卡 85×54 mm ≈ 1000 条 光电 + 步进(只够 hello 这种演示)
microcassette / 3.5" 软盘 50×33×8 / 90×94 mm 150 B/s / 46 KB/s FSK / MFM(装法 2 的源,慢)

配套软件因此更简单:tape pack 输出 .bin 就是存储器内容,烧进 28C256 / 39SF010 / FPGA 的 BRAM 初始化文件即可,没有镜像布局、没有 FAT、没有 loader。需要装载体时再加 一个 --at-lba 0(贴到 microSD 原始扇区)或 --fat12 disk.img(软盘)。

  • 第一步:M0 —— r8forge tape pack + hardware/rot8.v 的 testbench 对拍。不依赖任何 硬件采购,也不需要先定介质(打包输出同时喂 BRAM 初始化、EEPROM 烧写器、FAT12 镜像和 testbench)。