docs: README down to the essentials, serial/7E1 details into docs/serial.md

The README had grown to 305 lines while features kept getting appended to it: a
35-line frame dump, a full option table, and three paragraphs of essays about
parity hardware. Split by what a reader needs first:

  README.md       intro + instruction table + quick start + I/O modes + live
                  view (trimmed sample) + geometry + 7E1 in five lines +
                  build/test                            305 -> 181 lines
  docs/serial.md  bit 7 not owned by I/O, why characters are not space
                  separated, the frame layout, why a stop bit is a bit in the
                  cell, and the "parity costs one latch" essay

Verified the commands the new quick start and test sections show against the
build: --input R8F on serial_echo (prints R8F), -n on and/or/full_adder (numbers),
--dump on wave (259 cells), --7e1 with input A.
This commit is contained in:
dsh committed 2026-11-09 16:34:20 +08:00
1 parent a083a3422c
commit a4df21a47e
2 files changed
+153 -214

No files matched your search

+90 -214
View File
@@ -1,49 +1,75 @@
# ROT-8
以无ALU为前提设计的1-Bit Brainfuck变体\
以及用于测试该指令集的,以C实现的简单虚拟机
以无 ALU 为前提设计的 1-Bit Brainfuck 变体,以及用于测试该指令集的、以 C 实现的简单虚拟机。
## 概述
ROT-8 ([rəʊˈteɪt]) 提供了一套简洁的指令集,使利用无ALU的各种奇葩元件(如类似差分机的机械计算机,红石电路,甚至是水槽水闸与水车)进行计算变得可行且通用\
对,就是蒸汽朋克里最常见的那类东西,不过这个真的可以运行
ROT-8 ([rəʊˈteɪt]) 提供了一套简洁的指令集,使利用无 ALU 的各种奇葩元件(如类似差分机的
机械计算机、红石电路,甚至是水槽水闸与水车)进行计算变得可行且通用 ——
对,就是蒸汽朋克里最常见的那类东西,不过这个真的可以运行。
## 指令集
| ROT-8指令 | 对应BF字符 | 行为 |
| ROT-8 指令 | 对应 BF 字符 | 行为 |
| ----- | --- | ------ |
| `STP` | `>` | 数据指针右移 1 Cell |
| `BTP` | `<` | 数据指针左移 1 Cell |
| `ROR` | `+` | 当前 Cell 循环右移 1 bit |
| `FLB` | `-` | 翻转当前 Cell 的 LSB (最低位) |
| `FLB` | `-` | 翻转当前 Cell 的 LSB(最低位) |
| `BIZ` | `[` | 如果当前 Cell 的 LSB 为 0,跳到匹配的 `]` 之后 |
| `RNZ` | `]` | 如果当前 Cell 的 LSB 不为 0,跳回匹配的 `[` 之后 |
| `OUT` | `.` | 输出当前 Cell |
| `INP` | `,` | 从输入读取到当前 Cell |
> 方便起见,INP与OUT的实现不做定义,只要INP能改变整个Cell而OUT能读取整个Cell即可.\
> 本项目**默认按 7 位 ASCII 串行**做 I/O(8 位及以上的 cell,一个字符一次);更窄的 cell 和
> `-n` / `--numbers` 用"整格十进制整数"的老行为 —— 见下面的「I/O 模式」.
> INP/OUT 的实现不做规定,只要 INP 能改变整个 Cell、OUT 能读取整个 Cell 即可。本项目**默认
> 按 7 位 ASCII 串行**做 I/O(8 位及以上的 cell,一个字符一次);更窄的 cell 和 `-n` /
> `--numbers` 用"整格十进制整数"的老行为 —— 见「I/O 模式」。
> Cell 的位宽不属于指令集:任何位宽都成立(LSB 永远是那一位,`ROR` 在这个位宽里循环).\
> 本项目默认 8 bit,但位宽和纸带长度都能在运行时改 —— 见下面的「纸带尺寸与 Cell 位宽」.
> Cell 的位宽不属于指令集:任何位宽都成立(LSB 永远是那一位,`ROR` 在这个位宽里循环)。
> 本项目默认 11 bit,位宽和纸带长度都能在运行时改 —— 见「纸带尺寸与 Cell 位宽」。
## 使用
## 快速开始
```sh
rot8_test tape
mkdir build && cd build && cmake .. && make -j$(nproc)
./build/rot8_test --input R8F tapes/serial_echo.rot8 # 默认串行:读字符、原样打出来
./build/rot8_test -n tapes/and.rot8 # 要十进制整数就加 -n
./build/rot8_test --live tapes/wave.rot8 # 一边跑一边画内存
```
默认跟着位宽走:**8 位及以上的 cell 用串行字符 I/O**(`OUT` 就是 `putchar`),更窄的 cell 用
数值 I/O. 想显式指定就加 `-n` / `--numbers`(永远是数值)或 `-s` / `--serial`(要求 ≥ 8 位).
## I/O 模式:默认串行(7 位 ASCII),`-n` 切回十进制
`INP`/`OUT` **默认按一个字符**走(8 位及以上的 cell):tape 里放一个 `'R'`(82)出去就是一个
`R`。以前那套"整格十进制整数 + 换行"还在,用 `-n` / `--numbers` 打开:
| | 串行(默认,cell ≥ 8 位) | 十进制(`-n` / `--numbers`) |
|---|---|---|
| `OUT` | **低 7 位**当字符,直接 `putchar`,不加换行 | 整格的值 + 换行 |
| `INP` | 读**一个字符**,只写低 7 位 | 读一个十进制数,整格覆盖 |
| `--input` | **字符串**,一个字符一个 `INP` | 数字列表 `7,5` |
**默认由位宽决定**:cell ≥ 8 位走串行(7 位字符 + 1 位余量),< 8 位走数值 I/O —— 所以 1 bit
那种机器照旧跑,不需要额外参数。显式写了 `-s` / `--serial` 又不够宽会报错退出(exit 2);
`-n` 跟串行选项一起写也会被拒(exit 2)—— 两种模式互斥。`--input` 照模式解释,顺序无所谓。
```sh
rot8_test --input "R8F" tapes/serial_echo.rot8 # 打 R8F
echo A | rot8_test tapes/echo.rot8 # 管道里喂一个字符
rot8_test -n --input 65 tapes/echo.rot8 # 要十进制:65,不是 A
rot8_test --7e1 --input "A" tapes/serial_echo.rot8 # 一个 cell 装一整帧 7E1
```
bit 7 及更高位**不归 I/O 管**(`INP` 只改低 7 位)、字符流为什么不分隔、7E1 帧怎么算校验位,
细节在 [`docs/serial.md`](docs/serial.md)。
## 可视化内存
虚拟机可以一边执行 tape,一边把整条纸带(默认 259 个 Cell x 11 bit,`--mem` / `--cell` 可改)
画成一张实时视图:
`--live` 一边执行一边把整条纸带画成实时视图,`--dump` 只在结束时打一张静态快照:
```sh
./build/rot8_test --live tapes/wave.rot8
./build/rot8_test --dump tapes/wave.rot8
```
```
@@ -52,98 +78,67 @@ ROT-8 ([rəʊˈteɪt]) 提供了一套简洁的指令集,使利用无ALU的各
+--------------------------------------------------------+
| step 500 pc 01F4/0527 op ROR |
+--------------------------------------------------------+
| cell 90/256 value 16 = 0x10 '.' |
| cell 16/259 value 128 = 0x80 '.' |
| b7 b6 b5 b4 b3 b2 b1 b0 |
| . . . # . . . . |
| # . . . . . . . |
+--------------------------------------------------------+
| | +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F |
| 00 | 01 02 04 08 10 20 40 80 01 02 04 08 10 20 40 80 |
| 10 | 01 02 04 08 10 20 40 80 01 02 04 08 10 20 40 80 |
| 20 | 01 02 04 08 10 20 40 80 01 02 04 08 10 20 40 80 |
| 30 | 01 02 04 08 10 20 40 80 01 02 04 08 10 20 40 80 |
| 40 | 01 02 04 08 10 20 40 80 01 02 04 08 10 20 40 80 |
| 50 | 01 02 04 08 10 20 40 80 01 02 10*00 00 00 00 00 |
| 60 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| 70 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| 80 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| 90 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| A0 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| B0 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| C0 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| D0 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| E0 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
| F0 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |
+--------------------------------------------------------+
| out (0) none yet |
+--------------------------------------------------------+
```
画面从上到下:
(纸带按每行 16 格铺开,指针那一格反显;长纸带只画指针附近的一窗,末行注明窗口范围。)
| 区域 | 内容 |
| --- | --- |
| `step / pc / op` | 已经执行的指令数,程序计数器,以及 `pc` 处即将执行的指令 |
| `step / pc / op` | 已执行的指令数、程序计数器、`pc` 处即将执行的指令 |
| `cell ... value` | 指针所指 Cell 的编号、十进制值与十六进制值 |
| `b7 ... b0` | 该 Cell 的各位,`#` 为 1,`.` 为 0;宽 Cell 改画一行按 4 位分组的数据 |
| 纸带 | 每行 16 个 Cell(宽 Cell 会变少),行首是十六进制地址。**指针那一格反显**(终端没有颜色时,值后面跟一个 `*`,占的是它本来那个分隔空格);纸带比画面长时只画指针附近的一窗,末行注明窗口范围 |
| `out` | 到此刻为止 `OUT` 输出的值(保留最近 10 个) |
| `b7 ... b0` | 该 Cell 的各位(`#` 为 1,`.` 为 0);宽 Cell 改画一行按 4 位分组的数据 |
| 纸带 | 每行 16 格(宽 Cell 会变少),行首是十六进制地址;指针那格反显,终端没颜色时值后面跟 `*` |
| `out` | 到此刻为止 `OUT` 输出的值(保留最近 10 个) |
参数:
不加 `--live` 与 `--dump` 时直接跑完,只留下 `OUT` 的输出。`--live` 期间 `OUT` 被画面接管,
程序结束后再原样补打出来,所以重定向到文件依然拿到完整输出。输出不是终端时 `--live` 退化成
逐帧打印(可以直接 `less` 着看),程序也会在 stderr 提一句。
| 选项 | 说明 |
| --- | --- |
| `-l`, `--live` | 运行动画,原地刷新 |
| `-d`, `--dump` | 结束时打印一张静态快照 |
| `-e`, `--every <n>` | 每 n 条指令画一帧;`0`(默认)表示整段动画大约 300 帧 |
| `-f`, `--fps <n>` | 刷新率上限,默认 30;`0` 表示不限速 |
| `-t`, `--tty` / `--no-tty` | 强制当成/不当成终端(见下) |
| `-k`, `--compact` / `--full` | 强制精简画面/完整画面 |
| `-c`, `--color` / `--no-color` | 强制开/关 ANSI 颜色(默认跟随终端) |
| `-i`, `--input <v...>` | 预先喂给 `INP` 的值(串行下是字符串,`-n` 下是数字列表) |
| `-n`, `--numbers` | 数值 I/O:`OUT` 打整格十进制、`INP` 读一个十进制数 |
| `-s`, `--serial` | 串行字符 I/O(默认;写出来只是把默认说一遍) |
| `-m`, `--mem <n>` | 纸带长度(单位 Cell),任意值,默认 259,范围 1..1048576 |
| `-b`, `--cell <bits>` | Cell 位宽,任意值,默认 11,范围 1..32 |
| `-h`, `--help` | 帮助 |
画面高度自动挑:终端不足 30 行用精简版,测不出高度时也按 24 行来,`--full` 可以强制完整版。
**如果你的终端其实是通过管道接进来的**(网页版终端、某些 IDE 面板,`_isatty` 看不出来),画面会
一帧帧往下滚 —— 加 `-t` 就恢复原地重绘。
不加 `--live` 与 `--dump` 时直接跑完,只留下 `OUT` 的输出(默认是串行字符流,见「I/O 模式」).\
`--live` 期间 `OUT` 会被画面接管,程序结束后再原样补打出来,所以重定向到文件依然拿到完整的输出.\
输出不是终端(被管道/文件接管)时,`--live` 会退化成逐帧打印,可以直接 `less` 着看;程序也会在 stderr 上提一句.
画面高度是自动挑的:终端不足 30 行用 24 行的精简版,测不出高度时也先按 24 行来(猜你屏幕不大),`--full`
可以强制完整版. 用 `--tty` 之前那套原地重绘才生效,所以**如果你的终端其实是通过管道接进来的**
(网页版终端、某些 IDE 的面板,程序 `_isatty` 看不出来),画面会变成一帧帧往下滚 —— 加个 `-t` 就好了.
完整参数表见 `./build/rot8_test --help`(`-e` 每帧指令数、`-f` 帧率上限、`-c` 颜色、
`-k` 精简画面、`-i` 输入、`-m`/`-b` 几何)。
## 纸带尺寸与 Cell 位宽
两者都不在指令集里 —— 纸带是任意长的环,Cell 是任意宽的一圈位,所以这里也不做限制,
运行时随便给:
两者都不在指令集里 —— 纸带是任意长的环,Cell 是任意宽的一圈位,所以运行时随便给:
```sh
rot8_test --mem 300 tapes/wave.rot8 # 300 格(不是 2 的幂也行)
rot8_test --mem 300 tapes/wave.rot8 # 300 格(不是 2 的幂也行)
rot8_test --mem 1000 --cell 16 tapes/wave.rot8
rot8_test --mem 64 --cell 1 tapes/wave.rot8 # 1 bit 的 Cell(默认走数值 I/O)
rot8_test --mem 64 --cell 1 tapes/wave.rot8 # 1 bit 的 Cell(默认走数值 I/O)
rot8_test --mem 100 --cell 12 --live tapes/wave.rot8
```
- **位宽 1..32,任意值**:`ROR` 在这个位宽里循环(16 bit 时 bit0 转到 bit15),`FLB` 翻 LSB,
`BIZ`/`RNZ` 仍然只看 LSB,`INP` 的值截到该位宽. 同一条 `-++++`(置位后转 4 次)在
8 / 16 / 32 bit 下分别是 `0x10` / `0x1000` / `0x10000000`.
- **纸带长度 1..1048576,任意值**:指针走出纸带会**绕回另一端**(和 Cell 的 `ROR` 一样是个环),
不会越界. 末行不满一行时右边留空.
- **位宽 1..32,任意值**:`ROR` 在这个位宽里循环(16 bit 时 bit0 转到 bit15),`FLB` 翻 LSB,
`BIZ`/`RNZ` 仍然只看 LSB,`INP` 的值截到该位宽。同一条 `-++++`(置位后转 4 次)在
8 / 16 / 32 bit 下分别是 `0x10` / `0x1000` / `0x10000000`。
- **纸带长度 1..1048576,任意值**:指针走出纸带会**绕回另一端**(和 Cell 的 `ROR` 一样是个环),
不会越界;末行不满一行时右边留空。
画面完全跟着几何走,而且**每帧高度只由几何决定**,不随指针移动变化(`--live` 的原地重绘因此
不会拖影):
画面完全跟着几何走,**每帧高度只由几何决定**,不随指针移动变化(原地重绘因此不会拖影):
| 场景 | 表现 |
| --- | --- |
| 位宽 ≤ 8 | 每位一列(`b7 … b0`),8 bit 与以前一模一样 |
| 位宽 > 8 | 一行按 4 位分组的字串(`bits b15 .. b0 .... .... .... ..1.`) |
| 一格宽度 | 每格 `ceil(bits/4)` 个十六进制位;一格占的列数由宽度算出,所以画面永远 56 字符宽 |
| 纸带 ≤ 16 行 | 整条画出来 |
| 纸带 > 16 行 | 只画指针附近的一窗(指针始终在窗口里),末行注明 `window A..B of N cells` |
| 位宽 ≤ 8 | 每位一列(`b7 … b0`) |
| 位宽 > 8 | 一行按 4 位分组的字串(`bits b15 .. b0 .... .... .... ..1.`) |
| 一格宽度 | 每格 `ceil(bits/4)` 个十六进制位,画面永远 56 字符宽 |
| 纸带 > 16 行 | 只画指针附近的一窗(指针始终在窗口里) |
内嵌用法:
内嵌用法:
```c
rot8_config cfg = {1000, 12}; /* 纸带长度, Cell 位宽 */
@@ -153,153 +148,34 @@ ROT-8 ([rəʊˈteɪt]) 提供了一套简洁的指令集,使利用无ALU的各
unsigned bits = rot8_cell_width(iter);
```
`rot8_config_apply` 只在越界(0 格 / 位宽 0 或 >32 / 长度 >1048576)时返回 `false` 并且什么都不改.
把默认几何显式写出来(`--mem 256 --cell 8`)时,行为与改默认值之前逐字节一致:`--dump` 的
画面、`OUT` 的输出都没有变 —— 所以拿旧基准对比时记得把这两个参数带上.
`rot8_config_apply` 只在越界(0 格 / 位宽 0 或 >32 / 长度 >1048576)时返回 `false` 并且什么都不改。
> 注意:按 8 bit 写死的 tape 拿到 11 bit 下**不只是算错,还可能永远跑不完** ——
> 那些 `%rep 8` 的循环只转了 8 圈,cell 没转回原位,"转到某位清零"的条件于是永远不成立.
> 实测旧 `test.r8asm` 的纸带在 11 bit 下 `--dump` 会一直跑下去. 换位宽请重新汇编纸带.
> 按 8 bit 写死的 tape 拿到 11 bit 下**不只是算错,还可能永远跑不完**:那些 `%rep 8` 的循环只
> 转了 8 圈,cell 没转回原位,"转到某位清零"的条件于是永远不成立。换位宽请重新汇编纸带。
## 输入
## 7E1 帧:7 数据位 + 偶校验 + 1 停止位
`INP` 现在按这个顺序取值:先吃 `--input` 排好的队列,再问现场(live 模式),最后才回落到
stdin —— 所以不带 `--input`、也不开 `--live` 时输入那头和以前一样(输出模式见下一节).
```sh
rot8_test -n --input 7,5 tapes/full_adder.rot8 # 脚本/测试:一次喂完(数值)
rot8_test --input "hi" tapes/serial_echo.rot8 # 串行:一个字符一个 INP
rot8_test --live tapes/echo.rot8 # 现场:画面下方问 input>
```
下面这张是 `-n`(数值)模式的画面;串行模式长什么样见「I/O 模式」那一节.
live 模式下画面分两层,框里只**记录**已经产生的输入输出,提示在框**外面**:
```
+--------------------------------------------------------+
| in (2) 123 65 | <- 框里: 单行汇总
| out (2) 123 65 | <- 框里: 单行汇总
+--------------------------------------------------------+
input> 123 <- 框外: 逐事件日志
output> 123
input> 65
output> 65
```
框里那两行是**单行汇总**(各记全部值),框外是**逐事件日志** —— 每次 `INP`/`OUT` 各占一行,
所以输入和输出的先后顺序看得一清二楚. 因为日志已经记了输出,`--live` 结束时不再重复打印一遍
原始输出.
轮到输入时,最下面会多出一行空的 `input> ` 当提示,光标停在那里 —— 敲的数字落在窗口外面,
不会和画面挤在一起;回车之后提示消失,值进到上面日志里. 提示永远在最下面,所以不会出现
"后来的输出跑到提示上面"这种次序错乱. 日志只留最近 6 条,更早的用 `..` 表示.
一开头就是 `INP` 的 tape 也没问题:提示会先把第一帧画出来再问,所以内存的初始状态是看得到的
(为此输入回调拿到了迭代器).
精简画面没有 `in`/`out` 框,框外的日志照旧. 只产生输出、不读输入的 tape 也会有 `output>` 日志.
stdin 已经关掉(管道读完)时喂 0 并照常跑完,不会卡住. `tapes/echo.rot8`(内容就是 `,.`)是
拿来试这个的最小例子.
## I/O 模式:默认串行(7 位 ASCII),`-n` 切回十进制
`INP`/`OUT` **默认按一个字符**走(8 位及以上的 cell):tape 里放一个 `'R'`(82)出去就是一个 `R`.
以前那套"整格十进制整数 + 换行"还在,用 `-n` / `--numbers` 打开:
| | 串行(默认,cell ≥ 8 位) | 十进制(`-n` / `--numbers`) |
|---|---|---|
| `OUT` | **低 7 位**当字符,直接 `putchar`,不加换行 | 整格的值 + 换行 |
| `INP` | 读**一个字符**,只写低 7 位 | 读一个十进制数,整格覆盖 |
| `--input` | **字符串**,一个字符一个 `INP` | 数字列表 `7,5` |
**第 8 位(bit 7)以及更高的位不归 I/O 管**:`INP` 只改低 7 位,把原来的高半个 cell 原样留着 ——
所以 tape 可以拿 bit 7 当标志位、长度位或者别的什么,而读写字符时它不会被冲掉. 想要 char
以外的数据,就放在那上面.
**默认由位宽决定**:cell ≥ 8 位走串行(7 位字符 + 1 位余量),< 8 位走数值 I/O —— 所以 1 bit
那种机器照旧跑,不需要额外参数. 显式写了 `-s` / `--serial` 又不够宽,才报错退出(exit 2);
`-n` 想跟串行选项一起写也会被拒(exit 2)—— 两种模式互斥.
```sh
rot8_test --input "R8F" tapes/serial_echo.rot8 # 打 R8F
echo A | rot8_test tapes/echo.rot8 # 管道里喂一个字符
rot8_test --live --input "hi" tapes/serial_echo.rot8 # 画面里也显示成字符
rot8_test -n --input 65 tapes/echo.rot8 # 要十进制:65,不是 A
```
老脚本里写的 `-s` 仍然能用:串行已经是默认,它只是把默认再说一遍.
`tapes/serial_echo.rot8` 就是 `,.,.,.`(读三个字符、原样打三个字符). 串行模式下字符是**连着**显示的
(字符流不该被空格拆开),数字模式才用空格分隔;画面里长这样:
```
| in (3) R8F |
| out (3) R8F |
output> 'R' 82
output> '8' 56
output> 'F' 70
```
`--input` 喂进去的值现在也会进 `in` 那一行(以前只有 live 现场提问才记),所以脚本跑完跟现场
敲的一样能看出输入输出怎么交错.
### 7E1 帧:7 数据位 + 偶校验 + 1 停止位
`--7e1` = `--serial --parity even --stop`,一个 cell 装一整帧:
`--7e1` = `--serial --parity even --stop`,一个 11 位 cell 装一整帧还剩 2 位给 tape 用:
| bit | 8 | 7 | 6..0 |
|---|---|---|---|
| 含义 | 停止位(恒 1) | 偶校验位 | 7 位字符 |
| 含义 | 停止位(恒 1) | 偶校验位 | 7 位字符 |
11 位的 cell 放完这 9 位还剩 2 位给 tape 自己用. `INP` 负责**填**这两个帧位,`OUT` 负责**查**:
```sh
rot8_test --7e1 --input "A" tapes/serial_echo.rot8 # 读进来就带校验位和停止位
rot8_test --parity even --input "A" tape.rot8 # 只查/填校验位
rot8_test --stop --input "A" tape.rot8 # 只查/填停止位(要 cell >= 9)
```
帧不对的时候字符**照样**打出去(和真 UART 一样),但 stderr 上会记
`parity error` / `framing error`,跑完汇总一句,进程**退出码 4** —— 脚本可以直接用 `$?` 判断.
`bit7`/`bit8` 只在对应开关打开时才归帧所有,否则还是 tape 的.
为什么"1 个停止位"是 cell 里的一个 bit,而不是"线路空闲一个位时间":这台机器没有逐位时钟,
一次 `INP`/`OUT` 就是一整帧(起始位由操作边界隐式给出),所以帧里只剩停止位这一个显式字段.
**硬件上算校验位要什么**:什么都不用加. 偶校验就是"1 的个数是偶数",而 ROT-8 的读头本来就
一位一位地过 ring —— 每读到一个 1 就翻转一次那个 1 位锁存(机械拨杆、继电器自锁触点、水的
翻斗都行),7 位过完它上面就是校验位. **校验是同一个电路**:把收到的校验位也一起喂进去,
8 位过完期望它停在 0,于是连比较器都省了 —— 只要"读头 + 一个可翻转的锁存 + 一个门". 真 UART
也是这么做的.
不可打印的字符(以及 0)在画面里写成 `\x0A` 这种转义,免得把帧撑坏;真正写到 stdout 时当然
还是原字节. 因为字符输出不带换行,程序跑完后 CLI 会补一个换行,免得提示符粘在后面.
想验证 bit 7 真的没被动过:把 cell 预置成 `0x80` 再读一个 `A`,cell 会是 `0xC1`
(`-+` 在 8 位下就是把 bit0 的 1 转到 bit7,然后 `,.` 读一个字符再打出来,`--dump` 能看到).
`INP` 负责**填**这两个帧位,`OUT` 负责**查**;帧不对时字符照样打出去(和真 UART 一样),但
stderr 会记 `parity error` / `framing error`,进程**退出码 4**。校验位怎么用硬件算出来、
为什么停止位是 cell 里的一个 bit,见 [`docs/serial.md`](docs/serial.md)。
## 构建与测试
### 构建
```sh
mkdir build
cd build
cmake ..
make -j$(nproc)
mkdir build && cd build && cmake .. && make -j$(nproc)
./build/rot8_test -n tapes/and.rot8 # 与门
./build/rot8_test -n tapes/or.rot8 # 或门
./build/rot8_test -n tapes/full_adder.rot8 # 全加器
./build/rot8_test --dump tapes/full_adder.rot8 # 跑完看一眼纸带
./build/rot8_test --live tapes/wave.rot8 # 看它把纸带刷成一道波
```
### 运行(测试)
```sh
./build/rot8_test tapes/and.rot8
./build/rot8_test tapes/or.rot8
./build/rot8_test tapes/full_adder.rot8
./build/rot8_test --dump tapes/full_adder.rot8 # 跑完看一眼纸带
./build/rot8_test --live tapes/wave.rot8 # 看它把纸带刷成一道波
```
`tapes/serial_echo.rot8` 就是 `,.,.,.`(读三个字符、原样打三个字符),拿来试串行 I/O 和
`--input` 最小;`tapes/echo.rot8` 是 `,.`。
+63
View File
@@ -0,0 +1,63 @@
# 串行 I/O 与 7E1 帧
契约(默认模式、选项、`--input` 的两种含义)在 [`README.md`](../README.md) 的「I/O 模式」;
这里放细节和"为什么"。
## 1. 字符占低 7 位,高位不归 I/O 管
串行模式下一个 cell 的低 7 位(bit 0..6)是字符,**bit 7 以及更高的位不归 I/O 管**:
`INP` 只改低 7 位,把原来的高半个 cell 原样留着。所以 tape 可以拿 bit 7 当标志位、长度位或者
别的什么,而读写字符时它不会被冲掉。想要 char 以外的数据,就放在那上面。
验证方法:把 cell 预置成 `0x80` 再读一个 `A`,cell 会是 `0xC1`(`-+` 在 8 位下就是把 bit0
的 1 转到 bit7,然后 `,.` 读一个字符再打出来,`--dump` 能看到)。
## 2. 字符流不加空格
串行模式下字符是**连着**显示的(字符流不该被空格拆开),数字模式(`-n`)才用空格分隔。
画面里长这样:
```
| in (3) R8F |
| out (3) R8F |
output> 'R' 82
output> '8' 56
output> 'F' 70
```
`--input` 喂进去的值也会进 `in` 那一行,所以脚本跑完跟现场敲的一样能看出输入输出怎么交错。
不可打印的字符(以及 0)在画面里写成 `\x0A` 这种转义,免得把帧撑坏;真正写到 stdout 时
当然还是原字节。因为字符输出不带换行,程序跑完后 CLI 会补一个换行,免得提示符粘在后面。
## 3. 7E1:7 数据位 + 偶校验 + 1 停止位
`--7e1` = `--serial --parity even --stop`,一个 cell 装一整帧:
| bit | 8 | 7 | 6..0 |
|---|---|---|---|
| 含义 | 停止位(恒 1) | 偶校验位 | 7 位字符 |
11 位的 cell 放完这 9 位还剩 2 位给 tape 自己用。`INP` 负责**填**这两个帧位,`OUT` 负责**查**:
```sh
rot8_test --7e1 --input "A" tapes/serial_echo.rot8 # 读进来就带校验位和停止位
rot8_test --parity even --input "A" tape.rot8 # 只查/填校验位
rot8_test --stop --input "A" tape.rot8 # 只查/填停止位(要 cell >= 9)
```
帧不对的时候字符**照样**打出去(和真 UART 一样),但 stderr 上会记 `parity error` /
`framing error`,跑完汇总一句,进程**退出码 4** —— 脚本可以直接用 `$?` 判断。
`bit7` / `bit8` 只在对应开关打开时才归帧所有,否则还是 tape 的。
### 为什么"1 个停止位"是 cell 里的一个 bit
这台机器没有逐位时钟,一次 `INP`/`OUT` 就是一整帧(起始位由操作边界隐式给出),所以帧里
只剩停止位这一个显式字段。
### 硬件上算校验位要什么
什么都不用加。偶校验就是"1 的个数是偶数",而 ROT-8 的读头本来就一位一位地过 ring —— 每读到
一个 1 就翻转一次那个 1 位锁存(机械拨杆、继电器自锁触点、水的翻斗都行),7 位过完它上面就是
校验位。**校验是同一个电路**:把收到的校验位也一起喂进去,8 位过完期望它停在 0,于是连比较器
都省了 —— 只要"读头 + 一个可翻转的锁存 + 一个门"。真 UART 也是这么做的。