C 语言与嵌入式 · 从零到 51 单片机

导学习地图：三个星期怎么走

嵌入式这套东西看起来吓人，其实只有三层：语言 → 计算机底层 → 具体芯片。任何一层缺了，学起来都会变成「背代码」；三层都通了，你就能自己看懂数据手册、自己写驱动。

你手上应该有的两份教程，怎么配合用

每天怎么学（这是最省时间的顺序）

1. 先读一遍今天的概念，不要急着看代码 —— 先知道今天要解决什么问题。
2. 把代码亲手敲一遍（不要复制）。敲错、报错、改对，才是真正在学。
3. 改一改：把代码里的数字换掉、把条件反过来，看现象怎么变。这一条最重要，它把「抄写」变成「实验」。
4. 做当天末尾的自测，答不出来就回去看对应小节。
5. 点「标记为已学完」，进度会存在本机。

三周之后你能做什么

1Day 1 · 程序是怎么跑起来的

1.1 什么是程序

程序就是一份写给机器看的操作清单。你写的东西叫「源代码」，CPU 不认识它；CPU 只认识一条条「机器指令」——说白了就是一堆 0 和 1。

所以中间必须有个翻译：

1.2 第一个程序

#include <stdio.h>

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

逐行解释：

1.3 亲手编译运行一次

先确认你电脑上有 C 编译器（Windows 上装了 MinGW 或 Dev-C++ 都行）：

:: 在命令行里检查
gcc --version

:: 编译：把 hello.c 翻译成 hello.exe
gcc hello.c -o hello.exe

:: 运行
hello.exe
:: 输出：Hello, world!

1.4 程序是怎样一步步执行的

代码是从上往下一句句执行的。看这个例子：

#include <stdio.h>

int main(void)
{
    printf("第一句\n");
    printf("第二句\n");
    printf("第三句\n");
    return 0;
}

/* 输出 */
第一句
第二句
第三句

注意：C 是「顺序执行」的，除非你用分支和循环改变它（Day 4、Day 5 学）。这一点听起来废话，但当你后面写单片机程序时，「这一句在上一句之后多久执行」会变成关键问题。

1.5 注释：写给人的话

// 这是单行注释，从 // 到本行结尾都被忽略

/* 这是多行注释
   可以写好几行
   编译器完全不管它们 */

int a = 1;   // 也可以写在语句后面

TMOD = 0x01;    // 定时器0，工作方式1（16位定时）
TH0  = 0x3C;    // 50ms 初值高字节（12MHz 晶振）

1.6 常见错误（你一定会遇到）

2Day 2 · 变量与数据类型

2.1 变量：给内存里的一块地方起名字

电脑的内存像一长排储物柜，每个柜子有个编号（地址）。变量就是你给某个柜子起的名字，以后你说「a」，程序就知道去那个柜子拿东西。

int a = 10;    // 要一个柜子，起名 a，放进去 10
a = 20;        // 把 a 里的东西换成 20
printf("%d\n", a);   // 取出 a 里的东西打印：20

「声明变量」要告诉编译器两件事：① 起什么名字　② 这个柜子要多大（也就是类型）。

2.2 基本数据类型

2.3 用 sizeof 自己量一量

#include <stdio.h>

int main(void)
{
    printf("char   = %d 字节\n", (int)sizeof(char));
    printf("int    = %d 字节\n", (int)sizeof(int));
    printf("float  = %d 字节\n", (int)sizeof(float));
    printf("double = %d 字节\n", (int)sizeof(double));
    return 0;
}

/* 在 PC（GCC）上运行的结果 */
char   = 1 字节
int    = 4 字节
float  = 4 字节
double = 8 字节

到了 51 上，int 会变成 2。所以永远不要靠猜，用 sizeof 量。

2.4 输入：scanf

#include <stdio.h>

int main(void)
{
    int a, b;
    printf("请输入两个整数：");
    scanf("%d %d", &a, &b);       // 注意每个变量前的 &
    printf("它们的和是 %d\n", a + b);
    return 0;
}

2.5 变量命名与初始化

// 起名字的规矩
int led_count;      // ✓ 字母、数字、下划线，不能以数字开头
int LedCount;       // ✓ 另一种风格，都可以
int 2led;           // ✗ 不能数字开头
int led-count;      // ✗ 不能有减号（会被当成减法）
int int;            // ✗ 不能和关键字同名（int/for/if/while...）

// 大小写敏感！
int led, LED;       // 这是两个不同的变量

int a;                  // a 里是什么？谁也不知道
printf("%d\n", a);      // 可能输出 -858993460 之类的怪数

int a = 0;              // ✓ 声明时就给初值，这是好习惯

2.6 常量与字面量

int a = 10;          // 10 是十进制
int b = 0x0A;        // 0x 开头是十六进制，0x0A 就是 10
int c = 012;         // 0 开头是八进制，012 是十进制的 10
char d = 'A';        // 单引号是字符，'A' 其实就是 65
char e[] = "ABC";    // 双引号是字符串

3Day 3 · 运算符与表达式

3.1 算术运算符

int a = 7 / 2;         // a = 3，不是 3.5
float b = 7 / 2;       // b = 3.0！因为 7/2 先按整数算出 3，再转成 float
float c = 7.0 / 2;     // c = 3.5 ✓ 只要有一个是小数，就按小数算
float d = (float)7 / 2; // d = 3.5 ✓ 或者强制转换

3.2 取余 % 的妙用

取余在单片机里用得极多，因为它是「循环」和「拆分数字」的核心工具：

// ① 让一个数在 0~7 之间循环（8 个 LED 轮流亮）
i = (i + 1) % 8;      // 0,1,2,...,7,0,1,2,... 永远不越界

// ② 拆出一个三位数的各位数字（数码管显示要用）
int n = 258;
int ge   = n % 10;            // 8
int shi  = n / 10 % 10;       // 5
int bai  = n / 100 % 10;      // 2

3.3 关系运算符（比较）

if (a = 5) { ... }    // ✗ 这是赋值！把 5 塞进 a，然后判断 5 是不是真
if (a == 5) { ... }   // ✓ 这才是比较

3.4 逻辑运算符

3.5 自增自减与复合赋值

int i = 5;

i++;        // 等价于 i = i + 1;  现在 i 是 6
i--;        // i = i - 1;
i += 3;     // i = i + 3;
i -= 3;     // i = i - 3;
i *= 2;     // i = i * 2;
i %= 3;     // i = i % 3;

前加加和后加加的区别

int i = 5, a, b;

a = i++;    // 先把 i 的值给 a（a=5），再让 i 加 1（i=6）
i = 5;      // 复位
b = ++i;    // 先让 i 加 1（i=6），再把 i 的值给 b（b=6）

单独写 i++; 时两者没区别。只有当它和别的运算混在一行时才要小心 —— 建议别混，拆成两行最清楚。

3.6 运算符优先级（会咬人的地方）

高到低大致是：() → ! ~ ++ -- → * / % → + - → < > <= >= → == != → && → || → =

// 想表达「a 加 b 再乘 c」，但这样写是错的：
int r = a + b * c;          // 实际是 a + (b*c)
int r = (a + b) * c;        // ✓ 加括号

// 判断「第 3 位是不是 1」——这是 Day 11 的内容，先看个眼熟
if (P1 & 0x08 == 0)         // ✗ == 优先级高于 &，实际是 P1 & (0x08==0)
if ((P1 & 0x08) == 0)       // ✓ 必须加括号

4Day 4 · 分支：让程序会判断

4.1 if：如果……就……

if (条件) {
    // 条件成立（非 0）时执行这里
}

int score = 85;

if (score >= 60) {
    printf("及格\n");
}

if (a > 0)
    printf("正数\n");        // 只有这一句属于 if

if (a > 0)
    printf("正数\n");
    printf("这句永远执行\n");   // ✗ 它不属于 if！缩进骗了你

4.2 if-else：两条路选一条

if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

4.3 else if：多条路

if (score >= 90) {
    printf("优秀\n");
} else if (score >= 80) {
    printf("良好\n");
} else if (score >= 60) {
    printf("及格\n");
} else {
    printf("不及格\n");
}

4.4 switch：一个值分多种情况

当你的判断是「某个变量等于 1 做这个、等于 2 做那个」时，switch 比一串 else if 清楚得多：

switch (mode) {
    case 1:
        printf("模式一\n");
        break;              // 每个 case 末尾几乎都要 break
    case 2:
        printf("模式二\n");
        break;
    case 3:
    case 4:                 // 两个 case 共用一段代码：故意不写 break
        printf("模式三四\n");
        break;
    default:                // 都不匹配时走这里
        printf("未知模式\n");
        break;
}

switch (n) {
    case 1: printf("A\n");      // 忘了 break
    case 2: printf("B\n"); break;
}
// n=1 时输出：A 然后 B！因为执行完 case 1 会继续往下掉

4.5 条件运算符（三目）

// 写法： 条件 ? 成立时的值 : 不成立时的值
int max = (a > b) ? a : b;          // 取较大的那个
printf("状态：%s\n", led ? "亮" : "灭");

它适合「二选一取值」这种简单场合。逻辑复杂就别用它，可读性会变差。

4.6 嵌套与综合例子

#include <stdio.h>

int main(void)
{
    int score;
    printf("请输入成绩：");
    scanf("%d", &score);

    if (score < 0 || score > 100) {
        printf("成绩不合法\n");
    } else if (score >= 90) {
        printf("优秀\n");
    } else if (score >= 60) {
        printf("及格\n");
    } else {
        printf("不及格\n");
    }
    return 0;
}

5Day 5 · 循环：让程序会重复

5.1 while：条件成立就一直做

int i = 1;
while (i <= 5) {
    printf("%d\n", i);
    i++;                // 千万别忘了改 i，否则死循环
}

/* 输出 1 2 3 4 5 */

int i = 1;
while (i <= 5) {
    printf("%d\n", i);      // ✗ i 永远是 1 → 无限打印
}
// 按 Ctrl+C 可以强行中断

5.2 for：最常用的循环

// for (初始化; 继续条件; 每轮结束做的事)
for (int i = 1; i <= 5; i++) {
    printf("%d\n", i);
}

它和上面的 while 完全等价，但把「起点、终点、步进」都写在了一行里，不容易漏。

三种常见写法

// 从 0 数到 n-1（数组遍历的标准写法）
for (int i = 0; i < n; i++) { ... }

// 从 1 数到 n
for (int i = 1; i <= n; i++) { ... }

// 倒着数
for (int i = 10; i >= 1; i--) { ... }

// 每次加 2（只数奇数）
for (int i = 1; i <= 9; i += 2) { ... }

5.3 do-while：至少执行一次

int n;
do {
    printf("请输入 1~10 之间的数：");
    scanf("%d", &n);
} while (n < 1 || n > 10);   // 注意末尾有分号

区别在于：while 是先判断再执行（可能一次都不做），do-while 是先执行再判断（至少做一次）。适合「必须问一次，不合格就再问」的场景。

5.4 break 与 continue

for (int i = 1; i <= 10; i++) {
    if (i == 5) break;        // 整个循环立刻结束，i=5 后面的都不做了
    printf("%d ", i);         // 输出 1 2 3 4
}

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) continue;  // 跳过本轮剩下的语句，直接进入下一轮
    printf("%d ", i);          // 输出 1 3 5 7 9
}

5.5 嵌套循环

// 打印九九乘法表
for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        printf("%d*%d=%-3d", j, i, i * j);
    }
    printf("\n");           // 每打完一行换行
}

两层循环的执行次数是相乘关系：外层 9 次 × 内层最多 9 次 = 81 次。这个「乘法关系」在你以后算程序耗时（单片机主循环能不能跑得过来）时是关键概念。

5.6 循环在单片机里的特殊地位

void main(void)
{
    Init();              // 初始化（只做一次）

    while (1) {          // 主循环：永远不退出
        DoSomething();   // 反复执行的工作
    }
}

6Day 6 · 数组与字符串

6.1 为什么需要数组

假设你要存 8 个 LED 的状态。不用数组你得写 8 个变量：

int led0, led1, led2, led3, led4, led5, led6, led7;   // 又长又没法循环
led0 = 1; led1 = 0; ...                                // 想批量操作？做不到

用数组：

int led[8];                 // 一次要 8 个格子，编号 0~7
led[0] = 1;                 // 用下标访问
led[3] = 0;

for (int i = 0; i < 8; i++) {   // 可以循环处理，这是数组最大的价值
    led[i] = 0;
}

6.2 下标的范围（最容易错的地方）

int a[5];       // 要了 5 个格子

a[0] = 1;       // ✓ 第 1 个
a[4] = 1;       // ✓ 最后一个（下标从 0 开始，所以是 4）
a[5] = 1;       // ✗ 越界！不存在 a[5] 这个格子

6.3 初始化

// 方式一：声明时全部给出
int a[5] = {10, 20, 30, 40, 50};

// 方式二：只给前几个，剩下的自动补 0
int b[5] = {1, 2};          // 变成 {1, 2, 0, 0, 0}

// 方式三：全部清零的标准写法
int c[5] = {0};             // ✓ 所有元素都是 0

// 方式四：让编译器自己数个数
int d[] = {1, 2, 3};        // 自动是 d[3]

int a[5] = {0};    // ✓ {0,0,0,0,0} —— 全部清零
int b[5] = {1};    // ✗ {1,0,0,0,0} —— 只有第一个是 1！

for (int i = 0; i < 5; i++) b[i] = 1;   // ✓ 这才是全部设成 1

6.4 遍历数组

#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int sum = 0;

    for (int i = 0; i < 5; i++) {
        printf("a[%d] = %d\n", i, a[i]);
        sum += a[i];
    }
    printf("总和 = %d，平均 = %d\n", sum, sum / 5);
    return 0;
}

/* 输出 */
a[0] = 10
a[1] = 20
a[2] = 30
a[3] = 40
a[4] = 50
总和 = 150，平均 = 30

6.5 二维数组

一排格子不够用时，可以要一个「表格」：

int a[3][4];            // 3 行 4 列，共 12 个格子
a[0][0] = 1;            // 第 0 行第 0 列
a[2][3] = 9;            // 第 2 行第 3 列

// 初始化：外面一层花括号是行，里面一层是列
int b[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

// 遍历要两层循环
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", b[i][j]);
    }
    printf("\n");
}

二维数组在单片机里主要用来存「点阵字模」—— 比如 8×8 点阵的一个汉字，就是一个 unsigned char[8]（每行一个字节，8 个字节 = 8×8 个点）。

6.6 字符串 = 字符数组

C 里没有字符串类型，字符串就是 char 数组，并且有一个特殊约定：末尾必须有一个 '\0'（值为 0 的字符）表示「到此结束」。

char s1[] = "hello";                      // 编译器自动加 '\0'，共 6 字节
char s2[] = {'h','e','l','l','o','\0'};   // 手动写，必须自己加

// 二者等价。内存里长这样：
// 下标:  0    1    2    3    4    5
// 内容: 'h'  'e'  'l'  'l'  'o'  '\0'

char s[3] = {'a','b','c'};    // ✗ 没有结束符
printf("%s\n", s);            // 输出 "abc" 后面跟一串随机字符

char s[4] = {'a','b','c','\0'};   // ✓

6.7 常用字符串操作

要 #include <string.h>：

char a[10] = "hi", b[10];
b = a;                    // ✗ 编译错误
strcpy(b, a);             // ✓ 用函数拷

if (a == "hi")            // ✗ 比的是地址，永远不相等
if (strcmp(a, "hi") == 0) // ✓ 比内容

7Day 7 · 函数 + 第一周复盘

7.1 函数：给一段代码起个名字

你已经在用函数了（printf、scanf、strlen）。现在学怎么自己写。

// 语法：  返回类型  函数名(参数列表) { 函数体 }
int add(int a, int b)
{
    int sum = a + b;
    return sum;          // 把结果送回去
}

int main(void)
{
    int x = add(3, 5);   // 调用：传 3 和 5 进去，拿到 8
    printf("%d\n", x);   // 8
    return 0;
}

7.2 为什么要用函数

7.3 没有返回值：void

void blink(void)          // void 表示"不返回任何值"
{
    printf("闪一下\n");
    // 没有 return，或者写 return; （不带值）
}

int main(void)
{
    blink();              // 直接调用，不用接收返回值
    return 0;
}

(void) 表示「不接收参数」，比空括号 () 更明确。单片机的函数几乎都是 void 名字(void) 这个形状。

7.4 参数是「复制」进去的（这点非常重要）

void change(int x)
{
    x = 100;             // 改的是复制品
}

int main(void)
{
    int a = 5;
    change(a);
    printf("%d\n", a);   // 输出 5！不是 100
    return 0;
}

7.5 函数要「先声明后使用」

// 写法一：把函数定义写在 main 前面（简单，适合小程序）
int add(int a, int b) { return a + b; }

int main(void) { ... }

// 写法二：先声明（也叫原型），定义放后面
int add(int a, int b);      // 只写这一行，末尾有分号

int main(void) { int x = add(1,2); }

int add(int a, int b) { return a + b; }   // 真正的定义

如果函数写在 main 后面又没声明，编译器会报 implicit declaration（隐式声明）警告或错误。第三周你会看到所有 51 程序都把函数声明放最上面，或者放进 .h 文件。

7.6 一个实用的例子：自己写延时

#include <stdio.h>

/* 打印一条分割线，长度由参数决定 */
void line(int n)
{
    for (int i = 0; i < n; i++) {
        printf("-");
    }
    printf("\n");
}

/* 求数组最大值 */
int max_of(int a[], int n)      // 数组作为参数，要另外传长度
{
    int m = a[0];
    for (int i = 1; i < n; i++) {
        if (a[i] > m) m = a[i];
    }
    return m;
}

int main(void)
{
    int data[6] = {3, 9, 2, 7, 5, 8};

    line(30);
    printf("最大值 = %d\n", max_of(data, 6));
    line(30);
    return 0;
}

7.7 第一周复盘

七天下来，你应该已经能读写这些：

#include <stdio.h>

int main(void)
{
    int score[10];
    int i, max, min, sum = 0, pass = 0;

    for (i = 0; i < 10; i++) {
        scanf("%d", &score[i]);
    }

    max = min = score[0];        // 先把第一个当成最大最小

    for (i = 0; i < 10; i++) {
        if (score[i] > max) max = score[i];
        if (score[i] < min) min = score[i];
        sum += score[i];
        if (score[i] >= 60) pass++;
    }

    printf("最高分：%d\n", max);
    printf("最低分：%d\n", min);
    printf("平均分：%d\n", sum / 10);
    printf("及格人数：%d\n", pass);
    return 0;
}

#include <stdio.h>

int find_max(int a[], int n)
{
    int m = a[0];
    for (int i = 1; i < n; i++) if (a[i] > m) m = a[i];
    return m;
}

int find_min(int a[], int n)
{
    int m = a[0];
    for (int i = 1; i < n; i++) if (a[i] < m) m = a[i];
    return m;
}

int count_pass(int a[], int n)
{
    int c = 0;
    for (int i = 0; i < n; i++) if (a[i] >= 60) c++;
    return c;
}

int main(void)
{
    int s[10], i, sum = 0;

    for (i = 0; i < 10; i++) scanf("%d", &s[i]);
    for (i = 0; i < 10; i++) sum += s[i];

    printf("最高分：%d\n", find_max(s, 10));
    printf("最低分：%d\n", find_min(s, 10));
    printf("平均分：%d\n", sum / 10);
    printf("及格人数：%d\n", count_pass(s, 10));
    return 0;
}

8Day 8 · 指针（一）：地址是什么

8.1 内存与地址

把内存想成一条很长的街，每间房子 1 字节，门牌号就是地址。你声明一个变量，等于占了一间（或几间）房子。

int a = 10;

// a 住在哪？用 & 取地址
printf("a 的值  = %d\n", a);        // 10
printf("a 的地址= %p\n", &a);       // 0x7ffd4c2a 之类

8.2 第一个指针程序

#include <stdio.h>

int main(void)
{
    int a = 10;
    int *p = &a;              // p 里存的是 a 的地址

    printf("a   = %d\n", a);   // 10
    printf("*p  = %d\n", *p);  // 10   顺着 p 找到 a，取出里面的值

    *p = 20;                   // 顺着 p 找到 a，把值改成 20
    printf("a   = %d\n", a);   // 20   a 被改了！

    return 0;
}

int *p;      // 声明：* 表示"p 是个指针"
*p = 20;     // 使用：* 表示"p 指向的那块内存"

8.3 指针变量里存的是什么

int  a = 10;
int  b = 20;
int *p;

p = &a;      // p 指向 a
printf("%d\n", *p);   // 10

p = &b;      // 改成指向 b（指针本身可以被重新赋值）
printf("%d\n", *p);   // 20

p = &a;
*p = *p + 5;         // 把 a 加 5（*p 代替了 a 的位置）
printf("%d\n", a);   // 15

看出来了：*p 和 a 指的是同一块内存。用哪个名字都行。

8.4 为什么单片机离不开指针

先看一个「预告版」例子（Day 9 详解）：

/* 把地址 0x80 当成一个可读写的 8 位寄存器 */
*(volatile unsigned char *)0x80 = 0x55;

单片机里，硬件就是用「地址」来访问的。芯片手册上写「P1 口的地址是 0x90」，意思是：往 0x90 这个地址写数据，就改变了那 8 个引脚的电平。

所以你必须会「把某个地址当成变量来用」—— 这正是指针唯一不可替代的地方。

8.5 三种指针事故（一定要知道）

// 事故一：野指针 —— 没初始化的指针
int *p;              // p 里是垃圾值，指向随机地方
*p = 5;              // ✗ 往随机内存写 → 崩溃

int *p = NULL;       // ✓ 先给 NULL（表示"不指向任何地方"）

// 事故二：用之前不检查
if (p != NULL) {     // ✓ 好习惯
    *p = 5;
}

// 事故三：返回局部变量的地址
int *bad(void)
{
    int x = 10;
    return &x;       // ✗ x 是局部变量，函数一返回它就没了
}

9Day 9 · 指针（二）：数组、传参与寄存器

9.1 数组名就是首地址

int a[5] = {10, 20, 30, 40, 50};

printf("%p\n", (void*)a);       // a 本身就是首元素的地址
printf("%p\n", (void*)&a[0]);   // 和上面一样

所以可以这样用：

int *p = a;             // 等价于 int *p = &a[0];

printf("%d\n", a[2]);    // 30
printf("%d\n", *(a+2));  // 30   ← a[i] 本质就是 *(a+i)
printf("%d\n", p[2]);    // 30   ← 指针也能用中括号
printf("%d\n", *(p+2));  // 30

9.2 指针传参：让函数能改动外部变量

Day 7 说过，函数参数是值传递，改不了外面。现在有办法了：把地址传进去。

// ✗ 改不了外面
void addOne_bad(int x)
{
    x++;                 // 改的是复制品
}

// ✓ 能改
void addOne(int *x)
{
    (*x)++;              // 顺着地址找到外面的变量，把它加 1
}

int main(void)
{
    int a = 5;

    addOne_bad(a);
    printf("%d\n", a);   // 5    没变

    addOne(&a);          // 传地址，前面加 &
    printf("%d\n", a);   // 6    变了！

    return 0;
}

void f(int *x) {
    *x++;      // ✗ 把指针自身往后挪一格，再取值（几乎肯定不是你要的）
    (*x)++;    // ✓ 把指向的那个值加 1
}

9.3 什么时候真的需要指针传参

两个场景：

// 场景一：函数要"返回"多个值（C 的 return 只能返回一个）
void min_max(int a[], int n, int *pmin, int *pmax)
{
    *pmin = *pmax = a[0];
    for (int i = 1; i < n; i++) {
        if (a[i] < *pmin) *pmin = a[i];
        if (a[i] > *pmax) *pmax = a[i];
    }
}

// 调用时把两个变量的地址传进去
int lo, hi;
min_max(data, 10, &lo, &hi);
// 现在 lo 是最小值，hi 是最大值 —— 一次拿到两个结果

// 场景二：字符串/数组的处理函数（避免复制整个数组）
void upper(char *s)
{
    while (*s != '\0') {
        if (*s >= 'a' && *s <= 'z') *s = *s - 32;   // 小写转大写
        s++;                                        // 指针往后挪一格
    }
}

注意 while (*s != '\0') 这个写法 —— 它靠字符串的结束符来终止循环，所以后面没有长度参数。这是 C 处理字符串的经典写法。

9.4 用指针访问寄存器（单片机的命根子）

现在把 Day 8 的预告讲清楚：

/* 把地址 0x90 当成一个可读写的 8 位寄存器，写入 0xFE */
*(volatile unsigned char *)0x90 = 0xFE;

从里往外拆开读：

sfr P1 = 0x90;      // 给地址 0x90 起名叫 P1

9.5 读寄存器

/* 读 P3 口的状态（判断按键） */
unsigned char v = P3;

/* 等价的手写形式 */
unsigned char v = *(volatile unsigned char *)0xB0;

你会发现芯片手册里每个寄存器的「地址」一栏，就是你将来可能用到的数字。有名字的用名字，没名字的（或自定义地址）就用指针。

10Day 10 · 结构体 / 枚举 / 联合

10.1 为什么需要结构体

假设你要描述 3 个 LED 的状态：颜色、亮灭、亮度。用数组很难表达「这几个数据属于同一个东西」：

int led_color[3];
int led_on[3];
int led_bright[3];      // 三个数组靠下标硬凑，很容易搞错

结构体让不同类型的数据打包成一个整体：

struct Led {
    int  color;         // 颜色
    int  on;            // 亮/灭
    int  bright;        // 亮度
};

struct Led myled;       // 一个 Led，包含三个成员

myled.color  = 1;
myled.on     = 1;
myled.bright = 80;
printf("%d\n", myled.bright);   // 80

用点 . 访问成员。

10.2 C 里的必写套路：typedef

上面每次都要写 struct Led 很烦。C 程序员统一用 typedef 给它起个别名：

typedef struct {
    int color;
    int on;
    int bright;
} Led;                  // 从这行之后，Led 就是一个类型名

Led a, b;               // ✓ 和 int 一样好用，不用再写 struct

typedef struct {
    成员...
} 类型名;

10.3 结构体数组：管理一组同类对象

Led leds[3];             // 3 个 LED，每个都有自己的三个成员

leds[0].color = 1;  leds[0].on = 1;
leds[1].color = 2;  leds[1].on = 0;
leds[2].color = 3;  leds[2].on = 1;

for (int i = 0; i < 3; i++) {
    printf("LED%d: 颜色=%d 状态=%d\n", i, leds[i].color, leds[i].on);
}

10.4 指针访问成员：箭头 ->

Led led1 = {1, 1, 80};
Led *p = &led1;              // 指向结构体的指针

printf("%d\n", led1.bright);   // 80    变量用点
printf("%d\n", (*p).bright);   // 80    先解引用再取成员，写法啰嗦
printf("%d\n", p->bright);     // 80    箭头是上面那种写法的简写

void Led_On(Led *l) { l->on = 1; }   // 传指针，能改到外面
Led_On(&myled);                       // 调用

10.5 结构体映射寄存器（嵌入手法的核心）

这是结构体在单片机里最重要的用途：把地址连续的一堆寄存器，用一个结构体描述出来。

/* 假设某个外设的寄存器从 0x40000000 开始，每个占 4 字节，依次排列 */
typedef struct {
    volatile unsigned int CR;      // 偏移 0x00  控制寄存器
    volatile unsigned int SR;      // 偏移 0x04  状态寄存器
    volatile unsigned int DR;      // 偏移 0x08  数据寄存器
} UART_TypeDef;

/* 把基地址强制转换成这种结构体指针 */
#define UART1  ((UART_TypeDef *)0x40000000)

/* 之后就能用成员名访问寄存器，不用记偏移量 */
UART1->CR = 0x01;         // 实际写到了 0x40000000
UART1->DR = 'A';          // 实际写到了 0x40000008

原理就是 Day 9 学的：结构体成员在内存里依次排列，所以成员名会对应到固定偏移的地址上。

10.6 枚举 enum：给数字起名字

typedef enum {
    LED_OFF   = 0,
    LED_ON    = 1,
    LED_BLINK = 2
} LedState;

LedState s = LED_ON;

if (s == LED_BLINK) { ... }

它就是个整数，但比记「0 是灭、1 是亮、2 是闪」清楚得多。单片机里凡是「有限几个状态」的东西（工作模式、错误码），都适合用枚举。

10.7 联合 union：几种看法共用一块内存

typedef union {
    unsigned int  word;       // 当 16 位数看
    unsigned char byte[2];    // 拆成两个 8 位看
} Data16;

Data16 d;
d.word = 0x1234;
printf("%02X %02X\n", d.byte[0], d.byte[1]);   // 34 12

联合的所有成员共用同一块内存。用它可以在「一个整体」和「拆开的部分」之间自由切换 —— 处理传感器数据、串口收包时很方便。

手写也能做（d >> 8 和 d & 0xFF），但 union 更直观、也不用算。

11Day 11 · 位运算：单片机的母语

11.1 一个字节 = 8 个引脚

先建立直觉。P1 是一个 8 位寄存器，每一位对应一个引脚：

P1 = 0xFE;        // 二进制 1111 1110 —— 只有 P1.0 是 0，其余是 1
P1 = 0x7F;        // 二进制 0111 1111 —— 只有 P1.7 是 0
P1 = 0x00;        // 全部为 0
P1 = 0xFF;        // 全部为 1

LED 常见接法是「低电平点亮」，所以 P1 = 0xFE 的效果是「P1.0 那个灯亮，其余灭」。Day 16 会讲清为什么。

11.2 六个运算符

11.3 四个必背惯用法（练成肌肉记忆）

这四行你要练到不用想就能写。设 n 是位号（0~7）：

/* ① 置位：把第 n 位变成 1，其它位不动 */
reg |= (1 << n);

/* ② 清零：把第 n 位变成 0，其它位不动 */
reg &= ~(1 << n);

/* ③ 翻转：第 n 位取反，其它位不动 */
reg ^= (1 << n);

/* ④ 判断：第 n 位是不是 1 */
if (reg & (1 << n)) { /* 是 1 */ }

为什么「清零」要写成 &= ~(1<<n) 这么绕？

因为 |= 只能把位变成 1，没法把位变成 0。想让第 n 位变 0、其它位不变，就得拿一个「除了第 n 位是 0，其余全是 1」的掩码去与：

1 << 2            = 0000 0100    // 只有第 2 位是 1
~(1 << 2)         = 1111 1011    // 只有第 2 位是 0 ← 这就是我们要的掩码
reg &= ~(1 << 2)  // reg 的第 2 位被清 0，其余原样保留

11.4 手推一遍（一定要自己推一次）

设 P1 初值是 1111 0000（写成 0xF0）：

11.5 实战用法

/* 判断按键是否按下（P3.2 接按键，按下时该位为 0） */
if ((P3 & (1 << 2)) == 0) {
    // 按下了
}

/* 一次点亮低 4 个 LED，不影响高 4 位 */
P1 |= 0x0F;

/* 一次熄灭低 4 个 LED，不影响高 4 位 */
P1 &= 0xF0;

/* 取低 4 位的值单独看 */
unsigned char low = P1 & 0x0F;

/* 高低 4 位互换 */
P1 = (P1 << 4) | (P1 >> 4);

/* 两个 8 位数拼成一个 16 位数（传感器数据常见） */
unsigned int v = ((unsigned int)high << 8) | low;

/* 从 16 位数里拆出高、低字节 */
unsigned char h = (unsigned char)(v >> 8);
unsigned char l = (unsigned char)(v & 0xFF);

11.6 四个经典坑

if (P1 & 0x08 == 0)        // ✗ == 优先级高于 &
// 实际被理解成： P1 & (0x08 == 0)  →  P1 & 0  →  永远是 0

if ((P1 & 0x08) == 0)      // ✓ 位运算加括号

unsigned char a = 0x0F;
unsigned char b = ~a;      // 0xF0（8 位下正确）

int c = ~0x0F;             // 在 32 位 int 上是 0xFFFFFFF0，不是 0xF0！

unsigned char a = 1 << 8;    // ✗ 8 位类型左移 8 位 —— 结果不可预测
unsigned int  b = 1 << 16;   // ✓ 16 位类型可以移到 15
unsigned long c = 1UL << 31; // ✓ 要做大位号掩码，加 UL 后缀

if (a && b)    // 逻辑与：结果是 0 或 1
if (a & b)     // 按位与：结果是两个数按位运算的结果

P1 | 0x01;     // ✗ 这只是算了一下，结果丢掉了！
P1 |= 0x01;    // ✓ 才是"写到 P1"

11.7 自测（不看上面，写出这几行的作用）

P1 |= 0x01;
P1 &= ~0x01;
P1 ^= 0x01;
if (P1 & 0x01) { }
x = (a << 8) | b;
P1 |= (1 << 3);
P1 &= ~(1 << 3);

12Day 12 · 宏与预处理

12.1 预处理是什么

在真正编译之前，编译器会先做一遍文本处理：把所有 # 开头的指令处理掉，生成一份"展开后的代码"，再拿去编译。

12.2 常量宏：单片机里最常用

#define LED_PIN     1
#define MAX_SIZE    100
#define CRYSTAL     12000000UL     // 晶振频率 12MHz
#define LED_PORT    P1             // 甚至可以直接替换寄存器名

// 用起来和普通名字一样
LED_PORT = 0xFE;
if (i < MAX_SIZE) { ... }

注意全大写加下划线的命名风格 —— 这不是语法要求，是约定，让人一眼看出「这是个宏」。

12.3 带参数的宏（以及那个著名的括号陷阱）

#define SQUARE(x)   ((x) * (x))
#define MAX(a, b)   ((a) > (b) ? (a) : (b))

int y = SQUARE(3);        // 展开成 ((3) * (3)) = 9

#define SQUARE(x)  x * x

SQUARE(2 + 3)    // 你以为：(2+3) * (2+3) = 25
                 // 实际展开：2 + 3 * 2 + 3 = 2 + 6 + 3 = 11  ← 错！

#define SQUARE(x)   ((x) * (x))     // ✓ 双层括号
#define HALF(x)     ((x) / 2)
#define MUL(a,b)    ((a) * (b))

12.4 条件编译

用法一：头文件保护（Day 13 会详细用）

#ifndef __LED_H__
#define __LED_H__

/* 头文件的真正内容 */

#endif

意思是：「如果 __LED_H__ 还没被定义过，就定义它并保留下面的内容；否则整段跳过。」这样同一个头文件被包含多次也只生效一次。

用法二：调试开关（非常实用）

#define DEBUG 1

// 只有 DEBUG 为真时才编译进去
#if DEBUG
    #define LOG(x)   printf(x)
#else
    #define LOG(x)   /* 什么都不做 */
#endif

LOG("init ok\n");     // DEBUG=1 时打印；改成 0 后这行自动消失

单片机 ROM 很小，调试信息不该带到最终版本里。这个技巧能让你「调试时打开、发布时一行改掉」。

12.5 宏 vs 函数：怎么选

12.6 单片机里的实战写法

/* 位掩码宏：配合 Day 11 的位运算 */
#define BIT(n)          (1 << (n))

/* 引脚操作宏：把"低电平点亮"这件事封装成一个动作 */
#define LED_ON()        (P1 &= ~BIT(LED_PIN))
#define LED_OFF()       (P1 |=  BIT(LED_PIN))
#define LED_TOGGLE()    (P1 ^=  BIT(LED_PIN))

/* 用起来就像在说人话 */
LED_ON();
LED_TOGGLE();

#define LED_ON()   P1 &= ~BIT(LED_PIN)     // ✗ 少了最外层括号

// 如果有人这样用：
if (cond)
    LED_ON();
else
    LED_OFF();
// 展开后变成 if (cond) P1 &= ~BIT(...); else ... → 语法错误

13Day 13 · 多文件工程与内存分区

13.1 你的代码变成了什么（编译四个阶段）

13.2 为什么要拆成多个文件

13.3 .h 和 .c 的分工（一句话规则）

led.h —— 对外接口

#ifndef __LED_H__
#define __LED_H__

#include <reg51.h>

/* 宏 */
#define LED_PORT   P1
#define LED_COUNT  8
#define BIT(n)     (1 << (n))

/* 函数声明（只有一行，末尾分号，没有函数体） */
void Led_Init(void);
void Led_On(unsigned char index);
void Led_Off(unsigned char index);
void Led_Toggle(unsigned char index);
void Led_AllOff(void);

#endif

led.c —— 真正的实现

#include "led.h"

void Led_Init(void)
{
    LED_PORT = 0xFF;              /* 全灭（低电平点亮） */
}

void Led_On(unsigned char index)
{
    LED_PORT &= ~BIT(index);      /* Day 11 的清零写法 */
}

void Led_Off(unsigned char index)
{
    LED_PORT |= BIT(index);
}

void Led_Toggle(unsigned char index)
{
    LED_PORT ^= BIT(index);       /* 翻转 */
}

void Led_AllOff(void)
{
    LED_PORT = 0xFF;
}

main.c —— 只管流程

#include "led.h"

void DelayMs(unsigned int ms);

void main(void)
{
    unsigned char i;

    Led_Init();

    while (1) {
        for (i = 0; i < LED_COUNT; i++) {
            Led_On(i);
            DelayMs(200);
            Led_Off(i);
        }
    }
}

看 main.c —— 它完全不需要知道 LED 接在哪个口、低电平还是高电平点亮。这就是模块化的价值。

13.4 #include 的两种写法

13.5 extern 与 static

/* extern：声明"这个变量在别的文件里定义了" */
extern unsigned int g_tick;      // 只是打个招呼，不分配内存
unsigned int g_tick = 0;         // 真正的定义，只能有一处

/* static 修饰全局变量/函数：只在本文件可见 */
static void internal_helper(void) { }    // 别的 .c 文件调不到
static unsigned char buf[16];            // 别的 .c 文件访问不到

13.6 常见错误

14Day 14 · 内存、栈与 volatile

今天是第二周的最后一天，我们把「你的变量到底住在哪」讲清楚。理解这个，第三周看单片机就不再有迷雾。

14.1 程序的内存分成四块

/* 看清楚每一类变量住在哪 */

int global_var;                  // 静态区（全局变量）
static int file_var;             // 静态区（文件内静态）
const unsigned char table[4] = {1,2,3,4};   // 静态区/代码区（只读）

void func(void)
{
    int  local = 1;              // 栈（局部变量）
    static int count = 0;        // 静态区（函数退出后值还在）
    char *p = malloc(10);        // 堆（p 本身在栈上）
    free(p);
}

14.2 栈：函数调用是怎么工作的

每次调用函数，系统就在栈上给它分配一块空间（叫「栈帧」），放它的局部变量和返回地址；函数返回时，这块空间被回收。

void funcB(void)
{
    int b = 2;        // b 在栈上
}

void funcA(void)
{
    int a = 1;        // a 在栈上
    funcB();          // 调用 funcB，栈上又多一层
}

int main(void)
{
    funcA();
    return 0;
}

/* 栈的变化过程（从下往上长） */

调用 main : | main 的局部变量 |
调用 funcA: | main ... | funcA 的 a |
调用 funcB: | main ... | funcA 的 a | funcB 的 b |   ← 栈顶
funcB 返回: | main ... | funcA 的 a |
funcA 返回: | main ... |

int *bad(void) {
    int x = 10;
    return &x;      // ✗ x 所在的栈空间已经作废
}

14.3 51 特有的存储类型（了解即可）

51 的存储器分好几块，C 编译器用关键字指定变量放哪：

/* 数码管段码表放进 Flash，不占 RAM —— 单片机省内存的常规操作 */
unsigned char code seg_table[10] = {
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90
};

不加 code 的话，这 10 个字节就白占 RAM 了。51 的 RAM 是按字节省的，这个习惯要养成。

14.4 volatile：嵌入式的第一关键字

编译器的优化逻辑是：「如果一个变量我没看见谁改它，那它的值就不用重新读。」但单片机里有两种它看不见的修改：

• 硬件改的 —— 寄存器内容会被外设自己改变
• 中断改的 —— 中断服务函数随时可能插进来改

/* 错误示范：等串口收到数据 */
unsigned char flag = 0;

void Uart_ISR(void) interrupt 4     /* 中断服务函数（Day 22 学） */
{
    flag = 1;                       /* 中断里改 flag */
}

void main(void)
{
    while (flag == 0);              // ✗ 编译器认为 flag 永远是 0
                                    //   于是把整个循环优化掉 → 卡死
}

/* 正确写法 */
volatile unsigned char flag = 0;    /* 加 volatile */

void main(void)
{
    while (flag == 0);              // ✓ 每次都真的去内存读
}

14.5 第二周复盘

15Day 15 · 单片机是什么

15.1 单片机就是一台最小的电脑

你电脑里有 CPU、内存、硬盘、显卡、网卡…… 单片机把其中最核心的几样塞进了一块芯片：

15.2 芯片长什么样：40 个引脚怎么分工

经典 51（如 AT89C51 / STC89C52）是 40 脚 DIP 封装。按功能分成五类，记住分类，不要死记 40 个：

四个 IO 口各自有分工（P3 带串口/中断等复用功能），Day 17 专门讲。

15.3 最小系统：让芯片能跑起来的最少元件

芯片本身不会跑，必须外面配三个东西：

1. 电源：VCC 接 5V、GND 接地。这是最基本也最容易被忽略的 —— 「灯不亮」的排查第一步永远是量电源。
2. 晶振 + 两个电容：接在 XTAL1/XTAL2 上，给 CPU 提供时钟。没有时钟，CPU 一步都不走。
3. 复位电路：RST 脚接一个 10µF 电容到 VCC 和一个 10kΩ 电阻到 GND。上电瞬间电容充电，RST 短暂保持高电平完成复位；再并一个按钮可以用来手动复位。

15.4 时钟：CPU 的心跳

晶振就是 CPU 的节拍器。三个时间单位的关系（务必记牢）：

时钟周期 = 1 / 晶振频率            ← 最小的时间单位
机器周期 = 12 × 时钟周期           ← 标准 51 的"一步"
指令周期 = 1 ~ 4 个机器周期        ← 不同指令耗时不同

15.5 上电之后发生了什么

很多人以为「烧进去的程序会自动从某处开始跑」，其实有个固定流程：

1. 上电，电源稳定。复位电路让 CPU 保持复位状态一小会儿（保证电源稳了再开始）。
2. 复位结束，CPU 的程序计数器（PC）被置为 0x0000，从那里取第一条指令。
3. 而 0x0000 处放的是编译器安排的「启动代码」：初始化栈指针、把全局变量搬到 RAM 并清零，然后跳到你的 main 函数。
4. 你的 main 开始执行 —— Init() 配置各个寄存器，然后进入 while(1) 主循环。

16Day 16 · 点亮第一颗 LED

今天你会走完完整的一圈：画电路 → 写代码 → 编译 → 下载 → 灯亮。这一圈走通，后面全是它的变体。

16.1 电路：LED 怎么接

推荐接法（灌电流，51 的标准做法）：

   +5V
    │
   [LED]         ← 长脚（正极）朝上
    │
   [电阻] 330Ω   ← 限流电阻，必须要有
    │
   P1.0  ──────── 单片机引脚

工作原理：引脚输出 低电平（0）时，电流从 +5V 经 LED、电阻流入引脚 → 灯亮。
引脚输出高电平（1）时，引脚和 +5V 都是 5V，没有电压差 → 没有电流 → 灯灭。

16.2 为什么必须用灌电流接法

因为 51 的 IO 口两个方向的能力差得非常远：

原因在 Day 17 讲：P1/P2/P3 内部是「弱上拉 + 强下拉」，往上拉的力量很弱，往下拉的力量很强。

16.3 算一下限流电阻

LED 不能直接接 5V，必须串电阻，否则电流过大烧灯（甚至烧口）。公式：

R = (VCC − V_LED) / I

VCC  = 5V        （电源电压）
V_LED = 2V       （红色 LED 的正向压降，红/黄约 1.8~2.2V，蓝/白约 3.0~3.4V）
I    = 10mA = 0.01A   （目标电流，LED 正常 3~10mA）

R = (5 − 2) / 0.01 = 300Ω   →  取标准值 330Ω

16.4 代码：让 P1.0 的灯亮

/*==============================================================
  文件名 : main.c
  功能   : 点亮接在 P1.0 上的 LED
  硬件   : STC89C52RC @ 12MHz，LED 接 P1.0，低电平点亮
==============================================================*/
#include <reg51.h>          /* 芯片寄存器定义，必有 */

void main(void)
{
    P1 = 0xFE;              /* 1111 1110 → P1.0 输出低电平 → 灯亮 */

    while (1) {
        /* 空循环，让程序停在这里 */
    }
}

逐句解释：

16.5 从代码到硬件：这一句到底做了什么

这就是「底层逻辑」。你以后每写一行操作寄存器的代码，脑子里都应该能放一遍这条链。

16.6 Keil 建工程 + 下载（简版流程）

1. 新建工程：Project → New µVision Project，选一个空文件夹，工程名随意。
2. 选芯片型号：搜索你的型号（如 AT89C52 或 STC89C52）。没有 STC 的话选 AT89C52 也能用，它们寄存器兼容。
3. 新建源文件：File → New，把上面的代码粘进去，存成 main.c（后缀必须是 .c）。
4. 把文件加入工程：左侧 Source Group 1 右键 → Add Existing Files，选 main.c。这一步最容易漏，漏了会报「没有可编译的文件」。
5. 设置晶振频率：Options for Target → Target 页，Xtal 填 12.0（要和板子上实际的晶振一致）。
6. 勾选生成 HEX：Options for Target → Output 页，勾上 Create HEX File。不勾就没有 HEX，下载工具会找不到文件。
7. 编译：按 F7（或点 Build）。下面窗口出现 0 Error(s) 才算成功。
8. 下载：打开 STC-ISP → 选型号和串口号 → 打开 .hex 文件 → 点「下载/编程」→ 给板子断电再上电（STC 需要冷启动）→ 看到「操作成功」。

16.7 灯不亮怎么办（按这个顺序查）

17Day 17 · IO 口与寄存器

昨天你让一个灯亮了。今天要搞清楚：为什么引脚能输出高低电平？为什么它有方向？为什么读之前要先写 1？

17.1 四个口的分工

17.2 为什么叫「准双向口」

每一根 P1/P2/P3 的引脚内部大致是这样：

        内部 +5V（很弱的上拉）
           │
         [弱上拉管]        ← 拉高能力弱（几十~几百 µA）
           │
引脚 ──────┼──────→ 读到 CPU
           │
         [强下拉管]        ← 拉低能力强（10~20mA）
           │
          GND

• 写 0：强下拉管导通 → 引脚被强力拉到 0V → 灌电流能力强（能点灯）
• 写 1：弱上拉管导通 → 引脚被微弱地拉向 5V → 拉电流很弱（点不亮灯）

「准双向」的意思是：同一根引脚既能输出也能输入，不需要像别的单片机那样配置方向寄存器。但代价是下面这条铁律 ——

/* 读按键的标准写法 */
P1 = 0xFF;                  /* ① 先写 1，松开所有下拉管 */
if ((P1 & 0x01) == 0) {     /* ② 再读，才能读到外部真实的电平 */
    /* 按键按下 */
}

17.3 P0 的特殊性：开漏 + 需要上拉

P0 和另外三个口不一样，它内部没有弱上拉，是真正的「开漏」结构：

写 0 → 引脚被拉到 0V          ✓
写 1 → 引脚悬空（高阻态）      ← 不是 5V！

所以 P0 想输出高电平，必须外接一个上拉电阻（通常 10kΩ 排阻到 VCC）：

   +5V
    │
   [10kΩ]  ← 上拉电阻，P0 必须要有
    │
   P0.0 ──── 外设

17.4 寄存器名字是怎么来的：sfr 与 sbit

Day 9 讲过：P1 = 0xFE; 本质是 *(volatile unsigned char *)0x90 = 0xFE;。那 P1 这个名字是哪里来的？

/* reg51.h 里大致就是这样定义的 */
sfr  P1 = 0x90;          /* 给地址 0x90 起名叫 P1（8 位整体） */
sbit P1_0 = P1^0;        /* 给 P1 的第 0 位起名叫 P1_0（单独一位） */

/* 用 sbit 写代码，可读性会好很多 */
sbit LED1 = P1^0;
sbit KEY1 = P3^2;

LED1 = 0;                /* 点亮 —— 等价于 P1 &= ~(1<<0); */
LED1 = 1;                /* 熄灭 —— 等价于 P1 |= (1<<0); */

if (KEY1 == 0) { }       /* 读按键 —— 不用写位运算 */

17.5 电流限制：什么时候必须加驱动

所以下面这些必须加驱动电路：

18Day 18 · 流水灯与花样灯

今天把 Day 5（循环）、Day 6（数组）、Day 11（位运算）全部用起来。这是你第一次写「看起来像那么回事」的单片机程序。

18.1 延时函数：先把时间解决掉

流水灯要「一个一个依次亮」，中间必须有停顿。单片机没有 sleep，靠的是空转（执行一堆没用的指令来消耗时间）：

/* 粗略毫秒延时（12MHz 晶振）—— 软件延时 */
void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);      /* 空循环，什么都不做 */
}

18.2 流水灯：让那个 0 动起来

核心思路：让「唯一的那个 0」在位里从左往右移动。

i=0:  ~(1<<0) = 1111 1110   → 第 0 个灯亮
i=1:  ~(1<<1) = 1111 1101   → 第 1 个灯亮
i=2:  ~(1<<2) = 1111 1011   → 第 2 个灯亮
...
i=7:  ~(1<<7) = 0111 1111   → 第 7 个灯亮

/*========== 流水灯（单向循环） ==========*/
#include <reg51.h>

void DelayMs(unsigned int ms);

void main(void)
{
    unsigned char i;

    while (1) {
        for (i = 0; i < 8; i++) {
            P1 = ~(1 << i);      /* 只有第 i 位是 0，其余是 1 */
            DelayMs(200);
        }
    }
}

18.3 左右来回（Knight Rider 效果）

让灯走到头再走回来。关键是记录一个「方向」：

#include <reg51.h>

void DelayMs(unsigned int ms);

void main(void)
{
    unsigned char i;
    char dir = 1;            /* 1 = 往右，-1 = 往左。注意用 char 才有负数 */

    i = 0;
    while (1) {
        P1 = ~(1 << i);
        DelayMs(150);

        /* 到头了就把方向反过来 */
        if (i == 7) dir = -1;
        if (i == 0) dir =  1;

        i += dir;
    }
}

18.4 花样灯：查表法

如果要显示的花样没有规律（比如「两边向中间合拢」），一个个算反而麻烦。直接把每个状态写进数组，然后依次取出来：

#include <reg51.h>

void DelayMs(unsigned int ms);

/* 把每个状态写死在表里，放在 Flash 里省 RAM */
unsigned char code pattern[] = {
    0xFE,   /* 1111 1110  最右一个 */
    0xFC,   /* 1111 1100  右两个 */
    0xF8,   /* 1111 1000  右三个 */
    0xF0,   /* 1111 0000  右四个 */
    0xE0,   /* 1110 0000  右五个 */
    0xC0,   /* 1100 0000  右六个 */
    0x80,   /* 1000 0000  右七个 */
    0x00,   /* 0000 0000  全亮 */
    0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC,   /* 再收回来 */
    0x7F,   /* 0111 1111  最左一个 */
    0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01   /* 从左边收拢 */
};

void main(void)
{
    unsigned char i;
    unsigned char n = sizeof(pattern);   /* 表里有几个状态 */

    while (1) {
        for (i = 0; i < n; i++) {
            P1 = pattern[i];             /* 直接取出来用 */
            DelayMs(120);
        }
    }
}

18.5 试着改一改（这一步比读代码有用）

19Day 19 · 延时：时间从哪来

昨天你用 DelayMs(200) 让灯慢慢流。今天要搞清楚：这个「200 毫秒」到底准不准？为什么不准？什么时候能用、什么时候不能用？

19.1 软件延时的本质：数时间

单片机的 CPU 一步一步走，每一步花固定的时间。所以「让 CPU 空转 N 步」就等于「等一段时间」。

void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);     /* 空转 */
}

计算逻辑大致是：

一条指令 = 1~4 个机器周期
12MHz 下 1 个机器周期 = 1µs
内层循环 j 跑 120 次 ≈ 1000µs = 1ms
外层再跑 ms 次 → 约 ms 毫秒

19.2 为什么它不准（四个误差来源）

19.3 什么时候能用、什么时候不能用

19.4 让延时稍微靠谱一点的两招

/* 招一：用 volatile 阻止编译器乱优化（代价是慢一点） */
void DelayMs(unsigned int ms)
{
    volatile unsigned int i, j;        /* volatile 保证循环真的被执行 */
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);
}

/* 招二：用定时器写"精确延时"（后面 Day 22 的写法，这里先看一眼） */
void DelayMs_Exact(unsigned int ms)
{
    unsigned int i;
    for (i = 0; i < ms; i++) {
        TMOD &= 0xF0;  TMOD |= 0x01;   /* 定时器0，方式1 */
        TH0 = 0xFC;  TL0 = 0x18;       /* 1ms 初值 @12MHz */
        TR0 = 1;                       /* 启动 */
        while (!TF0);                  /* 等溢出标志 */
        TR0 = 0;  TF0 = 0;             /* 停，清标志 */
    }
}

招二虽然精确，但仍然是「等」——CPU 还是被困在 while 里。最好的用法是 Day 22 的中断方式。

19.5 一个能立刻做的实验：测一测你的延时准不准

让一个 LED 每秒翻转一次（500ms 亮、500ms 灭），然后用手机秒表对着一分钟数一数：

#include <reg51.h>

void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);
}

void main(void)
{
    while (1) {
        P1 &= ~0x01;        /* 翻转 P1.0（Day 11 的 ^= 写法也可以） */
        DelayMs(500);
    }
}

如果你数出来一分钟闪了 58 次而不是 60 次，那误差就是 3% —— 这就是软件延时的真实水平。

20Day 20 · 按键输入与消抖

到今天为止，单片机一直在「自己演给自己看」。今天它第一次接受你的输入。

20.1 按键怎么接

        +5V（单片机内部弱上拉）
           │
   P3.2 ───┼────── 平时读到 1
           │
         [按键]
           │
          GND      按下时引脚接地 → 读到 0

因为 P1/P2/P3 内部有弱上拉（Day 17），所以按键可以直接一端接引脚、一端接 GND，不需要外接上拉电阻。

P3 = 0xFF;                  /* 先松开所有下拉管 */
if ((P3 & 0x04) == 0) {     /* 再读 P3.2 */
    /* 按键按下 */
}

20.2 抖动：一个必须处理的问题

按键内部是机械触点。你按下的一瞬间，金属片会弹跳好几下才稳定接触：

理想情况:  ────────┐            ┌────────
                   └────────────┘
                   按下          松开

真实情况:  ────────┐┌┐┌─┐┌──────┐┌┐──────
                   └┘└┘ └┘      └┘└
                   ← 5~20ms 抖动 →

结果就是：你按一次，程序可能判断成按了七八次。现象是「按一下灯闪了好几下」或「按一下计数加了 5」。

20.3 消抖方案一：延时确认法（最简单）

#include <reg51.h>

sbit KEY = P3^2;            /* 用 sbit 给引脚起名字，代码更清楚 */
sbit LED = P1^0;

void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);
}

void main(void)
{
    while (1) {
        if (KEY == 0) {             /* 第一次检测到按下 */
            DelayMs(15);            /* 等 15ms 让抖动过去 */
            if (KEY == 0) {         /* 再确认一次，还是 0 才算真按下 */
                LED = ~LED;         /* 翻转 LED */
                while (KEY == 0);   /* 等松手，否则会连续翻转 */
            }
        }
    }
}

三个关键点：

20.4 消抖方案二：状态机（不阻塞 CPU）

方案一有个缺点：DelayMs 和 while 期间 CPU 被卡住，别的事都干不了。如果同时还要扫描数码管，就会闪。

正规写法是用「状态记录 + 每次循环检查一次」：

/* 放在主循环里，每轮调用一次，绝不阻塞 */
unsigned char KeyScan(void)
{
    static unsigned char last = 1;      /* 上一次的电平（static：值会保留） */
    static unsigned int  count = 0;     /* 稳定计数 */
    unsigned char now = KEY;

    if (now != last) {                  /* 电平变了 */
        count = 0;
        last = now;                     /* 重新开始计时 */
    } else {
        if (count < 1000) count++;
    }

    /* 连续 3 次读到 0（配合主循环节奏 ≈ 十几毫秒）→ 判定按下 */
    if (count == 3 && now == 0) {
        return 1;                       /* 返回一次"按下"事件 */
    }
    return 0;
}

这段代码用到了 Day 14 学的 static（局部变量值会保留）。它的好处是每次只花几个机器周期，主循环可以继续干别的事。

20.5 按键的三种「事件」

实际产品里的按键通常要区分这些情况：

这三种的判定都靠「记录按下时刻」+「比较时间差」。而「记录时刻」这件事必须用定时器（Day 22）—— 否则时间基准不准，长按的「1 秒」会变成 0.8 秒或 1.3 秒。

20.6 完整实战：一个按键控制一个灯

/*==============================================================
  功能：按一下 P3.2 的按键，P1.0 的 LED 翻转一次
  硬件：LED 接 P1.0（低电平点亮），按键接 P3.2 到 GND
==============================================================*/
#include <reg51.h>

sbit KEY = P3^2;
sbit LED = P1^0;

void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);
}

void main(void)
{
    LED = 1;                    /* 初始熄灭（低电平点亮，所以 1 是灭） */

    while (1) {
        if (KEY == 0) {
            DelayMs(15);            /* 消抖 */
            if (KEY == 0) {
                LED = !LED;         /* 翻转 */
                while (KEY == 0);   /* 等松手 */
            }
        }
    }
}

21Day 21 · 数码管与动态扫描

LED 只能告诉你「亮/灭」，数码管能告诉你「是几」。今天学怎么让单片机显示数字。

21.1 数码管的内部：8 个 LED

一位数码管里面就是 8 个 LED（7 段笔画 a~g + 1 个小数点 dp），它们的正极或负极被接在一起：

   aaa
  f   b
   ggg
  e   c
   ddd  · dp

买数码管一定要看清型号是共阳还是共阴 —— 用错了段码表，显示的会是乱七八糟的图案。

21.2 段码表（共阳，直接背下来）

一个字节的 8 位依次对应 dp g f e d c b a：

unsigned char code seg_table[10] = {
/*    dp g f e d c b a    */
    0xC0,   /* 1100 0000 → 0 ：a~f 亮，g 灭 */
    0xF9,   /* 1111 1001 → 1 ：b、c 亮 */
    0xA4,   /* 1010 0100 → 2 */
    0xB0,   /* 1011 0000 → 3 */
    0x99,   /* 1001 1001 → 4 */
    0x92,   /* 1001 0010 → 5 */
    0x82,   /* 1000 0010 → 6 */
    0xF8,   /* 1111 1000 → 7 */
    0x80,   /* 1000 0000 → 8 ：全亮 */
    0x90    /* 1001 0000 → 9 */
};

共阴的段码就是共阳的按位取反：0 = ~0xC0 = 0x3F，1 = ~0xF9 = 0x06……

21.3 静态显示：简单但费引脚

/* 一位数码管接 P0，共阳，显示 5 */
P0 = seg_table[5];      /* 0x92 */

4 位数码管如果都用静态显示，需要 4 × 8 = 32 根线 —— 而 51 总共只有 32 个 IO，别的什么都别想接了。

21.4 动态扫描：用时间换引脚

4 位数码管的接法（8 根段线共用 + 4 根位选线 = 12 根）

      段线 a~g,dp （8 根，4 位共用）
            │
    ┌───────┼───────┬───────┐
   位1     位2     位3     位4
    │       │       │       │
   位选1   位选2   位选3   位选4  （4 根，决定"现在轮到谁"）

/* 扫描的核心：每次只让一位的位选有效，送对应的段码，然后迅速切下一位 */
void Display(unsigned char d1, unsigned char d2,
             unsigned char d3, unsigned char d4)
{
    P0 = seg_table[d1];   /* 送第 1 位的段码 */
    P2 = 0x01;            /* 只选中第 1 位 */
    DelayMs(2);

    P0 = seg_table[d2];
    P2 = 0x02;            /* 只选中第 2 位 */
    DelayMs(2);

    P0 = seg_table[d3];
    P2 = 0x04;
    DelayMs(2);

    P0 = seg_table[d4];
    P2 = 0x08;
    DelayMs(2);
}

在主循环里不停调用 Display()，4 位就同时亮了：

void main(void)
{
    while (1) {
        Display(1, 2, 3, 4);      /* 显示 "1234" */
    }
}

21.5 三个必须知道的细节

void Display(unsigned char d1, unsigned char d2,
             unsigned char d3, unsigned char d4)
{
    P0 = 0xFF;            /* ① 先熄灭所有段（共阳写 0xFF 全灭） */
    P2 = 0x01;            /* ② 再选位 */
    P0 = seg_table[d1];   /* ③ 最后送段码 */
    DelayMs(2);
    /* 后三位同理 */
}

21.6 把数字拆成各位（用上 Day 3 的取余）

/* 把 0~9999 的数拆成 4 位，送给数码管 */
void ShowNumber(unsigned int n)
{
    unsigned char d1, d2, d3, d4;

    if (n > 9999) n = 9999;

    d1 = n / 1000 % 10;      /* 千位 */
    d2 = n / 100  % 10;      /* 百位 */
    d3 = n / 10   % 10;      /* 十位 */
    d4 = n        % 10;      /* 个位 */

    Display(d1, d2, d3, d4);
}

这就是 Day 3 讲的「先除到那一位，再对 10 取余」第一次派上真正的用场。1000 是四位数的最高位权值，所以从它开始除。

22Day 22 · 定时器与中断

22.1 定时器是什么

定时器就是一个硬件计数器：它自己在那儿数数，数满了（溢出）就举起一面旗子告诉你。

它数的对象：内部机器周期（12MHz 下每个 1µs 数一次）
数到最大值（方式1是 65535）再进一位 → 溢出 → 置位 TF0 标志

所以：「数了多少个数」×「一个数的时间」= 经过的时间。这就是定时器的全部原理。

初值 = 65536 − 需要数的个数
需要数的个数 = 定时时间 / 机器周期

22.2 常用初值速查（12MHz，方式 1）

if (++tick >= 20) {      /* 20 × 50ms = 1s */
    tick = 0;
    /* 这里做每秒一次的事 */
}

22.3 两个控制寄存器：TMOD 与 TCON

不用背，理解每个位的用途，用的时候查表：

TMOD —— 设置工作方式（不可位寻址，要整体写）

TMOD = 0x01;        /* 定时器0，方式1，定时模式，软件启动 —— 背下来这一行 */

/* 更安全的写法：只改低 4 位，不动定时器 1 的设置 */
TMOD &= 0xF0;
TMOD |= 0x01;

TCON —— 控制启停与标志（可位寻址）

22.4 写法一：查询法（简单，但仍占着 CPU）

void DelayMs_Exact(unsigned int ms)
{
    unsigned int i;
    for (i = 0; i < ms; i++) {
        TMOD &= 0xF0;  TMOD |= 0x01;
        TH0 = 0xFC;  TL0 = 0x18;    /* 1ms */
        TR0 = 1;                    /* 启动 */
        while (TF0 == 0);           /* 等溢出（CPU 卡在这里） */
        TR0 = 0;                    /* 停止 */
        TF0 = 0;                    /* 手动清标志 */
    }
}

比软件延时精确得多，但 CPU 还是在等。要真正解放 CPU，必须用中断。

22.5 中断：让硬件来通知 CPU

中断相关的寄存器

ET0 = 1;        /* ① 打开"定时器0"这个分开关 */
EA  = 1;        /* ② 打开"总开关" */
/* 只开一个都不行 —— 这是"中断进不去"的头号原因 */

中断服务函数：C51 的特殊语法

void Timer0_ISR(void) interrupt 1      /* interrupt 1 = 定时器0 */
{
    TH0 = 0x3C;                        /* 重新装初值（方式1不会自动重装） */
    TL0 = 0xB0;
    /* 中断里要做的事，要尽量短 */
}

22.6 完整例子：用定时器让 LED 精确闪烁

/*==============================================================
  功能：P1.0 的 LED 精确每 1 秒翻转一次（亮 1s，灭 1s）
        主循环完全空闲 —— CPU 不再被延时占用
  硬件：LED 接 P1.0；晶振 12MHz
==============================================================*/
#include <reg51.h>

sbit LED = P1^0;

unsigned char tick = 0;        /* 50ms 中断计数，凑 1 秒用 */

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

/* 定时器0 中断服务函数：每 50ms 进来一次 */
void Timer0_ISR(void) interrupt 1
{
    TH0 = 0x3C;                /* 重新装初值 */
    TL0 = 0xB0;

    tick++;
    if (tick >= 20) {          /* 20 × 50ms = 1s */
        tick = 0;
        LED = !LED;            /* 每秒翻转一次 */
    }
}

void main(void)
{
    LED = 1;
    Timer0_Init();

    while (1) {
        /* 主循环是空的！CPU 在这里可以干任何别的事 */
    }
}

22.7 中断里必须遵守的四条纪律

void Timer0_ISR(void) interrupt 1
{
    /* 忘了 TH0/TL0 重装 */
    tick++;
    if (tick >= 20) { tick = 0; LED = !LED; }
}
/* 现象：第一次 1 秒正常，之后变成 1.31 秒一次（65.54ms × 20） */

22.8 外部中断（顺带掌握）

除了定时器，51 还有两个外部中断，接在 P3.2（INT0）和 P3.3（INT1）上。适合处理「按键立刻响应」这类需求：

void ExtInt0_Init(void)
{
    IT0 = 1;        /* 1 = 下降沿触发（按下瞬间触发一次）；0 = 低电平触发 */
    EX0 = 1;        /* 允许外部中断0 */
    EA  = 1;        /* 总中断 */
}

void ExtInt0_ISR(void) interrupt 0
{
    /* 按键一按下就立刻执行这里，不用等主循环轮询 */
    LED = !LED;
}

23Day 23 · 串口通信

今天让单片机学会「说话」—— 把数据发给电脑，你就能在串口助手上看到它的想法。这是嵌入式调试最重要的手段。

23.1 为什么要串行

想让单片机把 8 位数据传给电脑，可以并行（8 根线同时传），也可以串行（一根线一位一位传）。

51 的串口用 P3.0（RXD，接收）和 P3.1（TXD，发送）—— 这就是 Day 17 讲的 P3 第二功能。

23.2 一帧数据长什么样（8N1 是最常用的格式）

空闲（高电平）
  │
  └─┐ 起始位   ┌─── 8 个数据位（低位先发）───┐  ┌ 停止位
    └─0───────┤ b0 b1 b2 b3 b4 b5 b6 b7 ├──1──┘
               └──────────────────────────┘

"8N1" 的意思：8 个数据位、N = 无校验位、1 个停止位

发一个字节实际上要发 10 位（1 起始 + 8 数据 + 1 停止）。所以 9600bps 的波特率，每秒实际能传 960 字节。

23.3 波特率：为什么必须用 11.0592MHz 晶振

波特率 = 每秒传多少个位。收发两端必须一致，否则收到的全是乱码。

51 的串口波特率由定时器 1 的溢出率决定：

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

反推 TH1：

23.4 串口控制寄存器 SCON

SCON = 0x50;      /* 0101 0000 = 方式1 + 允许接收 —— 背下来这一行 */

23.5 完整的串口初始化

/*==============================================================
  串口初始化：9600bps，8N1，允许接收，中断方式
  晶振：11.0592MHz
==============================================================*/
void Uart_Init(void)
{
    SCON = 0x50;        /* 方式1，允许接收 */

    TMOD &= 0x0F;       /* 清掉定时器1的设置，保留定时器0 */
    TMOD |= 0x20;       /* 定时器1，方式2（8位自动重装）—— 串口专用 */

    TH1 = 0xFD;         /* 9600bps @11.0592MHz */
    TL1 = 0xFD;         /* 方式2自动重装，TL1 也要给初值 */

    TR1 = 1;            /* 启动定时器1（它负责产生波特率） */

    ES  = 1;            /* 允许串口中断 */
    EA  = 1;            /* 总中断 */
}

23.6 发送与接收

发送一个字节（查询法）

void Uart_SendByte(unsigned char dat)
{
    SBUF = dat;             /* 把数据放进发送缓冲器，硬件自动开始发 */
    while (TI == 0);        /* 等发完（TI 由硬件置 1） */
    TI = 0;                 /* 软件清标志，为下一次做准备 */
}

void Uart_SendString(char *s)
{
    while (*s != '\0') {    /* 用 Day 6 学的字符串结束符 */
        Uart_SendByte(*s);
        s++;
    }
}

接收（中断法，推荐）

volatile unsigned char rx_data = 0;
volatile bit rx_flag = 0;               /* volatile！中断改的变量 */

void Uart_ISR(void) interrupt 4
{
    if (RI) {                           /* 是接收引起的 */
        RI = 0;                         /* 必须手动清 */
        rx_data = SBUF;                 /* 读走数据 */
        rx_flag = 1;                    /* 通知主循环 */
    }
    /* TI 产生的也可以在这里清，如果用中断方式发送的话 */
}

void main(void)
{
    Uart_Init();

    while (1) {
        if (rx_flag) {
            rx_flag = 0;
            Uart_SendByte(rx_data);     /* 收到什么就回什么（回显） */
        }
    }
}

23.7 printf 重定向：最舒服的调试方式

与其一直用 Uart_SendString，不如让 printf 直接输出到串口。原理是 C51 库的 printf 最终会调用 putchar，我们把它替换掉：

#include <stdio.h>

char putchar(char c)            /* C51 库的 printf 会调用这个函数 */
{
    SBUF = c;
    while (TI == 0);
    TI = 0;
    return c;
}

void main(void)
{
    Uart_Init();

    printf("系统启动\r\n");                 /* 现在 printf 输出到串口了 */
    printf("温度 = %d C\r\n", 25);
    printf("十六进制 = 0x%02X\r\n", 0xAB);   /* 调试寄存器特别有用 */

    while (1);
}

printf("P1 = 0x%02X\r\n", P1);       /* 端口实际电平是多少 */
printf("tick = %d\r\n", tick);       /* 中断进了几次 */
printf("进中断了\r\n");               /* 有没有进到某个分支 */

23.8 接线与调试

单片机           USB-TTL 模块          电脑
P3.1 (TXD) ────  RXD
P3.0 (RXD) ────  TXD
GND        ────  GND          ← 必须共地！
                         USB ──── 串口助手

24Day 24 · 综合项目 + 底层逻辑总串

最后一天做两件事：把学过的东西拼成一个完整的作品，然后把整条链路的底层逻辑串一遍。

24.1 综合项目：按键计数的秒表

/*==============================================================
  文件 : main.c
  功能 : 秒表 —— 数码管显示秒数，按键控制，串口上报
  硬件 : STC89C52RC @ 11.0592MHz
         P1.0      LED（状态指示）
         P3.2      K1  开始/暂停
         P3.3      K2  清零
         P0        数码管段码（共阳）
         P2.0~P2.3 数码管位选
         P3.0/P3.1 串口（接 USB-TTL）
==============================================================*/
#include <reg51.h>
#include <stdio.h>

sbit LED  = P1^0;
sbit KEY1 = P3^2;
sbit KEY2 = P3^3;

/* ---------- 全局变量 ---------- */
volatile unsigned char tick  = 0;     /* 50ms 计数 */
volatile unsigned char sec   = 0;     /* 秒 */
volatile bit           running = 0;   /* 是否在计时 */

/* ---------- 数码管段码表（共阳，放 Flash） ---------- */
unsigned char code seg_table[10] = {
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90
};

/* ---------- 毫秒延时（只用于按键消抖） ---------- */
void DelayMs(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 120; j++);
}

/* ---------- printf 重定向到串口 ---------- */
char putchar(char c)
{
    SBUF = c;
    while (TI == 0);
    TI = 0;
    return c;
}

/* ---------- 串口初始化：9600 8N1 ---------- */
void Uart_Init(void)
{
    SCON = 0x50;
    TMOD &= 0x0F;
    TMOD |= 0x20;          /* 定时器1 方式2 产生波特率 */
    TH1 = 0xFD;
    TL1 = 0xFD;
    TR1 = 1;
    /* 这里不用串口中断，用查询方式发 */
}

/* ---------- 定时器0 初始化：50ms @11.0592MHz ---------- */
void Timer0_Init(void)
{
    /* 11.0592MHz 机器周期 = 12/11.0592 = 1.0851us，50ms 需数 46080 个 */
    /* 初值 = 65536 - 46080 = 19456 = 0x4C00 */
    TMOD &= 0xF0;
    TMOD |= 0x01;
    TH0 = 0x4C;
    TL0 = 0x00;
    ET0 = 1;
    EA  = 1;
    TR0 = 1;
}

/* ---------- 定时器0 中断：每 50ms ---------- */
void Timer0_ISR(void) interrupt 1
{
    TH0 = 0x4C;                     /* 重装初值，别忘了！ */
    TL0 = 0x00;

    if (!running) return;           /* 暂停时不计数 */

    tick++;
    if (tick >= 20) {               /* 20 × 50ms = 1 秒 */
        tick = 0;
        sec++;
        if (sec > 99) sec = 0;
    }
}

/* ---------- 数码管动态扫描（显示秒数） ---------- */
void Display(unsigned char value)
{
    unsigned char d1, d2;

    d1 = value / 10;                /* 十位 */
    d2 = value % 10;                /* 个位 */

    /* 第 1 位（十位） */
    P0 = 0xFF;                      /* 先关段（消影） */
    P2 = 0x01;                      /* 选位 */
    P0 = seg_table[d1];             /* 送段码 */
    DelayMs(2);

    /* 第 2 位（个位） */
    P0 = 0xFF;
    P2 = 0x02;
    P0 = seg_table[d2];
    DelayMs(2);
}

/* ---------- 按键扫描（带消抖，不阻塞） ---------- */
unsigned char KeyScan(void)
{
    static unsigned char last1 = 1, last2 = 1;
    unsigned char now1 = KEY1, now2 = KEY2;

    if (now1 != last1) { last1 = now1; if (now1 == 0) return 1; }
    if (now2 != last2) { last2 = now2; if (now2 == 0) return 2; }
    return 0;
}

/* ---------- 主程序 ---------- */
void main(void)
{
    unsigned char key;

    Uart_Init();
    Timer0_Init();

    LED = 1;
    printf("秒表就绪，按 K1 开始\r\n");

    while (1) {
        /* ① 扫描按键 */
        key = KeyScan();

        if (key == 1) {                 /* K1：开始/暂停 */
            DelayMs(15);                /* 消抖 */
            if (KEY1 == 0) {
                running = !running;
                LED = !running;         /* 计时中灯亮 */
                printf(running ? "开始计时\r\n" : "暂停\r\n");
                while (KEY1 == 0);      /* 等松手 */
            }
        }

        if (key == 2) {                 /* K2：清零 */
            DelayMs(15);
            if (KEY2 == 0) {
                sec = 0;
                tick = 0;
                printf("已清零\r\n");
                while (KEY2 == 0);
            }
        }

        /* ② 刷新数码管（每次主循环都刷，保证不闪） */
        Display(sec);

        /* ③ 每秒上报一次（靠比较秒数变化） */
        {
            static unsigned char last_sec = 255;
            if (sec != last_sec) {
                last_sec = sec;
                printf("计时: %d 秒\r\n", sec);
            }
        }
    }
}

需要数的个数 = 50000µs / 1.0851µs = 46080
初值 = 65536 - 46080 = 19456 = 0x4C00   →  TH0 = 0x4C, TL0 = 0x00

24.2 底层逻辑总串：从一行 C 到引脚上的电压

这是整份教程的收束。你写的每一行操作寄存器的代码，都走这条链：

24.3 三周知识地图

24.4 排错方法论（比任何具体知识都值钱）

1. 从底层往上层查：电源 → 时钟 → 复位 → 程序有没有跑 → 寄存器值 → 接线 → 代码逻辑。永远不要一上来就改代码。
2. 先确认「芯片在跑」：量 ALE 脚（第 30 脚）应有约 1/6 晶振频率的方波（11.0592MHz → 约 1.8MHz）。没波形 = 芯片根本没运行，代码再改也没用。
3. 把内部状态打印出来：有了 Day 23 的 printf 重定向，把 P1、标志位、计数器的值打出来看，比猜快十倍。
4. 一次只改一个变量：同时改三处，现象变了你也不知道是哪一处生效。
5. 相信现象，不要相信推断：你觉得「这里肯定是 1」，就用 printf 打出来验证。
6. 回到最小可工作版本：代码越改越乱时，退回上一个能跑通的版本，再一小步一小步加。

24.5 下一步学什么