Files
R8Forge/docs/hardware.md
T
dsh 9d9d64a1d9 hardware: LOAD then RUN -- which makes a floppy a perfectly good tape
A mechanical medium is only a bad *execution* memory; real machines loaded from the
medium into RAM and ran from there.  That decouples the medium speed from the
machine: the medium just has to deliver tens of KB/s once, and execution costs no
traversal at all.  With that architecture a 3.5 inch floppy is fine, and the note
now records what is still buyable: USB floppy drives are still made (about 50-120
CNY) but only expose whole 512 byte sectors, so a small microcontroller or a Pi
acts as the host and feeds them to the machine; a 34 pin drive plus an N82077AA
class controller is the all period correct route and much more work; Gotek style
emulators are the reliable but media-less option; audio cassettes are still
sold and load the 19 KB image in about two minutes, which is plenty when the
program then runs from RAM.

A floppy can even be the executing tape: at 300 rpm and 18 sectors per track it
streams 46 KB/s, so the 51378 instruction tape goes round in 0.4 s and with the
loop stack it only ever streams forward -- but you have to do MFM decoding and
sector framing yourself, and every input character waits 0.4 s.  LOAD then RUN is
an order of magnitude simpler and a hundred times faster.

The real floppy risk is not the drive, it is the media: 20 to 30 year old disks
grow mould and lose their field, so keep several NOS disks and two copies of each
image.  The software side is small: a --fat12 disk.img output on the packer,
writing HELLO.R8T and CALC.R8T into a standard 1.44 MB image that any USB drive
can put on a real disk.
2026-11-20 15:58:39 +08:00

21 KiB
Raw Blame History

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

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

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

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

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

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

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

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

项 值 硬件含义
指令 8 条:> < + - [ ] , . 3 bit 操作码,纸带就是 ROM/EEPROM,只读、无自修改
程序 线性执行,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 → 跳到配对 ] 之后 前向扫描,深度计数
] (rnz) 最低位 = 1 → 跳回配对 [(它要重跑) 后向扫描,深度计数
, 整字节写入输入字符 阻塞到有字符;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 里几行)。 前提是纸带的括号良构(汇编器会保证;不平衡的 ] 在扫描式里是"扫到纸带外面", 在栈式里是"空栈弹出"→ 定义成停机即可)。
  • +/- 的读改写:单口 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 仿真 hello(577 条)、term(16 414)、asm/test.r8asm(43 676)三条纸带的终态与 tape_run 一致
    M1 上板,面板 + 单步 单步跑 hello,OUT 与仿真逐字符一致
    M2 UART + 连续运行 asm/test.r8asm 跑完:52 个 OUT、步数 = 99 824
    M3 交互 终端里把计算器会话打出来(12 34 + . → 046,166 348 步)
    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)。

装载架构:从介质装进 RAM,再从 RAM 跑(推荐)

上面那张速度表说明"直接拿机械介质当执行存储器"不划算,但它不该判软盘/卡带死刑 —— 真实机器都是 LOAD → RUN:介质只负责把镜像送进 64 KB RAM(几十毫秒到几秒都无所谓), 执行永远在 RAM 里(零遍历成本)。这样:

  • 介质只需要"能顺序读出字节",速度只要 ≥ 几十 KB/s;
  • 括号栈、ip 计数器、64 格数据环都不变;
  • 机器开机跑一小段 ROM 里的 loader(或面板上一个 LOAD 键),之后就是纯 RAM 执行。

按这个架构,软盘是完全合格的介质,而且今天的可得性比想象中好:

选项 现在的可得性 说明
USB 软驱(3.5",1.44 MB) 仍在量产,¥50~120 走 USB 大容量存储(UFI),只给整扇区读写,所以要一个 µC/树莓派当 host 把扇区喂给机器 —— "介质是真的,读盘的是现代小板"
内置 34 pin 软驱 + N82077AA 一类控制器 二手/NOS,驱动器 ¥50~200,控制器芯片更少 全部复古件,接口是并行的(数据 + 寄存器),要自己写 MFM 扇区状态机;坏了难修
Gotek / USB 软驱模拟器 新货,¥100~200 插 34 pin,放 .img 文件;没有真介质,但最可靠
音频卡带 空白带仍在卖,随身听遍地 1200 baud ≈ 150 B/s:19 KB 镜像装 2 分钟 ✓ 装载体完全够用;执行仍在 RAM
EEPROM + 面板"选程序" 一直好买 内置程序(monitor / 计算器 / hello)走它,不需要"换带"

软盘作为"直接执行的纸带"也不是不行:300 rpm、18 扇区/轨 → 46 KB/s 的顺序流; 5 万条(19 KB)的纸带一轮 0.4 s,配循环栈(只往前流)就能跑 —— 代价是每读一个字符要等 0.4 s,而且必须自己做 MFM 解码/扇区同步。相比之下 LOAD→RUN 简单一个量级,还快 100 倍。

软盘的真实风险不在买不到驱动机,而在介质:2030 年的 3.5" 盘会发霉、掉磁;NOS 盘 ¥510 一片,多备几片、存两份镜像就没事。配套的软件工具很轻:tape pack 加一个 --fat12 disk.img 输出,把 HELLO.R8T、CALC.R8T 写进一张标准 1.44 MB 镜像, PC 上用任何 USB 软驱把它写进真盘,机器上的 loader 读回来即可。

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