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.
23 KiB
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 |
三个直接结论:
- 选 8 位顺手把
ip预算的问题解决了:8 位计算器是 51 378 条,重新回到 65536 以内 (11 位那版 73 624 已经越过了历史INS_SIZE)。16 位ip就够装,做成 20 位只是留余量。 - 数据 RAM 就是 64 字节:一片 6116(2K×8)里塞 32 台都没问题;
dp6 位,回绕免费。 - 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 的步数口径不变,因为扫描不计步数):
- 扫描式(照 §2 的伪码):
[且最低位=0 时前向扫到配对的]之后,]且最低位=1 时后向扫回配对的[。需要介质能反向迭代。 - 循环栈式(就地执行时用这个):
[且最低位=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)。前提是纸带的括号良构(汇编器会保证;不平衡的]在扫描式里是"扫到纸带外面",在栈式里是"空栈弹出"→ 定义成停机即可)。
- 扫描式(照 §2 的伪码):
+/-的读改写:单口 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 |
| 合计 |
速度: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. 验证方案(这是软件层白送的大礼)
- 打包器:新工具
r8forge tape pack <x.r8asm> -o x.bin,按 3 bit 小端打包(8 条指令 3 字节)。 同时给r8forge_tape_run加一个.bin载入路径 —— 打包器对不对,用现有四份 VM 一比就知道。 - RTL 仿真对拍:同一份
.bin在 Verilog testbench 里跑完,比较(ip, dp, 环里的 cell, OUT 流, steps)与tape_run的终态;再抽几条 tape 逐步比。 - 单步对拍(上板之后):
tape_run --trace导出每步状态,面板单步一遍对照 (M1 阶段就靠这个把接线错误抓出来)。 - 里程碑(数字都按 8 位实测):
内容 验收 ✅ M0 打包器 + RTL 仿真 做完(2026-11,iverilog 14): hello417 步、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. 动手前必须先定下来的语义(软件里已经定了,硬件要照抄)
,是阻塞的。derive/tape_run用-i预装输入、读空后给 0;viz 的串行模式 是真的getchar()阻塞,EOF 给 0。硬件取后者:UART RX等到一个字节再继续; EOF 是一个显式事件(终端发0x04,或面板上的"EOF"键),此时读入 0 —— 否则交互时每个空读都会把程序送去退出。.只做一种输出:8 位下就是把低 7 位当字符发给串口(bit 7 留给校验/停止位,默认关)。 W < 8 的"打十进制"是 viz 的兼容行为,物理机不需要。,写整格:8 位下就是"把收到的字节写进那一格"(2026-11 改过的语义:整格写入, 不是只写低 7 位)。要复刻 7E1 帧就把 bit 7 填成校验、bit 8 填停止位,默认不填。[/]的扫描边界照 §2 那两段伪码,尤其]要跳回[本身。- 宽度是构建参数,不是运行时状态:同一份纸带只对一个宽度成立(库宏按
_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、演示 正/反向 演示级: hello577 条可以,计算器 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)。