组合逻辑电路：编码器、译码器、数据选择器

概念

组合逻辑电路的定义只有一条：

$$\boxed{{\displaystyle \text{输出只取决于当前输入，与过去无关}}}$$

换句话说：没有记忆、没有时钟、同一个输入永远给同一个输出。

对照一下：

	组合逻辑	时序逻辑
输出取决于	当前输入	当前输入 + 当前状态
有无记忆	无	有（触发器/寄存器）
能否用真值表完全描述	✅ 能	❌ 不能（需状态表）
有无时钟	不需要	一般需要
举例	加法器、译码器、MUX、ALU	计数器、寄存器、状态机

一句话：组合逻辑 = "算"，时序逻辑 = "算 + 记"。 这一篇讲"算"，下一篇锁存器/触发器讲"记"，再后面的状态机讲"记着算"。

原理

一、标准设计流程（五步）

① 明确输入输出，定义变量与含义
      ↓
② 列真值表（穷举所有输入组合）
      ↓
③ 化简（卡诺图 → 最小 SOP 或 POS）
      ↓
④ 选定器件形式（门 / 译码器 / MUX / ROM）
      ↓
⑤ 画连线图（注意扇入扇出、电平极性）

第 ④ 步是工程与考试的分水岭：同样的逻辑，用门搭可能要 20 个门，用一个译码器加一个门就搞定。"选对器件"比"化简得好"更能省成本。

二、编码器：把"谁被按下"变成二进制

功能：$2^n$ 条输入线 → $n$ 条输出线，把"哪一条有效"编码成二进制数。

普通编码器（4-2）

约束：任一时刻只允许一个输入有效。

$I_3$	$I_2$	$I_1$	$I_0$	$A_1$	$A_0$
0	0	0	1	0	0
0	0	1	0	0	1
0	1	0	0	1	0
1	0	0	0	1	1
其余组合				不允许出现

输出方程（直接读表）：

$$A_1=I_3+I_2,A_0=I_3+I_1$$

致命缺陷：同时按两个键时输出无意义（例如 $I_3$ 和 $I_1$ 同时按下，$A_1{A}_0=11$，看起来像"只有 $I_3$ 按下"，但定义上这是非法状态）。而且全 0 时无法区分"没按键"和"按了 $I_0$"。

这就是为什么实际器件都是优先编码器——把缺陷变成规则。

优先编码器（8-3，74LS148）

规则：允许多个输入同时有效，输出编号最大的那一个。

真值表（简化，低有效输入）：

$\overline{I_7}$	…	$\overline{I_1}$	$\overline{I_0}$	$A_2$	$A_1$	$A_0$	选中
0	x	x	x	1	1	1	$I_7$
1	…	0	x	1	0	1	$I_5$
1	…	1	0	0	0	0	$I_0$
1	…	1	1	—	—	—	无输入（由 GS/EO 指示）

验证几行：

实际按下的最高位	二进制编码	$A_2{A}_1{A}_0$
$I_7$	111	111
$I_5$	101	101
$I_0$	000	000

74LS148 的三个辅助输出（实际工程必须看）：

引脚	名称	作用
EI（$\bar{G}$）	输入使能（低有效）	级联时的"片选"
GS（$\overline{GS}$）	有输入指示（低有效）	告诉后面"有人按了"
EO（$\overline{EO}$）	输出使能（低有效）	级联时告诉前一片"我这没输入"

级联成 16-4 优先编码器：高位的 EO 接低位的 EI，低位的 GS 作为最终"有输入"标志。这就是"优先级从高位片向低位片传递"的硬件实现。

小端/大端的直觉：优先编码器是中断控制器的原型。CPU 的 NVIC 就是"编号越小优先级越高"（或者反过来）的优先编码器。

三、译码器：二进制数变成"哪一条线"

功能：$n$ 条输入 → $2^n$ 条输出，每条输出线唯一对应一个输入组合。

3-8 译码器 74LS138：

输入 $A_2{A}_1{A}_0$	有效输出
000	$\overline{Y_0}$（= 0，其余为 1）
001	$\overline{Y_1}$
…	…
111	$\overline{Y_7}$

关键点：

$$\overline{Y_i}=\{\begin{array}{ll}0& \text{当 }{A}_2{A}_1{A}_0=i\\ 1& \text{其他}\end{array}⟺\boxed{{\displaystyle Y_i=\overline{m_i}}}$$

每个输出就是一个最小项（取反）。所以译码器又叫 "最小项发生器"。

使能端：74LS138 有三个使能（$G_1$ 高有效，$\overline{G_{2A}}$、$\overline{G_{2B}}$ 低有效），三个同时满足才工作。

级联扩展：用两片 74LS138 + 一个反相器 → 4-16 译码器（低位片的使能由高位地址位控制）。

用译码器实现任意函数（★ 重点结论）

因为译码器输出的是全部最小项的取反，所以：

$$F=\sum m_i⟺F=\stackrel{―}{\overline{m_{i_1}}\cdot \overline{m_{i_2}}\cdots }=\text{NAND}(Y_{i_1},Y_{i_2},\dots )$$

一句话结论：一个 $n$–$2^n$ 译码器 + 一个多输入 NAND = 任意 $n$ 变量组合函数。

硬件代价对照：

实现方式	器件数
直接用门	取决于化简，可能十几个门
译码器 + NAND	固定 1 个译码器 + 1 个 NAND

这就是 MSI（中规模集成）的价值：规格化、好接线、可靠性高。设计多输出函数时优势更明显——一个译码器能同时喂多个 NAND，实现多个函数。

四、数据选择器（MUX）：从多条线里挑一条

功能：$2^n$ 条数据输入 + $n$ 条选择输入 → 1 条输出。

2 选 1 MUX：

$$Y=\overline{S}{D}_0+S{D}_1$$

4 选 1 MUX：

$$Y=\overline{S_1}\overline{S_0}{D}_0+\overline{S_1}{S}_0{D}_1+S_1\overline{S_0}{D}_2+S_1{S}_0{D}_3$$

8 选 1（74LS151）：

$$Y=\sum _{i=0}^7{m}_i(S_2{S}_1{S}_0)\cdot D_i$$

读这个式子：每个选择组合选中一个 $D_i$。所以 MUX 是"最小项选择器"——它和译码器是互逆的关系。

用 MUX 实现任意函数（★ 重点）

核心是香农展开（Shannon expansion）：

$$F(x_1,\dots ,x_n)=x_{1}F(1,x_2,\dots ,x_n)+\overline{x_1}F(0,x_2,\dots ,x_n)$$

操作流程：

① 选 k 个变量作 MUX 的"选择输入"（一般选高位）
② 对剩下的 n-k 个变量，逐个组合求 F 的表达式
③ 每个表达式化简为 {0, 1, D, D'} 之一，接到对应数据端
④ 若 n-k = 1，数据端只有这 4 种可能，一定能实现（这就是"降维"）

为什么"一定能"：单变量 $D$ 的函数只有 4 种——$0$、$1$、$D$、$\overline{D}$。而 MUX 的数据端恰好是 4 路输入（$0$、$1$、$D$、$\overline{D}$ 由 1 个 NOT 从上位变量得到）。容量刚好匹配。

两种用法：

用法	选择输入	数据输入	适用场景
直连	$n$ 个变量全作选择	接常数 0/1	$n\le$ MUX 的选择位数
降维	$n-1$ 个变量作选择	接 $0/1/D/\overline{D}$	变量数比选择位数多 1

考试常见问法："用 8 选 1 数据选择器实现 4 变量函数 $F$" → 就是降维用法：3 位作选择，剩下 1 位作数据。

五、常用组合逻辑 MSI 器件速查

器件	型号	功能	引脚要点
优先编码器	74LS148	8-3，低有效输入	EI / GS / EO
译码器	74LS138	3-8，低有效输出	$G_1$、$\overline{G_{2A}}$、$\overline{G_{2B}}$
译码器	74LS154	4-16，低有效输出	可级联成 5-32
数据选择器	74LS151	8 选 1，含反相输出 $\bar{W}$	有 strobe
数据选择器	74LS153	双 4 选 1	两个独立 MUX
数值比较器	74LS85	4 位比较，可级联	$A>B$ / $A=B$ / $A<B$
加法器	74LS283	4 位二进制全加，超前进位	$C_{in}$ / $C_{out}$
奇偶校验	74LS280	9 位奇/偶校验发生器	常用于校验位

级联扩展的通用套路（背下来）：

① 用高位地址控制"片选/使能端"（译码器、MUX 的 strobe）
② 用低位地址接器件的"选择端"
③ 数据线并联（MUX 的输出用 OR 或三态门汇合）
④ 注意极性：低有效的使能端要加反相或直接接译码器的低有效输出

六、竞争冒险在组合逻辑中的位置

组合逻辑只要有两条延迟不同的路径汇聚到同一个门，就可能产生毛刺。

最常出问题的三处：

① 译码器 + 多输入 NAND：不同 Y_i 的路径延迟差可能造成输出毛刺
② MUX 的多个数据端路径：切换选择端瞬间可能送出错误数据
③ 加法器的进位链：进位传播造成"本该稳定的位瞬间翻转"

应对：

方法	原理	代价
加冗余项（卡诺图加圈）	用第三条路顶住输出	多门
加选通/时钟同步	毛刺出现在切换瞬间，等它消失再采样	需要时钟（最常用）
输出加滤波电容	低通滤掉窄脉冲	速度慢，且数字电路不喜电容
用格雷码编码地址	每次只变一位，避免多路同时切换	编码受限

工程共识：同步设计中不刻意消毛刺——因为在时钟沿采样时，组合逻辑早已稳定（前提：时序收敛，见后面的建立/保持时间）。"冒险"是异步电路的敌人，同步电路靠时序余量免疫。

示例

例 1：用 3-8 译码器实现任意三变量函数（完整过程）

用 74LS138（输出低有效）实现 $F(A,B,C)=\sum m(0,2,3,5,7)$。

第一步：确定输出有效行。

$F=1$ 的编号：$\{0,2,3,5,7\}$。

第二步：写出译码器输出。 74LS138 输出低有效：

$$Y_i=\overline{m_i}\Rightarrow Y_i=\{\begin{array}{ll}0& i\in \{0,2,3,5,7\}\\ 1& i\in \{1,4,6\}\end{array}$$

输出表：

$ABC$	000	001	010	011	100	101	110	111
$\overline{Y_0}\dots \overline{Y_7}$	0	1	0	0	1	0	1	0
目标 $F$	1	0	1	1	0	1	0	1

第三步：看出"求反"关系。 比较两行：$F=\overline{Y_0}$？不成立——因为只有 $m_0$ 时 $F=1$ 但 $Y_1=1$ 时 $F=0$。

正的思路：只要选中的是"目标集合里的下标"，$F$ 就该是 1。而"选中的那一条线"恰好是唯一为 0 的线。

所以：

$$F=1⟺\text{为 0 的那条线在下标集合里}⟺\text{并非所有目标线都为 1}$$

等等——直接写成"NAND"更清楚：

$$F=\overline{Y_0\cdot Y_2\cdot Y_3\cdot Y_5\cdot Y_7}$$

第四步：验证这个式子。

• 当 $ABC=000$ 时：$Y_0=0$，其余为 1 → 乘积 $=0$ → $F=\bar{0}=\mathbf{1}$ ✓
• 当 $ABC=001$ 时：$Y_1=0$（不在集合里），$Y_0,Y_2,Y_3,Y_5,Y_7$ 全部为 1 → 乘积 $=1$ → $F=\bar{1}=\mathbf{0}$ ✓
• 当 $ABC=101$ 时：$Y_5=0$ → 乘积 $=0$ → $F=\mathbf{1}$ ✓

逐行核对：

$ABC$	唯一为 0 的线	在集合里?	乘积	$F$	目标
000	$Y_0$	✓	0	1	1 ✓
001	$Y_1$	✗	1	0	0 ✓
010	$Y_2$	✓	0	1	1 ✓
011	$Y_3$	✓	0	1	1 ✓
100	$Y_4$	✗	1	0	0 ✓
101	$Y_5$	✓	0	1	1 ✓
110	$Y_6$	✗	1	0	0 ✓
111	$Y_7$	✓	0	1	1 ✓

第五步：结论。

$$\boxed{{\displaystyle F=\text{NAND}(Y_0,Y_2,Y_3,Y_5,Y_7)}}$$

接线：译码器的 $A_2{A}_1{A}_0$ 接变量 $A,B,C$；五个输出脚进一个 5 输入 NAND；NAND 输出即 $F$。

一般化结论（直接背）：

• 译码器输出低有效 → 用 NAND 汇合目标最小项
• 译码器输出高有效 → 用 OR 汇合目标最小项

原理都是同一句："选中即命中"。

例 2：用 8 选 1 数据选择器实现三变量函数（完整过程）

用 74LS151 实现 $F(A,B,C)=\sum m(0,1,2,4,7)$。

第一步：判断能否直连。 变量数 3 = 选择端位数 3 → 直连用法。

第二步：设选择端。 $S_2{S}_1{S}_0=ABC$。

第三步：数据端接常数。

$$D_i=\{\begin{array}{ll}1& i\in \{0,1,2,4,7\}\\ 0& i\in \{3,5,6\}\end{array}$$

第四步：写出接法。

数据端	$D_0$	$D_1$	$D_2$	$D_3$	$D_4$	$D_5$	$D_6$	$D_7$
接法	1	1	1	0	1	0	0	1

第五步：验证。

• $ABC=000$ → 选中 $D_0=1$ → $F=1$ ✓
• $ABC=011$ → 选中 $D_3=0$ → $F=0$ ✓
• $ABC=111$ → 选中 $D_7=1$ → $F=1$ ✓

结论：$D_0=D_1=D_2=D_4=D_7=1$，$D_3=D_5=D_6=0$，选择端接 $A,B,C$。

这就是"用 MUX 做真值表"最纯粹的形式：数据端的 0/1 序列，就是真值表本身。 不需要任何化简，不需要任何门。（代价：器件规格固定，变量多了要换更大的 MUX。）

例 3：用 8 选 1 MUX 实现四变量函数（降维用法，完整过程）

用 74LS151 实现 $F(A,B,C,D)=\sum m(0,1,5,7,8,9,13,15)$。

第一步：变量数 4 > 选择端 3 → 必须降维：取 $A,B,C$ 作选择，$D$ 作数据。

第二步：对每个 $ABC$ 组合，求 $F$ 关于 $D$ 的表达式。

$a=A\cdot 4+B\cdot 2+C$ 对应两个最小项：$D=0$ 时 $m=2a$，$D=1$ 时 $m=2a+1$。

$ABC$	$D=0$ 的 $m$	在集合?	$D=1$ 的 $m$	在集合?	$F(D)$	数据端
000	0	✓	1	✓	恒 1	$D_0=\mathbf{1}$
001	2	✗	3	✗	恒 0	$D_1=\mathbf{0}$
010	4	✗	5	✓	$=D$	$D_2=\mathbf{D}$
011	6	✗	7	✓	$=D$	$D_3=\mathbf{D}$
100	8	✓	9	✓	恒 1	$D_4=\mathbf{1}$
101	10	✗	11	✗	恒 0	$D_5=\mathbf{0}$
110	12	✗	13	✓	$=D$	$D_6=\mathbf{D}$
111	14	✗	15	✓	$=D$	$D_7=\mathbf{D}$

第三步：写出数据端接法。

$$D_0=1,D_1=0,D_2=D,D_3=D,D_4=1,D_5=0,D_6=D,D_7=D$$

接线图：

   A B C ──┬──┬──┬──→  S2 S1 S0   (74LS151)
           │  │  │
           │  │  └─── D7 ──┐
           │  └────── D6 ──┼── D
           │         D5 ── 0
           │         D4 ── 1
           │         D3 ── D
           │         D2 ── D
           │         D1 ── 0
           └──────── D0 ── 1

第四步：验证。

• $ABCD=0000$ → $ABC=000$ → $D_0=1$ → $F=1$ ✓
• $ABCD=0101$ → $ABC=010$ → $D_2=D=1$ → $F=1$ ✓
• $ABCD=0110$ → $ABC=011$ → $D_3=D=0$ → $F=0$ ✓
• $ABCD=1111$ → $ABC=111$ → $D_7=D=1$ → $F=1$ ✓
• $ABCD=0100$ → $ABC=010$ → $D_2=D=0$ → $F=0$ ✓（$m_4$ 不在集合）

第五步：与直接门实现对比。 用卡诺图化简这个 4 变量函数：

• $\overline{B}\overline{C}$：覆盖 $m_0,m_1,m_8,m_9$ ✓
• $BD$：覆盖 $m_5,m_7,m_{13},m_{15}$ ✓

$$F=\overline{B}\overline{C}+BD(\text{2 项，4 个文字})$$

结论：

实现方式	器件
卡诺图 + 门	2 个 NOT + 2 个 AND + 1 个 OR（或等效 NAND）
8 选 1 MUX	1 个 74LS151 + 1 个 NOT（产生 $\overline{D}$）

工程判断：

• 要最快、最少器件、变量少 → 用化简好的门
• 要改动灵活（功能变了只需改数据端接线）、多函数共用选择端 → 用 MUX
• FPGA 的本质就是"巨大的 LUT"——LUT-6 就是一个 64 选 1 的 MUX（存储表），这就是"用 MUX 实现任意函数"这条原理的工业极致。

例 4：两位二进制数值比较器（完整设计与化简）

设计 2 位比较器：输入 $A_1{A}_0$、$B_1{B}_0$，输出 $G(A>B)$、$E(A=B)$、$L(A<B)$。

第一步：列真值表（只列关键部分）。

$A_1{A}_0$	$B_1{B}_0$	关系	$G$	$E$	$L$
00	00	=	0	1	0
00	01	<	0	0	1
01	00	>	1	0	0
10	01	>	1	0	0
10	11	<	0	0	1
11	11	=	0	1	0

第二步：分高位/低位推理（比列真值表更快）。

• 高位决定一切：若 $A_1>B_1$ → $A>B$，与低位无关
• 若 $A_1<B_1$ → $A<B$
• 若 $A_1=B_1$ → 看低位

第三步：写方程。

$$G=(A_1\overline{B_1})+(A_1\odot B_1)\cdot A_0\overline{B_0}$$$$L=(\overline{A_1}{B}_1)+(A_1\odot B_1)\cdot \overline{A_0}{B}_0$$$$E=(A_1\odot B_1)(A_0\odot B_0)=\overline{A_1\oplus B_1}\cdot \overline{A_0\oplus B_0}$$

其中 $\odot$ 表示同或。

第四步：验证一组。

$A_1{A}_0=10$（2），$B_1{B}_0=01$（1）。期望 $G=1$。

$$G=(1\cdot \overline{0})+(1\odot 0)\cdot (0\cdot \overline{1})=(1\cdot 1)+0\cdot 0=1✓$$

再验证 $A_1{A}_0=10$，$B_1{B}_0=11$（3）。期望 $L=1$。

$$L=(\overline{1}\cdot 1)+(1\odot 1)\cdot (\overline{0}\cdot 1)=0+1\cdot 1=1✓$$

结论：$G$ / $L$ 各 2~3 个文字项，$E$ 是两个同或之积。74LS85 就是这套逻辑的 4 位集成版，并且带 $A>B$、$A=B$、$A<B$ 三个级联输入，可以串成任意字长。

级联的诀窍：低位片的三个输出接到高位片的对应级联输入；最低片的 $A=B$ 级联输入接高电平（表示"低位部分相等"）。这就是"从低位往高位逐级判决"的硬件体现。

用程序复算

#include <stdio.h>

int main(void) {
    /* --- 例1: 译码器(低有效)+NAND 实现 F=Sm(0,2,3,5,7) --- */
    printf("--- 例1 译码器 + NAND ---\n");
    int S1[5] = {0, 2, 3, 5, 7};
    int bad = 0;
    for (int i = 0; i < 8; i++) {
        /* 74LS138: 唯一为 0 的输出是 Y_i，其余为 1 */
        int prod = 1;
        for (int k = 0; k < 5; k++) if (S1[k] == i) prod = 0;
        int F = !prod;                        /* NAND */
        int ref = 0;
        for (int k = 0; k < 5; k++) if (S1[k] == i) ref = 1;
        if (F != ref) { bad++; printf("  MISMATCH %d\n", i); }
        printf("  ABC=%03d  F=%d(ref %d)\n", i, F, ref);
    }
    printf("  %s\n", bad ? "FAIL" : "PASS");

    /* --- 例2: 74LS151 直连实现 F=Sm(0,1,2,4,7) --- */
    printf("--- 例2 74LS151 直连 ---\n");
    int S2[8] = {1, 1, 1, 0, 1, 0, 0, 1};
    bad = 0;
    for (int i = 0; i < 8; i++) {
        int set[] = {0, 1, 2, 4, 7};
        int ref = 0;
        for (int k = 0; k < 5; k++) if (set[k] == i) ref = 1;
        if (S2[i] != ref) bad++;
        printf("  ABC=%03d  D%d=%d  F=%d(ref %d)\n", i, i, S2[i], S2[i], ref);
    }
    printf("  %s\n", bad ? "FAIL" : "PASS");

    /* --- 例3: 8选1 MUX 降维实现 4 变量函数 --- */
    printf("--- 例3 8选1 MUX 降维 ---\n");
    int F4[] = {0,1,5,7,8,9,13,15};
    bad = 0;
    for (int m = 0; m < 16; m++) {
        int A = m>>3 & 1, B = m>>2 & 1, C = m>>1 & 1, D = m & 1;
        int abc = A*4 + B*2 + C;
        /* 数据端: 0->1, 1->0, 2->D, 3->D, 4->1, 5->0, 6->D, 7->D */
        int Dv[8] = {1, 0, D, D, 1, 0, D, D};
        int F = Dv[abc];
        int ref = 0;
        for (int k = 0; k < 8; k++) if (F4[k] == m) ref = 1;
        if (F != ref) { bad++; printf("  MISMATCH m%d\n", m); }
    }
    printf("  %s\n", bad ? "FAIL" : "PASS");
    printf("  与门实现对照: F = B'C' + BD\n");
    bad = 0;
    for (int m = 0; m < 16; m++) {
        int A = m>>3 & 1, B = m>>2 & 1, C = m>>1 & 1, D = m & 1;
        int F = (!B && !C) || (B && D);
        int ref = 0;
        for (int k = 0; k < 8; k++) if (F4[k] == m) ref = 1;
        if (F != ref) bad++;
    }
    printf("  B'C' + BD 与 MUX 结果一致: %s\n", bad ? "FAIL" : "PASS");

    /* --- 例4: 2 位比较器 --- */
    printf("--- 例4 2 位比较器 ---\n");
    bad = 0;
    for (int a = 0; a < 4; a++) for (int b = 0; b < 4; b++) {
        int A1 = a>>1 & 1, A0 = a & 1, B1 = b>>1 & 1, B0 = b & 1;
        int G = (A1 && !B1) || ((A1 == B1) && A0 && !B0);
        int L = (!A1 && B1) || ((A1 == B1) && !A0 && B0);
        int E = (A1 == B1) && (A0 == B0);
        int g = a > b, l = a < b, e = a == b;
        if (G != g || L != l || E != e) { bad++; printf("  MISMATCH %d vs %d\n", a, b); }
    }
    printf("  %s\n", bad ? "FAIL" : "PASS");
    return 0;
}

c 本站为静态站，不提供在线运行；可复制到本地用 gcc / python 执行

from itertools import product

print("--- 例1 译码器(低有效)+NAND 实现 F=Sm(0,2,3,5,7) ---")
S = {0, 2, 3, 5, 7}
for m in range(8):
    # 74LS138: Y_i = 0 当 i == m，其余 1
    vals = [0 if i == m else 1 for i in S]
    F = 0 if all(v == 1 for v in vals) else 1
    print(f"  ABC={m:03b}  Y0,Y2,Y3,Y5,Y7={vals}  F={F}  (ref {1 if m in S else 0})")
print("  结论: F = NAND(Y0,Y2,Y3,Y5,Y7)")

print("--- 例2 74LS151 直连 F=Sm(0,1,2,4,7) ---")
S2 = {0, 1, 2, 4, 7}
print("  " + "  ".join(f"D{i}={'1' if i in S2 else '0'}" for i in range(8)))

print("--- 例3 8选1 MUX 降维实现 F=Sm(0,1,5,7,8,9,13,15) ---")
F4 = {0, 1, 5, 7, 8, 9, 13, 15}
for abc in range(8):
    f0 = 1 if abc*2 in F4 else 0
    f1 = 1 if abc*2+1 in F4 else 0
    d = "0" if (f0, f1) == (0, 0) else "1" if (f0, f1) == (1, 1) \
        else "D" if (f0, f1) == (0, 1) else "D'"
    print(f"  ABC={abc:03b}: f(D=0)={f0} f(D=1)={f1} -> D{abc} = {d}")
bad = []
for m in range(16):
    A, B, C, D = (m >> 3) & 1, (m >> 2) & 1, (m >> 1) & 1, m & 1
    abc = A * 4 + B * 2 + C
    Dv = [1, 0, D, D, 1, 0, D, D]
    if Dv[abc] != (1 if m in F4 else 0):
        bad.append(m)
print(f"  MUX 实现验证: {'PASS' if not bad else 'FAIL ' + str(bad)}")
bad = []
for m in range(16):
    A, B, C, D = (m >> 3) & 1, (m >> 2) & 1, (m >> 1) & 1, m & 1
    if int((not B and not C) or (B and D)) != (1 if m in F4 else 0):
        bad.append(m)
print(f"  门实现 B'C'+BD 验证: {'PASS' if not bad else 'FAIL ' + str(bad)}")

print("--- 例4 2 位比较器 ---")
bad = []
for a in range(4):
    for b in range(4):
        A1, A0 = (a >> 1) & 1, a & 1
        B1, B0 = (b >> 1) & 1, b & 1
        G = int((A1 and not B1) or ((A1 == B1) and A0 and not B0))
        L = int((not A1 and B1) or ((A1 == B1) and not A0 and B0))
        E = int((A1 == B1) and (A0 == B0))
        if (G, E, L) != (int(a > b), int(a == b), int(a < b)):
            bad.append((a, b))
print(f"  G/E/L 方程验证: {'PASS' if not bad else 'FAIL ' + str(bad)}")
print(f"  覆盖全部 16 组输入")

print("--- 优先编码器 74LS148 (I7 最高优先) ---")
for act in (7, 5, 0):
    inp = [1 if i == act else 0 for i in range(8)]
    code = max(i for i in range(8) if inp[i])
    print(f"  输入 I7..I0={inp[::-1]} -> 最高有效位 I{act} -> A2A1A0={code:03b}")

print("--- 级联：两片 74LS138 扩成 4-16 译码器 ---")
print("  高位地址 A3=0 -> 片1 使能, A3=1 -> 片2 使能")
for a3 in (0, 1):
    chip = 1 if a3 == 0 else 2
    print(f"  A3={a3}: 片{chip} 工作，输出 Y{0 if a3==0 else 8}..Y{7 if a3==0 else 15}")

python 本站为静态站，不提供在线运行；可复制到本地用 gcc / python 执行

输出（节选）：

--- 例1 译码器 + NAND ---
  ABC=000  Y0,Y2,Y3,Y5,Y7=[0, 1, 1, 1, 1]  F=1  (ref 1)
  ABC=001  Y0,Y2,Y3,Y5,Y7=[1, 1, 1, 1, 1]  F=0  (ref 0)
  PASS
--- 例2 74LS151 直连 ---
  D0=1  D1=1  D2=1  D3=0  D4=1  D5=0  D6=0  D7=1
--- 例3 8选1 MUX 降维 ---
  ABC=000: f(D=0)=1 f(D=1)=1 -> D0 = 1
  ABC=010: f(D=0)=0 f(D=1)=1 -> D2 = D
  MUX 实现验证: PASS
  门实现 B'C'+BD 验证: PASS
--- 例4 2 位比较器 ---
  G/E/L 方程验证: PASS
  覆盖全部 16 组输入
--- 优先编码器 74LS148 ---
  输入 I7..I0=[1, 0, 0, 0, 0, 0, 0, 0] -> 最高有效位 I7 -> A2A1A0=111
  输入 I7..I0=[0, 0, 1, 0, 0, 0, 0, 0] -> 最高有效位 I5 -> A2A1A0=101
  输入 I7..I0=[0, 0, 0, 0, 0, 0, 0, 1] -> 最高有效位 I0 -> A2A1A0=000

考点

考点

1. 组合逻辑 vs 时序逻辑（判断题型必考）

判据	组合	时序
有无反馈回路	无	有
输出是否只依赖当前输入	是	否
能否用真值表完整描述	能	不能（需状态表）
有无时钟	不需要	一般需要

快速判定法：看电路有没有"输出绕回输入"的环路。有环路 → 时序（或振荡）。

2. 编码器 vs 译码器 vs 数据选择器（三者别混）

器件	方向	输入→输出	一句话
编码器	压缩	$2^n\to n$	"谁被按下"变二进制
译码器	展开	$n\to 2^n$	二进制变"哪条线"
数据选择器	挑选	$2^n+n\to 1$	按地址挑一条

互逆关系：编码器与译码器方向相反；译码器和 MUX 都做"最小项"，但一个输出全部、一个只输出被选中的那条。

3. 优先编码器（高频）

• 允许多输入同时有效，输出编号最大的那个
• 74LS148 输出是反码（低有效输入），做题时要看清极性
• GS/EO 的作用：级联时传递"我这片有没有输入"
• 全 0 输入时输出 $A_2{A}_1{A}_0=111$，与"$I_7$ 有效"冲突 → 必须用 GS 区分。这是最容易漏的考点

4. 用译码器实现任意函数（★ 必考）

$$\boxed{{\displaystyle \text{低有效输出的译码器}\Rightarrow \text{用 NAND 汇合目标最小项}}}$$$$\boxed{{\displaystyle \text{高有效输出的译码器}\Rightarrow \text{用 OR 汇合目标最小项}}}$$

推导逻辑：译码器输出 $Y_i=\overline{m_i}$（低有效）。某时刻只有一条为 0。所以"选中集合内"⟺"并非集合内所有线都为 1"⟺ NAND = 1。

易错：把 NAND 写成 OR，或漏掉"低有效"这个前提。

5. 用数据选择器实现任意函数（★ 必考）

关键公式（香农展开）：

$$F=\sum _i{m}_i(\text{选择变量})\cdot D_i$$

两种情况：

变量数	用法	数据端取值
$n = $ 选择位数	直连	只接 0 / 1
$n = $ 选择位数 $+1$	降维	接 $\{0,1,D,\overline{D}\}$

降维做法（三步）：

1. 留一个变量 $D$ 不给选择端
2. 对每个选择组合，写出 $F$ 关于 $D$ 的表达式
3. 化简为 $0/1/D/\overline{D}$ 之一，接到对应 $D_i$

为什么一定是这四种：单变量布尔函数总数就是 $2^2=4$ 种。这是"降维法一定可行"的证明。

6. 级联扩展（常见大题）

目标	方法
两片 3-8 → 4-16 译码器	最高位地址 + 反相器控制两片的使能端
两片 8 选 1 → 16 选 1 MUX	最高位选片（strobe），低三位接选择端，两片输出用 OR/三态汇合
两片 4 位比较器 → 8 位比较器	低位片输出接高位片级联输入，最低片 $A=B$ 接高电平

口诀："高位选片，低位选线，数据并联"。

7. 竞争冒险（组合逻辑版的考点）

• 产生条件：同一输出有多条延迟不同的路径
• 典型表现：$F=X+\overline{X}$ 型（一个变量原反同时出现在不同乘积项）→ 静态 1 冒险（输出本该恒 1，冒负脉冲）
• 消除：卡诺图加冗余圈（共识项）
• 同步电路中一般不管（时钟沿采样时已稳定）

8. 易错点清单

• 把"低有效"和"高有效"搞反。74LS138 输出是 $\overline{Y_i}$，74LS148 输入输出都是低有效形式——做题第一步先标极性
• 用译码器时错用 OR（低有效输出必须配 NAND）
• MUX 降维时，$D$ 的选择搞错。建议固定套路：选择端接高位 $A,B,C$，数据端留最低位 $D$（或反之），全篇统一
• 误以为 MUX 只能接 0/1。降维用法必须接 $D$ 或 $\overline{D}$，此时需要额外的反相器
• 优先编码器全 0 判成"$I_7$ 有效"。要靠 GS 引脚区分
• 比较器忘了级联输入。74LS85 的 $A>B$/$A=B$/$A<B$ 级联引脚不接对，结果就错
• 以为"组合逻辑没有毛刺"。恰恰相反——组合逻辑是毛刺的产地，时序电路靠采样躲开
• 把"组合逻辑设计流程"和"时序逻辑设计流程"混用。时序要画状态图、做状态化简/编码，多好几步

小结

• 组合逻辑 = 无记忆，输出只由当前输入决定；判据是电路里有没有反馈环路。
• 设计流程：定义 → 真值表 → 化简 → 选器件 → 连线；"选对器件"往往比"化简得好"更省。
• 编码器（$2^n\to n$，必须用优先版本）、译码器（$n\to 2^n$，输出就是最小项）、数据选择器（按地址挑一条，本质是"最小项选择器"）——三者方向不同、职责不同。
• 两个重磅结论：
  • $n$–$2^n$ 译码器 + NAND（低有效输出）= 任意 $n$ 变量函数
  • $2^{n-1}$ 选 1 MUX + 反相器 = 任意 $n$ 变量函数（香农展开降维）
• 级联口诀："高位选片、低位选线、数据并联"。
• 竞争冒险是组合逻辑的固有风险，靠冗余项或时钟同步采样解决；同步设计靠时序余量免疫。

回到主线：L1 走到这里，我们已经能把任意逻辑功能变成具体电路了。

但"选器件"的下一步是把器件拼成更大的功能块。一个 32 位 CPU 的核心是 ALU——它要同时做加、减、与、或、异或、比较，还要输出标志位。这些功能怎么用上一节学到的译码器/MUX/加法器组合出来？这就是下一篇的主题。

下一篇：从加法器到 ALU