51 单片机详细教程

怎么用这个教程

1. 按章节顺序走，不要跳。第 5 章（最小系统）和第 4 章（位运算）是后面所有实验的地基。
2. 每章的代码都要自己敲一遍，编译、烧录、看现象。看懂 ≠ 会做。
3. 每章末尾有练习，做完再进下一章。
4. 左侧可以搜索关键词（如「定时器」「TMOD」「晶振」）。

你的现有基础怎么用

你学过的	在哪里直接用上
C 语言	全程。单片机只用到基础语法 + 位运算
电路前三章（KCL/分压/欧姆定律）	第 5 章复位电路、第 8 章 LED 限流电阻
数电到 TTL 门电路	第 8 章「为什么低电平点亮」、第 10 章数码管、第 14 章 74HC595

模块一 · 入门准备　第 1-7 章

模块二 · GPIO 与外设　第 8-17 章

模块三 · 中断·定时器·串口　第 18-21 章

模块四 · 总线与传感器　第 22-27 章

模块五 · 显示与扩展　第 28-35 章

1.1 先说结论：单片机是「用软件控制硬件」

你已经会写 C 程序了，但你的程序现在只能：读键盘、算数、打印到屏幕。

单片机会让你的程序长出手脚 —— 同一段 C 代码，可以让一个灯闪、让电机转、让屏幕显示温度。

1.2 为什么从 51 开始，而不是 STM32

对比项	51（STC89C52）	STM32（ARM）
结构	简单，寄存器少	复杂，寄存器上千个
上手	一周能点亮灯、能中断	光配时钟就要学几天
资料	中文资料极多，普中/郭天祥	英文手册为主
用途	教学、小家电、简单控制	工业、消费电子主流

51 是「最小可用的完整模型」：CPU、存储器、定时器、中断、串口全都有，但每个都简单到能手算。学完再上 STM32，你会发现只是「同样的东西，多了十倍选项」。

1.3 学习方法：三条铁律

1.4 学习前准备清单

项目	说明	你有吗
开发板	普中-2/3/4 任意一款	✓
USB 线	能传数据的（不是只能充电的）	要确认
Keil C51	编译软件，本机已装在 D:\keli4	✓
烧录软件	普中下载软件 / STC-ISP	资料 5--开发工具 里
串口驱动	CH340 或 PL2303	资料 5--开发工具 里

1.5 常见疑问

常见错误速查

1.6 本章练习

1. 说出单片机和你电脑的区别（至少三条）。
2. 在资料里找到「5--开发工具」，列出里面有几个软件、各自干什么。
3. 给自己定一个目标：两周后能独立做出「按键控制 LED 流水灯」。

📖 参考答案（点击展开）

1. ① 单片机是「专用」的，只跑一个程序；电脑是「通用」的，能装各种软件。② 单片机资源极小（8KB Flash / 512B RAM），电脑是 GB 级。③ 单片机没有操作系统（裸机），程序直接从 main 开始。④ 单片机靠引脚直接控制硬件。
2. 打开 `5--开发工具`，通常有：Keil C51（编译）、普中下载软件或 STC-ISP（烧录）、CH340/PL2303 驱动（USB 转串口）、可能还有取模软件。具体以你本机目录为准。
3. 参考答案不重要，关键是写下日期并贴在显示器旁。建议：第 1 周跑通 1-13 章，第 2 周做 12/13/18-21 章，最后做「按键控制流水灯」。

2.1 开发板上有什么

普中-2/3/4 属于「全功能学习板」，资源很全。你只需要先认识这几块：

模块	接在哪个口	从第几章开始用
8 个 LED	P2 口（P2.0～P2.7）	第 8 章
蜂鸣器	P2.5	第 9 章
数码管	P0（段码）+ P2.2/P2.3/P2.4（位选）	第 10-11 章
独立按键	P3.0～P3.3	第 12 章
矩阵按键	P1 口	第 13 章
串口	P3.0(RXD) / P3.1(TXD)	第 21 章

2.2 板子的「三个开关」

拿到板子第一件事不是写程序，是确认这三个地方：

1. 电源开关 —— 拨到 ON，电源指示灯亮。
2. 下载/运行切换（部分型号有）—— 烧录时拨到「下载」，运行拨到「运行」。
3. USB 口 —— 有的板子有两个口（一个供电一个下载），插错就烧不进去。

2.3 烧录软件怎么用

普中板子用的是 STC 芯片，烧录流程（STC-ISP 或普中下载软件都一样）：

步骤	操作	注意
1	选芯片型号	STC89C52RC（板子上丝印为准）
2	选串口	设备管理器里看 COM 几
3	打开 .hex 文件	Keil 编译后生成的那个
4	点「下载/编程」	然后才给板子上电或按复位

2.4 驱动装不上怎么办

插上 USB 后设备管理器里出现黄色感叹号，说明缺驱动：

• CH340 芯片 → 装 CH341SER.EXE
• PL2303 芯片 → 装 PL2303 驱动（Win10 以上要用老版本 3.3.2.102）
• 装完重新插拔，设备管理器里应出现 USB-SERIAL CH340 (COMx)

常见错误速查

2.5 本章练习

1. 在设备管理器里找到你的串口号，记下来。
2. 把板子通电，找出电源灯、8 个 LED、4 个独立按键的物理位置。
3. 用万用表（或看丝印）确认 LED 是接 P2 口、按键接 P3 口。

📖 参考答案（点击展开）

1. 设备管理器 → 端口(COM 和 LPT) → 看到 `USB-SERIAL CH340 (COMx)`，那个 x 就是串口号。插拔 USB 会变，烧录前确认一次。
2. 电源灯通常在板子一角常亮；8 个 LED 排成一排标 D1~D8；4 个独立按键标 K1~K4，通常靠近边缘。
3. 看丝印：LED 旁边应印 `P20`~`P27`（即 P2.0~P2.7）；按键旁边印 `P30`~`P33`。用万用表蜂鸣档量 LED 阴极到 P2 引脚应导通。

3.1 一颗芯片里的五样东西

这颗芯片里有五个部分，你后面 30 多章做的事，本质上就是学会操作这五样东西：

部件	STC89C52 的规格	用来干什么	对应章节
ROM（程序存储器）	8 KB Flash	存你编译出来的程序	全部
RAM（数据存储器）	512 B	存变量、数组、堆栈	全部
I/O 口	P0~P3，共 32 根	接 LED、按键、屏幕	8-17
定时器/计数器	T0、T1，16 位	精确定时、数脉冲	20
中断系统	5 个中断源	让 CPU 响应突发事件	18-19
串口 UART	1 个全双工	和电脑/模块通信	21

3.2 引脚怎么认

40 根引脚分成几类：

类别	引脚	作用
电源	40 (VCC)、20 (GND)	供电，各接 5V 和地
时钟	18 (XTAL2)、19 (XTAL1)	接晶振
复位	9 (RST)	高电平复位
I/O 口	P0、P1、P2、P3 各 8 根	通用输入输出
控制	29 (PSEN)、30 (ALE)、31 (EA)	扩展外部存储器用，基础实验基本不接

3.3 型号怎么读

STC89C52RC-40I-PDIP40

字段	含义
STC	厂商（宏晶科技）
89	8051 内核
C	CMOS 工艺
52	ROM 8KB、RAM 512B（51 是 4KB/128B）
RC	RAM 加大版
40I	最高 40 MHz，工业级
PDIP40	40 脚双列直插封装

常见错误速查

3.4 本章练习

1. 不看图，说出 VCC、GND、RST、XTAL1、XTAL2 分别是第几脚。
2. P2.3 是第几脚？（提示：P2.0 是 21 脚，往下数）
3. 如果程序要存 20KB，STC89C52 够吗？为什么？

📖 参考答案（点击展开）

1. VCC = 40 脚；GND = 20 脚；RST = 9 脚；XTAL2 = 18 脚；XTAL1 = 19 脚。
2. P2.0 是 21 脚，往下数 P2.1=22、P2.2=23 → P2.3 = 24 脚。
3. 不够。STC89C52 只有 8KB Flash，20KB 装不下。需要换 32KB 以上的型号（如 STC89C52RC 实际是 8K，要更大得选 STC12C5A60S2 等）。

4.1 你已经会的，这里全用得上

这一章不重复讲你学过的东西，只讲「它们在这里长出什么新用法」。

你学过的	在单片机里变成	什么时候用
数电：逻辑门、真值表	数码管段码、74HC595 移位	第 10、14 章
数电：TTL 电平	0 = 0V、1 = 5V，但灌电流/拉电流不同	第 8 章 LED 为什么低电平亮
数电：触发器	74HC595 内部的移位寄存器	第 14 章
电路：分压、欧姆定律	算 LED 限流电阻	第 8 章
电路：RC 充放电	复位电路、按键消抖	第 5、12 章
C：位运算	直接操作寄存器	全部

4.2 最关键的衔接：位运算就是「控制引脚」

单片机的每个寄存器都是 8 位，每一位对应一个引脚或一个功能开关。你在 C 里学的位运算，在这里就是硬件控制。

写法	效果	典型用途
P2 = 0xFE;	1111 1110 → P2.0 为 0，其余为 1	只点亮 D1
P2 &= 0xFE;	把最低位清 0，不影响其他位	只熄灭 D1，保留其他 LED
P2 |= 0x01;	把最低位置 1	只点亮/熄灭某一位
P2 ^= 0xFF;	全部取反	8 个 LED 一起翻转
P2 = (P2 << 1) | 0x01;	左移一位再补 1	流水灯
if (P3 & 0x01)	只判断 P3.0 这一位	读按键

4.3 三个单片机专用的 C 语法

语法	作用	例子
sbit	把某一位定义成变量名	sbit LED1 = P2^0; 之后可以写 LED1 = 0;
interrupt n	把函数声明成中断服务程序	void timer0() interrupt 1
#include <reg52.h>	引入 51 的寄存器定义	有了它才能写 P0/P1/TMOD

4.4 中断号必须记

中断号	中断源	对应章节
0	外部中断 0（INT0，P3.2）	第 19 章
1	定时器 0	第 20 章
2	外部中断 1（INT1，P3.3）	第 19 章
3	定时器 1	第 20 章
4	串口	第 21 章

常见错误速查

4.5 本章练习

1. 写一行代码：让 P2.3 变 0，其他位不变。
2. 写一行代码：让 P1 的高 4 位变 1，低 4 位不变。
3. 判断 P3.2 是否为 0，用一行 if 写出来。
4. 说出 sbit KEY = P3^2; 里的 ^ 和普通异或的区别。

📖 参考答案（点击展开）

1. P2 &= 0xF7;　（P2.3 是 bit3，掩码 1111 0111 = 0xF7）
2. P1 |= 0xF0;　（高 4 位置 1，低 4 位不变）
3. if ((P3 & 0x04) == 0) { ... }　（P3.2 是 bit2，掩码 0x04）
4. sbit KEY = P3^2; 里的 ^ 是定义位变量的专用语法，只在定义时用；普通语句里 a ^ b 是按位异或。两者含义完全不同。

5.1 最小系统 = 芯片能跑起来的最低配置

把这三样接对，芯片就会开始执行 ROM 里的程序。普中开发板已经把这些做好了，你只需要理解原理 —— 因为一旦板子不工作，排查顺序就是这个顺序。

5.2 时钟电路：为什么是 11.0592 MHz 而不是 12 MHz？

这是个必考问题。答案只有一句话：为了串口波特率能整除。

51 的定时器时钟 = 晶振频率 ÷ 12。串口方式 1 的波特率公式（SMOD=1 时）：

波特率 = (2^SMOD / 32) × (晶振 / (12 × (256 - TH1)))

代入 SMOD=1、TH1=0xFA（即 250，重装值 6）：

波特率 = (2 / 32) × (晶振 / (12 × 6)) = 晶振 / 1152

要 9600：晶振 = 9600 × 1152 = 11059200 Hz = 11.0592 MHz  ✓ 正好
用 12 MHz：12 000 000 / 1152 = 10416.7 → 误差 8.5%  ✗ 通信必乱

5.3 复位电路：两个作用

方式	过程	作用
上电复位	上电瞬间电容充电，RST 保持高电平约 10 ms	保证上电时程序从头开始
按键复位	按下按键，RST 直接接 VCC	程序跑飞时手动重启

51 是高电平复位：RST 脚持续 2 个机器周期以上的高电平就复位。而 STM32 是低电平复位 —— 不要搞混。

5.4 电源与去耦电容

每个电源引脚旁边都要接一个 0.1 μF 的陶瓷电容到地。作用是：

• 滤掉高频噪声（防止误动作、程序跑飞）
• 就近提供瞬时电流（芯片瞬间拉电流时电容顶上）

5.5 排查顺序（背下来）

1. 量电源：VCC 对 GND 是不是 5 V。
2. 量复位：正常运行时 RST 应该是低电平。
3. 量晶振：用示波器看 XTAL2 有没有起振（万用表量不出来）。
4. 看 EA 脚（31 脚）：接高电平才是从内部 ROM 执行。

常见错误速查

5.6 本章练习

1. 用 11.0592 MHz 算：定时器方式 1 要定时 1 ms，初值是多少？
2. 如果晶振换成 12 MHz，同样初值实际定时多久？
3. 说出复位电路中电容和电阻各自的作用。
4. 为什么 RST 脚平时必须是低电平？

📖 参考答案（点击展开）

1. 机器周期 = 12/11.0592MHz = 1.0850694 μs。1ms 需要 1000/1.0850694 = 921.6 → 取 922 个计数。初值 = 65536 − 922 = 64614 = 0xFC66（TH0=0xFC, TL0=0x66）。
2. 同样初值 0xFC66 在 12MHz 下：机器周期 = 1 μs，922 × 1 μs = 0.922 ms（偏短 7.8%）。
   反过来说：若用 0xFC18（1000 计数），在 12MHz 下正好 1.000 ms —— 所以 12MHz 做定时更规整，11.0592MHz 是为了串口。
3. 电容：上电瞬间相当于短路，把 RST 拉高，随后充电到 5V，RST 慢慢降下来 —— 提供复位所需的高电平宽度。电阻：给电容提供放电回路，保证断电后能再次复位；同时限制按键按下时的电流。
4. RST 是高电平复位。平时必须是低电平，否则芯片会一直处于复位状态，程序根本不会跑。

6.1 你机器上的情况（已确认）

路径	版本	有没有 C51	用途
D:\keli4\UV4\Uv4.exe	μVision 4	有（C51 V9.01，完整授权）	51 就用这个
D:\UV4\UV4.exe	μVision 5 / MDK 5.40	无（只有 ARM）	STM32 用这个

6.2 新建工程的完整步骤

1. Project → New μVision Project，选一个纯英文路径（如 D:\keil_proj\test1）。
2. 选芯片：Atmel → AT89C52（STC89C52 与它兼容）。
3. 弹出「Copy Standard 8051 Startup Code?」→ 选否（普中模板不需要）。
4. 新建文件 main.c 并 Add to Group。
5. 打开 Project → Options for Target：
   • Target 页：Xtal 填 11.0592
   • Output 页：勾选 Create HEX File ← 不勾就烧不了
6. F7 编译。成功会显示 0 Error(s) 并生成 .hex。

6.3 编译输出怎么看

Build target 'Target 1'
compiling main.c...
linking...
Program Size: data=9.0 xdata=0 code=30
creating hex file...
"test1" - 0 Error(s), 0 Warning(s).

字段	含义	要看什么
data	占用 RAM 字节数	不能超过 128（这是 51 的 data 区）
code	占用 ROM 字节数	不能超过 8192
0 Error(s)	编译成功	有 Error 时看最后几行定位

6.4 常见编译错误

报错	原因	解决
undefined identifier 'P2'	没 include	加 #include <reg52.h>
syntax error near 'sbit'	sbit 写在函数里了	sbit 必须写在函数外（全局）
data space memory overlap	RAM 用超了	把大数组改小，或用 xdata
can't open file 'xxx.h'	头文件路径不对	Options → C51 → Include Paths 加上

常见错误速查

6.5 本章练习

1. 新建一个空工程，编译通过（0 Error），确认生成了 .hex 文件。
2. 故意把 #include <reg52.h> 删掉，看报什么错，再改回来。
3. 把 Output 页的 Create HEX File 取消，编译一次，看看输出目录里少了什么。

📖 参考答案（点击展开）

1. Project → New μVision Project → 选路径 → 选 AT89C52 → 不复制启动代码 → 新建 main.c 并 Add → Options 里 Xtal 填 11.0592、勾 Create HEX File → F7。看到 `0 Error(s)` 且目录出现 .hex 即为成功。
2. 会报 undefined identifier 'P2' 或类似「未定义」的错误 —— 因为 P0/P1/TMOD 这些名字都定义在 reg52.h 里。
3. 编译仍显示 0 Error，但输出目录里没有 .hex 文件（只有 .obj/.M51）。烧录软件会找不到文件。

7.1 工程模板是什么

普中资料里每个实验都是一个压缩包，解压后是同一套文件结构：

3-LED闪烁实验\
├─ main.c              你的代码
├─ template.uvproj     Keil 工程文件（双击它打开）
├─ template.uvopt      选项文件（调试器设置，丢了会自动重建）
├─ template.hex        编译产物，烧录用
├─ template.M51        链接映射文件（看内存占用）
└─ template            无扩展名，编译中间产物

7.2 第一个程序：点亮一个 LED

#include "reg52.h"

sbit LED1 = P2^0;      // 把 P2.0 这个引脚起名叫 LED1

void main()
{
    LED1 = 0;          // 输出低电平 → 电流从 VCC 流过 LED 进引脚 → 灯亮
    while(1)           // 停在这里，别让程序跑飞
    {
    }
}

逐行拆解

代码	作用	为什么必须这么写
#include "reg52.h"	引入 8052 的寄存器定义	没有它，P0/P1/TMOD 这些名字编译器不认识
sbit LED1 = P2^0;	定义位变量	之后写 LED1=0 比 P2 &= 0xFE 更直观
LED1 = 0;	P2.0 输出低	板上 LED 阳极接 VCC，低电平才形成回路
while(1) {}	死循环	单片机的 main 不能返回，返回后程序会跑飞

7.3 编译 → 烧录 → 看现象

步骤	操作	看到什么
1	Keil 里按 F7	底部显示 0 Error(s)，生成 template.hex
2	打开烧录软件，选芯片和 COM 口	—
3	载入 template.hex	显示文件大小
4	点「下载」，然后按板子复位	进度条走完，提示成功
5	观察板子	D1 常亮

7.4 如果灯不亮：五步排查

1. 烧进去了吗 —— 软件提示成功了吗？
2. 程序真的在跑吗 —— 把 LED1=0 改成 LED1=0; while(1){ LED1=!LED1; }，看是否闪烁（闪 = 程序在跑，说明是引脚/硬件问题）。
3. 引脚对吗 —— 板子上 D1 是不是真的接 P2.0？（看原理图）
4. 写的电平对吗 —— 试着改成 LED1=1 看会不会亮（排除板上电路不同）。
5. 芯片选对了吗 —— 烧录软件里型号必须和板上芯片一致。

常见错误速查

7.5 本章练习

1. 点亮 D1，然后改成点亮 D8（提示：P2.7）。
2. 让 8 个 LED 全亮（一行代码）。
3. 让 8 个 LED 全亮，但只用 |= 不用 =（体会区别）。
4. 如果把 while(1) 删掉会怎样？试一次，看现象。

📖 参考答案（点击展开）

1. sbit LED8 = P2^7; LED8 = 0;　或直接 P2 &= 0x7F;
2. P2 = 0x00;
3. P2 |= 0x00; 这句什么也不会改变（或运算 0 等于不变）。
   如果本意是「全亮」，正确写法是 P2 &= 0x00;（等价于 P2=0）。这个练习就是让你体会 |= 不能用于清零。
4. main 返回后程序会跑飞（PC 跳到未知地址）。现象：LED 保持亮着或乱闪，行为不可预测。所以 main 末尾必须有 while(1)。

8.1 GPIO 输出：让引脚听话

P2 口有 8 个引脚，每个引脚可以输出 0（约 0.3 V）或 1（约 5 V）。这就是全部的秘密。

写法	结果	板上的现象
P2 = 0xFE;	1111 1110，只有 P2.0 = 0	D1 亮，D2～D8 灭
P2 = 0x7F;	0111 1111，只有 P2.7 = 0	D8 亮
P2 = 0x00;	全 0	8 个 LED 全亮
P2 = 0xFF;	全 1	8 个全灭

8.2 三种常用花样

① 流水灯（一个一个亮过去）

#include "reg52.h"

void delay_ms(unsigned int ms)      // 约 1ms 的延时
{
    unsigned int i, j;
    for (i = ms; i > 0; i--)
        for (j = 110; j > 0; j--);  // 11.0592MHz 下约 1ms
}

void main()
{
    unsigned char i;
    while (1)
    {
        for (i = 0; i < 8; i++)
        {
            P2 = ~(1 << i);          // 第 i 位为 0，其余为 1
            delay_ms(200);
        }
    }
}

② 全部闪烁

while (1)
{
    P2 = 0x00;  delay_ms(300);   // 全亮
    P2 = 0xFF;  delay_ms(300);   // 全灭
}

③ 左右来回（跑马灯）

unsigned char i;
while (1)
{
    for (i = 0; i < 8; i++) { P2 = ~(1<<i); delay_ms(120); }  // 左到右
    for (i = 6; i > 0; i--) { P2 = ~(1<<i); delay_ms(120); }  // 右到左
}

8.3 逐行拆解：P2 = ~(1 << i)

i	1<<i	~ 之后	亮的 LED
0	0x01	0xFE	D1
1	0x02	0xFD	D2
2	0x04	0xFB	D3
3	0x08	0xF7	D4
7	0x80	0x7F	D8

8.4 易错点

8.5 练习

1. 写一个「4 个亮 4 个灭」的效果（P2 = 0x0F）。
2. 写一个「从两边向中间合拢」的效果。
3. 让流水灯的速度从慢到快（延时可变的循环）。

📖 参考答案（点击展开）

1. 让低 4 位亮：P2 = 0xF0;（D1~D4 亮、D5~D8 灭）。
2. unsigned char a[8]={0x7E,0xBD,0xDB,0xE7,0xE7,0xDB,0xBD,0x7E}; 循环送即可（每次两侧各灭一个）。
3. for(d=50; d<500; d+=50) { P2=~(1<<i); delay_ms(d); } —— 延时参数递增，速度就越来越慢（想变快就递减）。

9.1 有源蜂鸣器 vs 无源蜂鸣器

类型	内部	控制方式	现象
有源	自带振荡电路	给低电平就响	只能一种音调
无源	只有一个发声片	必须给方波	频率变，音调就变

普中板上是无源蜂鸣器（BEEP = P2.5），所以要用方波驱动。

9.2 为什么方波能让它响

无源蜂鸣器内部是一个压电陶瓷片。给它一个方波，它就会跟着方波的频率振动 —— 频率决定音调，占空比影响音色。

#include "reg52.h"

sbit BEEP = P2^5;

void delay_10us(unsigned int ten_us)
{
    while (ten_us--);          // ten_us = 1 时约 10us
}

void main()
{
    unsigned int i = 2000;
    while (1)
    {
        while (i--)            // 循环 2000 次
        {
            BEEP = !BEEP;      // 翻转，产生方波
            delay_10us(100);   // 每半个周期约 1ms
        }
        i = 0;
        BEEP = 0;              // 关掉（防止一直通电发热）
    }
}

9.3 频率怎么算

半个周期 = delay_10us(100) ≈ 1 ms，所以：

一个完整周期 = 2 ms  →  频率 = 1 / 0.002 s = 500 Hz

delay 参数	半周期	频率	听感
50	0.5 ms	1000 Hz	较尖
100	1 ms	500 Hz	中等
200	2 ms	250 Hz	低沉

9.4 易错点

9.5 练习

1. 让蜂鸣器发出 1 kHz 的声音。
2. 做「响 0.5 秒、停 0.5 秒」的报警声。
3. （进阶）用数组存三个音阶的参数，循环播放「do re mi」。

📖 参考答案（点击展开）

1. 1kHz → 周期 1ms → 半周期 0.5ms。用 delay_10us(50)（约 0.5ms）。
2. while(1){ for(i=0;i<25;i++){BEEP=!BEEP; delay_10us(100);} BEEP=0; delay_ms(500); }　（25 × 2ms = 50ms 响，然后停 500ms；按需调整）
3. do(262Hz) 半周期 1.9ms → 参数约 190；re(294Hz) → 170；mi(330Hz) → 151。把这三个数放进数组循环。

10.1 数码管是怎么显示数字的

一个数码管就是 8 个 LED 排成「日」字形：a～g 七段 + dp 小数点。
点亮不同的段，就能拼出不同的数字 —— 本质和你在数电课学的「译码器」是一回事。

10.2 段码怎么来的

把 8 个段看成一个字节的 8 位：

位:   dp  g  f  e  d  c  b  a
      7   6  5  4  3  2  1  0

要显示「0」，需要 a b c d e f 亮、g 灭：

a b c d e f 亮 → 0011 1111 → 0x3F

要显示「1」，只需要 b c 亮：

b c 亮 → 0000 0110 → 0x06

普中代码里的段码表就是这么一个数组（共阴）：

unsigned char code gsmg_code[16] = {
    0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
    0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71
};   // 对应 0 1 2 3 4 5 6 7 8 9 A B C D E F

10.3 静态显示：一位数码管

#include "reg52.h"

#define SMG_A_DP_PORT  P0        // 段码口接 P0

unsigned char code gsmg_code[16] = {
    0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,
    0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71
};

sbit LSA = P2^2;                 // 位选，74HC138 的三根地址线
sbit LSB = P2^3;
sbit LSC = P2^4;

void main()
{
    LSA = 0; LSB = 0; LSC = 0;   // 选中第 1 位
    SMG_A_DP_PORT = gsmg_code[0];// 显示 "0"
    while (1);
}

逐行拆解

代码	作用
#define SMG_A_DP_PORT P0	以后写 SMG_A_DP_PORT 就是写 P0，方便移植
code	把数组放 Flash，省 RAM
LSA/LSB/LSC = 0	74HC138 输入 000 → 输出 Y0 有效 → 第 1 位数码管通电
P0 = 0x3F	8 个段输出对应电平 → 显示「0」

10.4 为什么用 74HC138 而不是直接 8 根线

8 位数码管如果每位一根使能线，要 8 根 I/O。用 74HC138（3-8 译码器）只需要 3 根：

LSC LSB LSA	选中	LSC LSB LSA	选中
0 0 0	第 1 位	1 0 0	第 5 位
0 0 1	第 2 位	1 0 1	第 6 位
0 1 0	第 3 位	1 1 0	第 7 位
0 1 1	第 4 位	1 1 1	第 8 位

10.5 易错点

10.6 练习

1. 让第 1 位数码管显示 8。
2. 让第 8 位数码管显示 F。
3. 轮流显示 0～9，每秒变一次。
4. 算出显示「7」的段码（只亮 a b c）。

📖 参考答案（点击展开）

1. 第 1 位：LSA=LSB=LSC=0；段码 0x7F（全亮）。
2. 第 8 位：LSC=1; LSB=1; LSA=1;；段码 F = 0x71。
3. for(i=0;i<10;i++){ P0=gsmg_code[i]; delay_ms(1000); }
4. 只亮 a b c → 位 0,1,2 置 1 → 0b00000111 = 0x07。

11.1 8 位数码管只有一套段码线，怎么办？

8 位数码管的 a～g 段是并联在 P0 上的，只有位选（74HC138）不同。所以：

同一时刻，只能让一位亮 —— 否则 8 位会显示同样的数字

解决办法是动态扫描：快速轮流点亮每一位，每位移一次就换成那一位该显示的数字。

11.2 视觉暂留：为什么看起来是同时亮的

人眼有 0.05～0.2 秒的视觉暂留。只要每位每秒刷新超过 50 次，看起来就是稳定不闪的。

8 位扫描一遍	刷新率	效果
每位 1 ms	125 Hz	很稳
每位 2 ms	62.5 Hz	稳定（普中常用）
每位 5 ms	25 Hz	轻微闪烁
每位 10 ms	12.5 Hz	明显闪

11.3 完整代码

#include "reg52.h"

#define SMG_A_DP_PORT  P0
sbit LSA = P2^2;
sbit LSB = P2^3;
sbit LSC = P2^4;

unsigned char code gsmg_code[16] = {
    0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,
    0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71
};

void delay_10us(unsigned int ten_us)
{
    while (ten_us--);
}

void smg_display(void)
{
    unsigned char i;
    for (i = 0; i < 8; i++)
    {
        switch (i)                       // 选位
        {
            case 0: LSC=0; LSB=0; LSA=0; break;
            case 1: LSC=0; LSB=0; LSA=1; break;
            case 2: LSC=0; LSB=1; LSA=0; break;
            case 3: LSC=0; LSB=1; LSA=1; break;
            case 4: LSC=1; LSB=0; LSA=0; break;
            case 5: LSC=1; LSB=0; LSA=1; break;
            case 6: LSC=1; LSB=1; LSA=0; break;
            case 7: LSC=1; LSB=1; LSA=1; break;
        }
        SMG_A_DP_PORT = gsmg_code[i];    // 送段码
        delay_10us(100);                 // 亮约 1ms
        SMG_A_DP_PORT = 0x00;            // ★ 消影
    }
}

void main()
{
    while (1)
    {
        smg_display();
    }
}

11.4 ★ 消影：这一步为什么不能省

看代码里 SMG_A_DP_PORT = 0x00; 那一行。它的作用是在切换位之前先把段码清掉。

加了消影之后，切换瞬间 P0 = 0x00（全灭），再换位，再送新段码 —— 干净了。

11.5 扫描速度与亮度

delay 参数	每位亮的时间	亮度
50	0.5 ms	较暗但刷新快
100	1 ms	适中（推荐）
200	2 ms	较亮，接近临界闪烁

11.6 易错点

11.7 练习

1. 让 8 位数码管显示「01234567」。
2. 让显示内容每秒整体左移一位（滚动效果）。
3. 把消影那行注释掉，观察重影现象，再改回来。

📖 参考答案（点击展开）

1. 用一个数组存 0-7：unsigned char t[8]={0,1,2,3,4,5,6,7};，扫描时 P0=gsmg_code[t[i]];。
2. 每秒把数组整体左移：tmp=t[0]; for(i=0;i<7;i++) t[i]=t[i+1]; t[7]=tmp;
3. 会看到每一位都带着淡淡的前一位数字（重影）。原因是切换位时 P0 还是上一个段码，新位把它显示出来了。

12.1 按键接在哪个口

普中板 4 个独立按键：

按键	引脚	按下时
K1	P3.1	读到 0
K2	P3.0	读到 0
K3	P3.2	读到 0
K4	P3.3	读到 0

12.2 为什么必须消抖

机械按键在闭合和断开的瞬间会有 5～20 ms 的抖动。单片机一个循环只要几微秒，会把这串抖动读成「按了十几次」。

12.3 软件消抖的三步

unsigned char key_scan(void)
{
    static unsigned char key_up = 1;   // 松手标志

    if (key_up && (KEY1 == 0 || KEY2 == 0 || KEY3 == 0 || KEY4 == 0))
    {
        delay_10us(1000);              // ① 等 10ms，躲开抖动
        key_up = 0;                    // ② 标记「已经按下」
        if (KEY1 == 0) return 1;
        else if (KEY2 == 0) return 2;
        else if (KEY3 == 0) return 3;
        else if (KEY4 == 0) return 4;
    }
    else if (KEY1 == 1 && KEY2 == 1 && KEY3 == 1 && KEY4 == 1)
    {
        key_up = 1;                    // ③ 松手了，恢复
    }
    return 0;
}

逐行拆解

关键点	为什么
static	函数返回后值不丢，下次进来还记得「上次是否按下」
key_up && (...)	只有「上次是松开的」才处理 → 按住不放只触发一次
delay_10us(1000)	10 ms，比抖动时间长，抖完再读就稳定了
key_up = 0	立刻标记，防止 10ms 后被重复触发
最后 else if 全 1	四个都松开了，才允许下一次触发

12.4 两种模式：单次触发 vs 连续触发

模式	行为	适用场景
单次（mode=0）	按住不放只算一次	切换开关、菜单选择
连续（mode=1）	按住会一直触发	音量加减、连续调参

实现方法就是开头加一句 if (mode) key_up = 1; —— 强制让标志永远是「松开」，于是每次都触发。

12.5 易错点

12.6 练习

1. 按 K1 点亮 D1，再按一次熄灭（用状态翻转）。
2. 按 K1～K4 分别点亮 D1～D4。
3. 把消抖延时改成 1 ms，看会不会误触发。
4. （进阶）实现「按 K1 流水灯开始，按 K2 停止」。

📖 参考答案（点击展开）

1. 用 static bit flag=0;：if(key==1){ flag=!flag; LED1=flag; }
2. if(key==1)LED1=0; if(key==2)LED2=0; if(key==3)LED3=0; if(key==4)LED4=0;
3. 1ms 比抖动时间（5~20ms）短，会误触发——按一下可能翻好几次。所以消抖至少 10ms。
4. 加一个 run 标志：K1 时置 1，K2 时清 0；主循环里 if(run){流水灯推进}。

13.1 为什么要矩阵按键

要 16 个按键，独立按键要 16 根 I/O。用 4 行 × 4 列 矩阵，只要 8 根。

普中板矩阵按键接在 P1 口：

行: P1.7  P1.6  P1.5  P1.4
列: P1.3  P1.2  P1.1  P1.0

13.2 原理：一行一行地「扫」

把某一列拉低、其余列拉高，然后读行。如果某一行是低，说明「这一行 × 这一列」的那个键被按下了。

第1列拉低: P1 = 0xF7  → 读 P1
  P1 = 0x77 → 第1行第1列 → 键值 1
  P1 = 0xB7 → 第2行第1列 → 键值 5
  P1 = 0xD7 → 第3行第1列 → 键值 9
  P1 = 0xE7 → 第4行第1列 → 键值 13

为什么键值是 1、5、9、13？因为板子把 16 个键按 列优先 编号：第一列从上到下是 1、5、9、13，第二列是 2、6、10、14 ……

13.3 列扫描代码（简化版）

unsigned char key_matrix_scan(void)
{
    unsigned char key_value = 0;

    P1 = 0xF7;                       // 第 1 列拉低
    if (P1 != 0xF7)                  // 有键按下
    {
        delay_10us(1000);            // 消抖
        if (P1 != 0xF7)
        {
            switch (P1)
            {
                case 0x77: key_value = 1;  break;
                case 0xB7: key_value = 5;  break;
                case 0xD7: key_value = 9;  break;
                case 0xE7: key_value = 13; break;
            }
            while (P1 != 0xF7);      // 等松手
        }
    }
    /* 第 2/3/4 列同理，0xFB / 0xFD / 0xFE */
    return key_value;
}

13.4 更聪明的「翻转法」

列扫描要写 4 段几乎一样的代码。翻转法只要两段：

① 先给所有行低、列高：P1 = 0x0F
   读 P1 的低 4 位 → 知道「按在哪一列」

② 再给所有列低、行高：P1 = 0xF0
   读 P1 的高 4 位 → 知道「按在哪一行」

③ 行号 × 4 + 列号 → 键值

第一步读到	列	第二步读到	行
0x07	1	0x70	1
0x0B	2	0xB0	2
0x0D	3	0xD0	3
0x0E	4	0xE0	4

13.5 易错点

13.6 练习

1. 按下矩阵按键，把键值显示在数码管第 1 位（键值 10 以上显示 A-F）。
2. 用翻转法重写一遍，对比代码长度。
3. 做成「按一个键，数码管显示它的键值」的完整程序。

📖 参考答案（点击展开）

1. 扫描到键值 k 后：P0 = gsmg_code[k-1];（k=1..16 → 下标 0..15，正好对应 0-F）。
2. 列扫描要写 4 段几乎相同的代码（约 60 行）；翻转法只要两段（约 25 行），代码短一半且不易写错。
3. 把 key_matrix_flip_scan() 的返回值送数码管：注意键值 1-16 要减 1 才是数组下标。

14.1 三根线变八根线

74HC595 是一个 8 位串入并出移位寄存器。你用 3 根 I/O 线，就能控制 8 个输出。

引脚	接哪	作用
SER (DS)	P3.4	串行数据输入，一位一位送
SRCLK (SHCP)	P3.6	移位时钟，上升沿移一位
RCLK (STCP)	P3.5	锁存时钟，上升沿把 8 位一起送到输出

14.2 时序：两个时钟分工不同

14.3 代码

#include "reg52.h"

sbit SRCLK = P3^6;      // 移位时钟
sbit RCLK  = P3^5;      // 锁存时钟
sbit SER   = P3^4;      // 串行数据

void hc595_write_data(unsigned char dat)
{
    unsigned char i;
    for (i = 0; i < 8; i++)          // 送 8 位
    {
        SER = dat & 0x80;            // 取最高位
        dat <<= 1;                   // 左移一位
        SRCLK = 0;                   // 时钟拉低
        SRCLK = 1;                   // 上升沿 → 移入
    }
    RCLK = 0;
    RCLK = 1;                        // 上升沿 → 8 位一起输出
}

逐行拆解

代码	作用
dat & 0x80	取出最高位。结果只可能是 0x80 或 0x00
dat <<= 1	左移，把下一位挪到最高位，为下次取做准备
SRCLK=0; SRCLK=1;	造一个上升沿，595 在上升沿采样 SER
循环 8 次	8 位全部送完
RCLK=0; RCLK=1;	最后一个上升沿，把 8 位搬到输出端

14.4 级联：16 位、24 位

把第一片的 Q7' 接到第二片的 SER，就能级联。软件上就是连续调用两次 hc595_write_data，最后再统一 RCLK。

14.5 易错点

14.6 练习

1. 用 595 驱动 8 个 LED 做流水灯。
2. 送 0x01、0x02、0x04 … 观察哪个 LED 亮，验证位序。
3. 把 RCLK 那两行删掉，看现象，再改回来。

📖 参考答案（点击展开）

1. 循环送 hc595_write_data(1<<i)，i=0..7。
2. 该位为 1 的 LED 亮。0x01 → 只有 D1 亮，说明先送的高位最后落在 Q7，位序是对的。
3. 数据进了移位寄存器但输出端不变 —— 8 个 LED 全不亮（或保持上次状态）。这就是「两个时钟分工不同」的实证。

15.1 点阵的结构：行列交叉

8×8 LED 点阵里有 64 个 LED，但它们只引出 16 根线：8 行 + 8 列。

某个 LED 亮  ⇔  它的「行」和「列」同时有效

普中板的接法：

线	接哪	作用
行（阳极）	74HC595 输出	决定哪一行通电
列（阴极）	P0 口	决定这一行里哪几列亮

15.2 扫描：一行一行地亮

for (i = 0; i < 8; i++)
{
    hc595_write_data(0x01 << i);   // 选中第 i 行
    P0 = 字模[i];                   // 送这一行的列数据
    delay_10us(100);                // 亮 1ms
    P0 = 0xFF;                      // 消影
}

和动态数码管一个道理：8 行轮流亮，每行亮 1 ms，一帧 8 ms → 刷新率 125 Hz，看起来就是一幅稳定的图。

15.3 字模是怎么来的

把一幅 8×8 的图，逐行写成 8 个字节。1 = 亮，0 = 灭。

心形图案：
. . X X X X . .     → 0x3C
. X X X X X X .     → 0x7E
X X X X X X X X     → 0xFF
X X X X X X X X     → 0xFF
. X X X X X X .     → 0x7E
. . X X X X . .     → 0x3C
. . . X X . . .     → 0x18
. . . . . . . .     → 0x00

15.4 易错点

15.5 练习

1. 显示一个「笑脸」字模（自己画格子写出来）。
2. 让显示的字模逐行向下滚动。
3. 显示「1」这个数字的点阵字模。

📖 参考答案（点击展开）

1. 笑脸字模示例：{0x3C,0x42,0xA5,0x81,0xA5,0x99,0x42,0x3C}
2. 把字模数组当成队列，每次循环整体下移一行（最后一个移到第一个），延时后重画。
3. 数字「1」：{0x00,0x00,0x18,0x38,0x18,0x18,0x7E,0x00}

16.1 为什么电机不能直接接单片机

直流电机启动电流可达几百 mA，而单片机一个引脚最多 20 mA。直接接会烧引脚。

普中板用三极管（或驱动芯片）做「开关」：

单片机 P1.0 ── 基极电阻 ── 三极管基极
                           集电极 ── 电机 ── VCC
                           发射极 ── GND

P1.0	三极管	电机
1	饱和导通	转
0	截止	停

16.2 最简单：开 5 秒停 5 秒

#include "reg52.h"

sbit DC_Motor = P1^0;

#define DC_MOTOR_RUN_TIME  5000     // 运行 5000ms

void delay_ms(unsigned int ms)
{
    unsigned int i, j;
    for (i = ms; i > 0; i--)
        for (j = 110; j > 0; j--);
}

void main()
{
    while (1)
    {
        DC_Motor = 1;              // 转
        delay_ms(DC_MOTOR_RUN_TIME);
        DC_Motor = 0;              // 停
        delay_ms(DC_MOTOR_RUN_TIME);
    }
}

16.3 调速：PWM 是什么

直流电机的转速和平均电压成正比。用「快速开关」来调平均电压，就是 PWM（脉宽调制）。

占空比 = 高电平时间 / 周期

占空比 100% → 全速
占空比 50%  → 半速
占空比 10%  → 很慢

周期	占空比	平均电压	转速
1 ms	100%	5 V	满速
1 ms	50%	2.5 V	约半速
1 ms	20%	1 V	很慢

16.4 易错点

16.5 练习

1. 让电机转 2 秒、停 1 秒，循环。
2. 用按键控制电机的启停。
3. （进阶）用定时器做一个 1 kHz 的 PWM，占空比 30%。

📖 参考答案（点击展开）

1. DC_Motor=1; delay_ms(2000); DC_Motor=0; delay_ms(1000); 放在 while(1) 里。
2. 主循环里查按键：按下则翻转一个 run 标志，DC_Motor = run;
3. 1kHz → 周期 1ms。用定时器每 10μs 中断一次、100 次一周期：if(cnt<30) PWM=1; else PWM=0;（30% 占空比）。初值 = 65536 − 9 ≈ 0xFFF7。

17.1 步进电机和直流电机的区别

	直流电机	步进电机
控制	给电就转	给一个脉冲转一步
定位	不能定位	可以精确控制角度
用途	风扇、玩具车	3D 打印机、云台、机械臂

17.2 28BYJ-48 的结构

四相五线：4 个线圈（A/B/C/D）+ 1 根公共端。给哪个线圈通电，转子就转向哪里。

参数	值
步距角	5.625° / 64（内部减速比）
转一圈	64 × 64 = 4096 步（八拍时）
接线	IN1~IN4 → P1.0 ~ P1.3

17.3 八拍相序

拍	通电相	P1 的值
1	A	0x08
2	AB	0x0C
3	B	0x04
4	BC	0x06
5	C	0x02
6	CD	0x03
7	D	0x01
8	DA	0x09

unsigned char code FFW[8] = {0x08,0x0C,0x04,0x06,0x02,0x03,0x01,0x09};

17.4 完整代码骨架

#include "reg52.h"

sbit IN1_A = P1^0;
sbit IN2_B = P1^1;
sbit IN3_C = P1^2;
sbit IN4_D = P1^3;

unsigned char code FFW[8] = {0x08,0x0C,0x04,0x06,0x02,0x03,0x01,0x09};
unsigned char code REV[8] = {0x09,0x01,0x03,0x02,0x06,0x04,0x0C,0x08};

void delay_ms(unsigned int ms)
{
    unsigned int i, j;
    for (i = ms; i > 0; i--)
        for (j = 110; j > 0; j--);
}

void step_motor_send_pulse(unsigned char step, unsigned char dir)
{
    if (dir == 0)  P1 = FFW[step];       // 正转
    else           P1 = REV[step];       // 反转
    delay_ms(2);                         // 每拍间隔，决定转速
}

void main()
{
    unsigned char i = 0;
    while (1)
    {
        for (i = 0; i < 8; i++)
            step_motor_send_pulse(i, 0);       // 正转
    }
}

17.5 转速怎么算

每拍间隔 2ms → 8 拍一轮 = 16ms
4096 步 / 8 拍 = 512 轮
转一圈时间 = 512 × 16ms = 8.2 秒
转速 = 60 / 8.2 ≈ 7.3 转/分

每拍间隔	转一圈	转速
2 ms	8.2 s	7.3 rpm
5 ms	20.5 s	2.9 rpm
1 ms	4.1 s	14.6 rpm

17.6 易错点

17.7 练习

1. 让电机正转一圈，停 1 秒，再反转一圈。
2. 按键 K1 加速、K2 减速（改变 delay 参数）。
3. 算出「每拍 3 ms 时转一圈要多久」。

📖 参考答案（点击展开）

1. 正转一圈：for(n=0;n<512;n++) for(i=0;i<8;i++) step_motor_send_pulse(i,0);　（512 轮 × 8 拍 = 4096 步）
2. 把 delay 参数做成变量 spd，K1 时减小（加速）、K2 时增大（减速），范围限制在 1~5ms。
3. 8 拍 × 3ms = 24ms/轮；512 轮 → 12.29 秒转一圈。

18.1 中断解决了什么问题

假设你的程序在跑流水灯，同时要检测按键。不用中断，你只能：

while (1) { 跑一步流水灯(); 查一下按键(); // ← 不停地问「按了没」 }

这就是查询方式。它的毛病是：跑灯和查键被绑死，灯慢下来按键就迟钝。

中断换了个思路：平时专心跑灯，按键按下时硬件主动打断你，处理完再回来。

18.2 一次中断的完整过程

18.3 51 的 5 个中断源

中断号	中断源	触发条件	标志位	入口地址
0	外部中断 0（INT0，P3.2）	引脚下降沿/低电平	IE0	0003H
1	定时器 0	T0 溢出	TF0	000BH
2	外部中断 1（INT1，P3.3）	引脚下降沿/低电平	IE1	0013H
3	定时器 1	T1 溢出	TF1	001BH
4	串口	收到/发完一个字节	RI / TI	0023H

18.4 三个必须开的开关

中断默认是关着的，要一层层打开：

寄存器位	作用	写法
EA（总开关）	所有中断的总闸	EA = 1;
EX0 / ET0 …（分开关）	某一个中断的允许	EX0 = 1; 或 ET0 = 1;
IT0 / IT1（触发方式）	外部中断用边沿还是电平	IT0 = 1;（下降沿）

18.5 中断优先级

51 有两级优先级（高/低），由 IP 寄存器控制。同级中断按自然优先级排队：

INT0 > T0 > INT1 > T1 > 串口

（注意：这个顺序是硬件固定的，和中断号不完全一样 —— 中断号是入口地址顺序。）

高优先级中断可以打断低优先级中断（中断嵌套）；同级不能互相打断。

18.6 易错点

18.7 练习

1. 默写 5 个中断源的中断号和入口地址。
2. 说出「只开 EA 不开 EX0」会怎样。
3. 为什么中断函数要尽量短？

📖 参考答案（点击展开）

1. INT0=0(0003H)、T0=1(000BH)、INT1=2(0013H)、T1=3(001BH)、串口=4(0023H)。
2. 总开关开了但没有分开关，等于这个中断源的请求被屏蔽，中断永远不会进入。必须 EA=1; EX0=1; 两个都开。
3. 因为中断是「插队」。ISR 执行期间主程序停摆，太长会导致响应变慢、其他中断被延迟甚至丢失（同级不能嵌套）。

19.1 外部中断接在哪

	引脚	板上按键	中断号	控制位
INT0	P3.2	K3	0	IT0 / EX0 / IE0
INT1	P3.3	K4	2	IT1 / EX1 / IE1

19.2 两种触发方式

IT0	方式	什么时候触发	适合
0	低电平触发	引脚一直是低就一直触发	外部芯片给的电平信号
1	下降沿触发	只在「1 → 0」那一瞬间触发一次	按键（推荐）

19.3 完整代码：按键中断翻转 LED

#include "reg52.h"

sbit LED1 = P2^0;
sbit KEY3 = P3^2;              // INT0 引脚

void delay_10us(unsigned int ten_us)
{
    while (ten_us--);
}

void exti0_init(void)
{
    IT0 = 1;                   // ① 下降沿触发
    EX0 = 1;                   // ② 允许 INT0 中断
    EA  = 1;                   // ③ 打开总中断
}

void main()
{
    exti0_init();
    while (1)
    {
        /* 主程序可以干别的事，按键来了会被打断 */
    }
}

void exti0() interrupt 0       // ④ 中断服务函数，中断号 0
{
    delay_10us(1000);          // 消抖 10ms
    if (KEY3 == 0)             // 再确认真的按下了
    {
        LED1 = !LED1;          // 翻转 LED
    }
}

逐行拆解

代码	为什么
IT0 = 1	不用边沿触发的话，按住会反复进中断
EX0 = 1; EA = 1	两级开关，缺一不进
interrupt 0	告诉编译器把这个函数放到 0003H 去
delay_10us(1000)	ISR 里也要消抖（中断是硬件触发的，抖动会触发多次）
if (KEY3 == 0)	双重确认，防止抖动误触发

19.4 中断 vs 查询，怎么选

	查询（轮询）	中断
CPU 占用	一直问，浪费	平时不占，来了才处理
响应速度	取决于循环周期	快（微秒级）
代码	简单直观	要多配寄存器
适合	少量、不紧急	实时、突发

19.5 易错点

19.6 练习

1. 用 INT1（K4）实现同样的功能。
2. 改成「按一下亮，再按一下灭」（现在的 !LED1 就是）。
3. 如果把 IT0=1 改成 IT0=0，按住按键观察现象。

📖 参考答案（点击展开）

1. 把 IT0→IT1、EX0→EX1、KEY3→KEY4 改掉，中断函数写 interrupt 2（不是 1）。
2. 现在的 LED1 = !LED1; 就是这个效果，无需改动。
3. 改成 IT0=0（低电平触发）后，按住不放会不停进中断，LED 疯狂翻转甚至卡死。这就是按键必须用下降沿的原因。

20.1 定时器是什么

定时器就是一个自动加 1 的计数器，数到溢出就置标志位（并可以产生中断）。

它数的不是秒，是机器周期：

1 个机器周期 = 12 / 晶振频率
11.0592 MHz → 12 / 11059200 = 1.0850694 μs

20.2 两个寄存器就够

寄存器	作用	常用值
TMOD	选定时器/计数器和方式	0x01（T0 方式 1） 0x20（T1 方式 2，串口用）
TCON	启动位 TR0/TR1、标志位 TF0/TF1	TR0 = 1 启动

TMOD 的 8 个位：

TMOD = 0x01
位:  GATE C/T  M1 M0 | GATE C/T  M1 M0
      └── 定时器1 ──┘  └── 定时器0 ──┘

M1 M0 = 00 → 方式0（13位）
M1 M0 = 01 → 方式1（16位）★ 最常用
M1 M0 = 10 → 方式2（8位自动重装）★ 串口用
M1 M0 = 11 → 方式3（拆分）

20.3 两种工作方式

20.4 ★ 初值怎么算（核心）

要定时的机器周期数 = 定时时间 / 1.0850694μs
初值 = 65536 - 机器周期数
TH0 = 初值 / 256      TL0 = 初值 % 256

算例一：普中例程的「1ms」

TH0 = 0xFC, TL0 = 0x18  →  初值 = 0xFC18 = 64536
机器周期数 = 65536 - 64536 = 1000
实际定时 = 1000 × 1.0850694μs = 1.085 ms

算例二：真正精确的 1 ms

机器周期数 = 1000 μs / 1.0850694 μs = 921.6 → 取 922
初值 = 65536 - 922 = 64614 = 0xFC66
TH0 = 0xFC, TL0 = 0x66
实际 = 922 × 1.0850694 = 1.0004 ms  （误差 0.04%）

算例三：50 ms（最常用的值）

机器周期数 = 50000 / 1.0850694 = 46080
初值 = 65536 - 46080 = 19456 = 0x4C00
TH0 = 0x4C, TL0 = 0x00
实际 = 46080 × 1.0850694 = 50.000 ms  ✓ 几乎完美

20.5 完整代码：1 秒闪灯（50ms × 20 次）

#include "reg52.h"

sbit LED1 = P2^0;

void time0_init(void)
{
    TMOD |= 0x01;              // T0 方式 1（16 位）
    TH0 = 0x4C;                // 50ms 初值
    TL0 = 0x00;
    ET0 = 1;                   // 允许 T0 中断
    EA  = 1;                   // 总中断
    TR0 = 1;                   // 启动定时器
}

void main()
{
    time0_init();
    while (1);
}

void time0() interrupt 1       // 中断号 1
{
    static unsigned char cnt = 0;

    TH0 = 0x4C;                // ★ 方式 1 必须重装初值
    TL0 = 0x00;

    cnt++;
    if (cnt >= 20)             // 20 × 50ms = 1000ms
    {
        cnt = 0;
        LED1 = !LED1;          // 每 1 秒翻转一次
    }
}

为什么中断里要重装初值

方式 1 是 16 位计数器，溢出后从 0 开始，不是从初值开始。所以每次中断都要重新写 TH0/TL0 —— 否则下次就是 65536 个周期（71 ms）。

20.6 用定时器代替 delay 的好处

	delay_ms() 空循环	定时器中断
精度	差（受优化影响）	准（晶振决定）
CPU 占用	100% 死等	几乎不占
同时干别的	不行	可以

20.7 易错点

20.8 练习

1. 用 50 ms 定时器做一个「1 秒闪灯」。
2. 改成 0.5 秒闪灯（cnt 阈值改成 10）。
3. 算一下：定时 20 ms，初值是多少？（提示：20000/1.0850694 ≈ 18432，初值 0xB800）
4. 用定时器在数码管上做一个秒表（00～99）。

📖 参考答案（点击展开）

1. 50ms 初值 0x4C00，20 次到 1 秒：if(++cnt>=20){cnt=0; LED1=!LED1;}
2. 把 cnt>=20 改成 cnt>=10（10 × 50ms = 500ms）。
3. 20ms 需要 20000/1.0850694 = 18432 个计数；初值 = 65536 − 18432 = 47104 = 0xB800（TH0=0xB8, TL0=0x00）。
4. 两位秒表：一个变量 sec，每 1 秒 +1，到 99 归零；用两位扫描显示 gsmg_code[sec/10] 和 gsmg_code[sec%10]。

21.1 串口是什么

串口把 8 位数据一位一位地在一根线上发出去。51 有一个全双工串口（能同时收发）。

引脚	作用
P3.0 (RXD)	接收
P3.1 (TXD)	发送

21.2 一帧数据长什么样

21.3 四个寄存器

寄存器	作用	典型值
SCON	串口工作方式	0x50（方式 1，允许接收）
PCON	波特率加倍位 SMOD	0x80（SMOD=1）
TMOD	T1 用方式 2 产生波特率	0x20
SBUF	数据缓冲（读=收，写=发）	—

21.4 ★ 波特率怎么算

方式 1 波特率 = (2^SMOD / 32) × (晶振 / (12 × (256 - TH1)))

反推：TH1 = 256 - 晶振 / (12 × 16 × 波特率)     （SMOD=1 时）

11.0592 MHz、SMOD=1 时：

TH1 = 256 - 11059200 / (192 × 9600) = 256 - 6 = 250 = 0xFA

常用波特率对照表（11.0592 MHz，SMOD=1）：

波特率	TH1	每位时间	一帧 10 位
1200	0xD0 (208)	833 μs	8.33 ms
2400	0xE8 (232)	417 μs	4.17 ms
4800	0xF4 (244)	208 μs	2.08 ms
9600	0xFA (250)	104 μs	1.04 ms
19200	0xFD (253)	52 μs	0.52 ms

21.5 完整代码：发一个字节

#include "reg52.h"

void uart_init(unsigned char baud)
{
    TMOD |= 0x20;              // T1 方式 2（8 位自动重装）
    SCON  = 0x50;              // 方式 1，允许接收
    PCON  = 0x80;              // SMOD = 1，波特率加倍
    TH1   = baud;              // 重装值
    TL1   = baud;
    TR1   = 1;                 // 启动 T1
}

void uart_send_byte(unsigned char dat)
{
    SBUF = dat;                // 写 SBUF 就开始发送
    while (TI == 0);           // 等发完（TI 由硬件置 1）
    TI = 0;                    // ★ 必须手动清
}

void main()
{
    uart_init(0xFA);           // 9600 波特
    while (1)
    {
        uart_send_byte('A');
        /* 这里可以加延时，否则会刷屏 */
    }
}

逐行拆解

代码	为什么
TMOD |= 0x20	T1 方式 2；用 |= 不影响 T0 的设置
SCON = 0x50	0101 0000：方式 1 + REN=1（允许接收）
PCON = 0x80	SMOD=1，波特率翻倍
TH1 = TL1 = 0xFA	方式 2 下两个都要写（TL1 是当前值，TH1 是重装值）
TR1 = 1	启动 T1，波特率时钟才开始走
SBUF = dat	写 SBUF 触发发送，硬件自动一位位发出去
while (TI == 0)	TI 是发送完成标志，发完硬件置 1
TI = 0	硬件不会自动清，必须手动清

21.6 中断方式接收

void uart() interrupt 4
{
    unsigned char dat;

    if (RI == 1)               // 收到数据
    {
        dat = SBUF;
        RI = 0;                // ★ 手动清接收标志
        SBUF = dat;            // 原样回发（回显）
    }
    if (TI == 1)               // 发送完成
    {
        TI = 0;
    }
}

21.7 和电脑通信

1. 打开串口助手（普中下载软件里自带，或 SSCOM）。
2. 选 COM 口、波特率 9600、8 位数据、1 位停止、无校验。
3. 点「打开串口」。
4. 板子复位，应该能看到 'A' 刷屏。

21.8 易错点

21.9 练习

1. 让板子每秒发一次 "Hello"。
2. 改成 19200 波特，算出 TH1 应该是多少。
3. 实现「电脑发什么，板子回什么」（回显）。
4. （进阶）电脑发 '1' 点亮 LED，发 '0' 熄灭。

📖 参考答案（点击展开）

1. uart_send_byte('H'); 逐字符发 「Hello」，末尾加 delay_ms(1000) 否则会刷屏。
2. TH1 = 256 − 11059200/(192 × 19200) = 256 − 3 = 253 = 0xFD。
3. 在 interrupt 4 里：if(RI){ dat=SBUF; RI=0; SBUF=dat; while(!TI); TI=0; }
4. 收到后判断：if(dat=='1') LED1=0; if(dat=='0') LED1=1;

22.1 I2C 是什么

I2C 是两根线的总线，可以让多个芯片挂在同一条线上：

线	普中板	作用
SCL	P2.1	时钟，主机产生
SDA	P2.0	数据，双向

两根线都是开漏输出 + 上拉电阻。所以任何设备都能把它拉低，但没人能"强行拉高" —— 这就是多设备共享一根线还不短路的原因。

22.2 时序：全部规则就一句话

SCL 高电平期间，SDA 必须稳定 —— 变了就是起始/停止

22.3 四个基本动作

动作	时序
起始 S	SCL 高时，SDA 由 1 → 0
停止 P	SCL 高时，SDA 由 0 → 1
发一位	SCL 低时改 SDA，SCL 高时从机采样
应答 ACK	发完 8 位后，接收方把 SDA 拉低一个时钟

22.4 AT24C02：一颗 256 字节的"小硬盘"

参数	值
容量	2 Kbit = 256 字节
地址范围	0x00 ~ 0xFF（8 位地址）
器件地址	1010 A2 A1 A0 → 写 0xA0 / 读 0xA1
断电	数据不丢（EEPROM 特性）
寿命	约 100 万次写入

22.5 写一个字节的完整流程

起始 → 0xA0(写) → ACK → 字地址 → ACK → 数据 → ACK → 停止

void at24c02_write(unsigned char addr, unsigned char dat)
{
    iic_start();
    iic_write_byte(0xA0);      // 器件地址 + 写
    iic_wait_ack();
    iic_write_byte(addr);      // 字地址
    iic_wait_ack();
    iic_write_byte(dat);       // 数据
    iic_wait_ack();
    iic_stop();
    delay_10us(1000);          // ★ 等 10ms 让 EEPROM 内部写完
}

22.6 读一个字节

起始 → 0xA0(写) → ACK → 字地址 → ACK
     → 起始 → 0xA1(读) → ACK → 读数据 → NACK → 停止

最后那个 NACK 是主机发的，意思是"我只要一个字节，别发了"。

22.7 易错点

22.8 练习

1. 往地址 0x00 写 0x55，断电再上电读出来，验证掉电保存。
2. 连续写 8 个字节（页写），再连续读出来。
3. 做一个「开机次数计数器」：每次上电从 EEPROM 读、加 1、写回、显示。

📖 参考答案（点击展开）

1. 写 0x55 到 0x00，断电重上电再读。若还是 0x55，说明掉电保存成功（这就是 EEPROM 与 RAM 的区别）。
2. 页写：连续调用 write，地址递增。AT24C02 一页 8 字节，跨页要分开写，否则会回卷覆盖。
3. 上电流程：读 addr0 → 值 +1 → 写回 → 数码管显示。注意每次写完要延时 10ms。

23.1 单总线：一根线怎么传数据

DS18B20 只用一根线（DQ = P3.7），既传数据又供电（寄生供电）。

没有时钟线，怎么知道哪一位开始了？靠时间长短：

信号	怎么表示
写 0	拉低 ≥ 60 μs
写 1	拉低 1~15 μs 后立即释放
读	主机先拉低 1 μs，然后 15 μs 内采样

关键洞察：写 0 和写 1 的区别不是电平高低（都是先拉低），而是低电平持续多久。

23.2 复位 + 存在脉冲

主机拉低 750 μs  →  释放  →  从机拉低 60~240 μs（表示"我在"）

85 这个值是个信号：它正好是 DS18B20 上电默认值（+85°C），说明你根本没读到它，线没接好或时序不对。

23.3 三个命令就够

命令	含义
0xCC	SKIP ROM —— 总线上只有一个器件，跳过寻址
0x44	CONVERT T —— 开始测温（要等 750 ms）
0xBE	READ SCRATCHPAD —— 读出 9 个字节

复位 → 0xCC → 0x44        （启动转换）
复位 → 0xCC → 0xBE        （读结果）
读低字节 datl → 读高字节 dath

23.4 温度怎么算

原始值 = (dath << 8) | datl        （16 位有符号）
温度 = 原始值 × 0.0625  ℃

0.0625 从哪来？12 位分辨率下，最低位代表 1/16 = 0.0625 ℃。

原始值	温度
0x0191 (401)	401 × 0.0625 = 25.06 ℃
0x00C0 (192)	192 × 0.0625 = 12.00 ℃
0xFF38 (-200)	-200 × 0.0625 = -12.5 ℃（负数要按补码处理）

23.5 实验现象

数码管显示当前温度，格式如 25.06。用手指按一下传感器，数字会慢慢上升。

23.6 易错点

23.7 练习

1. 读出温度并用串口打印。
2. 算一下：原始值 0x02A8 是多少度？（提示：680 × 0.0625）
3. 显示保留一位小数（乘 10 取整再插小数点）。

📖 参考答案（点击展开）

1. 直接调 ds18b20_read_temp()，把结果拆分整数/小数用串口打印。
2. 0x02A8 = 680；680 × 0.0625 = 42.5 ℃。
3. 温度值 × 10 取整 → 如 425 → 显示 42.5：整数部分 425/10，小数部分 425%10。

24.1 DS1302 三根线

线	普中板	作用
RST	P3.5	片选（拉高才能通信）
CLK	P3.6	时钟
I/O	P3.4	数据（双向）

24.2 BCD 码：为什么时间要"多存一份"

DS1302 里的时间按 BCD 码存：一个字节的高 4 位存十位、低 4 位存个位。

十进制	二进制（普通）	BCD
25	0x19	0x25
59	0x3B	0x59
12	0x0C	0x12

好处是显示方便（一个字节直接对应两位数字），坏处是运算前要转换：

BCD → 十进制：  dec = (bcd >> 4) * 10 + (bcd & 0x0F);
十进制 → BCD：  bcd = (dec / 10 << 4) | (dec % 10);

24.3 寄存器地址

寄存器	读地址	写地址	范围
秒	0x81	0x80	00~59
分	0x83	0x82	00~59
时	0x85	0x84	00~23
日	0x87	0x86	01~31
月	0x89	0x88	01~12
星期	0x8B	0x8A	01~07
年	0x8D	0x8C	00~99

规律：写地址是偶数，读地址 = 写地址 + 1（最低位是读写标志）。

24.4 读写一个字节

void ds1302_write(unsigned char addr, unsigned char dat)
{
    unsigned char i;
    DS1302_RST = 0;            // 复位，准备开始
    DS1302_CLK = 0;
    DS1302_RST = 1;            // 拉高片选

    for (i = 0; i < 8; i++)     // 先送地址（低位先出）
    {
        DS1302_IO = addr & 0x01;
        addr >>= 1;
        DS1302_CLK = 1;
        DS1302_CLK = 0;
    }
    for (i = 0; i < 8; i++)     // 再送数据
    {
        DS1302_IO = dat & 0x01;
        dat >>= 1;
        DS1302_CLK = 1;
        DS1302_CLK = 0;
    }
    DS1302_RST = 0;            // 结束
}

24.5 易错点

24.6 练习

1. 把 25 分钟转换成 BCD 码（答案 0x25）。
2. 读出当前时间显示在数码管上（格式 HH.MM.SS）。
3. （进阶）用按键改成"调时模式"。

📖 参考答案（点击展开）

1. 25 → 十位 2、个位 5 → (2<<4)|5 = 0x25。
2. 读 0x81/0x83/0x85 三个寄存器（得到 BCD），转十进制后送数码管，用小数点分隔。
3. 加一个「设置模式」标志：正常显示时只读；进入设置后按 K1 选中字段、K2 加 1，写回寄存器。

25.1 红外遥控的基本原理

遥控器里有一颗红外 LED，按键时用 38 kHz 的脉冲快速开关它（人眼看不见）。接收头解调出这个 38 kHz，输出干净的 0/1 给单片机。

项目	说明
接收引脚	P3.2（同时也是 INT0）
协议	NEC（最常见）
载波	38 kHz

25.2 NEC 协议的时序

部分	时长	说明
引导码	9 ms 低 + 4.5 ms 高	一帧的开始
数据位 0	560 μs 低 + 560 μs 高	总长 1.12 ms
数据位 1	560 μs 低 + 1690 μs 高	总长 2.25 ms
结束位	560 μs 低	—

又是"靠时间长短区分"：0 和 1 的低电平都是 560 μs，区别在高电平持续多久。

25.3 一帧有 32 位

字节	内容
1	地址（用户码）
2	地址反码（用于校验）
3	按键值（命令）
4	命令反码

25.4 两种解码方式

方式	做法	优缺点
外部中断 + 定时器	下降沿进中断，用定时器量高电平宽度	准，但要配两个外设
纯轮询	主循环里死等电平变化，用 delay 计时	简单，但会占满 CPU

普中代码用的是轮询 + delay：等 9ms 低、等 4.5ms 高、然后逐位判断高电平有多长。

25.5 关键判断

if (高电平时间 > 1ms)  这一位是 1
else                    这一位是 0

因为 0 的高电平是 560 μs、1 的高电平是 1690 μs —— 用 1 ms 做分界正好。

25.6 易错点

25.7 练习

1. 按下遥控器的「1」，串口打印出它的键值。
2. 用遥控器控制 LED 亮灭（不同键值对应不同灯）。
3. 算一下：一帧 32 位如果全是 1，总共要多久？（提示：9+4.5+32×2.25+0.56 ms）

📖 参考答案（点击展开）

1. 用串口打印 ired_data[2]（命令字节），记下「1」对应的值（常见如 0x45 或 0x0C，不同遥控器不同）。
2. switch(键值){ case 0x45: LED1=!LED1; break; ... }
3. 9 + 4.5 + 32×2.25 + 0.56 = 9 + 4.5 + 72 + 0.56 = 86.06 ms。这是最坏情况（32 位全 1），典型帧约 67.5ms。

26.1 ADC 在做什么

把连续变化的电压换成有限个数字。XPT2046 是 12 位 ADC，所以：

数字量范围 0 ~ 4095（2^12 - 1）
分辨率 = 5 V / 4096 = 1.22 mV

26.2 XPT2046 的接法（类 SPI）

引脚	普中板	作用
CS	P3.5	片选，低有效
CLK	P3.6	时钟
DIN	P3.4	主机 → 芯片（发命令）
DOUT	P3.7	芯片 → 主机（回数据）

26.3 读一次电压

unsigned int xpt2046_read_adc(unsigned char cmd)
{
    unsigned char i;
    unsigned int dat = 0;

    XPT2046_CS = 0;                    // 片选
    for (i = 0; i < 8; i++)            // 发 8 位命令
    {
        XPT2046_DIN = cmd & 0x80;
        cmd <<= 1;
        XPT2046_CLK = 0;
        XPT2046_CLK = 1;               // 上升沿移入
    }
    for (i = 0; i < 16; i++)           // 读 16 位（12 位有效）
    {
        dat <<= 1;
        XPT2046_CLK = 0;
        XPT2046_CLK = 1;
        if (XPT2046_DOUT) dat |= 0x01;
    }
    XPT2046_CS = 1;
    return dat >> 4;                  // 低 4 位是无效的
}

26.4 数字量 → 电压

电压 = 数字量 × 5.0 / 4096

数字量	电压
0	0 V
1024	1.25 V
2048	2.50 V
4095	4.9988 V（不是 5V！）

又一次遇到"最大值不是满量程" —— 和第 12 篇 A/D 那章一个道理：4096 个格子里最高只能走到第 4095 格。

26.5 实验现象

转动电位器，数码管上的电压值跟着变（0.00 ~ 4.99 V）。

26.6 易错点

26.7 练习

1. 读电位器电压显示成 0.00~4.99 两位小数。
2. 数字量 2048 时电压是多少？
3. （进阶）接光敏电阻，做一个「天黑自动亮灯」。

📖 参考答案（点击展开）

1. 读 AD → voltage = ad * 5000 / 4096;（单位 mV，用 unsigned int 防溢出）→ 显示 voltage/1000 和 (voltage%1000)/10。
2. 2048 × 5 / 4096 = 2.500 V。
3. 光敏电阻分压 → ADC 读值；设一个阈值，暗时（AD 大于阈值）点亮 LED。

27.1 51 没有 DAC，怎么办

51 单片机没有硬件 D/A 转换器。要用它输出模拟电压，只能靠 PWM + RC 滤波：

PWM 方波 → RC 低通滤波 → 平滑的直流电压

平均电压 = 高电平电压 × 占空比

27.2 PWM 是什么

占空比	平均电压
100%	5.00 V
75%	3.75 V
50%	2.50 V
20%	1.00 V
0%	0 V

27.3 用定时器产生 PWM

#include "reg52.h"

sbit PWM = P2^1;

unsigned char pwm_duty = 50;       // 占空比 50%

void time0_init(void)
{
    TMOD |= 0x01;
    TH0 = 0xFF;                    // 每 100μs 进一次中断
    TL0 = 0x9C;
    ET0 = 1;
    EA  = 1;
    TR0 = 1;
}

void main()
{
    time0_init();
    while (1);
}

void time0() interrupt 1
{
    static unsigned char cnt = 0;

    TH0 = 0xFF;                    // 重装
    TL0 = 0x9C;

    cnt++;
    if (cnt >= 100) cnt = 0;       // 100 次 = 一个周期
    if (cnt < pwm_duty) PWM = 1;   // 前 duty% 为高
    else                PWM = 0;   // 其余为低
}

27.4 ★ PWM 频率算一下

初值 0xFF9C = 65436 → 计数 = 100
每次中断 = 100 × 1.0850694 μs = 108.5 μs
一个周期 = 100 次中断 = 10.85 ms
频率 = 1 / 10.85 ms = 92 Hz

改进办法：减小每次中断的间隔（把计数从 100 改小），或者用更高的晶振。比如每次中断约 10 μs（计数 9）、100 次一周期 → 1.023 kHz。

每次中断	周期	PWM 频率	效果
108.5 μs	10.85 ms	92 Hz	差（有纹波）
10.85 μs	1.085 ms	922 Hz	可接受
9.77 μs（计数 9）	0.977 ms	1023 Hz	好

27.5 RC 滤波怎么选

截止频率 fc = 1 / (2πRC) 要远低于 PWM 频率

比如 PWM 1 kHz，取 fc = 100 Hz：R = 1kΩ, C = 1.6μF（1/(2π×1000×1.6e-6) ≈ 100 Hz）。

27.6 实验现象

PWM 引脚接一个 LED，能看出亮度变化（占空比 10% 暗、90% 亮）。用万用表量 RC 滤波后的电压，会看到 0~5V 连续变化。

27.7 易错点

27.8 练习

1. 让 LED 的亮度从暗到亮再到暗（呼吸灯）。
2. 把 PWM 频率改到 1 kHz，算出新的初值。
3. 占空比 30% 时，RC 滤波后的电压是多少？

📖 参考答案（点击展开）

1. 主循环里让 pwm_duty 从 0 增到 100 再减回 0，每步延时 20ms。
2. 1kHz → 周期 1ms → 100 次中断则每次 10μs → 计数 = 10/1.0850694 ≈ 9 → 初值 = 65536−9 = 0xFFF7。
3. 占空比 30%：5V × 0.3 = 1.5 V。

28.1 LCD1602 是什么

16 列 × 2 行的字符液晶，每个字符用 5×8 点阵拼出来。它自带字库，你只要送 ASCII 码就能显示。

引脚	普中板	作用
RS	P2.6	1 = 发数据，0 = 发命令
RW	P2.5	1 = 读，0 = 写
E	P2.7	使能，下降沿完成写入
D0~D7	P0	8 位数据

28.2 写时序

28.3 三个基本函数

void lcd1602_write_cmd(unsigned char cmd)   // 写命令
{
    LCD1602_RS = 0;        // 命令
    LCD1602_RW = 0;        // 写
    LCD1602_DATAPORT = cmd;
    LCD1602_E = 1;
    delay_10us(1);         // 保持 >450ns
    LCD1602_E = 0;
    delay_10us(1);         // 等 LCD 处理
}

void lcd1602_write_data(unsigned char dat)   // 写数据（显示一个字符）
{
    LCD1602_RS = 1;        // 数据
    LCD1602_RW = 0;
    LCD1602_DATAPORT = dat;
    LCD1602_E = 1;
    delay_10us(1);
    LCD1602_E = 0;
    delay_10us(1);
}

两个函数只差 RS 一位 —— 这就是为什么 RS 叫"数据/命令选择"。

28.4 初始化：必须按顺序发这几条

lcd1602_write_cmd(0x38);   // 8 位数据、2 行显示、5×7 点阵
lcd1602_write_cmd(0x0C);   // 开显示、关光标、不闪烁
lcd1602_write_cmd(0x06);   // 写入一个字符后地址自动 +1
lcd1602_write_cmd(0x01);   // 清屏（要延时 2ms 以上！）

命令	含义
0x38	0011 1000：DL=1（8 位）、N=1（2 行）、F=0（5×7）
0x0C	0000 1100：D=1 开显示、C=0 无光标、B=0 不闪
0x06	0000 0110：I/D=1 地址加、S=0 不移动画面
0x01	清屏，耗时约 1.5 ms

28.5 在哪显示：地址

第一行：0x00 ~ 0x0F
第二行：0x40 ~ 0x4F

lcd1602_write_cmd(0x80 | 0x00);   // 光标到第一行第 1 格
lcd1602_write_data('H');          // 显示 H

28.6 易错点

28.7 练习

1. 第一行显示 "Hello"，第二行显示 "51 MCU"。
2. 做一个 1 秒加 1 的计数器显示。
3. 把 0x0C 改成 0x0F，观察光标出现。

📖 参考答案（点击展开）

1. write_cmd(0x80|0x00); 逐字符写 「Hello」；write_cmd(0x80|0x40); 写 「51 MCU」。
2. 每秒 cnt++，用 sprintf 格式化后定位到第 1 行显示。
3. 0x0C = 开显示、无光标；0x0F = 开显示 + 有光标 + 闪烁。改成 0x0F 后能看到闪烁的方块光标。

29.1 12864 和 1602 的区别

	LCD1602	LCD12864
分辨率	16×2 字符	128×64 点
显示内容	只有 ASCII	图形 + 汉字（带字库）
控制	8 位并口	并口或串行
引脚	RS/RW/E/D0-D7	RS/WR/E/PSB + 数据

引脚	普中板
RS	P2.6
WR	P2.5
E	P2.7
PSB	P3.2（1=并口，0=串口）

29.2 串行模式为什么省线

PSB = 0 时进入串行模式，只用 3 根线传数据：

一个字节 = 起始位(1) + 高4位(低位先) + 0 + 低4位 + 0
           （每个"位"由 E 的脉冲送出）

代价是慢（要发 24 个时钟才传 1 个字节），好处是省 I/O —— 和 74HC595 的取舍正好相反。

29.3 显示汉字

带字库的 12864（ST7920 芯片）内置 GB2312 字库，直接发两个字节的区位码就能显示汉字：

// 汉字「中」的 GB2312 编码是 0xD6 0xD0 lcd12864_write_data(0xD6); lcd12864_write_data(0xD0);

29.4 基本操作命令

命令	作用
0x30	基本指令集
0x0C	开显示
0x01	清屏
0x80 + 地址	设置 DDRAM 地址（字符定位）

一行 8 个汉字 = 16 字节地址（0x80~0x8F 第一行，0x90~0x9F 第二行）。

29.5 易错点

29.6 练习

1. 第一行显示「你好世界」。
2. 查一下「单」字的 GB2312 编码是多少。
3. 把 PSB 改成 1（并口），对比接线数量和速度。

📖 参考答案（点击展开）

1. write_cmd(0x80); 然后依次写「你(0xC4 0xE3) 好(0xBA 0xC3) 世(0xCA 0xC0) 界(0xBD 0xE7)」的 GB2312 编码。
2. 「单」的 GB2312 编码是 0xB5 0xA5。
3. 串行只需 3 根线（RS/WR/E 复用），并口要 8 根数据线 + 3 根控制线。并口快约 8 倍，但多占 8 个 I/O。

30.1 TFT 彩屏和单色屏的区别

	LCD1602/12864	TFTLCD 彩屏
颜色	单色	16 位真彩（65536 色）
分辨率	很低	常见 240×320
接口	并口/串口	SPI 或 8080 并口
数据量	几十字节	一屏 = 240×320×2 = 150 KB

30.2 16 位颜色怎么表示

RGB565：  RRRRR GGGGGG BBBBB
          5 位   6 位   5 位

红色 0xF800   绿色 0x07E0   蓝色 0x001F
白色 0xFFFF   黑色 0x0000

30.3 显示一个字符的流程

1. 用取模软件（资料里的「文字-图片取模软件」）把字或图转成点阵数组
2. 用 code 关键字把数组存进 Flash
3. 设置显示窗口（起始/结束坐标）
4. 逐个送像素数据

void lcd_show_char(unsigned int x, unsigned int y, ...)
{
    lcd_set_window(x, y, x+16, y+16);   // 开窗
    for (i = 0; i < 512; i++)           // 16×16 个像素
    {
        写一个像素();
    }
}

30.4 为什么彩屏要用 SPI

8080 并口要 16~18 根线，SPI 只要 4~5 根。在 51 这种 I/O 紧张的单片机上，省线比速度更重要。

30.5 易错点

30.6 练习

1. 用取模软件取一个 16×16 汉字，显示出来。
2. 算出 240×320 的 16 位图要多少字节。
3. 画一个红色的矩形。

📖 参考答案（点击展开）

1. 取模软件选 16×16、阴码/逐行式、十六进制，生成 32 字节数组；用 code 关键字存 Flash 后逐点送。
2. 240 × 320 = 76800 个像素；16 位色 → 76800 × 2 = 153600 字节 = 150 KB。
3. 设窗口 → 循环送 0xF800（红色）若干次 → 关闭窗口。整个矩形要送 w×h 个像素。

31.1 电阻触摸屏的原理

触摸屏是两层透明导电膜（X 层和 Y 层）。按下时两层接触，通过测电压分压比算出坐标。

步骤	做法	读到
测 X	X 层两端加电压，Y 层当探针	Y 层的电压 ∝ X 坐标
测 Y	换成 Y 层加电压，X 层当探针	X 层的电压 ∝ Y 坐标

测电压用的还是 XPT2046 —— 和第 26 章 ADC 是同一颗芯片（顺便也能测触摸）

31.2 坐标换算

屏幕坐标 = (AD 值 - AD 最小值) × 屏幕宽度 / (AD 最大值 - AD 最小值)

31.3 判断"按下了"

if (AD_Y < 阈值)    // 按下时 Y 层会被拉低
    有触摸;
else
    没触摸;

因为没按时两层不接触，Y 层被上拉电阻拉高；按下后才和 X 层导通。

31.4 易错点

31.5 练习

1. 读出触摸点的原始 AD 值。
2. 在四个角各点一下，记录 AD 范围。
3. （进阶）点屏幕上的按钮控制 LED。

📖 参考答案（点击展开）

1. 直接读 XPT2046 的 X/Y 通道原始值并串口打印。
2. 四角各点一下，记录 X 的 min/max 和 Y 的 min/max，作为校准参数。
3. 把屏幕划分成若干矩形区域，判断触摸点落在哪个区域，执行对应动作（如点亮不同 LED）。

32.1 继电器是什么

继电器 = 用电磁铁控制机械触点的开关。它的价值是电气隔离：用小电流控制大电流、用 5V 控制 220V。

端子	说明
线圈 +	接单片机（经三极管）
线圈 −	接 GND
COM	公共端
NO（常开）	线圈不通时断开，通电才闭合
NC（常闭）	线圈不通时闭合，通电才断开

32.2 为什么不能直连

继电器线圈要 30~70 mA，而单片机引脚最多 20 mA。必须用三极管（或 ULN2003 驱动芯片）放大。

P1.x ── 1kΩ ── 三极管基极
                集电极 ── 继电器线圈 ── +5V
                发射极 ── GND
        ★ 线圈两端并联一个续流二极管（1N4148）

32.3 代码

sbit RELAY = P1^4;      // 引脚以实际板子为准

void main()
{
    while (1)
    {
        RELAY = 1;      // 吸合（常开端子闭合）
        delay_ms(1000);
        RELAY = 0;      // 释放
        delay_ms(1000);
    }
}

32.4 易错点

32.5 练习

1. 让继电器每 2 秒吸合一次，听"嗒嗒"声。
2. 用按键控制继电器。
3. 想一想：为什么继电器能做"隔离"，而三极管不行？

📖 参考答案（点击展开）

1. RELAY=1; delay_ms(2000); RELAY=0; delay_ms(2000); 放在 while(1) 里，能听到「嗒」的吸合声。
2. 查按键，按下时翻转 RELAY。
3. 继电器靠电磁铁 + 机械触点，线圈和触点之间只有磁耦合、没有电气连接，所以能隔离高压。三极管是半导体器件，集电极和基极仍有漏电流和击穿通路，不能真正隔离。

33.1 74HC165 是 595 的反向

	74HC595	74HC165
方向	串入 → 并出	并入 → 串出
用途	用 3 根线驱动 8 个输出	用 3 根线读 8 个输入

两者配合就是：595 扩展输出、165 扩展输入。

33.2 三根线

引脚	作用
SH/LD	1 = 移位，0 = 装载（把 8 个输入读进寄存器）
CLK	时钟，上升沿移一位
Q7	串行输出，接到单片机

33.3 读 8 个输入的流程

PL = 0;   delay();   PL = 1;    // ① 装载（把 8 个引脚状态读进芯片）
for (i = 0; i < 8; i++)
{
    dat <<= 1;
    if (Q7) dat |= 0x01;         // ② 读当前位
    CLK = 0;  CLK = 1;           // ③ 移位，准备下一位
}

先读后移还是先移后读，取决于第一个有效位是 D7 还是 D0 —— 读出来顺序反了就调整循环。

33.4 级联

165 的 Q7 接下一片的 SER，就能读 16 位、24 位输入。软件上循环 16 次即可。

33.5 易错点

33.6 练习

1. 用 165 读 8 个拨码开关的状态，显示在 LED 上。
2. 把读到的值用串口打印出来。
3. 对比 165 和 595 的时序，找出异同。

📖 参考答案（点击展开）

1. PL=0; delay(); PL=1; 装载，然后循环 8 次「读 Q7 → 移位」，把结果送 P2 显示。
2. 同样的 8 位数据用 uart_send_byte(dat) 打印，注意串口助手选 HEX 显示更直观。
3. 相同：都是靠时钟上升沿移位、都串行。不同：595 是串入并出（写出去），165 是并入串出（读进来）；165 多一个 SH/LD 装载信号。

34.1 四线双极性和五线单极性

	五线（28BYJ-48）	四线双极性
线圈	4 相 + 公共端	2 组独立线圈（A+/A-、B+/B-）
驱动	单极性（每相一个开关）	双极性（每相要 H 桥换向）
扭矩	较小	较大
驱动芯片	ULN2003	L298N / A4988

34.2 为什么要 H 桥

双极性电机需要电流反向（A+ 到 A- 或者反过来）。四个开关组成 H 桥：

正转：S1 和 S4 通  →  电流 A+ → A-
反转：S2 和 S3 通  →  电流 A- → A+
停止：全断
刹车：S1S2 通 或 S3S4 通（线圈短路）

34.3 相序（两相四拍）

拍	A+	A-	B+	B-
1	1	0	0	1
2	0	1	0	1
3	0	1	1	0
4	1	0	1	0

八拍版本在每两拍之间加一个"两相都通电"的过渡，转动更平滑。

34.4 易错点

34.5 练习

1. 让电机正转一圈再反转一圈。
2. 把四拍改成八拍，比较平滑度。
3. 想一想："直通"为什么会烧管？（用电路课的 KVL 解释）

📖 参考答案（点击展开）

1. 先正转 4096 步（或对应圈数的拍数），停 1 秒，再反转变。
2. 八拍在两拍之间插入「两相同时通电」的过渡状态，转动更平滑、噪音更小，但同样转速下需要多一倍的拍数。
3. 同侧两管（如 S1 和 S2）同时导通时，电流从 VCC 直接经两个管子流到 GND，中间没有负载。按 KVL：负载电压为 0，电流只受管子内阻限制 → 瞬间几百 mA 甚至几 A，管子发热烧毁。这叫「直通」。

35.1 RS485 解决什么问题

	串口 TTL	RS485
信号	单端（对地）	差分（A、B 两线）
距离	几米	1200 米
抗干扰	差	强（干扰同时叠加在两线上，相减抵消）
设备数	点对点	一条总线挂 32~128 个

35.2 用 MAX485 转换

引脚	作用
RO	接收输出 → 单片机 RXD
DI	发送输入 ← 单片机 TXD
DE	发送使能（1 = 发送）
RE	接收使能（0 = 接收），通常和 DE 连一起
A / B	差分总线

35.3 半双工：一次只能一个方向

RS485 是半双工：同一时刻要么发要么收，不能同时。所以要有一个方向控制引脚：

sbit RS485_DE = P1^5;      // 引脚以实际板子为准

void rs485_send(unsigned char dat)
{
    RS485_DE = 1;          // 切到发送
    uart_send_byte(dat);
    while (TI == 0);       // 等发完
    TI = 0;
    RS485_DE = 0;          // ★ 立刻切回接收
}

35.4 终端电阻

总线两端各接一个 120 Ω 电阻，用来消除信号反射。

情况	要不要接
短距离（< 10m）、低速	可以不接
长距离、高速	必须接，否则误码

35.5 易错点

35.6 练习

1. 两块板子用 RS485 互发数据。
2. 把 DE 那行去掉，观察"能发不能收"的现象。
3. 查一下：为什么终端电阻是 120Ω 而不是 100Ω 或 200Ω？（提示：双绞线特性阻抗）

📖 参考答案（点击展开）

1. 两块板 A 接 A、B 接 B（必要时对调），各自初始化串口为同一波特率，一块发一块收。
2. 去掉 RS485_DE=0; 后，芯片一直处于发送模式、接收器被关断，于是发得出去、收不到任何东西。
3. 因为标准 RS485 用的双绞线特性阻抗约 120Ω。终端电阻等于特性阻抗时反射最小；用 100Ω 或 200Ω 都会因阻抗不匹配产生反射，长距离下误码率上升。