51 单片机入门前置知识 从电压和二进制，到点亮第一颗 LED 之前你需要知道的一切

很多同学第一次学单片机是这样的：拿到一块开发板，抄一段流水灯代码，编译、烧录、灯亮了，然后……就卡住了。因为看不懂 P1 = 0xFE; 到底在干什么，也解释不了为什么 LED 要串一个电阻，更不知道为什么有的引脚不接上拉电阻就没反应。

问题不在 51，而在于地基缺了几块。单片机是一门“软硬交界”的学科，它站在三个地方的交汇点上：

依赖关系：为什么必须按这个顺序学

下面这张图是从零到“写出第一个能跑的程序”的知识依赖链。箭头表示“必须先懂前者，后者才讲得通”。

电压/电流/电阻/地 ──► 高低电平 ──► 二进制 0 和 1 ──► 十六进制书写
      │                                    │
      ▼                                    ▼
 上拉/下拉/限流电阻                  位运算(& | ^ ~ << >>)
      │                                    │
      └──────────────┬─────────────────────┘
                     ▼
              CPU + 存储器 + 总线 + 时钟 + 中断      ← 计算机组成原理最小版
                     ▼
              8051 内核:累加器 / SFR / 4 组工作寄存器 / 4 个 IO 口
                     ▼
        定时器 · 中断控制器 · 串口 ·（外部:I2C/SPI/ADC）
                     ▼
        C51 语言要点(volatile / sbit / sfr / 位操作)
                     ▼
      编译器 → HEX 文件 → 烧录器 → 芯片复位运行 → 用眼睛看现象

怎么读这篇教程

1.1 从电脑到芯片：一脉相承的结构

你熟悉的电脑由 CPU、内存、硬盘、主板和各种外设组成。单片机做的事一模一样，只是把这一整套东西集成到了一个芯片里：

所以单片机常被形容为“麻雀虽小，五脏俱全的微型计算机”。它的特点不是快，而是小、便宜、省电、能直接接传感器和执行器——这正是嵌入式控制需要的能力。

1.2 “51”是什么？为什么它 1980 年出生却还在教

1980 年 Intel 推出 MCS-51 系列，其中最著名的是 8051。后来 Intel 把内核授权出去，大量厂商生产“指令兼容”的芯片，这类芯片统称 8051 内核单片机，国内习惯简称 51 单片机。今天你买到的板子上多半是：

为什么现在还要学它？因为它是结构最干净、寄存器最少、资料最全的入门芯片。你会亲手操作每一个寄存器、数清楚每一字节内存，这种“把机器看透”的经历，在 STM32 那种几千页手册的芯片上是很难快速获得的。学完 51 再学 STM32，你会发现概念是复用的。

1.3 学 51 需要的“全套家当”

在打开软件之前，先确认你有这些东西——缺的可以按这个清单去配，总价通常不到 100 元。

硬件部分

软件部分

1.4 认识“一条程序的生命周期”

以后你每天都会重复这个循环，先记住它，第 12 章会逐步拆开讲。

1. 写源码

   在 Keil 里创建工程，写 main.c，配置芯片型号和晶振频率。

2. 编译 / 链接

   编译器把 C 代码变成机器码，链接器把它放到正确的地址上，最后输出 .hex 文件。

3. 下载

   用 STC-ISP 把 HEX 写进芯片的 Flash。此时芯片里有了“新程序”。

4. 复位运行

   芯片复位后，CPU 从 Flash 的 0000H 地址开始一条一条取指令、执行指令。

5. 观察现象并调试

   看 LED、听蜂鸣器、看串口输出、用万用表量电平，再修改代码回到第 1 步。

2.1 三个最基本的量：电压、电流、电阻

把电想象成水：电压是水位差（水压），电流是水流的大小，电阻是水管的粗细限制。三者由欧姆定律联系起来：

2.2 电路基础：串联、并联与回路

回路是电流能走通一圈的路径。只有“电源正极 → 元件 → 电源负极（GND）”构成完整回路，电流才会流动，元件才会工作。单片机控制一个 LED 也是回路思维：

灌电流（sink，低电平点亮，51 常用）       拉电流（source，高电平点亮）
                                           
   VCC(5V)                                    P1.0 ──►|── 220Ω ── GND
     │                                         高电平(5V)          (0V)
     ├──►|── 220Ω ── P1.0
     │   LED        输出低(0V)
    GND
                                              
 电流从 VCC 经 LED、电阻流入引脚            电流从引脚经 LED、电阻流向 GND
 引脚“吸入”电流，驱动能力强                引脚“吐出”电流，多数 51 口能力弱

2.3 数字信号：为什么“电压”能表示 0 和 1

现实世界的电压是连续的（模拟量），但数字电路故意只承认两个区间：靠近 0V 的叫低电平 0，靠近 VCC 的叫高电平 1。中间那一大段是“不确定区/禁止区”，正常设计要避免停在那里。

为什么中间要留这么大的不确定区？因为它是对抗干扰的“安全垫”。真实电路里电压会有毛刺、抖动、压降，如果把判定阈值压得很紧，稍有干扰就会把 0 读成 1。留出宽裕的不确定区，就得到了噪声容限——这是数字电路比模拟电路抗干扰强得多的根本原因。

2.4 上拉电阻与下拉电阻（必考、必用）

如果一个引脚什么都不接，它叫悬空（浮空）。悬空引脚的电平是不确定的：可能因为一点点静电、邻近走线就飘到高或低，读到的值随机跳变。解决办法是给它一个“默认状态”，这就是上拉/下拉电阻。

内部上拉与开漏输出：为什么 P0 口一定要外接上拉

51 的 P1/P2/P3 口内部结构是“弱上拉 + 强下拉”，所以它们可以只靠内部上拉输出高电平（但拉电流能力很弱，约几十微安到几百微安，点亮 LED 基本不够）。而 P0 口是真正的开漏（open-drain）结构：

开漏输出的等效结构（P0 的每一位）

   VCC ──[ 外部上拉电阻 ]──┬── 引脚
                            │
                          [ MOS 管 ]   ← 只负责“拉低”
                            │
                           GND

 写 1 → MOS 管关断 → 引脚被外部上拉电阻拉高（所以外部电阻必须有）
 写 0 → MOS 管导通 → 引脚被强行拉到接近 0V（灌电流，能力强）

2.5 LED 与限流电阻：动手算一次

LED 不是电阻，它有正向压降 V_F（红光约 1.8~2.0V，绿/蓝光约 2.0~3.2V）和额定电流（普通指示灯 5~10mA 足够亮）。超过额定电流，几毫秒就能烧掉它，也可能烧掉 IO 口。

手算示例：5V 供电，红灯 V_F = 1.9V，希望电流 8mA。电阻要承受的电压是 5 - 1.9 = 3.1V，于是

R = U / I = 3.1V / 0.008A = 387.5Ω  →  取最接近的标准值 390Ω

校验实际电流：3.1V / 390Ω ≈ 7.9mA   ✓ 安全且足够亮
若用 220Ω：3.1V / 220Ω ≈ 14mA       ⚠ 偏大，长期点可能伤口
若用 10kΩ：3.1V / 10000Ω = 0.31mA    ✗ 几乎看不见

2.6 按键与“抖动”：为什么要有消抖

机械按键在按下和弹起的一瞬间，金属触点会弹跳几次，产生几十微秒到十几毫秒的一连串高低电平脉冲，这叫抖动（bounce）。如果 CPU 一检测到电平变化就计数，按 1 次可能被算成 5 次。所以必须消抖：

/* 软件消抖的标准写法：低电平有效的按键，接在 P3.2 */
if (KEY == 0) {                /* 第一次检测到按下 */
    DelayMs(15);              /* 等抖动结束 */
    if (KEY == 0) {            /* 再确认一次，仍是按下才算数 */
        /* 这里处理一次按键动作 */
        while (KEY == 0);      /* 可选：等松手，避免长按被当成多次 */
    }
}

2.7 逻辑门与组合逻辑（认识即可）

数字电路的最小运算单元是逻辑门。单片机内部由成千上万个门构成，而你写代码时用到的位运算（下一章）正是它们的软件版本。

组合逻辑 = 输出只取决于当前输入；时序逻辑 = 输出还取决于过去的输入（含触发器/寄存器）。单片机的 IO 口、定时器、串口都属于时序逻辑，因为它们需要时钟来推进状态。

3.1 为什么必须是二进制

因为电路里最容易做到的两件事就是“有电压”和“没电压”。做成开关最简单、最抗干扰、最省成本。十进制需要把电压精确分成十档，稍有干扰就出错。所以数字电路只认两个状态，用 0 和 1 表示，每一个 0 或 1 称为一个 位（bit）。

而 8 个 bit 组成一个字节（byte）——这正是 51 单片机一次能处理的数据宽度，所以 51 叫“8 位单片机”。

3.2 三种进制的写法与换算

同一个数可以被写成不同进制。C 语言里区分的办法是前缀：

换算法则：一句话记住

• 二 → 十六：从右往左每 4 位分一组，每组查表。例：1111 1110 → F E → 0xFE。
• 十六 → 二：每位十六进制展开成 4 位。例：0x5A → 0101 1010。
• 二 → 十：按权相加。例：10110011 = 128+32+16+2+1 = 179。
• 十 → 二：不断除以 2 取余数，倒着读。

3.3 十进制与十六进制的常见对照（背下来会快很多）

3.4 二进制的四则运算与移位

虽然单片机硬件会替你算，但理解这些运算才能看懂溢出、定时器溢出、移位流水灯等逻辑。

加法：逢二进一

  0+0=0   0+1=1   1+0=1   1+1=10（本位 0，进位 1）

     0000 1010   (10)
   + 0000 0110   ( 6)
   ────────────
     0001 0000   (16)    ← 第 4 位产生进位

8 位寄存器里若发生“进位丢掉”的情况，就叫溢出：
     1111 1111   (255)
   + 0000 0001   (  1)
   ────────────
   1 0000 0000   → 低 8 位是 0x00，最高位进位移入进位标志 CY

乘法与除法：用移位代替（重要）

在二进制里，左移一位等于乘 2，右移一位等于除以 2（丢掉余数）。51 是 8 位机，做乘除法比较慢，所以聪明的代码常用移位和加减来代替乘法：

a = a << 1;        /* a × 2      */
a = a << 3;        /* a × 8      */
a = (a << 2) + a;  /* a × 5      */
a = (a << 1) + (a << 3); /* a × 10 */
a = a >> 1;        /* a ÷ 2      */
a = a >> 4;        /* a ÷ 16     */

3.5 有符号数：补码与 0xFF 到底是 255 还是 −1

8 个 bit 没有“符号”概念，它只是 8 个 0/1。约定用最高位当符号位后，同一个 0xFF 就有了两种解释：

负数用补码表示，规则很简单：取反加一。

求 −5 的 8 位补码：
   5      = 0000 0101
   取反   = 1111 1010
   加一   = 1111 1011 = 0xFB      ← 这就是 −5

验算（用加法做减法）：8 + (−5) = 3
     0000 1000   (8)
   + 1111 1011   (−5)
   ────────────
   1 0000 0011   → 丢掉进位，低 8 位是 0000 0011 = 3   ✓

所以 −1 = 0xFF，−128 = 0x80。这就是为什么 0x80 在配置寄存器时常出现：
它既表示“第 7 位置 1”，也可能表示“−128”，要看上下文。

3.6 BCD 码：用十六进制“假装”十进制

BCD（Binary-Coded Decimal）用每 4 个 bit 表示一位十进制数字，即 0~9，剩下的 1010~1111 不使用。

十进制 254 的两种编码：
   纯二进制  = 1111 1110        = 0xFE
   BCD 码    = 0010 0101 0100   = 每 4 位一个数字 2 / 5 / 4

十进制 254 的 BCD 十六进制写法：0x0254
   ← 注意！0x0254 的“数值”是 596，但按 BCD 读却是 254

用在哪：数码管、DS1302 时钟芯片（时间寄存器就是 BCD）、部分传感器。典型写法：

/* 二进制 → BCD：先除 10 取十位，再取个位，拼成一个字节 */
u8 bcd = (value / 10) << 4 | (value % 10);

/* BCD → 二进制：高 4 位乘 10 再加低 4 位 */
u8 dec = (bcd >> 4) * 10 + (bcd & 0x0F);

4.1 为什么要位运算：一个字节，八个引脚

51 的 P1 是一个 8 位寄存器，它的 8 个 bit 直接对应 P1.0 ~ P1.7 八个物理引脚。当你写 P1 = 0xFE; 时，你其实是同时给 8 个引脚各送了一个电平：

P1 = 0xFE = 1111 1110
             │││││││└── P1.0 = 0   ← 唯一被拉低的引脚
             ││││││└─── P1.1 = 1
             │││││└──── P1.2 = 1
             ││││└───── P1.3 = 1
             │││└────── P1.4 = 1
             ││└─────── P1.5 = 1
             │└──────── P1.6 = 1
             └───────── P1.7 = 1

问题来了：如果我只想改变 P1.0，不想动其他 7 个引脚，直接写 P1 = 0; 会把 8 个灯全点亮。所以必须用一种只影响某几位的运算——这就是位运算存在的理由。

4.2 六个运算符与真值表

4.3 四个必须形成肌肉记忆的写法

把下面四行抄到你的笔记本第一页。几乎所有单片机代码的底层都是它们。

/* 假设 x 是目标字节，bit 是位号 0~7 */
#define BIT(n)  (1 << (n))      /* 生成只有第 n 位为 1 的掩码 */

/* ① 置位：把第 n 位变成 1，其他位不变 */
x |=  BIT(n);
/* 拆开看：  x = x | (1<<n)
   原值 1010 0101，n = 1
   掩码 0000 0010
   或   ─────────  => 1010 0111   ✓ 只有 bit1 被置 1 */

/* ② 清零：把第 n 位变成 0，其他位不变 */
x &= ~BIT(n);
/* 拆开看：  x = x & ~(1<<n)
   原值 1010 0101，n = 2
   ~(1<<2) = 1111 1011
   与      ─────────  => 1010 0001   ✓ 只有 bit2 被清 0 */

/* ③ 翻转：第 n 位取反，其他位不变（异或的独门绝技） */
x ^=  BIT(n);

/* ④ 读取：判断第 n 位是 0 还是 1 */
if (x & BIT(n)) { /* 第 n 位是 1 */ }
else            { /* 第 n 位是 0 */ }

4.4 经典应用：流水灯与按键状态

流水灯：用移位 + 取反点亮

/* 低电平点亮的流水灯：每次只让一个引脚为 0 */
while (1) {
    u8 i;
    for (i = 0; i < 8; i++) {
        P1 = ~(1 << i);   /* i=0 → 0xFE，i=1 → 0xFD，i=2 → 0xFB ... */
        DelayMs(200);
    }
}

/* 等价的手写序列，方便你对照二进制 */
/* 0xFE=1111 1110  0xFD=1111 1101  0xFB=1111 1011  0xF7=1111 0111 */
/* 0xEF=1110 1111  0xDF=1101 1111  0xBF=1011 1111  0x7F=0111 1111 */

按键状态：一个字节装 8 个按键

/* P3 口接了 8 个按键，读一次就能得到全部状态 */
u8 keys = P3;                     /* 例如读到 0b1110_1101 */

if ((keys & BIT(1)) == 0) { /* P3.1 被按下（低电平有效） */ }
if ((keys & BIT(4)) == 0) { /* P3.4 被按下 */ }

/* 把某几位单独取出来（例如取低 4 位） */
u8 low4  = keys & 0x0F;
u8 high4 = keys >> 4;          /* 或 (keys & 0xF0) >> 4 */

4.5 一个几乎人人踩过的坑：优先级

C 语言里位运算符的优先级低于比较运算符，高于逻辑运算符，顺序很反直觉。下面两行结果完全不同：

/* ✗ 错误：先算 (flags & 0x02) == 0，结果等价于 flags & 1 */
if (flags & 0x02 == 0) { ... }

/* ✓ 正确：永远加括号 */
if ((flags & 0x02) == 0) { ... }

4.6 汇编里的对应指令（了解即可）

51 的汇编指令直接内建了位运算能力，这也是它“控制能力强”的体现。等你以后看反汇编或写底层时会遇到：

5.1 内部结构：一台 8 位小电脑

把 51 拆开看，它由 6 个部分组成。你要记住的不是细节，而是数据怎么在这些部件之间流动。

                         ┌──────────────── 8051 内部 ────────────────┐
                         │                                          │
   时钟 XTAL1/XTAL2 ────►│  时钟与定时控制电路                        │
                         │        │                                 │
                         │        ▼                                 │
                         │  ┌───────────┐   8 位内部数据总线         │
                         │  │  CPU 内核  │◄──────────────────────┐   │
                         │  │ 控制器/ALU │                       │   │
                         │  │  ACC  B   │                       │   │
                         │  │  PSW  SP  │                       │   │
                         │  └─────┬─────┘                       │   │
                         │        │ 16 位地址总线                │   │
                         │        ▼                             │   │
                         │  ┌──────────────┐   ┌──────────────┐ │   │
                         │  │ 程序存储器    │   │ 数据存储器    │ │   │
                         │  │ Flash 4~64KB │   │ RAM 128/256B │ │   │
                         │  │ （只读执行）  │   │（读写）       │ │   │
                         │  └──────────────┘   └──────────────┘ │   │
                         │                                      │   │
                         │  ┌────────────┬───────────┬────────┐ │   │
                         │  │ 定时器 T0/T1│ 串口 UART │中断控制 │ │   │
                         │  └────────────┴───────────┴────────┘ │   │
                         │        │            │          │     │   │
                         │        ▼            ▼          ▼     │   │
                         │   ┌────────────────────────────────┐ │   │
                         │   │  P0    P1    P2    P3  (各 8 位)│◄┘   │
                         └───┴────────────────────────────────┴─────┘
                                        │
                                        ▼
                                 32 根 IO 引脚 ──► 外设、LED、传感器…

架构上要区分的一个概念：冯·诺依曼 vs 哈佛

5.2 内核里的六个关键寄存器

“寄存器”就是 CPU 内部的一个小盒子，容量通常只有 1 字节，但 CPU 可以直接读写它，速度最快。51 里你必须认识这几个：

PSW 的每一位（配置位，重要）

PSW  (位地址 D0H，可位寻址)
 ┌───┬───┬───┬───┬───┬───┬───┬───┐
 │CY │AC │F0 │RS1│RS0│OV │  —│ P │
 └───┴───┴───┴───┴───┴───┴───┴───┘
  D7  D6  D5  D4  D3  D2  D1  D0

 CY  进位/借位标志：加法有进位或减法有借位时置 1
 AC  辅助进位：低 4 位向高 4 位进位（BCD 调整时用）
 F0  用户自定义标志位（可自由使用的一位）
 RS1 RS0 工作寄存器组选择：00→第0组, 01→第1组, 10→第2组, 11→第3组
 OV  溢出标志：有符号运算结果超出范围时置 1
 P   奇偶标志：A 中 1 的个数为奇数时置 1（串口校验会用到）

5.3 40 引脚 DIP 封装：逐个点开看

下面是可以点击的 8051 引脚图。左边是 DIP-40 的 1~20 脚（逆时针从左上角开始数），右边是 21~40 脚。点任意一只脚看它的功能和典型接法。

5.4 引脚归类记忆法

5.5 时钟电路与复位电路：最小系统的两件大事

        XTAL1 ──┬──┤├──┬── GND
                │  11.0592MHz │
                │  30pF       │
        XTAL2 ──┴─────┬──────┘
                      │
                    30pF
                      │
                     GND

        VCC ──[ 10µF ]──┬── RST(9)
                        │
                     [ 10kΩ ]
                        │
                       GND

5.6 CPU 的心跳：取指—译码—执行

CPU 永远在重复三件事，一秒钟重复上百万次：

1. 取指（Fetch）

   PC 指向的地址被送到程序存储器，取出指令字节，同时 PC 自动加 1（指向下一条）。

2. 译码（Decode）

   控制电路看懂这条指令要做什么：是加法？是读引脚？还是跳转？需要哪些操作数？

3. 执行（Execute）

   ALU 完成运算，结果写回寄存器或送到 IO 引脚；如果影响标志位（CY/OV/P），同步更新 PSW。

这三步的时间由时钟推动。标准 8051 每 12 个时钟周期构成一个机器周期，一条指令需要 1~4 个机器周期（1~4µs @12MHz）。这就是为什么 DelayMs() 这种“空转延时”能被算得比较准——它本质上是在数机器周期。（详情见第 8 章）

6.1 四个口的分工

P3 口的第二职业（必须知道）

P3.0  RXD   串口接收数据          P3.4  T0    定时器/计数器 0 外部输入
P3.1  TXD   串口发送数据          P3.5  T1    定时器/计数器 1 外部输入
P3.2  INT0  外部中断 0            P3.6  WR    片外数据存储器写选通
P3.3  INT1  外部中断 1            P3.7  RD    片外数据存储器读选通

6.2 内部结构：为什么叫“准双向口”

51 的 P1/P2/P3 每个位内部结构可以简化成下面这样（注意那个“弱上拉”）：

P1 的一位内部结构（准双向）

   VCC
    │
  [ 弱上拉 ]         ← 大约 20~50µA 的电流能力，仅供“拉高”用
    │
    ├──────────┬──► 到内部总线（读锁存器 Q）
    │          │
  [ 强下拉 ]   └──► 引脚 P1.x ──► 外部电路
  (MOS 管)          │
    │            读引脚缓冲器 ──► 到内部总线
   GND

  写 1 → 下拉管关断 → 靠弱上拉把引脚拉高（但没力气驱动负载）
  写 0 → 下拉管导通 → 引脚被强力拉到 0V（灌电流能力强）

“准双向”的意思是：同一个引脚既能输出也能输入，不用像 AVR 那样去配置方向寄存器（DDR）。但代价是——

/* 错误示例：上一句把 P1.0 拉低，下一句想读按键，永远读到 0 */
P1_0 = 0;                  /* 点亮 LED，下拉管导通 */
if (P1_0 == 0) { ... }     /* ✗ 恒成立，因为引脚被自己拉低了 */

/* 正确做法：读之前先把它置为输入态（写 1） */
P1_0 = 1;                  /* 关下拉管，引脚交给外部 */
if (P1_0 == 0) { ... }     /* ✓ 现在读到的是外部真实电平 */

/* 用 P1 口读按键时，通常整个口先写 1 */
P1 = 0xFF;                  /* 全口置 1 = 全部成为输入态 */
u8 keys = P1;               /* 一次读回 8 个按键 */

“读引脚”还是“读锁存器”？

这是 51 的一个精巧设计，理解了它就不会对某些指令感到奇怪：

好在如果你遵守了“读之前先写 1”的规则，锁存器里的值就等于引脚被释放后的状态，两者基本一致，问题就不会暴露。这也是为什么很多教程只强调写 1，而不展开这个细节。

6.3 驱动能力：什么时候必须加驱动

51 的 IO 口能力很有限，超限会永久损坏引脚或整颗芯片。记住这组经验数据：

三种典型驱动方案

① 直接驱动（小电流负载，推荐）
   LED 用灌电流接法，电流控制在 5~10mA，每路独立限流电阻。

② 三极管驱动（继电器、蜂鸣器、电机等大电流负载）
        VCC ── 负载 ── 集电极 C
                        │
   P1.0 ──[1kΩ]── 基极 B │  NPN(如 S8050)
                      发射极 E ── GND
   * 感性负载（继电器/电机/蜂鸣器）必须并联续流二极管，否则关断高压会打坏三极管

③ 专用驱动芯片（多路、大电流、隔离）
   74HC245 / ULN2003（达林顿阵列，8 路，可直接驱动继电器）/ 光耦隔离

6.4 完整实战：按键控制 LED（含消抖）

这是把前面所有知识串起来的最小完整程序：上拉/下拉、限流电阻、位操作、消抖、IO 读写规则全在里面。

/* ------------------------------------------------------------
   现象：按下 K1，LED1 翻转一次；按下时灯的状态保持，松手不改变
   硬件：LED 接 P1.0（低电平点亮，串 470Ω）
         按键 K1 接 P3.2 与 GND 之间（低电平有效，靠内部上拉）
   ------------------------------------------------------------ */
#include <reg52.h>
#include <intrins.h>

sbit LED1 = P1^0;        /* 定义单个引脚，这是 51 的专属语法 */
sbit KEY1 = P3^2;

void DelayMs(unsigned int ms)     /* @12MHz 粗略延时 */
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 110; j++);
}

void main(void)
{
    LED1 = 1;               /* 初始熄灭（低电平点亮，所以写 1 是灭）*/
    KEY1 = 1;               /* 关键：先把引脚置 1，才能作为输入读取 */

    while (1) {
        if (KEY1 == 0) {            /* 检测到疑似按下 */
            DelayMs(15);          /* 等抖动结束 */
            if (KEY1 == 0) {        /* 复检确认 */
                LED1 = ~LED1;     /* 翻转 LED，位变量取反 */
                while (KEY1 == 0);  /* 等松手，保证按一次只翻转一次 */
            }
        }
    }
}

6.5 端口相关的其他实用知识

7.1 四个地址空间

注意 STC89C52 是增强型号：Flash 有 8KB、RAM 有 512B（其中 256B 在片内，另外 256B 通过 MOVX 访问，属于“片内扩展 RAM”）。做题时以你芯片的手册为准。

7.2 内部 RAM 详解：256 字节怎么分

标准 8051 的内部 RAM 是 256 字节（地址 00H~FFH），但它被切成两块，访问方式不同：

地址        区域                     容量    访问方式
─────────────────────────────────────────────────────────────
00H ─ 1FH   工作寄存器区（4 组 × R0~R7）  32B   直接/寄存器寻址
20H ─ 2FH   位寻址区（16 字节 = 128 位）   16B   直接寻址 + 位寻址（00H~7FH）
30H ─ 7FH   用户 RAM 区                   80B   直接/间接寻址（默认堆栈也在这）
──────────────────────────  低 128 字节：直接寻址可达 ←────────────
80H ─ FFH   高 128 字节（仅 52 系列有）    128B  只能间接寻址（@R0/@R1）
            其中 80H~FFH 与 SFR 地址重叠！              ↑
            ── 同一地址，用不同寻址方式访问到不同的东西 ──
80H ─ FFH   特殊功能寄存器 SFR              128B  只能直接寻址

工作寄存器区：4 组 R0~R7

00H~1FH 这 32 字节被分成 4 组，每组 8 个字节，名字都叫 R0~R7，靠 PSW 里的 RS1/RS0 决定当前用哪一组。下面的演示可以让你“切换寄存器组”，观察同一段 RAM 的两种解读方式。

7.3 位寻址：51 的独门绝技

51 有两个“位寻址区”，可以直接对单独一个 bit 读写，不需要读—改—写整个字节。这是它控制能力强的重要原因。

位地址计算公式（背下来就不怕 sbit）

位地址 = 字节地址 × 8 + 位号

例 1：RAM 20H 的第 0 位    →  20H × 8 + 0 = 00H      （位寻址区的起点）
例 2：RAM 2AH 的第 5 位    →  2AH × 8 + 5 = 165H     见下方说明
例 3：P1 口地址是 90H，求 P1.3 → 90H × 8 + 3 = 483

※ 位地址超过 7FH 时，汇编里写“字节地址.位号”更直观：2AH.5、90H.3
※ C51 里直接用 sbit P1_3 = P1^3; 或 sbit b = 0x2A^5; 由编译器帮你算

7.4 特殊功能寄存器 SFR：81 个“开关盒子”

所有外设（IO 口、定时器、串口、中断）都是通过读写 SFR 来控制的。SFR 分布在 80H~FFH，只能用直接寻址访问。下面是你在入门阶段一定会用到的：

完整列表在 Keil 的 reg51.h / reg52.h 头文件里可以逐条对照，建议打开看一次，你会立刻明白代码里的 TMOD、SCON 到底是什么。

7.5 C 语言的存储类型：data / idata / xdata / code

C51 编译器扩展了 4 个关键字来指定变量住在哪个空间。明白它们，你就能看懂“变量为什么突然丢了”或“程序为什么放不下”。

unsigned char data   flag;    /* 低 128B 内部 RAM，访问最快（默认首选） */
unsigned char idata  buf[32]; /* 全部内部 RAM（含高 128B），需间接寻址，稍慢 */
unsigned char xdata  big[512];/* 片外 RAM，用 MOVX 访问，最慢但容量大 */
unsigned char code   tab[] = {1,2,3}; /* 存进 Flash，只读，省 RAM */

/* 最实用的三条经验：
   ① 频繁访问的变量 → data
   ② 常量表、字库、点阵数据 → code（否则会吃掉宝贵的 RAM）
   ③ 大数组、缓冲区 → xdata（前提是片内实在放不下） */

7.6 堆栈：地址在里面怎么走

复位后 SP = 07H（在寄存器组 0 内，很危险，必须自己重设！）

典型的初始化：
    SP = 0x60;      /* 把堆栈放到用户 RAM 区，避开 R0~R7 和位寻址区 */

51 的堆栈是"向上生长"的：
    压栈 PUSH：先 SP = SP + 1，再把数据放到 SP 指向的单元
    弹栈 POP ：先取 SP 指向的数据，再 SP = SP - 1

调用子函数、进中断时，返回地址会自动压栈；所以堆栈空间不够会直接
导致程序跑飞（返回地址被变量覆盖）。这是 51 项目最难查的 bug 之一。

8.1 时钟：一切时序的源头

时钟周期（振荡周期）= 1 / 晶振频率        ← 最小的节拍
     12MHz 时 = 1/12µs ≈ 0.0833µs

机器周期 = 12 × 时钟周期               ← 标准 51 的"一步"
     12MHz 时 = 12/12µs = 1µs           ← 好记：12MHz → 1µs
     11.0592MHz 时 ≈ 1.085µs

指令周期 = 1 ~ 4 个机器周期            ← 不同指令耗时不同

8.2 定时器 / 计数器：同一个硬件的两种用法

核心原理：溢出即"到点"

51 的定时器是加计数的：给 TH/TL 装一个初值，然后让它往上数，数到最大值再加 1 就“溢出”——溢出时硬件自动把溢出标志 TF0/TF1 置 1。所以：

需要的计数值 = 定时时间 / 机器周期
定时初值     = 最大值 - 需要的计数值

方式 1（16 位）：最大值 = 65536，初值写入 TH 和 TL
方式 2（8 位自动重载）：最大值 = 256，初值只写 TH，TL 溢出后自动从 TH 重载

例：12MHz 晶振，机器周期 1µs，要定时 50ms
    需要的计数 = 50000
    初值 = 65536 − 50000 = 15536 = 0x3CB0
    所以  TH0 = 0x3C;  TL0 = 0xB0;

8.3 TMOD 与 TCON：两个必须会“拼”的寄存器

TMOD（89H，不可位寻址）——选工作方式

TMOD  ┌────┬────┬────┬────┬────┬────┬────┬────┐
      │ GATE│ C/T│ M1 │ M0 │ GATE│ C/T│ M1 │ M0 │
      └────┴────┴────┴────┴────┴────┴────┴────┘
        D7   D6   D5   D4   D3   D2   D1   D0
        └──── 定时器 1 ────┘  └──── 定时器 0 ────┘

M1 M0   工作方式
 0  0   方式 0：13 位定时器（为了兼容老芯片，很少用）
 0  1   方式 1：16 位定时器/计数器（最常用）
 1  0   方式 2：8 位自动重载（做串口波特率发生器必用）
 1  1   方式 3：T0 拆成两个 8 位定时器（特殊用途）

C/T ：0 = 定时器（内部时钟）；1 = 计数器（外部引脚脉冲）
GATE：0 = 只要 TR 置 1 就启动（99% 的情况用 0）
      1 = 还要 INT 引脚为高才启动（测脉冲宽度时用）

典型写法：TMOD = 0x01; 表示定时器 1 不用、定时器 0 工作在方式 1 定时模式。

TCON（88H，可位寻址）——启停与标志

8.4 两种编程方式：查询法与中断法

方式一：查询法（不占中断资源，简单但不精确）

/* 定时 50ms，查询 TF0 */
void Timer0_Init(void)
{
    TMOD &= 0xF0;        /* 只清 T0 的 4 位，保留 T1 的配置（好习惯）*/
    TMOD |= 0x01;        /* T0 = 方式 1，定时器模式 */
    TH0 = 0x3C;          /* 初值高 8 位 */
    TL0 = 0xB0;          /* 初值低 8 位 */
    TR0 = 1;             /* 启动 */
}

void Delay50ms(void)
{
    while (!TF0);          /* 原地等待溢出 */
    TF0 = 0;              /* 软件清零，为下一次做准备 */
    TH0 = 0x3C;          /* 重装初值（方式 1 必须手动重装！）*/
    TL0 = 0xB0;
}

方式二：中断法（推荐，不阻塞主程序）

/* 1 秒闪烁 LED：50ms × 20 次
   LED 接 P1.0，低电平点亮；晶振 12MHz */
#include <reg52.h>
sbit LED = P1^0;
u8 cnt = 0;

void Timer0_Init(void)
{
    TMOD &= 0xF0;  TMOD |= 0x01;   /* T0 方式 1 定时 */
    TH0 = 0x3C;  TL0 = 0xB0;          /* 50ms @12MHz */
    ET0 = 1;                          /* 允许 T0 中断 */
    EA  = 1;                          /* 打开总中断 */
    TR0 = 1;                          /* 启动定时器 */
}

void Timer0_ISR(void) interrupt 1    /* T0 的中断号是 1 */
{
    TH0 = 0x3C;  TL0 = 0xB0;          /* 先重装初值，减少误差 */
    if (++cnt >= 20) {                /* 20 × 50ms = 1s */
        cnt = 0;
        LED = ~LED;                   /* 每秒翻转一次 */
    }
}

void main(void)
{
    Timer0_Init();
    while (1) { /* 主程序空着也行，定时完全由中断完成 */ }
}

8.5 定时精度：误差从哪来

9.1 一个生活类比就懂了

你在写作业（主程序）。突然手机响了（中断请求）。你把笔放下、在书页上夹个书签记住写到哪（保护现场 / 压栈返回地址），接完电话（执行中断服务函数），回到书签处继续写（恢复现场 / 返回）。

如果电话是妈妈打来的（高优先级）而门铃也响了（低优先级），你会先接电话再接门铃——这就是中断优先级。如果接电话时又来一条更重要的短信（更高优先级中断），你先看短信再继续打电话，这就是中断嵌套。

9.2 51 的中断源与中断向量表

“中断向量”就是每个中断对应的固定入口地址。CPU 一旦响应某个中断，就自动跳到这个地址执行你写的中断函数。这是硬件规定死的，必须记住：

为什么地址间隔是 8 字节？因为每个中断入口只留了 8 个字节放跳转指令。真正的中断函数放在程序的其他位置，入口处只是一条跳转。这就是“中断向量”这个说法的由来。

9.3 两个控制寄存器：IE 与 IP

IE（A8H，可位寻址）——中断允许（开关）

IE   ┌────┬────┬────┬────┬────┬────┬────┬────┐
     │ EA │ —  │ —  │ ES │ET1 │EX1 │ET0 │EX0 │
     └────┴────┴────┴────┴────┴────┴────┴────┘
       D7   D6   D5   D4   D3   D2   D1   D0

EA ：总开关（必开）。EA = 1 才允许任何中断
ES ：串口中断允许      ET1：定时器 1 中断允许
EX1：外部中断 1 允许   ET0：定时器 0 中断允许
EX0：外部中断 0 允许

典型写法：ET0 = 1; EA = 1;      /* 用位操作，清晰不易错 */
也可以：IE = 0x82;              /* 位操作本质就是这一句 */

IP（B8H，可位寻址）——中断优先级

IP   ┌────┬────┬────┬────┬────┬────┬────┬────┐
     │ —  │ —  │ —  │ PS │PT1 │PX1 │PT0 │PX0 │
     └────┴────┴────┴────┴────┴────┴────┴────┘
      相应位置 1 = 高优先级，置 0 = 低优先级（默认全部为 0）

规则：
 ① 高优先级中断可以打断正在执行的低优先级中断（中断嵌套）
 ② 同优先级中断不能互相打断，按"内部查询顺序"排队：
    外部0 → 定时0 → 外部1 → 定时1 → 串口
 ③ 任何中断都不能打断同级或高优先级中断

9.4 CPU 响应中断的完整过程

1. 中断请求

   某个中断源满足条件（定时器溢出、引脚电平变化、串口收到数据），对应标志位置 1。

2. 判断是否响应

   要同时满足：该中断的分开关和 EA 都打开、没有更高优先级中断在执行、当前指令已执行完。

3. 保护断点

   硬件自动把 PC 的值压入堆栈（记住回来的路），然后跳到中断向量地址。

4. 执行中断服务函数

   你的代码运行。C 编译器还会自动保护用到的寄存器（压栈），函数结束时恢复。

5. 清除标志并返回

   定时器/外部中断的标志通常由硬件自动清除（串口的 TI/RI 必须软件清！），然后执行 RETI 弹出 PC，继续主程序。

9.5 外部中断的两种触发方式

/* 外部中断 0 完整配置：P3.2 下降沿触发，按一下 LED 翻转一次 */
void ExtInt0_Init(void)
{
    IT0 = 1;      /* 下降沿触发（写 0 则是低电平触发）*/
    EX0 = 1;      /* 允许外部中断 0 */
    EA  = 1;      /* 打开总中断 */
}

void ExtInt0_ISR(void) interrupt 0   /* 中断号 0 = 外部中断 0 */
{
    DelayMs(10);               /* 若接按键，这里做一次消抖 */
    if (INT0_PIN == 0) {       /* 确认真按下 */
        LED = ~LED;
    }
}

/* 主函数里要注意：INT0 引脚必须先置 1（读引脚规则），
   而且中断函数执行期间该引脚应保持高电平 */

9.6 C51 的中断函数语法

void 函数名(void) interrupt 中断号 [using 寄存器组号]
{
    /* 中断服务代码 */
}

/* 例子：定时器 0 中断，使用第 1 组工作寄存器 */
void T0_ISR(void) interrupt 1 using 1
{
    TH0 = 0x3C;  TL0 = 0xB0;
}

/* volatile 的典型场景：中断置标志，主程序检查 */
volatile bit g_tick = 0;      /* 必须 volatile，否则主程序可能永远读到 0 */

void T0_ISR(void) interrupt 1
{
    TH0 = 0x3C;  TL0 = 0xB0;
    g_tick = 1;               /* 只做最简单的事 */
}

void main(void)
{
    Timer0_Init();
    while (1) {
        if (g_tick) {
            g_tick = 0;
            /* 耗时的活儿放在这里做，不阻塞中断 */
        }
    }
}

9.7 常见故障速查

10.1 为什么要“串行”

51 引脚本来就少，所以外设几乎都用串行接口。UART（通用异步收发器）是最常用的一个：它不需要时钟线，双方事先约定好同样的波特率就能通信。

10.2 UART 一帧数据长什么样

空闲(高)  起始位  D0  D1  D2  D3  D4  D5  D6  D7  停止位  空闲(高)
────────┐      ┌──┬──┬──┬──┬──┬──┬──┬──┐        ┌──────────
        └──────┘  │  │  │  │  │  │  │  └────────┘
        低电平   LSB                     MSB   高电平

一帧 = 1 起始位 + 8 数据位 + 1 停止位 = 10 位      （最常用的 8N1 格式）
"8N1" 读作：8 位数据、无校验（None）、1 位停止位

波特率 9600 表示每秒传 9600 个位 → 一字节 10 位 → 约 960 字节/秒
这也是为什么串口打印多了会"卡"：它真的很慢。

10.3 SCON：串口控制寄存器（98H，可位寻址）

SCON ┌────┬────┬────┬────┬────┬────┬────┬────┐
     │SM0 │SM1 │SM2 │REN │TB8 │RB8 │TI  │RI  │
     └────┴────┴────┴────┴────┴────┴────┴────┘
       D7   D6   D5   D4   D3   D2   D1   D0

SM0 SM1  工作方式
 0   0   方式 0：同步移位寄存器（扩展 IO，不常用）
 0   1   方式 1：8 位 UART，波特率可变          ← 最常用
 1   0   方式 2：9 位 UART，波特率固定
 1   1   方式 3：9 位 UART，波特率可变

REN ：允许接收（1 = 允许）。忘了置 1 就永远收不到数据
TI  ：发送中断标志。写 SBUF 后自动开始发送，发完硬件置 1，必须软件清 0
RI  ：接收中断标志。收到完整一帧后硬件置 1，必须软件清 0

常用写法：SCON = 0x50;   /* SM0=0 SM1=1 方式1，REN=1 允许接收 */

10.4 波特率是怎么产生的

方式 1 和方式 3 的波特率由定时器 1 工作在方式 2（8 位自动重载）产生。公式是：

反过来算 TH1：

TH1 = 256 − f_osc / (12 × 32 × 波特率 / 2^SMOD)

例：11.0592MHz，9600bps，SMOD = 0
    TH1 = 256 − 11059200 / (12 × 32 × 9600)
        = 256 − 11059200 / 3686400
        = 256 − 3
        = 253 = 0xFD      ← 恰好是整数！误差为 0

同一个波特率若用 12MHz 晶振：
    TH1 = 256 − 12000000 / 3686400 = 256 − 3.255 = 252.7 → 只能取 253 或 252
    取 253 时实际波特率 ≈ 10416.7，误差约 8.5%   ← 太大了，通信会出错！

10.5 完整的串口收发程序

/* ------------------------------------------------------------
   串口演示：收到什么就回显什么（回环），并每秒主动发一句问候
   硬件：11.0592MHz 晶振，波特率 9600，8N1，通过 USB-TTL 接电脑
   注意：51 的 TXD 接 TTL 模块的 RXD，RXD 接 TXD（交叉接线），GND 共地
   ------------------------------------------------------------ */
#include <reg52.h>

void Uart_Init(void)
{
    SCON = 0x50;        /* 方式 1，允许接收 REN = 1 */
    TMOD &= 0x0F;        /* 清 T1 的配置位，保留 T0 */
    TMOD |= 0x20;        /* T1 = 方式 2（8 位自动重载），作波特率发生器 */
    TH1  = 0xFD;        /* 9600bps @11.0592MHz，SMOD=0 */
    TL1  = 0xFD;        /* 方式 2 下 TL1 会自动从 TH1 重载 */
    PCON &= 0x7F;       /* SMOD = 0（若要倍速则写 PCON |= 0x80）*/
    TR1  = 1;           /* 启动 T1 */
    ES   = 1;           /* 允许串口中断 */
    EA   = 1;           /* 打开总中断 */
}

/* 发送一个字节（查询法，简单可靠）*/
void Uart_SendByte(unsigned char dat)
{
    SBUF = dat;             /* 写入 SBUF 即开始发送 */
    while (!TI);             /* 等待发送完成（TI 被硬件置 1）*/
    TI = 0;                /* 必须软件清 0！*/
}

/* 发送字符串 */
void Uart_SendStr(char *s)
{
    while (*s) { Uart_SendByte(*s++); }
}

/* 接收中断：收到一个字节就原样发回去 */
void Uart_ISR(void) interrupt 4
{
    if (RI) {                   /* 接收中断 */
        RI = 0;               /* 先清标志，再处理 */
        Uart_SendByte(SBUF);    /* 回显 */
    }
    if (TI) { TI = 0; }        /* 发送中断也要清（本程序用查询法发送）*/
}

void main(void)
{
    Uart_Init();
    Uart_SendStr("UART ready!\r\n");

    while (1) {
        Uart_SendStr("hello 8051\r\n");
        DelayMs(1000);
    }
}

#include <stdio.h>
char putchar(char c)          /* 库函数 printf 最终会调用它 */
{
    if (c == '\n') { Uart_SendByte('\r'); }  /* 串口助手需要 \r\n 才换行 */
    Uart_SendByte(c);
    return c;
}
/* 之后就能用了： */
printf("value = %d, hex = 0x%02X\r\n", val, val);

10.6 三种常用同步总线对比

UART 是异步的（无时钟线）。接传感器、存储器时，更常用带时钟线的同步总线：

11.1 程序骨架：从今天起就按这个结构写

/* ============================================================
 * 文件名 : main.c
 * 芯片   : STC89C52RC @ 11.0592MHz
 * 功能   : 按键控制 LED，并用串口回显(一句话说明现象)
 * 硬件   : LED 接 P1.0(低电平点亮) 按键接 P3.2(低电平有效)
 * 日期   : 2025-xx-xx
 * ============================================================ */
#include <reg52.h>        /* 51 寄存器定义头文件（必加）*/
#include <intrins.h>       /* 需要 _nop_() 循环移位等内部函数时加 */

/* ---------- 1. 类型别名：让代码更短、更清晰 ---------- */
typedef unsigned char u8;   /* 0~255，单片机的"万能类型" */
typedef unsigned int  u16;  /* 0~65535，用于延时、计数值 */
typedef unsigned long u32;

/* ---------- 2. 引脚与常量定义：集中管理，方便换板子 ---------- */
sbit LED1 = P1^0;
sbit KEY1 = P3^2;
#define LED_ON   0          /* 低电平点亮，用宏表达语义 */
#define LED_OFF  1

/* ---------- 3. 全局变量：尽量少，够用就行 ---------- */
volatile u8 g_tick = 0;       /* 中断与主程序共享 → 必须 volatile */

/* ---------- 4. 函数声明 ---------- */
void System_Init(void);
void DelayMs(u16 ms);

/* ---------- 5. 主函数 ---------- */
void main(void)
{
    System_Init();                   /* 所有初始化集中在这里 */
    while (1) {
        /* 主循环只做逻辑，不做长阻塞 */
    }
}

/* ---------- 6. 函数实现 ---------- */
void System_Init(void)
{
    LED1 = LED_OFF;                  /* 先给引脚确定状态，避免上电闪一下 */
    KEY1 = 1;                       /* 读引脚前先写 1 */
}

void DelayMs(u16 ms)
{
    u16 i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 110; j++);
}

11.2 51 独有的扩展关键字

/* sbit 的三种写法（等价） */
sbit P1_0 = P1^0;      /* 最常用：口地址 + 位号 */
sbit P1_0 = 0x90^0;    /* 直接写寄存器地址 + 位号 */
sbit P1_0 = 0x90;       /* 位地址形式（这里 0x90 恰好是 P1.0 的位地址）*/

/* 使用位变量，注意它只能取 0 或 1 */
bit key_pressed = 0;
if (KEY1 == 0) { key_pressed = 1; }

/* 声明一个新寄存器（例如某型号的 PWM 寄存器在 0xCC） */
sfr  PWM_CTL = 0xCC;
sbit PWM_EN  = PWM_CTL^7;

11.3 数据类型与取值范围（8 位机必须精打细算）

11.4 配置一个外设的标准五步法

以后你会配置几十种外设（定时器、串口、ADC、PWM、外部芯片）。它们的配置思路完全一致，照这五步做就不会乱：

1. 查手册确认寄存器

   找到相关的寄存器（如 TMOD、TCON）和它的每一位含义。不要凭记忆。

2. 确定“保留位”和“目标位”

   哪些位是别人的（比如 T1 的配置）、哪些是你要改的。能用位操作就别整字节赋值。

3. 按“读—改—写”方式修改

   TMOD &= 0xF0; TMOD |= 0x01; —— 先清目标位，再置新值，保留其他位。

4. 打开允许/中断开关

   例如 ET0 = 1; EA = 1; 或 REN = 1; 开关没开，配置再好也不工作。

5. 启动并验证

   例如 TR0 = 1; 然后用 LED、串口、万用表验证现象是否符合预期。

/* 对照示例：同一份需求，两种写法的差别 */

/* ✗ 危险写法：整字节覆盖，把 T1 的配置也清掉了 */
TMOD = 0x01;

/* ✓ 推荐写法：只动 T0 的 4 位，T1 的设置保持原样 */
TMOD &= 0xF0;      /* 清低 4 位（T0 部分）*/
TMOD |= 0x01;      /* 写入 T0 = 方式 1 定时 */

/* 记忆口诀：清位用 &= ~掩码，置位用 |= 掩码 */

11.5 头文件与工程组织

/* ---------- 单文件小程序：一个 main.c 就够了 ---------- */

/* ---------- 多文件工程：推荐这样分 ---------- */
/* timer.h */
#ifndef __TIMER_H__          /* 头文件保护，防止重复包含 */
#define __TIMER_H__
void Timer0_Init(void);
void DelayMs(unsigned int ms);
#endif

/* timer.c */
#include "timer.h"
#include <reg52.h>
void Timer0_Init(void) { /* ... */ }

/* main.c */
#include "timer.h"
void main(void) { Timer0_Init(); while(1){} }

Keil 里要记得把 timer.c 加入工程（Add Files to Group），只创建文件不加入工程会报“undefined symbol”。

11.6 编译器的“好意”：优化与 volatile

/* 场景：中断里改变量，主程序等待它 */
u8 flag = 0;                    /* ✗ 少了 volatile */

void T0_ISR(void) interrupt 1 { flag = 1; }

void main(void)
{
    Timer0_Init();
    while (flag == 0);          /* 编译器可能认为 flag 永不改变，
                                       直接优化成 while(1);  → 死循环！ */
}

12.1 工具链全貌

你写的代码                工具                       产物
──────────────       ──────────────────       ──────────────
 main.c        ──►   C51 编译器 (Keil)   ──►    main.obj（目标文件）
                                                      │
 启动文件 STARTUP.A51 ► 汇编器 ──► STARTUP.obj        │
                                                      ▼
                       链接器 (L51/BL51)  ──►  main.hex / main.bin
                       分配地址、解决符号引用        │
                                                    ▼
                       STC-ISP（串口）或编程器   ──►  写进芯片 Flash
                                                    │
                                                    ▼
                       芯片复位，PC = 0000H 开始执行你的程序

三种常见工具链的选择

12.2 Keil 建工程：八步走

1. 新建工程

   Project → New µVision Project，建议每个实验建一个独立文件夹，路径不要有中文和空格（很多人被这个坑掉半小时）。

2. 选择芯片型号

   在 Device 里搜索你的芯片：AT89C52、STC89C52（若列表没有 STC，选 Atmel 的 AT89C52 即可，寄存器兼容）。

3. 是否复制启动代码

   弹出 “Copy Standard 8051 Startup Code?” 时选是（生成 STARTUP.A51，负责清零 RAM）。

4. 添加源文件

   新建 main.c 并保存到工程目录，然后右键 Source Group 1 → Add Existing Files 加入工程。

5. 设置晶振频率

   Project → Options for Target → Target 页，把 Xtal 改成你板子的实际频率（11.0592 或 12MHz）。这会影响下载工具的波特率计算和调试时序。

6. 生成 HEX 文件

   Options for Target → Output 页，勾选 “Create HEX File”。不勾选的话编译器不会生成 hex，STC-ISP 里就找不到文件。

7. 编译

   按 F7（Build）。底部 Build Output 出现 0 Error(s) 即成功；若有 warning 尽量也解决掉。

8. 找到 HEX

   HEX 文件在工程目录下的 Objects（或你设置的 Output）文件夹里，文件名通常是工程名.hex。

12.3 下载：STC-ISP 五步走

1. 连接硬件

   USB 线接开发板；若是外接 USB-TTL 模块，注意 TXD↔RXD 交叉、GND 共地。板子先不要上电（或准备好断电重上）。

2. 选择芯片型号

   在 STC-ISP 左上角选对型号（如 STC89C52RC / STC89C52RC/LE52RC）。型号选错会导致下载失败或参数错误。

3. 选择串口号

   插上 USB 后，在设备管理器里找到 “USB-SERIAL CH340 (COMx)”，在软件里选同一个 COM 口。看不到 COM 口说明驱动没装。

4. 打开 HEX 文件

   点“打开程序文件”，选择 Keil 生成的 .hex。软件会显示程序占用的字节数。

5. 冷启动下载

   点“下载/编程”，然后给开发板断电再上电（或按板上的电源开关/复位键）。STC 芯片上电时先运行固化在内部的 Bootloader，通过串口接收新程序再写进 Flash。

下载失败的常见原因

12.4 芯片启动后发生了什么

上电 / 复位
   │
   ▼
PC = 0000H ──► 执行启动代码 STARTUP.A51
   │            ① 清零内部 RAM（保证变量初值为 0）
   │            ② 按需初始化变量区
   │            ③ 设置 SP（你若不手动设，默认 07H，很危险）
   │            ④ 跳到 main()
   ▼
main() 里的初始化（配置 IO、定时器、串口、中断）
   │
   ▼
while (1) 主循环，同时中断在后台随时插队
   │
   └──► 直到下一次复位或断电

12.5 调试方法：没有断点，怎么找问题

51 的开发板通常没有硬件调试器，所以你要掌握的“穷人调试法”是这几件：

12.6 “编译通过但没现象”排查流程

1. 确认程序真的下进去了

   STC-ISP 是否提示“操作成功”？重新下一个最简单的点灯程序验证整条链路。

2. 确认端口号对不对

   拿原理图核对：LED 到底接在 P1 还是 P2？是高电平点亮还是低电平？这一步能解决 80% 的“没现象”。

3. 确认电路本身没问题

   LED 极性是否接反、限流电阻是否虚焊、排线是否插错位、共地是否可靠。

4. 确认程序在运行

   用万用表量 ALE 引脚（第 30 脚），正常运行时应有约 1/6 晶振频率的方波（12MHz → 约 500kHz）。没有波形说明芯片没跑起来（复位电路、晶振或 EA 接法有问题）。

5. 缩小范围二分定位

   把代码注释掉一半，看现象是否变化，逐步缩小到出问题的那几行。不要靠猜。

6. 检查那三个“隐藏杀手”

   忘了开总中断 EA；读引脚前没写 1；整字节赋值覆盖了其他引脚的状态。

12.7 你的第一周任务清单

13.1 症状 → 原因速查表

13.2 排错的四条纪律

13.3 自测：15 题检验你的地基

点击你认为正确的选项，会立即给出对错和解析。全部做完后上方会显示得分。

14.1 SFR 速查

14.2 引脚速查

注意 P0 的引脚编号方向：Pin 32 是 P0.7，Pin 39 是 P0.0，与 P1/P2/P3 的顺序相反，抄原理图时容易看错。

14.3 公式速查

14.4 常用 C 代码片段

/* ① 位操作宏 */
#define BIT(n)      (1 << (n))
#define SET_BIT(x,n)   ((x) |=  BIT(n))
#define CLR_BIT(x,n)   ((x) &= ~BIT(n))
#define TOG_BIT(x,n)   ((x) ^=  BIT(n))
#define GET_BIT(x,n)   (((x) >> (n)) & 1)
#define ARRAY_LEN(a)   (sizeof(a) / sizeof((a)[0]))

/* ② 毫秒级空转延时（@12MHz，粗略值，仅供非精确场合）*/
void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 110; j++);
}

/* ③ 定时器 0 初始化：50ms @12MHz，中断方式 */
void Timer0_Init(void)
{
    TMOD &= 0xF0;  TMOD |= 0x01;   /* T0 方式 1 定时 */
    TH0 = 0x3C;  TL0 = 0xB0;          /* 65536 − 50000 = 15536 */
    ET0 = 1;  EA = 1;  TR0 = 1;
}

/* ④ 串口初始化：9600 @11.0592MHz，8N1，允许接收 */
void Uart_Init(void)
{
    SCON = 0x50;
    TMOD &= 0x0F;  TMOD |= 0x20;   /* T1 方式 2 作波特率发生器 */
    TH1 = 0xFD;  TL1 = 0xFD;
    TR1 = 1;  ES = 1;  EA = 1;
}

/* ⑤ 按键消抖读取（低电平有效）*/
u8 Key_Scan(u8 mode)
{
    static u8 key_up = 1;
    if (mode) key_up = 1;               /* 支持连按 */
    if (key_up && KEY1 == 0) {
        DelayMs(15);
        key_up = 0;
        if (KEY1 == 0) return 1;       /* 确认按下 */
    } else if (KEY1 == 1) {
        key_up = 1;
    }
    return 0;
}

14.5 术语表

MCU

Microcontroller Unit，微控制器。CPU、存储器、外设集成在一颗芯片上。

SFR

Special Function Register，特殊功能寄存器。控制外设的“开关盒子”，分布在 80H~FFH。

准双向口

51 的 IO 口结构：内部弱上拉 + 强下拉，可直接当输入，但读之前必须先写 1。

开漏输出

只能拉低、不能主动拉高，输出高必须靠外部上拉电阻。P0 口就是这种结构。

机器周期

标准 51 中 12 个时钟周期构成的基本时间单位，12MHz 下等于 1µs。

中断向量

每个中断固定对应的入口地址（外0=0003H，定0=000BH…）。

波特率

串口每秒传输的位数，常用 9600、115200。收发双方必须一致。

BCD

用 4 个二进制位表示一位十进制数字的编码方式，数码管、时钟芯片常用。

消抖

消除机械按键触点弹跳造成的多次误触发，常用 10~20ms 延时法。

上拉/下拉

给悬空引脚一个确定的默认电平，避免状态随机。

灌电流 / 拉电流

电流流入引脚（引脚输出低）/ 电流流出引脚（引脚输出高）。51 的灌电流能力远强于拉电流。

HEX 文件

编译器输出的烧录文件，用十六进制文本记录每个地址上的机器码。

冷启动下载

STC 芯片的下载方式：先点下载、再给板子上电，让芯片进入 Bootloader 接收程序。

14.6 延伸阅读与官方资料

14.7 下一步学什么

1. 把外设一个个打穿

   数码管（静态/动态扫描）→ 独立按键与矩阵键盘 → 蜂鸣器 → 继电器 → LCD1602 → DS18B20 → AT24C02 → 红外遥控 → 步进电机。

2. 把协议吃透

   UART / I2C / SPI / 单总线的手册时序，自己用 IO 口模拟一遍，再看示波器波形对照。

3. 做一个完整的作品

   把多个模块组合成有实际用途的东西（电子钟、温控风扇、计数器），会逼你处理状态机、按键交互、异常情况。

4. 然后升级到 STM32 / 国产 32 位 MCU

   你会惊喜地发现：GPIO、定时器、中断、串口这些概念完全复用，只是寄存器变多、工具链变现代、能跑 RTOS。