简介：计算机组成原理课程中的微程序控制器实验报告，面向正在学习相关原理的本科生及研究人员。文档围绕微程序控制器展开，系统说明指令系统、控制存储器、微指令格式及地址转移逻辑等核心概念，并依托多思虚拟实验系统讲解如何绘制实验电路、执行微指令，适合作为理论结合实践的补充材料。资源为单个docx文档，压缩包共1个文件，大小约485KB，内容为一份完整的实验报告。目前已有649人学习浏览。报告包含实验目的、实验电路图、主要元器件（如74LS175、EPROM2716）功能说明、微指令二进制编码表、四条机器指令（IN、ADD、STA、JMP）的微程序流程图，以及详细实验步骤与思考题。读者可通过虚拟实验系统实操，加深对微程序执行流程的理解，并掌握微地址生成与指令操作码的对应方法。
1. 微程序控制器虚拟实验：值得自己动手实现的三个理由
微程序控制器是计算机组成原理实验里少有的、能让你同时看到“程序怎么被解释执行”的东西。它本质上是一台跑在 CPU 内部的微型计算机：控制存储器放着微程序，微地址寄存器一条条取出微指令，再用几十个控制信号驱动数据通路。很多人以为它和硬连线控制器一样，结果进了虚拟实验系统后，微地址和机器指令地址搅在一起，单步几拍就开始怀疑人生。这一篇我会把微程序控制器原理和虚拟实验系统实现一起讲，并给出一个能用浏览器直接打开的最小版本，覆盖微指令格式、微地址生成、单步/连续执行，以及我踩过的那些坑。适合正在做组成原理实验的学生、想自建实验平台的技术人员，也适合想用软件仿真把硬件实验补完的开发者。
2. 微指令与微地址生成：虚拟实验系统建模时必须先立住的三个对象
做虚拟实验系统，最关键的不是把界面画得多漂亮，而是先把原理层拆成三个能落地的对象：微指令格式、微地址生成规则、时钟步进时各寄存器的更新时机。很多参考实现只顾着模拟指令执行，却把微程序控制器最核心的“微地址怎么来”一笔带过，最后用户只能看到一个黑匣子，实验也没法做。
2.1 先分清两套存储与两套地址：机器程序在主存，微程序在控制存储器
先从最容易混淆的地方入手。虚拟实验系统里至少有两个“地址寄存器”：
| 对比项 | 机器指令程序 | 微程序 |
|---|---|---|
| 存储位置 | 主存 MEM | 控制存储器 CM |
| 地址寄存器 | PC | μAR（代码里是 cmAddr） |
| 取出的内容 | 机器指令，进入 IR | 微指令，直接产生控制信号 |
| 由谁解释 | CPU 控制器 | 微指令译码/执行逻辑 |
主存里放的是用户写的程序，比如“把 5 加到累加器”，PC 每步指向下一条机器指令。控制存储器里放的是微程序，它解释每条机器指令应该分成哪几步、每步打开哪些数据通路的开关，μAR 每步指向下一条微指令。虚拟实验系统必须把这两个地址独立显示出来，否则调试时很容易把 PC 的值当成微地址。
对应到代码里，我会用state.pc表示机器指令地址，用state.cmAddr表示微地址，两者互不干扰。取指周期的微程序负责把 PC 指向的机器指令送到 IR，而执行周期的微程序则根据 IR 中的操作码跳转到对应入口。
2.2 微指令格式：操作控制字段和顺序控制字段分开设计
教学用微程序控制器大多采用水平型微指令，也就是把每个控制信号单独占一个位或一个字段，这样界面上一眼就能看出这一步打开了哪些开关。我的虚拟实验系统把微指令设计成四个部分：
| 字段 | 作用 | 取值示例 |
|---|---|---|
| cond | 微地址生成的条件 | UNCOND / Z / OPMAP |
| nextAddr | 默认下一条微地址 | 0~255 |
| ifCondAddr | 条件成立时的微地址 | 0~255 |
| ops | 操作控制信号位掩码 | PCout、MARin、ReadMem… |
其中ops用位掩码而不是字符串数组，是因为后续不管是判断信号还是界面显示二进制，都能直接用位运算，性能好也不会写错键名。下面是微指令构造器：
const OPS = { PCout: 1 << 0, PCin: 1 << 1, MARin: 1 << 2, PCinc: 1 << 3, ReadMem: 1 << 4, MDRin: 1 << 5, MDRout: 1 << 6, IRin: 1 << 7, IRaddr: 1 << 8, ACCin: 1 << 9, ALU_ADD: 1 << 10, HALT: 1 << 11 }; function micro(cond, nextAddr, ifCondAddr, ops) { return { cond: cond, nextAddr: nextAddr, ifCondAddr: ifCondAddr, ops: ops }; }micro的四个参数看起来简单，却是整个虚拟实验数据结构的根基。nextAddr是顺序控制的核心，它告诉系统“默认情况下下一条微指令在哪”；ifCondAddr只在条件分支里使用；如果这条微指令不产生分支，我会让ifCondAddr和nextAddr保持一致，避免后续判断时出现 undefined。ops里的每一个位都对应一个数据通路开关，比如1 << 0表示 PC 输出到地址总线。
2.3 微地址生成：顺序、条件分支和操作码映射
微地址寄存器的下一个状态，在虚拟实验里不外乎四种来源：顺序执行、无条件跳转、条件跳转、取指结束后按机器指令操作码映射到微程序入口。前两种直接看nextAddr就行，真正需要小心的是条件分支和操作码映射。
下面这段代码实现微地址生成，也是整个控制器最关键的函数：
const entryMap = { 0x1: 4, // ADD 0x2: 7, // JMP 0x3: 8, // JZ 0x0: 10 // HLT }; function nextMicroAddr(cmAddr, ir, flags) { const inst = cm[cmAddr]; if (inst.cond === 'OPMAP') { const op = (ir >> 12) & 0xf; const next = entryMap[op]; if (next !== undefined) return next; state.halted = true; return cmAddr; } if (inst.cond === 'Z') { return flags.Z ? inst.ifCondAddr : inst.nextAddr; } return inst.nextAddr; }OPMAP通常放在取指微程序的最后一步，也就是 IR 已经装好机器指令之后。它从 IR 的高 4 位取出操作码，再通过entryMap找到这条机器指令对应的微子程序入口。这里的entryMap本质上是硬布线译码器的软件替代品，教学实验里也可以换成分支表或者 if-else，但查表最直观。flags.Z是之前周期锁存下来的标志位，这一点非常重要，如果你在条件分支里读取的是当前周期 ALU 刚算出来的实时标志，就会出现第 5 章里提到的“JZ 不跳转”问题。
3. 从指令集到控制存储器：虚拟实验系统的分层设计
原理立住之后，下一步就是把整个系统分层。我会按“机器指令集 → 微程序入口表 → 控制存储器 → 数据通路状态”的顺序来搭。先定指令集，再写微程序，最后才写界面和交互。
3.1 先定机器指令集，再写微程序入口表
很多初学者上来就写微程序，结果指令操作码和微地址入口对不上，越改越乱。正确做法是先定一套最小机器指令集。我的最小模型机只有 4 条指令，16 位定长：高 4 位是操作码，低 12 位是地址字段，实验内存只用低 8 位地址，也就是 256 字节。
| 助记符 | 操作码 | 功能 |
|---|---|---|
| ADD addr | 0x1 | ACC ← ACC + M[addr] |
| JMP addr | 0x2 | PC ← addr |
| JZ addr | 0x3 | if Z then PC ← addr |
| HLT | 0x0 | 停机 |
为什么这么少？因为虚拟实验系统的目标是让学生看懂微程序控制器怎么工作，而不是把 CPU 做完。4 条指令已经能覆盖顺序执行、取指、执行、条件分支和停机五类典型场景。等这套骨架跑通，再扩展 LDA、STA、SUB 就只是加一条微子程序的事。
指令格式确定后，操作码到微程序入口的映射关系也就固定了。我把入口表直接放在nextMicroAddr旁边，方便对照：
// 操作码 -> 微程序入口 const entryMap = { 0x1: 4, // ADD 从 CM[4] 开始 0x2: 7, // JMP 从 CM[7] 开始 0x3: 8, // JZ 从 CM[8] 开始 0x0: 10 // HLT 从 CM[10] 开始 };入口表的编号不是随意的，它取决于你安排控制存储器时的顺序。我通常把取指公用段放在 0~3，执行段从 4 开始，这样微地址短，界面也好看。如果你以后要加指令，只需要在 entryMap 里新增一项，再在 CM 末尾追加微程序。
3.2 选型：为什么用前端仿真内核，而不是 Verilog 或控制台程序
实现虚拟实验系统有三种常见路线，我最终选的是 Web 前端加 JavaScript 仿真内核。先看对比：
| 实现路线 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| Verilog / HDL 仿真 | 贴近真实 RTL，控制信号精度高 | 需要仿真工具，界面交互弱，搭环境成本高 | 硬件验证、时序分析 |
| C++ / Java 控制台 | 逻辑清晰，运行快 | 没有可视化，改微指令不直观 | 算法验证 |
| Web 前端 + JS | 零安装、可视化强、易分享 | 不适合做时序收敛验证 | 虚拟实验系统、教学平台 |
我的理由很直接：虚拟实验系统要解决的是“让学生看到微指令执行过程”，而不是“证明电路时序能收敛”。软件仿真不需要精确到纳秒，但必须模仿“时钟边沿更新寄存器”的语义。如果只是把每个周期当成纯组合逻辑顺序执行，那 ADD 指令算出来的进位标志会在同一周期内部被后面的分支判断读到，结果就和真实硬件不一致。
所以我在设计仿真内核时，刻意把“应用控制信号”和“计算下一条微地址”分成两个阶段，并且微地址生成使用的标志位是锁存后的快照。这样既保持了代码简单，又在教学语义上贴近真实处理器。
3.3 数据通路部件与核心状态定义
整个虚拟实验系统的状态可以集中放在一个对象里。我习惯先定义状态，再写控制函数，因为状态字段决定了后续所有微指令怎么写：
const state = { pc: 0, ir: 0, mar: 0, mdr: 0, acc: 0, flags: { Z: false, C: false }, mem: new Uint16Array(256), cm: [], cmAddr: 0, cycle: 0, halted: false };字段含义如下：pc是机器指令地址，cmAddr是微地址，mar和mdr是访存地址和数据缓冲，acc是累加器，flags保存零标志和进位标志。mem用Uint16Array(256)是因为主存容量只开 256 字节，刚好一个屏幕能显示完，也方便调试。cm是控制存储器，保存微指令数组，和mem严格分开。
加载用户程序时，我只会重置mem和 PC 等用户可见状态，不会动cm：
function loadProgram(program) { state.mem.fill(0); for (let i = 0; i < program.length; i++) { state.mem[i] = program[i] & 0xffff; } state.pc = 0; state.acc = 0; state.flags.Z = false; state.flags.C = false; state.cmAddr = 0; state.cycle = 0; state.halted = false; }这段代码强调的是分层：控制存储器cm由系统初始化时写入，用户程序复位不能把它清空。你可以把cm想象成 ROM，而mem是 RAM，两类存储器的生命周期完全不同。
4. 用一个 HTML 文件跑通最小微程序控制器：代码与操作步骤
这一章给你一个能直接跑起来的最小实现。我不会贴完整项目，只放关键代码和接线方式，你按顺序把这些代码放进同一个 HTML 文件，浏览器打开就能看到微程序控制器在眼前一步一步执行。
4.1 准备单文件页面：页面骨架与三个按钮
最小交互只需要四个按钮：单步、运行、暂停、复位。加一个预格式文本区域用来显示当前状态。
<!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8"> <title>微程序控制器虚拟实验</title> </head> <body> <div> <button onclick="stepOnce()">单步</button> <button onclick="run()">运行</button> <button onclick="stop()">暂停</button> <button onclick="reset()">复位</button> <pre id="panel"></pre> </div> <script> // 后面三小节的代码全部放在这里 </script> </body> </html>我建议直接把所有 JS 写在一个 HTML 文件里，因为本地双击打开不会遇到跨域问题，也不需要启动本地服务器。如果你打算放到课程平台上，再把 JS 拆到单独文件也不迟。
4.2 初始化控制存储器：取指段和一条加法指令
控制存储器的初始化是整个实验的核心。下面这段initCM定义了 11 个微指令单元，覆盖取指、ADD、JMP、JZ、HLT：
function initCM() { state.cm = [ // 取指公用段 micro('UNCOND', 1, 1, OPS.PCout | OPS.MARin | OPS.PCinc), // 0 micro('UNCOND', 2, 2, OPS.ReadMem | OPS.MDRin), // 1 micro('UNCOND', 3, 3, OPS.MDRout | OPS.IRin), // 2 micro('OPMAP', 0, 0, 0), // 3 // ADD addr micro('UNCOND', 5, 5, OPS.IRaddr | OPS.MARin), // 4 micro('UNCOND', 6, 6, OPS.ReadMem | OPS.MDRin), // 5 micro('UNCOND', 0, 0, OPS.ALU_ADD | OPS.ACCin), // 6 // JMP addr micro('UNCOND', 0, 0, OPS.IRaddr | OPS.PCin), // 7 // JZ addr micro('Z', 0, 9, 0), // 8 micro('UNCOND', 0, 0, OPS.IRaddr | OPS.PCin), // 9 // HLT micro('UNCOND', 0, 0, OPS.HALT) // 10 ]; }我来带你走一遍 ADD 的微地址流。复位后cmAddr是 0，执行 0 号微指令：把 PC 送给 MAR，同时 PC 自增 1。然后进入 1 号微指令，根据 MAR 读主存到 MDR。2 号微指令把 MDR 送给 IR。3 号微指令是 OPMAP，这时nextMicroAddr会取 IR 高 4 位的操作码，查到entryMap[0x1] = 4，于是跳到 4 号微指令。4、5、6 三步完成“取地址 → 读内存 → 累加器加 MDR”，最后回到 0 号微指令，开始取下一条机器指令。
这里有一个所有教材都会强调的细节：取指需要 4 步而不是 3 步，因为 MAR 到 MDR 再到 IR 每步都有因果依赖。如果你把读内存和装入 IR 合并成一条微指令，虚拟实验执行顺序上就会出现 MDR 还没就绪就把旧值装入 IR 的问题，第 5 章会专门讲这个坑。
4.3 单步执行、连续运行与界面渲染
单步函数是整个系统的发动机。我的做法是严格分成两步：先应用当前微指令的控制信号，再用“锁存后的标志位”计算下一条微地址。
function stepOnce() { if (state.halted) return; const oldFlags = { Z: state.flags.Z, C: state.flags.C }; const inst = state.cm[state.cmAddr]; applyControlSignals(inst.ops); state.cmAddr = nextMicroAddr(state.cmAddr, state.ir, oldFlags); state.cycle++; render(); }applyControlSignals负责解释微指令里的操作控制字段。这个函数相当于真实硬件里的微指令译码与数据通路开关：
function applyControlSignals(ops) { if (ops & OPS.PCout) state.mar = state.pc; if (ops & OPS.PCinc) state.pc = (state.pc + 1) & 0xffff; if (ops & OPS.ReadMem) state.mdr = state.mem[state.mar]; if (ops & OPS.MDRout) state.ir = state.mdr; if (ops & OPS.IRin) state.ir = state.mdr; if (ops & OPS.IRaddr) state.mar = state.ir & 0xff; if ((ops & OPS.ALU_ADD) && (ops & OPS.ACCin)) { const r = (state.acc + state.mdr) & 0xffff; state.flags.Z = (r === 0); state.flags.C = (r > 0xffff); state.acc = r; } if (ops & OPS.HALT) state.halted = true; }你可能注意到这里没有显式的总线仲裁，这是因为我的最小系统里 ALU 是直接读 ACC 和 MDR 的双输入模型，省掉了一条数据总线。真实教学模型如果是单总线结构，ADD 还需要先把 ACC 送进暂存器、再把 MDR 送上总线，最后 ALU 结果写 ACC，那 ADD 会多两条微指令。在虚拟实验里，我更倾向于少一点数据通路细节、多一点微程序控制流程的可读性。
连续运行和界面刷新用最简单的定时器就够了：
let timer = null; function run() { if (timer) return; timer = setInterval(() => { if (state.halted) stop(); stepOnce(); }, 100); } function stop() { clearInterval(timer); timer = null; } function render() { const inst = state.cm[state.cmAddr]; document.getElementById('panel').textContent = 'cycle=' + state.cycle + ' cmAddr=' + state.cmAddr + ' pc=' + state.pc + ' ir=' + state.ir.toString(16) + ' acc=' + state.acc + ' Z=' + state.flags.Z + ' C=' + state.flags.C + ' halted=' + state.halted + ' ops=' + inst.ops.toString(2); }setInterval的 100ms 就是虚拟时钟周期，你可以把它改成 10ms 体验高速运行，也可以改成 500ms 让初学者看清每一步。为了防止死循环，run里检测到halted会自动stop。如果你想给界面加“当前微指令助记符”，只需要在render里把inst.ops翻译成信号名列表。
5. 微程序控制器虚拟实验的 5 个高频翻车现场与排查方法
这一段写的全是我自己调试时踩过的坑。每个问题都有明确的现象，你照着自己的实现比对，基本能定位。
5.1 指令寄存器 IR 一直为 0
现象：单步执行三次后，界面上的 IR 还是 0，程序明明已经加载进主存了。
原因：取指微程序把“读主存”和“MDR 装入 IR”写在同一条微指令里。比如micro('UNCOND', 2, 2, OPS.ReadMem | OPS.IRin)。顺序执行时，ReadMem先把主存内容读进 MDR，但IRin在同一周期内想要的是旧 MDR 值，结果 IR 装进去的是上一步的残留数据，而整个系统启动时 MDR 是 0。
解决：严格分开，先ReadMem | MDRin，等下一个周期再MDRout | IRin。也就是上面initCM里 1 号和 2 号微指令的写法，一步只干一件事。
5.2 微地址跳到了主存地址
现象：单步几次后，界面上的cmAddr突然变成 0x200、0x300 这种明显不是微程序入口的值。
原因：微地址生成函数里把state.pc当成微地址返回了。这通常发生在你合并 PC 和 μAR 的显示模块，或者某个跳转微指令里不小心写了return state.pc。
解决：在调试面板里同时显示 PC 和 cmAddr，并给两者分别加上“机器指令地址”和“微地址”的文字标签。我自己的习惯是让cmAddr永远只由nextMicroAddr返回，不在任何其他函数里单独修改。
5.3 单步正常，连续运行结果却不对
现象：一步一步点单步，每次结果都对；一按“运行”，最后累加器的值就变成乱码。
原因：最常见的是run里写了while (true) { stepOnce(); }这种同步死循环，页面在每次循环中来不及刷新，甚至直接卡死。另一种情况是点击事件在定时器回调中间插入，导致状态更新重叠。
解决：把stepOnce当作唯一的状态修改入口，连续运行只用setInterval周期性调用它。不要在run里开辟第二条执行路径，也不要在render里修改任何寄存器状态。
5.4 JZ 指令不跳转，或者反向跳转
现象：累加器结果为 0，Z 标志已经变成 true，但 JZ 还是顺序执行；反过来 Z 是 false，它却跳了。
原因：微地址生成时读取的是当前周期 ALU 刚算出的实时标志位。比如你在 ADD 微指令里更新了flags.Z，下一条微指令又立刻用这个新值做 JZ 判断，时序上是对的；但如果你在同一周期里既执行 ADD 又执行 JZ 判断，或者在条件分支微指令里先改了标志再判断，就会乱。还有一种是micro('Z', 0, 9, 0)里把ifCondAddr和nextAddr写反了。
解决：始终让 ADD 的结果和标志位先锁存，微地址生成使用锁存后的oldFlags。我在stepOnce里用一行const oldFlags = { Z: state.flags.Z, C: state.flags.C }锁存，就能保证 JZ 判断的是上一条微指令结束时的标志。
5.5 复位后微程序变成空白
现象：程序跑完，点复位，再点单步，系统直接报错或者微地址跳到不存在的单元。
原因：reset 函数里为了“彻底重置”，把state.cm重新赋成空数组，或者调用了一次initCM。但cm是控制存储器，不是临时状态，复位不应该重新加载它。
解决：复位只重置用户可见状态，不碰cm：
function reset() { state.pc = 0; state.ir = 0; state.mar = 0; state.mdr = 0; state.acc = 0; state.flags.Z = false; state.flags.C = false; state.cmAddr = 0; state.cycle = 0; state.halted = false; }如果你确实想要“重新初始化整个实验系统”，那可以单独提供一个“重置实验”按钮，它负责重新执行initCM和loadProgram，而不是在普通复位里混着做。
6. 验证与进阶：用一段小程序的运行轨迹检验微程序控制器
最小系统写完，第一步不是加功能，而是验证它真的能正确执行程序。我会用一个最简单的小程序做冒烟测试：内存0x10放一个常数 5，程序从0x20开始，第一条是ADD 0x10，第二条是HLT。初始化 ACC 为 0，预期结果是执行完 ADD 后 ACC 等于 5，且 Z 标志为 false。
function loadTestProgram() { state.mem.fill(0); state.mem[0x10] = 5; state.mem[0x20] = 0x1010; // ADD 0x10 state.mem[0x21] = 0x0000; // HLT state.pc = 0x20; }验证时不要只看最后结果，还要把每个周期的cmAddr、pc、ir打出来，形成一条运行轨迹。正常 ADD 的轨迹应该是：
cycle=0 cmAddr=0 pc=0x20 cycle=1 cmAddr=1 pc=0x21 cycle=2 cmAddr=2 pc=0x21 cycle=3 cmAddr=3 pc=0x21 cycle=4 cmAddr=4 pc=0x21 cycle=5 cmAddr=5 pc=0x21 cycle=6 cmAddr=6 pc=0x21 cycle=7 cmAddr=0 pc=0x21 cycle=8 ...这段轨迹对得上，说明取指、译码、执行和回写的主链路都通了。接下来我会推荐你做三件进阶的事。
第一，给系统加“微指令回放”。也就是每次stepOnce前把state的深拷贝压进一个数组，需要回退时直接弹出最近一份，相当于给虚拟实验吃了后悔药。实现很简单，但要记得深拷贝mem和flags。
第二，自定义一条新指令。比如增加SUB addr，流程是：在指令集里分配操作码 0x4，在entryMap里加一项0x4: 11，然后在initCM追加三条微指令完成 MAR 取地址、读 MDR、ACC 减 MDR，最后回到微地址 0。这一套流程走一遍，比看十遍书都管用。
第三，把微指令位掩码翻译成助记符。render里对inst.ops逐位判断，输出PCout MARin PCinc这样的字符串，方便用肉眼核对每一条微指令的控制信号。
我现在的习惯是，先列出所有控制信号的位掩码表，再开始写微程序。因为后面加指令最容易遇到“两个信号共用一个位”的冲突，比如把MARin和PCin都放在第 3 位，那微程序跑起来就是灾难。有了位掩码表，每加一条微指令前先对照一遍，能省掉大量返工。希望这篇笔记能让你的实验 7 顺利落地，也希望你在照着做完之后，敢于关掉参考代码，自己从头写一个微程序控制器。
本文还有配套的精品资源，点击获取
