Files
R8Forge/docs/hardware.md
T
dsh 9b31a51fec hardware: M0 -- the packer, the RTL, and a simulator that agrees byte for byte
The two things software cannot check by reading its own source are the 3 bit
packing and the bracket strategy, so both got a tool and a test.

New in the library (r8forge/tape.hh, src/tape.cc): the opcode numbering (taken
from ROT-8-viz enum, so the packed image and the hardware decoder cannot drift),
text <-> opcodes, opcodes <-> 3 bit bytes, the .r8t image with its trailer and
crc32, and a machine model that runs a packed tape the way a board would.  The
model takes the bracket strategy as an option: backward scan with loop stack or
not, and jump-back-onto-the-[ (the contract) or past it (what the interpreters
do).  All four combinations print the same thing, and the step count differs by
exactly the number of taken ] instructions -- which is what the test asserts.

Found and fixed while writing it: the loop stack discipline depends on the jump
convention.  Jumping onto the [ means the [ re-pushes, so ] must pop on the jump;
jumping past it means the entry must stay until the loop exits.  Mixing them up
emptied the stack on the second iteration of the calculator main loop -- caught
by the equivalence test on examples/calc.r8asm, not by reading the code.

Tools: r8forge_tape_pack (text tape -> image + --hex for $readmemh + --verify,
727 instructions become 273 bytes for hello, 62%, and the trailer sits past the
halt so address 0 of a ROM is instruction 0), and r8forge_tape_run now reads an
image directly and takes --loop-stack / --retest.

hardware/rot8.v: the 8 bit / 64 cell machine -- 3 bit opcodes from a byte
addressed memory read as a 16 bit window, a 6 bit dp with free wrap, the loop
stack bracket jump, blocking input, halt on ip == length, and a step counter that
counts instructions rather than cycles.  hardware/tb_rot8.v loads a --hex image
and prints the OUT stream in tape_run format.

Verified with Icarus Verilog 14 (the RTL against tape_run --loop-stack --retest):
  hello        577 instructions  417 steps  10 outs
  term         16414            17643      11 (fed "lhi")
  calc         51378           166741      19 (fed "12 34 + .": prints the prompt,
                                                046 and the next prompt)
  flagship     43676           100142      93
Every OUT stream identical.  ctest -R rtl_sim runs that comparison from an 8 bit
build (11 tests in the default build now, where the RTL test self-skips because
the RTL is the 8 bit machine).

Two traps worth remembering: Icarus passes plusargs through as raw bytes, so an
absolute +HEX path containing non-ASCII (this checkout is under a Chinese
directory name) arrives mangled, $readmemh silently leaves the memory empty and
the machine obediently runs LEN steps of opcode 0 printing nothing -- run vvp
from the directory holding the hex with a relative name.  And in_ready must not
be qualified with !in_valid or the input handshake deadlocks.
2026-11-20 16:25:54 +08:00

23 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. 载体三档

A. FPGA(建议先做这一档)

项 选择
板子 Tang Nano 9K(GW1NR-9):≈58 KB BSRAM、HDMI、板载 USB 串口,¥100 上下
能跑 8 位全家桶(16.4 KB)✓、8 位计算器(19.3 KB)✓;11/16/32 位纸带只当对照(37 KB / — / ✗)
工具 Gowin IDE 或开源的 yosys + nextpnr-gowin(后者更符合这个项目的脾气)
I/O UART 115200 进/出,HDMI 画 64 格环 + dp/ip/当前格
工作量 300~500 行 Verilog + testbench,一个周末
速度 50 MHz / 4 拍 ≈ 12 M 指令/秒(比软件快一个量级,面板上能看到"瞬间算完")

B. 分立 TTL("真机器",博物馆档)

按 8 位算,片数比原来那版少一截(没有 11 位那种 8+3 的拼法,也没有位宽开关):

部件 选型 片数
程序 ROM 29C010 / 39SF010(128 KB flash,用低 3 bit;8 位全家桶只要 16.4 KB) 1
ip 计数器 74HC161 ×4(16 位够装 51 378 条;做 20 位就 ×5) 4~5
数据 RAM 6116(2K×8)—— 只用 64 字节,一片能用 32 台 1
数据寄存器/右旋 74HC299(8 位通用移位寄存器,右旋 + 保持一片搞定) 1
dp 计数器 74HC161 ×2(6 位,回绕免费,不用比较器) 2
括号扫描 74HC191 ×2(上下计数)+ 比较器,或塞进 CPLD 3~4
控制/微码 GAL22V10 ×2 或 ATF1502 CPLD(一片搞定解码 + 微序列) 1~3
UART 6850 ACIA 或 ATmega/CH340 桥 1~2
时钟/复位/面板 555 或晶振、74HC14、LED/数码管 5~8
合计 2028 片,¥250~500

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

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 ✓; 计算器(73 624 条)≈ 187 m ✗ —— 所以纸带只适合演示级小程序,大纸带还是进 EEPROM。 折中:卡带(FSK 12009600 baud)当"装载介质",23 KB 在 20160 s 内装进 RAM。
  • 也可以只做"面板 + 真 I/O"的半机电:MCU 跑 ISA,面板是真按键/LED/数码管。
A FPGA B TTL C 机电
上手时间 一个周末 几周 几个月起
成本 ¥100~300 ¥250~500 ¥1000+ + 机加工
速度 12 M 指令/秒 0.25~0.5 M 40~45 k
能跑 8 位全家桶/计算器 ✓ ✓ ✓(慢,但够:一次会话 ~20 s)
教学/观赏性 中 高 最高
可改 ISA/调试 改一行重烧 换 ROM 换凸轮/继电器

建议: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)。