一、单片机开发与仿真环境搭建

1.1 Keil 软件

1.1.1 Keil软件的简介

大家安装完Keil软件肯定是要学习使用的，这里不建议将软件汉化，软件本来原生态的样子就很看，要学会适应英化的软件。

Keil C51 是德国 Keil Software 公司（现已被 ARM 收购）推出的 8051 系列的 IDE(Integrated Development,集成开发环境)。它不仅支持汇编语言开发，更支持 C/C++等高级语言开发单片机。其可以完成从工程建立和管理、编译、链接、目标代码生成、软件仿真调试等完整的开发流程。

1.1.2 Keil C51的工作界面

1.1.3 Keil C51建立工程

首先你需要在电脑文件资源管理器中新建一个文件夹用来存放你的工程，下面是新建工程的GIF演示。注意的AT89C52是吕老师要求的，如果不一样请换成你们的，如果直接找AT89C52是找不到的，要先找对应的厂商然后点击+就可以看到相对应的芯片型号了。

1.1.4 建立/编辑C语言源程序文件

下面是GIF演示，比较简单，一定要记得后缀是.c。

以上，我们就完成了最基本的软件使用，下面是一些进阶使用。

1.1.5 工程的设置

在工程建立后，还需要对工程进行设置。在 μVision5 的上方工具栏中，右击工程名 Target 1 框旁的魔术棒 ，即打开工程设置对话框。啊，好多我也不懂，看老师PPT吧，这些你说重要吧它也不是那么重要，看一遍过去吧。

1.1.6 Keil C51 的Debug

大家都知道Debug在调试程序中重要地位，所以我将Keil C51的Debug单独拿出来学习。

源程序编写完毕后还需要编译和链接才能够进行软件和硬件仿真。① 编译；②排错；在程序的编译/链接中，如果用户程序出现错误，还需要修正错误后重新编译/链接，重新烧录程序查看错误现象，十分消耗时间。因此需要单步调试，一步一步的查看代码运行效果来加快对错误的排查速度。

进入DEBUG模式后，黄色箭头为汇编程序运行位置光标，蓝黄三角形为当前 C 语言运行位置，指向当前等待运行程序行。其界面如下,其中单个黄色箭头为汇编程序运行位置光标(汇编一生之痛)。

在 μVision5 中，有 4 种DEBUG运行方式 ：单步跟踪(Step Into)，单步运行(Step Over)，运行到光标处(Run to Cursor line)，全速运行(Go)。

下面是使用Debug进行调试的GIF录像，测试用例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 理论
#include<reg52.h>

sbit led0 = P0^0;
sbit led1 = P0^1;
sbit led2 = P0^2;
sbit led3 = P0^3;


sbit led4 = P0^4;
sbit led5 = P0^5;
sbit led6 = P0^6;
sbit led7 = P0^7;


void main ()
{
    led0 = 0;
    led1 = 0;
    led2 = 0;
    led3 = 0;


    led4 = 0;
    led5 = 0;
    led6 = 0;
    led7 = 0;


}

1.1.7 存储空间资源的查看和修改

这一部分对我来说还是太早了，先看PPT吧

1.2 Proteus软件

1.2.1 Proteus软件的简介

① Proteus 是英国 Lab Center Electronics 公司推出的用于仿真单片机及其外围设备的EDA工具软件。

② Proteus 与 Keil C51 配合使用，可以在不需要硬件投入的情况下，完成单片机 C 语言应用系统的仿真开发。

③ Proteus 具有高级原理布图(proteus)、混合模式仿真(PROSPICE)、PCB 设计以及自动布线(ARES)等功能。

1.2.2 Proteus简单使用

继续看PPT吧，一定要看啊，我是太懒了就不想打字😀

1.2.3 Proteus 8 与 Keil C51 的联合使用

下面进行基本演示：① 将源程序编译、链接生成HEX文件，这里需要将工程设置中的Output设置中的Create HEX File勾选上。

1.2.4 Proteus 画出单片机的最小系统

使用Proteus选择元器件的方法如下

电气连接方法如下

1.2.5 实战教学：流水灯的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 实际
#include <reg52.h>

sbit LED=P0^0;
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

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

void led()
{
	int i=0;
	for(i=0;i<8;i++)
	{
		P0=~(0x01<<i);
		delay(50);
	}
}

void main(){
	
	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;
	
	while(1){
		led();
	}
}

搭建如图所示仿真电路，这里采用共阳极二极管接法

然后对C源码进行编译生成HEX文件，之后导入芯片中

1.3 STC-ISP软件

1.3.1 STC-ISP软件的简介

STC-ISP是一款又 STC 研发的单片机程序下载烧录软件，是针对 STC 系列单片机而设计的，可下载 STC89 系列、STC12 系列和 STC15 等系列的 STC 单片机，使用简便。

1.3.2 STC-ISP软件的使用

安装好STC-ISP和驱动后，当我们电脑插上板子之后，打开设备管理器，查看端口，我这里是COM12

1.3.3 实战教学： 点亮第一个LED灯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 实际
#include<reg52.h>

sbit LED = P2^0;
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;


void main() {
    ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;
    
    LED = 0;
    while(1);
}

1.4 单片机最小系统

单片机最小系统也叫做单片机最小应用系统，是指用最少的原件组成单片机可以工作的系统。单片机最小系统的三要素就是电源、晶振、复位电路。如下图所示

1.4.1 电源

1.4.2 晶振

1.4.3 复位电路

复位电路是一种用来使电路恢复到起始状态的电路设备，它的操作原理与计算器有着异曲同工之妙，只是启动原理和手段有所不同。复位电路，就是利用它把电路恢复到起始状态。就像计算器的清零按钮的作用一样，以便回到原始状态，重新进行计算。

和计算器清零按钮有所不同的是，复位电路启动的手段有所不同。一是在给电路通电时马上进行复位操作；二是在必要时可以由手动操作；三是根据程序或者电路运行的需要自动地进行。复位电路都是比较简单的大都是只有电阻和电容组合就可以办到了，再复杂点就有三极管等配合程序来进行了。（上电复位和手动复位和程序自动复位）

上电复位：假如我们的单片机程序有 100 行，当某一次运行到第 50 行的时候，突然停电了，这个时候单片机内部有的区域数据会丢失掉，有的区域数据可能还没丢失。那么下次打开设备的时候，我们希望单片机能正常运行，所以上电后，单片机要进行一个内部的初始化过程，这个过程就可以理解为上电复位，上电复位保证单片机每次都从一个固定的相同的状态开始工作。这个过程跟我们打开电脑电源开电脑的过程是一致的。

手动复位：当我们的程序运行时，如果遭受到意外干扰而导致程序死机，或者程序跑飞的时候，我们就可以按下一个复位按键，让程序重新初始化重新运行，这个过程就叫做手动复位，最典型的就是我们电脑的重启按钮。

程序自动复位：当程序死机或者跑飞的时候，我们的单片机往往有一套自动复位机制，比如看门狗，具体应用以后再了解。在这种情况下，如果程序长时间失去响应，单片机看门狗模块会自动复位重启单片机。还有一些情况是我们程序故意重启复位单片机

程序跑飞是指系统受到某种干扰后,程序计数器PC的值偏离了给定的唯一变化历程,导致程序运行偏离正常的运行路径.程序跑飞因素及后果往往是不可预计的.在很多情况下,程序跑飞后系统会进入死循环而导致死机。

1.4.4 单片机看门狗

看门狗(WDT)是一个定时器。看门狗是用来防止万一单片机程序出错造成重大损失的。防错的原理很简单，它在硬件上就是一个定时器，当它溢出的时候就会让单片机强制复位使程序重新开始执行。

正常的情况下是不能让它溢出的，所以在程序上每隔一段时间要给他置一次值（俗称喂狗），只要程序中正常给它喂他就不会溢出。

一旦程序跑飞了，有干扰或者进入死循环之类的情况时，不能正常执行程序了，那么就永远执行不到喂狗的指令了，但此时定时器是硬件控制的，仍然会走，所以溢出了，单片机就复位了。

一般安全性要求比较高的，系统跑飞了会造成重大事故的都会加一个“狗”保安全。

通常，看门狗的溢出时间越短越灵敏，跑飞之后复位的时间越短，也就越安全，但是，喂狗的操作也要更频繁。

1.5 LED小灯原理

LED(light-emitting diode)，即发光二极管，俗称 LED 小灯，它的种类很多，参数也不尽相同，我们板子上用的是普通的贴片发光二极管。这种二极管通常的正向导通电压是 1.8V到 2.2V 之间，工作电流一般在 1mA～20mA 之间。其中，当电流在 1mA～5mA之间变化时，随着通过 LED 的电流越来越大，我们的肉眼会明显感觉到这个小灯越来越亮，而当电流从5mA～20mA 之间变化时，我们看到的发光二极管的亮度变化就不是太明显了。当电流超过20mA 时，LED 就会有烧坏的危险了，电流越大，烧坏的也就越快。所以我们在使用过程中应该特别注意它在电流参数上的设计要求。

1.5.1 USB接口电路

通过 USB 线，电脑给我们的开发板供电和下载程序以及实现电脑和开发板之间的通信。从图上可以看出，USB 座共有 6 个接口，其中 2
脚和 3 脚是数据通信引脚，1 脚和 4 脚是电源引脚，1 脚是VCC 正电源，4 脚是 GND 即地线。5 脚和 6 脚是外壳，我们直接接到了 GND 上，大家可以观察一下开发板上的这个 USB座的 6 个引脚。

我们现在主要来看 1 脚 VCC 和 4 脚 GND。1 脚通过 F1（自恢复保险丝）接到右侧，在正常工作的情况下，保险丝可以直接看成导线，因此左右两边都是 USB 电源+5V，自恢复保险丝的作用是，当你后级电路哪个地方有发生短路的时候，保险丝会自动切断电路，保护开发板以及电脑的 USB 口，当电路正常后，保险丝会恢复畅通，正常工作。右侧有 2 条支路，第一条是在+5V 和 GND 接了一个 470uF 的电容，电容是隔离直流的，所以这条支路是没有电流的，电容的作用，我们下节课再介绍，这节课我们主要看第二条支路。我们把第二条支路摘取出来就是如图 2-4 这个样子。

1.5.2 LED小灯电路

发光二极管是二极管中的一种，因此和普通二极管一样，这个二极管也有阴极和阳极，习惯上也称之为负极和正极。我们接入的 VCC 电压是 5V，发光二极管自身压降大概是 2V，那么在右边 R34 这个电阻上承受的电压就是 3V。现在我们要求电流范围是 1~20mA 的话，就可以根据欧姆定律 R=U/I，把这个电阻的上限和下限值求出来：U=3V，当电流是 1mA 的时候，电阻值是 3K；当电流是 20mA 的时候，电阻值是 150欧，也就是 R34 的取值范围是 150~3K 欧姆。这个电阻值大小的变化，直接可以限制整条通路的电流的大小，因此这个电阻我们通常称之限流电阻。同理，我们在板子后级开关控制的地方，又添加了一个 LED10 发光二极管，作用就是当我们打开开关时，这个二极管才会亮起。

这里的开关虽然只有一个，但是是 2 路的，2 路开关并联能更好的确保给后级提供更大的电流。电容 C19 和 C10，都是隔离断开直流的。把右侧的 GND 去掉，改成一个单片机的IO口，如图所示

我们把右侧的原 GND 处接到单片机 P0.0 引脚上，那么如果我们单片机输出一个低电平，也就是跟 GND 一样的 0V 电压，就可以让 LED
小灯发光了。我们可以让 P0.0 这个引脚输出一个高电平，就是跟 VCC 一样的 5V 电压，那么这个时候，左侧 VCC 电压和右侧的 P0.0 的电压是一致的，那就没有电压差，没有电压差就不会产生电流，没有电流 LED 小灯就不会亮，也就是会处于熄灭状态。

1.5.3 单片机端口

STC89C52RC芯片有4*8=32个IO端口可以供我们用程序输出高低电平。拿P0表示它可以一次性控制8个引脚端口输出每个引脚想输出的电平状态。P0是一个寄存器，它的功能是控制所对应的8个IO口(P0.0-P0.7)。如果我们控制P0.0单个端口输出低电平，P0.1~P0.7这7个IO端口输出高电平，程序中使用这条语句P0=0xFE;为什么是0xFE呢？

C语言中的十六进制0xFE用二进制表示11111110，我们就知道了单片机的P0.0排在这八个位的最低端。我们控制P0.2单个IO端口输出低电平，其他IO端口输出高电平，则是P0=0xFB; 二进制表示11111011。

显然我们使用P0=0xFE就是强制把其他7个IO端口都输出了固定高电平状态。要想实现单独控制一个IO端口，这时我们用这条语句来声明sbit LED=P0^0;也就是只控制一个位，此时想让单独的P0.0输出低电平只需LED=0;即可，LED不过是表示P0.0所用的名字而已,你可以根据喜好改写这个名字。值得注意的是，程序书写中如果没有sbit LED=P0^0;这个提前定义，直接P0.0=0;这样书写是不符合语法的，必须先给IO端口一个命名，而且sbit LED=P0.0;这样的写法同样也不符合语法，规定是P0^0。还有我们也不能命名已经在 #include<reg52.h>头文件中已有的名字，查看头文件内容可知，有些名字已经被使用，像sbit PSW=P0^0;，sbit CY=P0^0;这样定义会编译报错的，因为命名冲突了。#include<reg52.h>头文件中已有的名字我们后期会使用到的。

1.5.4 实际LED硬件连接

1.5.4.1 三极管认识

先看左边的图，想要点亮LED灯，只需要+5v和R1处于短接状态即可，那么PNP型三极管就是起到被单片机IO端口控制是否允许此处短接的作用，也叫三极管是否导通。如果单片机IO端口输出的是低电平（0V）,此时我们可以直观的认为+5那端与单片机IO端口形成压差有电流通过，而电流流向正如箭头所示，则表明此时+5与R1是短接状态，三极管导通，灯就被点亮了。如果单片机IO端口输出的是高电平（5V）时，则没有形成压差也就产生不了电流，那么箭头不能代表此时有电流流向这个方向，所以+5与R1是断开状态，灯没有被点亮。箭头起到的就是辅助我们理解的优势，这样我们可以根据箭头很形象的判断出单片机IO端口输出什么电平状态时就可以点亮LED。R1,R2电阻起到的是限流保护，右图使用的是NPN型三极管，那么单片机IO端口输出高电平时点亮LED,输出低电平时点不亮LED。

1.5.4.2 三八译码器

该元器件只需要用到我们单片机三个IO端口就可以控制它的八个引脚其中的一个输出低电平，开发板就用到这种叫74HC138三八译码器。我们省略它的电源供电引脚，画出需要讲解的引脚。

首先有三个引脚E0,E0,E1需要固定给它默认的电平它才能正常工作，俗称使能器件。

此时3个单片机IO端口输出不一样的电平时，IO0~IO7的其中一个引脚就会输出低电平，而其他7个IO都是输出高电平。

当我们的三个IO端口这样输出时，则有以下情况

1

三个IO端口输出的三个值从 IO端口3→IO端口2→IO端口1排成二进制数的得数就是哪个IOx输出低电平。比如三个IO端口这样输出：1 1 0。此时二进制值为十进制的6，那么IO6就输出低电平，其他输出高电平

1.6 蜂鸣器原理

1.6.1 单片机IO端口电流

不知道大家有没有发现，绝大部分单片机上的LED小灯电路基本都是确定+5v正压，而让单片机IO口输出低电平使小灯发光。为什么呢？

我们来看看宋老师的讲解吧。下面是两个LED小灯电路

左边电路即使单片机IO端口输出高电平5V，灯的亮度是很低的，因为单片机IO端口流出来的电流太小，无法驱动LED正常发光。这个是关联到单片机内部的集成电路原因的，大家可以上网上查查。

右边电路这时单片机IO端口输出低电平时灯却很亮，原因这是电源供给的5V，电流比较大，所以可以使LED发光较亮。举个例子：充电宝的接口输出电压5V，但是它流出的电流大，所以给手机充电就快，虽然电脑USB口接口电压也是5V但充电却非常慢，原因是USB口电流太小。

STC89C52RC这款芯片的P1，P2，P3这一共24个IO端口由于内部硬件的原因上电的时候都是输出高电平的，而P0一开始是一种不确定的状态（有时是高有时是低），但我们用的开发板已经把P0端口接了上拉电阻，所以开发板的P0.0~P0.7初始时也是输出高电平的。

1.6.2 有源蜂鸣器

蜂鸣器分有源蜂鸣器和无源蜂鸣器，两者表面长相相同，有源蜂鸣器有正负极之分，正极接5V，负极接地就可以响。和LED小灯一样，我们可以从简到繁的理解有源蜂鸣器。

1.6.3 无源蜂鸣器

开发板中无源蜂鸣器硬件连接除了一个续流二极管外就如有源蜂鸣器一样了，无源蜂鸣器实物可以不分正负极接，但它也标有“+”符号，也许是为了在我们不知道这是有源蜂鸣器还是无源蜂鸣器的情况上统一规定接法吧。

要让无源蜂鸣器发声，需要我们在单片机IO端口上输出500Hz~4.5kHz的脉冲频率信号。

用时间表示就是要输出周期为0.22ms~2ms（（1/4500s）~（1/500s））范围的方波,这个周期内高电平时间和低电平时间各占一半。

1.6.4 无源蜂鸣器鸣叫

1. 输出方波图解

现在要给单片机IO端口输出4KHz的方波，其方波周期为：$\frac{1}{4000}=0.25ms$，高电平时间：$\frac{0.25}{2}=0.125ms$，低电平时间：$\frac{0.25}{2}=0.25ms$。

1.7 独立按键

独立按键是单片机最常用的硬件部分

1.7.1 独立按键与矩阵按键

4个独立按键已经可以满足大部分的程序测试。学会了独立按键，矩阵按键是十分好学的。

首先看一下我们按键的分布

看一下是K4按键的电路图，我们让单片机的P2.3输出低电平，按键被按下，则被圈出部分的电压均为0V，因为都接地了。

1.7.2 按键的原理

单片机上的按键使用的是没有自锁的按钮，当我们按下按键后两个断点就被短接起来，松手后，按键自动弹起两个断点恢复原来的状态不再短接。

使用P2.7进行理解，我们按下K4按键，则断点之间导通，P2.7与GND连接被接地，此时P2.7的IO端口为0V，也就是低电平，俗称被拉低。这时候即使是程序令P2.7输出5V高电平都于事无补，因为这是外部电路直接导致，IO端口就是0V。内部硬件也能感觉到这个信号属于被强制拉低。因此程序中寄存器位的值是可以受外部电路影响而改变的。

基于以上我们对按键的认识我们理想中的按键过程图如下。

1.7.3 按键用法

联系生活按键的常用做法就像生活中的电磁炉或者门铃那样，按下电磁炉上的加热功能键后马上松开，发现电磁炉上的数就增加了。现在我们打算用开发板像按电磁炉上的按键一样，按一下灯被点亮，再按一次灯被熄灭这样的来回切换灯的状态的功能。

我们之前所讲的按键过程解析图只是理想中的效果，真正的按键过程图是这样的(按键的抖动)

按键按下的前期，IO端口并不是马上就接通地而处在稳定状态的，按键按下时，IO端口有短暂的时间接通地之后又松开了这么的一个来回的过程，这是自弹式按键本身的结构属性，此处称作按键抖动。如果我们一直按着不放，这时IO端口就会处在一种很稳定的接触状态，当我们松开按键时也会产生弹起抖动，这种抖动持续时间一般少于10ms。在之前的实验中，按键动作常速下“稳定接触状态”也会持续在50ms，这个时候程序去读取稳定的状态时是0，这样就可以判断是否按键已经按下，按下了就执行相应的程序功能。

那么我们如何处理这种抖动状态呢？

我们在软件上可以这样处理，当程序检测到上图的A段时“if(KEY4==0)”满足了条件，但是KEY4因为按键的抖动会在短时间里时而变为1时而变为0，所以我们在满足第一个“if(KEY4==0)”条件的时候马上做延时50ms，等待抖动过去，然后再次判断此时的KEY4还是等于0吗，是的话就执行切换灯的状态程序。（双层if嵌套，使用第一个if判断是否为低电平，延迟后判断是否是稳定态）,图解如下

但是在代码实现后，如果我们按下按键一直不松手，则灯会一直闪烁。这是因为“稳定接触状态”一直保持着长时间的低电平，所以程序的二次“if(KEY4==0)”判断一直满足条件就会在“LED2=0;”和“LED2=1;”之间来回切换，再加上50ms延时才会保持亮一段时间灭一段时间所体现的LED闪烁。

1.7.4 按键模式

按键模式主要分为两种支持连按和不支持连按。其中支持连按即我们使用遥控器放大电视的音量时只需按住“+”键不放，屏幕上的音量值在一直累加，松手后就停止累加了，这种就叫做按键支持连按功能。不支持连按”，例如我们用的电磁炉上的“+”键，按下不松手时数值只加一次就不加了，只有松手后再按才会进行数值的第二次累加。两种按键模式在单片机开发中都会经常使用。

1.7.5 不支持连按模式

我们要实现稳定接触状态的时间再怎么长，只能执行一次功能代码的目的。我们可以利用IO端口检测到按键按下然后执行完功能程序之后，下一个语句就写：如果IO端口还是保持着低电平（不松手状态），那程序就不往下执行了，让程序在这里“停止”，只有IO端口变成高电平（已松手）才允许“放行”程序去运行。我们知道按键抖动的时间少于10ms，所以在满足第一次“if(KEY4==0)”判断的时候只做“delay_ms(10);”的延时左右，过了这段时间就是“稳定接触状态”了，于是再去二次判断“if(KEY4==0)”即可。

以上虽然我们仅用while(KEY4==0)就把按键模式给切换了，不过这条语句严格来说是有缺陷的。如果我们编写更加复杂的程序时，while(KEY4==0)就成了Bug了。如果我们对按键按下不松手，那程序就一直在循环等待，不遇到高电平就不往下执行代码，如果这时有重要的程序要执行，那岂不是因按键而耽误。

1
2
3
4
5
6
7
8

while(1) {
    if(KEY4==0) {
        delay(50);
        if(KEY4 == 0) {
            //要执行某些功能的语句
        }
    }
}

即使我们不使用while(KEY4==0);，只要我们按键不松手，每次都要执行delay_ms(10);，这样的代码称不上高效率，我们只能再次完善代码了。

所以我们需要改善我们的程序，这里为了让程序做到通用性，我们定义一个key_up为unsigned char类型的变量。我们新定义的key_up变量是用来记录此时按键IO端口的扫描值，进一步分析，当按键按下不松手时，此时的key_up等于KEY4（也就是0），当按键松手后，key_up就等于1了。然后想进入执行功能语句时，先过了“if(key_up==0)”这一关，因为我们一直让key_up在死循环里存取KEY4的值，所以只要没有按键动作，key_up一直等于1，这样连进入功能语句的第一关都没有资格。

当有按键按下时，key_up等于0了，进入了第一关，然后我们再设最后一关，如果通过了最后一关就可以执行功能语句了，最后一关是判断“if(KEY4==1)”，也就是说如果按键没松手，就无法执行功能语句了。没错，我们这次的不支持连按模式是只有按键松手之后才去执行的，上一讲则是按下之后过了10ms就执行代码了。大家可以根据这一思路写代码了。

1.7.6 回归按键

按键的执行任务也可以封装为函数，需要静态变量static去定义key_up，因为它需要跟着KEY4变化，而不是每次都被初始化为同一个值。

1.7.7 支持连按（全局变量）

支持连按的代码就是在不支持连按代码的思路上把if(KEY4==1/0)改为if(KEY4==0/1)，这样的话按键不松手程序就能一直进入if(KEY4==0/1)的大括号里面。然后我们定义一个变量times，如果一直按着不放，times就一直累加，累加到1000，意味着低电平已经持续了一定的时间，我们就可以执行功能代码了，如图所示

全局变量就是先在所有函数前定义，这种变量可以在所有函数中使用，例如这个变量的值发生改变成为另一个值时，假设是12，其他函数此时运用这个变量的值就是12。全局变量有利有弊，可以自己学习一下。

1.7.8 双模式函数封装

以上我们学会了两种按键模式(不能连按模式和连按模式)的代码，我们现在决定将这两种模式封装成一个函数，然后通过参数选择是支持连按还是不支持连按。

考虑到，两种模式的选择，现在利用两个按键来实现按键模式的切换，K3负责用来给K4做支持连按还是不支持连按的选择。这里可不是说K3,K4各自负责一个模式。

在我的开发板的原理图，在P2.3输出低电平的情况下，K1,K2,K3,K4就可以当独立按键。

大家可以自己想一下如何实现这一功能，写写代码，然后参考第二章的按键部分。

1.8 外部中断

1.8.1 寄存器

1.8.1.1 单片机的内部资源

我们熟知的P0,P1,P2,P3，包括上图中的TCON以及#inlcude <reg52.h>头文件中的IE、SCON等等都叫做寄存器。这些寄存器都可以粗浅的认为就是一个8位的变量，其中像P0^0这个最低位就是控制单片机的外部IO端口输出高低电平。而像TOCN^1(IEO)这些有什么作用呢？这就涉及到单片机的内部资源了。

1.8.1.2 IE0的作用

我们先看一下原理图中的P3端口

P3寄存器中的每一位都在#include <reg52.h>头文件中声明好了。我们拿P3^2来说，如果这个IO端口被外部电路拉低，那么TCON的第一位(也就是TCON^1)就会被置1，在程序中IE0变为1。

我们来验证一下，我们用一根杜邦线的一头插入P3.2的引脚，然后另一头插入GND(拉低)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <reg52.h>
#include "function.h"

//请提前将P3.2和GND相连
void main() {
	LED_Init(); //初始化LED硬件模块
	while(1) {
		if(IE0 == 0) {
			LED2 = !LED2;
			delay_ms(50);
			LED2 = 1; //如果IE0不等于0了，要保证熄灭LED2;
		}
		if(IE0 == 1) {
			LED9 = !LED9;
			delay_ms(50);
			LED9 = 1; //如果LED0不等于1了，要保证熄灭LED9
		}
		delay_ms(50); //总要执行`if(IE0 == 0)`或者`if(IE0 == 1)`，这个延时要保证其中一盏灯灭的时间，保证总有灯闪烁的现象
	}
}

我们看到LED9在不停的闪烁，此时拔了连接GND那头的杜邦线看到LED9熄灭，LED2不停的闪烁，连着插拔几次观察得到当P3.2遇到低电平的时候IE0会一直等于1，只有当P3.2为高电平时IE0才会等于0。

1.8.1.3 IT0的作用

再看看TCON^0(也就是IT0)，我们把上面的代码中的IE0改为IT0的初始值是多少。经测试，IT0初始值为0。若是我们再主函数开头赋值给IT0为1，那么IE0只有当P3^2从高电平变成低电平(俗称下降沿)就会被1，即使P2^3后面变成高电平IE0也不会变成0，一直是1。

这时需要我们在程序里让IE0清零（俗称软件清零）才行。

我们把下面的代码下载进去

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <reg52.h> 
#include <function.h> //详见第六章第8讲
 
void main()
{  
    IT0 = 1;
    LED_Init();   //初始化LED硬件模块 
     
    while(1)
    { 
        if(IE0==1)//只有当P3.2从高电平变成低电平这个瞬间（下降沿）IE0才会被置1，后面P3.2不管是一直保持高电平还是低电平，IE0被清0之后都不会再次被置1，只有P3.2再次产生下降沿才会被置1
        {  
            IE0=0;
            LED2=!LED2;  
        }     
        delay_ms(50);
    }   
}

即使杜邦线一直都插着GND端口，也就是P3.2都保持着低电平，LED2也不会闪烁，只有不断拔插杜邦线，LED2才会有亮灭的跳变。

所以当IT0等于1时，P3.2遇到下降沿IE0就会被置1，我们软件把这个位清0之后，如果P3.2没有再次遇到下降沿，IE0都不会被置1。

1.8.2 中断函数

根据上述，当赋值IT0为1时，P3.2遇到下降沿，IE0被置1，要想使IE0自动清零，需要引用中断函数。中断函数就是当它满足一定的条件时就会暂停主函数的执行内容，转而去执行中断函数。

1.8.2.1 中断函数的书写

中断函数与其他我们封装过的子函数的写法不同，有个区分标志interrupt。至于后面为什么会有个数字0，我们后面会了解到。

1
2
3

void EXTI0_IRQHandler() interrupt 0 {
    
}

以上函数名是可以随意取的，只要不跟以前封装定义好的函数名冲突就行。这里我们取EXTI0_IRQHandler作为函数名是模仿STN32单片机的写法。

1.8.2.2 EX0和EA

想要进入中断函数，必须满足它的一些前提条件。这里EX0(IE^0)和EA(IE^7)要初始化赋值给1才能进入中断程序取执行任务。

EA叫做中断总开关，EX0是针对P3.2的外部中断的开关，也就是说想要进入中断子程序必须满足两个开关都要闭合。

1.8.3 进一步理解中断函数

1.8.3.1 外部中断1

以上我们注意到我们使用标志interrupt 0，这表明我们使用的是外部中断0（P3.2的功能）。还有一个外部中断1（P3.3的功能），想要使用外部中断1，代码中需要把EX0改为EX1，IT0改为IT1。interrupt后面的0要改为2，函数名我们改为EXTI1_IRQHandler()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <reg52.h>
#include "function.h"

void main() {
	IT1 = 1; //下降沿触发模式
	EA = 1;
	EX1 = 1;
	
	LED_Init(); //初始化LED硬件电路
	while(1);
}



void EXIT1_IRQHandler() interrupt 2 {
	LED2 = !LED2;
}

为什么是interrupt 2呢？

1.8.3.2 按键触发中断

每次要把P3.2和P3.3外部拉低或释放，都需要拔插杜邦线，这样太麻烦，我们可以用按键来取代这些拔插动作，按键按下不放就相当于一直拉低，跟杜邦线一直插着GND一个效果，松开按键就跟杜邦线没插GND一样。把杜邦线这样接，让P3.3和P2.3一起相连，K4的按键动作可以使P2.3和P3.3同步电平。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <reg52.h> 
#include <function.h>//详见第六章第8讲
 
void main()
{  
    IT1 = 1;   //下降沿触发模式
    EX1 = 1;
    EA  = 1;
   
    LED_Init();//初始化LED硬件模块 
    KEY_Init();//初始化按键功能模块
    while(1);
}
  
void EXTI1_IRQHandler() interrupt 2
{
    LED2=!LED2; 
}

1.8.3.3 按键触发中断消抖

以上按键似乎没能很灵敏的按一下松手LED2就跳变一次亮或灭的效果，那是因为我们没有延时消抖，一个按键动作就存在好几个下降沿了，导致中断函数被执行了几遍。

在中断函数中加延时就可以消除这种失灵现象了，不过在以后编程里不能在中断函数里使用延时，这样会使程序的执行效率大打折扣，我们本次只是作为测试代码才在中断函数里用延时。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <reg52.h> 
#include <function.h>//详见第六章第8讲
 
void main()
{  
    IT1 = 1;   //下降沿触发模式
    EX1 = 1;
    EA  = 1;
   
    LED_Init();//初始化LED硬件模块 
    KEY_Init();//初始化按键功能模块
    while(1);
}
  
//请把P3.3和P2.3用杜邦线连接起来
void EXTI1_IRQHandler() interrupt 2
{
    delay_ms(50);//去抖动
    if(INT1==0)  //P3.3是否还处于低电平的稳定接触状态，INT1已在“#include <reg52.h>”中定义好了
    {
        LED2=!LED2; 
    } 
}

1.9 定时器

以上对中断知识的了解，外部中断这种需要物理动作才能触发中断函数执行，但很多情况下我们需要的是中断函数在适当时刻可以自动的去执行，所以就需要定时器来辅助了。

定时器是单片机内部的一个硬件资源。

用生活常见现象举例：定时器相当于一个闹钟，我们调5分钟后闹钟就响，在这5分钟里我们想做什么就做什么，相当于我们自己是主函数里的任务，想运行什么任务就运行什么，也不用去理会闹钟还剩多少时间就响，我们只是一直做我们想做的事就行。

之后闹钟响了，这时我们不能再任性去做主函数的事了，得赶紧把中断函数里的事办完先，也就是要去执行中断函数了，主函数的事要暂停不做先，执行完中断函数之后继续回到主函数做我们的事。可是又过了5分钟闹钟又响了，没办法，我们又要放停自己的事去执行中断函数了，当然闹钟是可以关闭的，这就相当于是把中断函数的触发开关给断开了。

1.9.1 溢出

我们知道秒表计时到59秒的时候，再过1秒就变成了00。同理，当我们的unsigned char类型的变量的数值为255时，再加1就变为0了, unsigned int的变量如果此时的值为65535，后面再加1也同样成为0，这些都叫溢出。

再举一个例子来理解定时器溢出概念，中学时我们做过一些化学实验，其中有一种容器叫做试管，如果试管是空的，我们用一个导管往试管里加水，导管的水流流速是均匀不变的，试管里的水要想溢出，需要的是x个单位的时间，如果我们想把距离溢出的时间缩短为一半，那我们提前把试管里的水装满到一半，这样就可以改变了溢出时间。

通过这个例子我们就可以明白，要想确定好定时器溢出产生中断的间隔时间，我们就要往这个“试管”提前装好合适的水量。

1.9.2 两种定时模式

试管有65535个刻度的型号，也有255个刻度的型号，不过我们的导管水流流速是永远不变的。

如果我们用的是大试管（65535个刻度），那么溢出时间我们可以控制的长一些，也就是定时时间可以多一点。我们要是想定时36个单位刻度的时间，那就先往试管装好65500个刻度的水量先，这样等到水位到达65535那个刻度时，再加一个刻度就溢出了，这时溢出的就是36个单位刻度的时间。试管每次水溢出，试管里的水就会消失不见（归0），如果我们还想定时36个单位刻度的时间，还需要重新把65500个刻度的水量再次装好给试管。

如果我们用的是小试管（255个刻度），虽然它的定时时间远远没有大试管的定时时间长，但是只要我们第一次装好水量，每次它溢出之后，不会马上归0，而是试管里的水重新归为我们第一次那个时候装好的水量，所以只要在第一次确定了水量，也就确定了以后的所有定时时长。

这种叫做试管的东西就是我们单片机内部的另一个寄存器，51单片机有两个定时器，分别叫做定时器0和定时器1，跟外部中断有 0和1的两个硬件资源一样。这里我们先拿定时器0来讲解，定时器1大体原理都一样。

1.9.3 定时器模式的选择

我们想选用哪个试管作为定时时长，首先需要初始化寄存器TMOD相对应的位的值。先看到下面这张图

可以看到圈出来的左右两个紫色框，4-7位是控制定时器1的，0-3位是控制定时器0的。我们要确定选择的定时器模式们主要看M1和M0两个参数。

1. 如果M1=0，M0=1，选用的是大试管定时模式。
2. 如果M1=1，M1=0，选用的是小试管定时模式。

因为我们暂时没有使用到定时器1，所以4-7位(俗称高四位)可以全置为0.2-3位用不到，也是置为0，我们先选择大使馆作为定时模式，所以TMOD这个寄存器初始化为TOMD=0x01;。这里注意，因为M1和M0在#include<reg52.h>头文件中并没有sbit M0=TMOD^0;的内容，所以我们初始化只能是TMOD=0x01，一次性操作8个位，而在程序里书写M1=0或M0=1是错位的。

之后我们把使用“大试管”称为定时器的工作模式1，使用“小试管”称为定时器的工作模式2。

1.9.4 定时时长的做法

定时器0有两个寄存器分别是TH0和TL0，大家再次粗浅的把TH0和TL0认为是两个8位的变量吧。因为我们用的是定时器的工作模式1，这两个8位的变量相当于组合成了16位的变量，TH0是高8位（H:High），TL0是低8位（L:Low）。假如此时再过一个刻度的时间就溢出，那么此时会有TH0等于255，TL0等于255，因为二进制的1111111111111111等于十进制的65535。65535再加1就溢出嘛。因为我们用的是11.0592M的晶振，所以每增加1花费的时间是（12/11059200）秒。

如果我们用定时器的工作模式1定时20毫秒后触发中断该怎么实现呢？首先我们先往这两个寄存器填充数值

可以看到，两个“8位的变量”从高到低合起来成为16位的变量，至于定时20ms为什么是这样填充，我们先用反推法给大家演示。

十六进制的0XB800换算成十进制的值为47104，于是定时的时长为（65536-47104）=18432个刻度的单位时间。18432*（12/11059200）=0.02秒=20毫秒。

我们再正推，要定时50毫秒怎么给TH0和TL0赋初值？设距离溢出还剩x个刻度，x*（12/11059200）=0.05，解得x=46080。所以需要提前装好65536-46080=19456个刻度的水量。也就是填充给TH0和TL0合成的16位的变量的值就是19456。19456换算成十六进制为0x4C00。所以要定时50毫秒，那么TH0=0x4C;、“TL0=0x00;。

1.9.5 定时器简单运用

·注：我们知道TH0和TL0合成的“16位的变量”的初值最小要为0，不能是负数，所以我们要满足：65536-( x/(12/11059200) )>=0。解得x<= 0.071111秒=71.111毫秒。也就是用定时器的工作模式1最长的定时时间为71毫秒左右而已。

下面我们来学习定时器的简单运用，这方便我们理解相关的理论知识。

1. 首先定时器也是有开关的，这个相当于我们的导管是否打开让水流进“试管”里。因为我们用的是定时器0，TCON^4这个位就是控制定时器0是否打开或关闭，所以TR0=1;就是打开了定时器开始计时，TR0=0;是关闭了定时器计时功能。只要打开了定时器，TH0和TL0合成的“16位的变量”就会每过(12/11059200)秒就自加1，直到定时器溢出。
2. 我们的定时器0一旦溢出，TCON^5就会被置1（TF0==1）,如果我们不使用中断函数也是可以在主函数里等待判断“if(TF0==1)”。TF0跟外部中断0的IE0一样，被置1了需要软件清零。

用定时器0来实现间隔50ms的流水灯实验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<reg52.h>
#include "function.h"

void main() {
    u8 i = 0;
    LED_Init(); //初始化LED硬件模块
    TMOD = 0x01; //设置定时器0位工作模式1
    TH0 = 0x4C; //色湖之定时时间位50ms
    TL0 = 0x00;
    TR0 = 1; //启动定时器0
    
    while(1) {
        if(TF0 == 1) { //判断定时器0是否溢出，每隔50ms就可以进入一次这个if语句内部
            TF0 = 0; //软件清零，定时器0溢出后，清0溢出标志
            TH0 = 0x4C; //重新赋值，保证下次溢出时间间隔还是50ms
            TL0 = 0x00;
            P0 = ~(0x01 << i); //每盏灯的点亮时间都保持者50ms
            i++;
        }
        if(i >= 8) i = 0;
    }
}

用定时器1来实现间隔50ms的流水灯实验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <reg52.h> 
#include <function.h>//详见第六章第8讲
 
void main()
{   
    u8 i=0;
    LED_Init();   //初始化LED硬件模块 
    TMOD = 0x10;  //设置定时器1为工作模式1
    TH1  = 0x4C;  //设置定时时间为50ms
    TL1  = 0x00;
    TR1  = 1;     //启动定时器1
     
    while(1)
    {
        if (TF1 == 1)     //判断定时器1是否溢出，每隔50ms就可以进入一次这个if语句
        {
            TF1 = 0;      //定时器1溢出后，清0溢出标志
            TH1 = 0x4C;   //重新赋初值，保证下次溢出间隔时间还是50ms
            TL1 = 0x00;
            P0=~(0x01<<i);//每盏灯的点亮时间都保持着50ms
            i++;
        }   
        if(i>=8)i=0;
    }
}

1.9.6 定时器工作模式2

这里我们讲解一下定时器0的工作模式2，也就是使用小试管的方式，TMOD的初始化就为TMOD=0x02;。我们知道工作模式2的最长溢出时间仅为256*(12/11059200)=0.000277秒=277微秒。

我们想实现间隔51ms的流水灯实验该怎么做？我们需要利用循环，首先我们定义一个变量cnt用来记录每次的溢出次数，然后我们的定时时间为51微秒（因为最大定时只有278微秒），cnt记录的值等于1000的时候，证明时间已经过去了51ms，于是再去执行流水灯的任务。

我们已经知道工作模式2是不需要在溢出之后再填充初始值的，比如我们定时的时间为51微秒，那么计算出“距离溢出的刻度”就为47（实际计算出的是47.0016，所以定时为51微秒误差就不大）。所以给TL0赋初值为256-47=209=0xD1。那么TH0也是给初值为0xD1，这是保证每次TL0溢出之后新的初始值是等于TH0的值的，所以定时器工作模式2又叫做8位自动重装载模式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <reg52.h>
#include "function.h"

void main() {
    u8 i = 0;
    u16 cnt = 0;
    LED_Init(); //初始化LED硬件模块
    TMOD = 0x02; //设置定时器0为工作模式2
    TH0 = 0xD1; // 定时51us
    TL0 = 0xD1;
    TR0 = 1; // 启动定时器0
    while(1) {
        if(TF0 == 1) { //每隔51us,cnt加1
            TF0 = 0; //定时器溢出TF0软件清零
            cnt ++; //记录溢出次数
        }
        if(cnt >= 1000) { // 溢出次数为1000时表明过去了51ms
            cnt = 0;
            P0 = ~(0X01 << i); // 执行流水灯，保证每个流水灯亮51ms
            i++;
        }
    }
    if(i >= 8) i = 0;
}

1.9.7 定时器中断函数的使用

定时器和掩饰其的概念不同，延时函数需要占用CPU的使用权，正在延时的时候其他任务没有CPU使用权就会拖慢执行效率。而定时器是不需要占用CPU的使用权，它是独立运行的，所以上面的代码的实现原理就是每隔51微妙，有个变量会自动加1，过了1000个51微妙的时候LED的状态才会发生改变，可以说CPU在51ms的时间里基本什么都没有做，只是在51微妙到了的时候做了cnt++;的工作。

与外部中断一样，定时器中断也有中断函数，同理，程序去执行中断函数就会把TF0的中断标志位自动清0，所以只要我们用了定时器中断函数，那么TF0就可以不用再出现在程序书写中了。

外部中断

定时器0的中断函数

interrupt”后面的数字为什么是1?

1. 这些编号是为了区分哪些硬件资源的相关中断函数，如果我们同时使用两个定时器，那么只能用“interrupt 1”和“interrupt 3”来区分谁是谁的中断函数了。
2. 使用“TIM0_IRQHandler”作为函数名也是模仿STM32定时器中断函数名的写法。
3. 如果我们使用的是工作模式1，每次触发中断函数的执行内容首先就是再次给TH0和TL0赋初值保证下次的定时时间还是一样。这里我们使用中断函数的执行方式来实现30ms的间隔流水灯，算出TH0和TL0合成的“16位的变量”要填充的值为37888=0x9400。
4. 在中断函数里也是可以定义局部变量的，当然如果这个变量是用来辅助流水灯的，那么肯定是要定义成静态变量的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <reg52.h>
#include "function.h"

void main() {
    LED_Init(); //初始化LED硬件模块
    EA = 1; //打开总中断开关
    TMOD = 0x01; //设置定时器0为工作模式1
    TH0 = 0x94; // 设置定时时间为30ms
    ET0 = 1; //打开定时器0中断的开关
    TR0 = 1; //启动定时器0
    while(1);
}

void TIM0_IRQHandler() interrupt 1 {
    static u8 i;
    TH0 = 0x94; //重新设定时间为30ms
    TL0 = 0x00;
    
    P0 = ~(0x80 >> i); //流水灯向左移动
    i++;
    if(i >= 8) i = 0;
}

觉得30ms的流速太快，想改为300ms的话，修改一下中断函数即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <reg52.h>
#include "function.h"

void main() {
	LED_Init();
	EA = 1;
	TMOD = 0x01;
	TH0 = 0x94;
	TL1 = 0x00;
	ET0 = 1;
	TR0 = 1;
	while(1);
}
//通过重复10次30ms实现定时300ms
void TIM0_IRQHandler() interrupt 1 {
	static u8 i = 0;
	static u8 cnt = 0;
	TH0 = 0x94;
	TL0 = 0x00;
	cnt++;
	
	if (cnt >= 10) {
		cnt = 0;
		P0 = ~(0x80 >> i);
		i++;
		if(i >= 8) i = 0;
	}
}

1.9.8 定时器初始化优化

之前我们对定时器进行初始化（即填充初始值）我们写TH0=0x94;TL0=0x00;。我们这样写是因为我们提前计算了需要装填的数字，显然如果没有注释我们很难指导这是要定时多长时间，所以为了增强程序的可读性，我们需要优化定时器初始化的写法。

要优化初始化的写法，首先要明白在程序书写过程中，赋值给寄存器的值可以书写成16进制的数也可以是十进制的数。TH0填充的是高八位，TL0填充的是低8位，那么如果这个16位的变量的十进制值是258，二进制的值就是0000000100000010。所以高八位的值位1(258/256=1)，低八位的值是2(258%256=2)。我们也可以认为258/256=1是0x0102(258)右移了8位等于0x0001,简化书写就是0x01。而58%256=2是0x0102(258)舍去了高8位等于0x0002，简化书写就是0x02。

下面是图解，以一个16位的变量的十进制值是47104，二进制的值是1011100000000000，所以高八位的值是184(47104/256=184)，第八位的值是0(47104%256=0)

综上所述我们要定时20ms的话，给TH0和TL0赋值方式可以为TH0=184;TL0=0;。

我们通过对TH0和TL0传递十进制数字对初始化过程进行了优化，但这仍需要我们自己进行计算。假定定时的时间为1ms。算出要填的16位的变量为64614=0xFC66按照之前的写法就是TH0=0xFC/252;TL0=0x66/102。而我们也可以像下面这样写以打掉相同的效果。

1. TH0=( 65536-( 0.001/(12/11059200) ) )/256
2. TL0=( 65536-( 0.001/(12/11059200) ) )%256

因为( 65536-( 0.001/(12/11059200) ) )/256 = 252；( 65536-( 0.001/(12/11059200) ) )%256 = 102。有了这个思路，我们就可以将初始化赋值过程的写法改写为一串数字公式即可。

比如我们定时的最小单位时间为1微秒，那么定时50000微秒（50毫秒）就可以这样写来给TH0和TL0赋初值

1. TH0=( 65536-( (50000/1000000)/(12/11059200) )/256;

2. TL0=( 65536-( (50000/1000000)/(12/11059200) )%256;

这里的(50000/1000000)代表定时的是0.05秒，也就是50毫秒。

如果要定时其他毫秒数, 数字公式中的其他数字我们不需要修改，只需要把50000改为想定时的时间就可以了，计算过程交给单片机算出来，我们也就不需要自己用计算器把最终值算出来再赋给TH0和TL0这么麻烦了。

我们再化简上式就是

1. TH0=( 65536-( (50000*110592)/120000) )/256;

2. TH0=( 65536-( (50000*110592)/120000) )%256;

1.9.9 初始化需要注意的点

按上一讲说的书写方式，实现定时50ms间隔的流水灯。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <reg52.h>
#include "function.h"

void main() {
    LED_Init(); //初始化LED硬件电路
    EA = 1; //打开中断总开关
    TMOD = 0x01; //设置定时器0为工作模式1
    TH0 = (65536 - ( (50000 * 110592) / 120000 )) / 256; //设置定时时间为50ms
    TL0 = (65536 - ( (50000 * 110592) / 120000 )) % 256; 
    ET0 = 1; //启动定时器0中断的开关
    TR0 = 1; //启动定时器0
    while(1);
}

void TIM0_IRQHanler() interrupt 1 {
    static u8 i;
    TH0 = (65536 - ( (50000 * 110592) / 120000 )) / 256; //重新初始化填充
    TL0 = (65536 - ( (50000 * 110592) / 120000 )) % 256;
    P0 = ~(0x01 << i);
    i++;
    if(i >= 8) i = 0;
}

下载进开发板发现根本不是间隔50ms！靠！！！！！！！！这是为什么呢？

首先我们要知道，51单片机能存储最大的一个整型数的大小只有4个字节，也就是最多能记忆这个数到4294967296（2的32次方），而在

( 65536-( (50000110592)/120000 )中明显不能把(50000\110592)给临时存储，因为这个等式的得数已经大过2的32次方。所以我们的定时器才会无法实现准确的50ms定时。如果我们对编程没有一定的积累是很难察觉出这个隐形漏洞的。

解决办法就是，我们的定时最小单位只能是10微秒，也就是定时的时间必须是10微秒的整数倍。书写如下TH0=( 65536-(5000*110592)/12000 ) )/256;把之前的50000和120000都去掉一个零，这样就可以准确的定时50ms了，因为“(5000)*110592)”没有超过2的32次方，读者自行修改本讲提供的代码中的4处之后下载进开发板观察现象是不是又实现50ms的间隔流水了。

但是这样好像不是很通用，我们需要在此优化初始化的写法

上述程序中的5000意为定时的是50ms，也就是5000*10微秒，但我们希望潜意识里假如要定时200微秒，如果写成20我们的思维还要绕个弯再把20默默乘以10才领悟出这是定时200微秒。倒不如这样，我们看到关键的数字是多少那就是要定时多少微秒。

比如看到关键数字为50000时就知道定时的是50000微秒。所以我们这样改写：TH0=( 65536-( (50000/10)110592)/12000 )/256;这样既保证了“(50000/10)\110592”没有超过2的32次方，也使“50000”更直观的让我们知道要定时的是50000微秒。但是大家要记住，关键数字必须是10的整数倍，如果想定时个208微秒，“(208/10)”还是等于20，所以定时时间还是200微秒。

1.9.10 代码参考

我们分析如下的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void ConfigTimer0(unsigned int ms)
{
    unsigned long tmp;              //临时变量
     
    tmp = 11059200 / 12;            //定时器计数频率
    tmp = (tmp * ms) / 1000;        //计算所需的计数值
    tmp = 65536 - tmp;              //计算定时器重载值
    tmp = tmp + 13;                 //补偿中断响应延时造成的误差
    T0RH = (unsigned char)(tmp>>8); //定时器重载值拆分为高低字节
    T0RL = (unsigned char)tmp;
    TMOD &= 0xF0;                   //清零T0的控制位
    TMOD |= 0x01;                   //配置T0为模式1
    TH0 = T0RH;                     //加载T0重载值
    TL0 = T0RL;
    ET0 = 1;                        //使能T0中断
    TR0 = 1;                        //启动T0
}

第一句：tmp = 11059200 / 12;。定时器的寄存器计数，每加1计数就是经过（12/11059200）秒。那么计数了11059200次就是经过12秒了。经过1秒计数就是（11059200/12）= 921600。这样我们就明白了第一条语句的意思。

第二句：tmp = (tmp * ms) / 1000;我们想定时1ms，需要的计数就是（921600/1000）=921.6，需要定时xms就是需要计数921.6x。例如：如果我们想定时5ms，那么需要的计数值就是921.6*5=4608。

定时器初始化：TH0=(65536-4608)/256，TL0=(65536-4608)%256。当然也可以这样表达，两种书写方式的功能作用都一样：TH0= (unsigned char)(65536-4608)>>8；TL0= (unsigned char)(65536-4608)。这里先不考虑中断响应延时造成的误差。T0RH，T0RL是两个全局变量，为的是在中断函数中可以重新赋初值给寄存器TH0和TL0。

解释tmp + 13：由于中断函数的执行有时需要消耗不同的时间，所以定时时间会有误差导致进入中断函数时会产生与设想时的时间不同，所以需要调整计数值，也就是上面代码中的tmp需要微调节成一个合适的数，上面是固定加了13这个数，但是有时需要灵活改变这个微调值，所以我们改为传入不同的参数来改变这个微调值。

基于微调我们改进以上代码，上述代码定时的最小单位为1ms，下一章由于我们要学舵机，需要定时的最小单位是0.1ms，所以我们的代码定时的最小单位必须是0.1ms，也就是100us。看到我们的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void TIM0_Init(u32 us,int trim)//trim:微调
{
    u32 tmp;                        //临时变量
      
    tmp = 11059200 / 12;            //定时器计数频率
    tmp = ( tmp * (us/100) )/10000; //计算所需的计数值
    tmp = 65536 - tmp;              //计算定时器重载值
    tmp = tmp+trim;                 //微调计数值使其定时更精确到我们想要的定时时间
    T0RH = (unsigned char)(tmp>>8); //定时器重载值拆分为高低字节  
    T0RL = (unsigned char)tmp;
    TMOD &= 0xF0; //清0低四位 
    TMOD |= 0x01; //设置定时器0为工作模式1   
    TH0 = T0RH;   //加载T0重载值   
    TL0 = T0RL;
    ET0 = 1;      //闭合定时器0中断的开关        
    TR0 = 1;      //启动定时器0         
}

要想定时2ms，传入的参数就是2000，我们的参数是us数，如果传入的是2000，第二条语句就是“(tmp*2)/1000”，与宋老师的代码原理一样。不过需要记住的是改代码不能定时小于100us的时间，最低单位只能是100us。

1.9.11 微调定时精确时间

一般定时器中断函数里的内容最好是能够快速地去执行完，比如只执行几条简单的语句，这样与主函数配合才会使程序更加高效。前面，只使用定时器中断负责某个IO引脚间隔跳变或者使一个变量间隔自加1的简单语句。

现在要实现间隔50ms左右的时间让流水灯左右循环移动的同时，还需要无源蜂鸣器一直响，这样的功能，思路该怎么去实现？

首先我们知道无源蜂鸣器要想鸣叫的比较尖锐，那P1.6需要一个合适的脉冲信号，这个信号打算使P1.6高低电平保持的时间为300微秒不断循环。所以我们用定时器中断实现P1.6的电平间隔跳变，主函数里负责完成流水灯的任务即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <reg52.h>
#include <function.h>

u8 T0RH, T0RL;
void TIM0_Init(u32 us,int trim)//trim:微调
{
    u32 tmp;                       //临时变量
     
    tmp = 11059200 / 12;           //定时器计数频率
    tmp = ( tmp * (us/100) )/10000;//计算所需的计数值
    tmp = 65536 - tmp;             //计算定时器重载值
    tmp = tmp+trim;                //补偿中断响应延时造成的误差
    T0RH = (unsigned char)(tmp>>8);//定时器重载值拆分为高低字节  
    T0RL = (unsigned char)tmp;
    TMOD &= 0xF0; //清0低四位 
    TMOD |= 0x01; //设置定时器0为工作模式1   
    TH0 = T0RH;   //加载T0重载值   
    TL0 = T0RL;
    ET0 = 1;      //闭合定时器0中断的开关        
    TR0 = 1;      //启动定时器0         
}
void main()
{  
    u8 i,dir;
    LED_Init();       //初始化LED硬件模块
    EA = 1;           //闭合总中断开关
    TIM0_Init(300,0); //用定时器0定时300us,不微调
    while(1)
    {
        if(i<8)dir=0;//向左移
        if(dir==0)P0=~(0x01<<i);
 
        if(i>=8)dir=1;//向右移 
        if(dir==1)P0=~( 0x80>>(i-7) );//当i大于等于8之后，(i-7)其实也还是在1~7之间变化
 
        i++;
        if(i>=15)i=1;//让i一直在1~14之间变化
        delay_ms(50);
    }
}
 
void TIM0_IRQHandler() interrupt 1
{
    TH0 = T0RH;   //重新加载重载值
    TL0 = T0RL;
    BEEP=!BEEP;
}

1.9.12 封装函数

封装timer.h和time.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

//time.c
#include <reg52.h> 
#include "function.h" //详见第六章第8讲
   
u8 T0RH,T0RL,T1RH,T1RL;
   
void TIM0_Init(u32 us,int trim)//trim:微调
{
    u32 tmp;  //临时变量
     
    tmp = 11059200 / 12;            //定时器计数频率
    tmp = ( tmp * (us/100) )/10000; //计算所需的计数值
    tmp = 65536 - tmp;              //计算定时器重载值
    tmp = tmp+trim;                 //微调计数值使其定时更精确到我们想要的定时时间
    T0RH = (unsigned char)(tmp>>8); //定时器重载值拆分为高低字节  
    T0RL = (unsigned char)tmp;
    TMOD &= 0xF0; //清0低四位 
    TMOD |= 0x01; //设置定时器0为工作模式1   
    TH0 = T0RH;   //加载T0重载值   
    TL0 = T0RL;
    ET0 = 1;      //闭合定时器0中断的开关        
    TR0 = 1;      //启动定时器0         
}  
  
void TIM1_Init(u32 us,int trim)//trim:微调
{
    u32 tmp;  //临时变量
     
    tmp = 11059200 / 12;            //定时器计数频率
    tmp = ( tmp * (us/100) )/10000; //计算所需的计数值
    tmp = 65536 - tmp;              //计算定时器重载值
    tmp = tmp+trim;                 //微调计数值使其定时更精确到我们想要的定时时间
    T1RH = (unsigned char)(tmp>>8); //定时器重载值拆分为高低字节    
    T1RL = (unsigned char)tmp;
    TMOD&=0x0F;//清0高四位
    TMOD|=0x10;//设置定时器1为工作模式1 
    TH1 = T1RH;//加载T1重载值     
    TL1 = T1RL;
    ET1 = 1;   //闭合定时器1中断的开关        
    TR1 = 1;   //启动定时器1         
}

1
2
3
4
5
6
7
8
9
10

//timer.h
#ifndef __TIMER_H__
#define __TIMER_H__
   
extern u8 T0RH,T0RL,T1RH,T1RL;
  
void TIM0_Init(u32 us,int trim);//trim:微调 
void TIM1_Init(u32 us,int trim);//trim:微调 
 
#endif

1.9.13 呼吸灯

呼吸灯的实现原理就是让小灯的IO端口在一段时间里PWM由大到小变化的占空比输出，接着又由小到大的占空比输出，小灯显示效果就是时亮时暗地交替闪烁。首先我们用定时器0定时0.1ms，全局变量pwm在其中断函数里执行简单的从0到99的循环自加，这样周期就是10ms。假如主函数里我们这样执行

1
2

if(pwm<90)P0=0xFF;
else P0=0x00;

那么IO端口输出的一直是周期为10ms占空比为90%的波形，这样8盏小灯一直是处于较暗的显示状态不变，要想实现呼吸灯，就要不停改变PWM波形的占空比，所以我们使用定时器1来做间隔10ms地改变占空比，我们再定义一个全局变量highval，这个变量每隔10ms就会在定时器1中断函数中实现加1或者减1，加到99时又从99减回到0，减回到0又从0开始加到99的这样循环过程，大家回去研究左右往复循环流水灯的代码就会明白都是一样的思路。然后主函数这样执行

1
2

if(pwm<highval)P0=0xFF;//highval每隔10ms就会变化加1或者减1
else P0=0x00;

效果图如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <reg52.h>
#include "function.h"
#include "timer.h"

u8 pwm = 0; highval = 99;
void main() {
    LED_Init(); //初始化LED硬件模块
    EA = 1; //闭合中断总开关
    TIM0_Init(100, 9); //定时0.1ms, 9是微调是定时时间更精确
    TIM1_Init(10000, 10); //定时10ms，10是微调使定时时间更精确
    
    while(1) {
        if(pwm < highval) P0 = 0xFF; //highval每隔10ms就会变化加一或者减一
        else P0 = 0x00;
    }
}

void TIM0_IRQHandler() interrupt 1 {
    TH0 = T0RH; //重新初始化
    TL0 = T0RL;
    pwm++;
    if(pwm >= 100) pwm = 0; //pwm在0-99之间间隔每隔0.1ms变化，周期就为10ms
}

void TIM1_IRQHandler() interrupt 3 {
    static u8 dir;
    TH1 = T1RH; //重新初始化
    TL1 = T1RL;
    
    if(dir == 1) highval--; //占空比逐渐减小，小灯逐渐变亮
    if(highval == 0) dir = 0;
    
    if(dir == 0) highval++; //占空比逐渐增大，小灯逐渐变暗
    if(highval >= 99) dir = 1;
}

1.10 舵机

1.10.1 认识舵机

舵机是单片机机械控制入门必学的模块，在一些机器人关节中也是采用舵机作为控制，学习并熟练掌握使用舵机是我们对单片机的进一步认识。所以我们不能一直局限地使用开发板进行学习，而是扩展一些电子模块来辅助我们更加深入了解单片机，请自信购买舵机。

小型的舵机与大型的舵机控制原理几乎大同小异，考虑到我没钱，我肯定选择小型舵机作为入门学习和简单实用。常见的小型舵机型号为9g舵机，外观如下

1.10.2 舵机控制原理

我们使用的舵机为9g尺寸，信号为MG90S。这种舵机的作用角度为0°~180°，也就是舵机桨可以任意在某个角度卡死不动，由于供电原因我们使用蛮力是很难掰动舵机桨的，只有舵机掉电之后舵机桨才会任意地为我们所扭动。

舵机有三根线，除了供电的两根电源线还有一根信号线，我们使用的是5v电压功率的舵机，所以其他电源线可以直接接到单片机的+5v和GND上，信号线的话就接到单片机的一个IO端口上，这个IO端口通过输出PWM控制舵机桨的角度在任意位置上固定停留。

这个PWM的周期为20ms，高电平的时间在0.5ms~2.5ms之间可以控制舵机桨角度的停留位置。

我们把舵机的电源线接好，然后信号线连接P1.7，把代码下载进去，舵机桨在上电后就会旋转到一个固定角度的位置上停留在那不动。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <reg52.h> 
#include <function.h>//详见第六章第8讲
#include <timer.h>   //详见第八章第11讲
sbit PWMOUT = P1^7;  //舵机信号线引脚
  
void main()
{   
    LED_Init();//初始化LED硬件模块
    EA = 1;    //闭合总中断开关
    TIM0_Init(100,9);//定时0.1ms,9是微调使定时精度更高
    while(1); 
}
  
void TIM0_IRQHandler() interrupt 1
{ 
    static u8 pwm=0;
    TH0 = T0RH;  //重新加载重载值
    TL0 = T0RL;
    
    pwm++;
    if(pwm>=200)pwm=0; //pwm在0~199之间间隔0.1ms变化，周期为20ms
 
    if(pwm<10)PWMOUT=1;//高电平在周期为20ms的PWM中持续的时间为1ms，低电平持续的时间就是19ms，舵机桨在45度处的位置停留不动
    else PWMOUT=0; 
}

1.10.3 按键控制舵机

使用按键控制舵机桨在我们想要的位置上停留。K8负责控制舵机桨往一个方向不停旋转，K16则控制相反方向旋转。按键模式为支持连按。然后数码管显示高电平持续的时间，如果数码管显示5，则高电平在20ms周期里持续的时间为0.5ms，如果显示的是20，那就是持续2ms的高电平时间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <reg52.h> 
#include "function.h"
#include "timer.h"
sbit PWMOUT = P1^7;  //舵机信号线引脚
  
u16 highval=15; 
void main()
{   
    u8 key;
    LED_Init();//初始化LED硬件模块
    KEY_Init();//初始化按键模块
    EA = 1;    //闭合总中断开关
    TIM0_Init(100,9); //定时0.1ms,9是微调使定时精度更高
    TIM1_Init(1000,0);//定时1ms，用来刷新数码管显示,定时精度要求不高可不微调
  
    ShowNumber(highval);
    while(1)
    {      
        key=KEY_Scan(1,500);//支持连按 
        if(key==8)
        {
            highval++;
            if(highval>25)highval=25;//高电平持续时间不能超过2.5ms
            ShowNumber(highval);
        }
  
        if(key==16)
        {
            highval--;
            if(highval<5)highval=5;//高电平持续时间不能低于0.5ms
            ShowNumber(highval);
        }     
    }   
}
   
void TIM0_IRQHandler() interrupt 1
{ 
    static u8 pwm=0;
    TH0 = T0RH;  //重新加载重载值
    TL0 = T0RL;
     
    pwm++;
    if(pwm>=200)pwm=0;//pwm在0~199之间间隔0.1ms变化，周期为20ms
  
    if(pwm<highval)PWMOUT=1;//highval的值决定舵机桨的停留位置
    else PWMOUT=0; 
}
  
void TIM1_IRQHandler() interrupt 3
{ 
    TH1 = T1RH;  //重新加载重载值
    TL1 = T1RL;
    SEG_Scan();
}

1.10.4 呼吸灯与舵机

呼吸灯的程序思想如果用在舵机控制上，那么舵机桨就是从0度的位置转到180度的位置又从180度处转回0度处如此循环往复，现在我们动手改写一下呼吸灯的程序使其能融入舵机的控制中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <reg52.h>
#include "function.h"
#include "timer.h"

sbit PWMOUT = P1^7; //舵机信号线引脚

u16 highval = 5;
void main() {
	u8 key;
	LED_Init(); //初始化LED硬件模块
	KEY_Init(); //初始化按键模块
	EA = 1; //闭合总中断开关
	TIM0_Init(100, 9); //定时0.1ms, 9是微调使定时精度更高
	TIM1_Init(50000, 0); //定时50ms，定时精度要求不高可以不微调
	while(1);
}

void TIM0_IRQHandler() interrupt 1 {
	static u8 pwm = 0;
	TH0 = T0RH; //重装初始值
	TL0 = T0RL; 
	
	pwm++;
	if(pwm >= 200) pwm = 0; //pwm在0-199之间间隔0.1ms变化，周期为20ms
	if(pwm < highval) PWMOUT = 1; //highval的值决定舵机桨的停留位置
	else PWMOUT = 0;
}

void TIM1_IRQHandler() interrupt 3 {
	static u8 dir;
	TH1 = T1RH; //重装初始值
	TL1 = T1RL;
	
	//控制highval只能在5~24之间变化
	if(dir == 1) highval--; //占空比逐渐减少，舵机桨往0度的位置走动
	if(highval < 5) dir = 0;
	
	if(dir == 0) highval++; //占空比逐渐增加，舵机桨往180度的位置走动
	if(highval>=24)dir = 1; //测试发现，24已经是舵机桨的尽头，无需写25
}

1.11 串口通信

1.11.1 串口通信入门

对于单片机来说，通信则与传感器、存储芯片、外围控制芯片等技术紧密结合，成为整个单片机系统的神经中枢。

UART（Universal Asynchronous Receiver/Transmitter，即通用异步收发器）串行通信是单片机最常用的一种通信技术，通常用于单片机和电脑之间以及单片机和单片机之间的通信。

通信按照基本类型可以分为并行通信和串行通信。并行通信时数据的各个位同时传送，可以实现字节为单位通信，但是通信线多占用资源多，成本高。比如我们前边用到的P0 = 0xFE;一次给 P0 的 8 个 IO 口分别赋值，同时进行信号输出，类似于有 8 个车道同时可以过去 8 辆
车一样，这种形式就是并行的，我们习惯上还称 P0、P1、P2 和 P3 为 51 单片机的 4 组并行总线。 而串行通信，就如同一条车道，一次只能一辆车过去，如果一个 0xFE 这样一个字节的数据要传输过去的话，假如低位在前高位在后的话，那发送方式就是 0-1-1-1-1-1-1-1-1，一位一位的发送出去的，要发送 8 次才能发送完一个字节。

STC89C52 有两个引脚是专门用来做 UART 串行通信的，一个是P3.0一个是P3.1，它们还分别有另外的名字叫做RXD和TXD，由它们组成的通信接口就叫做串行接口，简称串口。用两个单片机进行 UART 串口通信，基本的演示图如图所示。

图中，GND 表示单片机系统电源的参考地，TXD 是串行发送引脚，RXD 是串行接收引脚。两个单片机之间要通信，首先电源基准得一样，所以我们要把两个单片机的 GND 相互连接起来，然后单片机 1 的 TXD 引脚接到单片机 2 的 RXD 引脚上，即此路为单片机 1 发送
而单片机 2 接收的通道，单片机 1 的 RXD 引脚接到单片机 2 的 TXD 引脚上，即此路为单片机 2 发送而单片机 1 接收的通道。

当单片机 1 想给单片机 2 发送数据时，比如发送一个 0xE4 这个数据，用二进制形式表示就是 0b11100100，在 UART 通信过程中，是低位先发，高位后发的原则，那么就让 TXD首先拉低电平，持续一段时间，发送一位 0，然后继续拉低，再持续一段时间，又发送了一位 0，然后拉高电平，持续一段时间，发了一位 1……一直到把 8 位二进制数字 0b11100100全部发送完毕。

这里我们提及持续一段时间，那么要持续多久呢？下面我们学相关概念。

• 波特率：波特率就是发送二进制数据位的速率，习惯上用baud表示，即我们发送一位二进制数据的持续时间=1/baud。在通信之前，单片机 1 和单片机 2 首先都要明确的约定好它们之间的通信波特率，必须保持一致，收发双方才能正常实现通信。常用的波特率为9600，所谓9600指的是一秒钟单片机可以发送9600个数据位，也就是1秒钟的时间里单片机可以发送(9600/8)=1200字节，一个字节等于八个位，一字节等于八比特，因此一个字节等于八个二进制位。

我们知道了接受（发送）持续的时间，那么如何确定起始或停止发送的呢？

• 规定当没有通信信号发生时，通信线路保持高电平，当要发送数据之前，先发一位 0 表示起始位，然后发送 8 位数据位，数据位是先低后高的顺序，数据位发完后再发一位 1 表示停止位。这样本来要发送一个字节的 8 位数据，而实际上我们一共发送了 10位，多出来的两位其中一位起始位，一位停止位。而接收方呢，原本一直保持的高电平，一旦检测到了一位低电平，那就知道了要开始准备接收数据了，接收到 8 位数据位后，然后检测到停止位，再准备下一个数据的接收。

我们以一个具体的例子感受一下，单片机的P3.1（TXD）是发送引脚，也就是说要发送字符“A”，这个引脚的变化如下图所示

单片机要发送一个字节给电脑端，首先发送引脚需要先拉高，然后拉低持续(1/9600)秒，电脑端检测到这个低电平信号就会准备接收数据字节。然后我们要发送的二进制位是01000001，但是串口通信发送的字节是低位在前，高位在后，所以上图的发送顺序就是01000001反过来为10000010。一个字节发送完成之后还要发送一个停止位1，电脑端接收到这个停止位就认为一个字节发送完成了。

我们用定时器来实现引脚的持续时间，怎么定时(1/9600)秒怎么设置，计算一下就可以了。

解得：$X = 96$，因为定时时间间隔比较短，所以我们使用定时器0的工作模式2就可以了。填充TH0的初始值就是$256-96=160 \rightarrow 0xA0$。因为P3^1在#include <reg52.h>已有定义为TXD， 我们可以直接使用。通过按K4来启动发送字节数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <reg52.h>
#include "function,h"
#include "timer.h"

void TIM0_Mode2_Init() {
    TMOD &= 0xF0; //清零低四位
    TMOD |= 0x02; //设置定时器0为工作模式2
    TH0 = 0xA0; //计算出波特率9600
    TL0 = 0x00;
    ET0 = 1; //闭合定时器0中断的开关
    TR0 = 1; //启动定时器0
}

void main() {
    u8 key;
    LED_Init(); //初始化LED硬件模块
    KEY_Init(); //初始化按键模块
    EA = 1; //闭合总中断开关
    TIM0_Mode2_Init(); //定时（1 / 9600）秒
    TR0 = 0; //关闭定时器
    while(1) {
        key = KEY_Scan(0, 1000);
        if(key == 4) TR0 = 1; //开启定时器，启动一个字节传输，按一次一次发送
    }
}

void TIM0_IRQHandler() interrupt 1 {
    static u8 cnt = 0, i, TXDBUF = 65; //字符`A`的ASCII值为65
    cnt++; //cnt一直在1-10之间变化
    
    if(cnt == 1) TXD = 0; //cnt变为1，发送起始位，这次的中断函数就执行完了，持续够(1/9600)秒之后，再次进入中断函数，然后就是发送数据字节的8位的任务
    if(cnt >= 2 && cnt <= 9) { //发送8位数据位，从低位开始引脚的变化为 1 0 0 0 0 0 1 0
        TXD = TXDBUF & 0x01; //要么等于1要么等于0，这样P3.1的引脚要么保持高电平，要么保持低电平
        TXDBUF >>= 1;
    }
    if (cnt == 10) {
        TXD = 1; //发送停止位
        TR0 = 0; //关闭定时器，结束一次字节传输
        cnt = 0;
        i++;
        TXDBUF = 65+i; //下次按下按键发送的是B C D E...
    }
}

这里简单说明一下，我们按下K4启动了定时器，然后第一次进入中断函数时，做的任务就是拉低P3.1，然后这次的中断函数的任务就结束了，等过了(1/9600)秒之后，再次进入中断函数，上一次拉低P3.1的时间已经持续够(1/9600)秒了，这第二次的中断函数任务就是拉高P3.1，因为发送字符A这个字节的最低位为1，持续够(1/9600)秒进入第三次执行中断函数，拉低P3.1，第四，第五，第六，第七都是拉低P3.1发送0，以此类推，到第10次中断函数执行就是拉高P3.1发送停止位，关闭定时器结束一次字节的传输，要想再次发送需要按K4启动定时器，TXDBUF=65+i;表示下次发送的是66这个数据，再下次就是发送67，68以此类推。

1.11.2 软件设置

下载以上代码，不断按下Key4可以看见按输出A B C D C等…

1.11.3 串口配置函数

这里讲解一两处配置的知识，首先SCON=0x50;是让SCON寄存器的第4位和第6位的置1，其他位置0。TH1=256-(11059200/12/32/buad);是波特率设置的计算公式，由于串口的使用是要占用定时器1，那么定时器1的定时中断将不能使用，所以必须使ET1=0;禁止其产生定时中断，也就是使用了串口，那么void TIM1_IRQHandler() interrupt 3将不能再出现在程序书写中。不过，串口也有相应的中断函数，像ET0,ET1一样，这些都是子开关，串口中断的子开关为ES，ES=1;和EA=1;就开启了串口的中断函数。我们串口发送数据的时候会产生中断，接收到数据的时候也会产生中断，这两个瞬间我们在中断函数里需要执行相关任务。要知道串口有动作的时候，总会有RI或者TI被置1，前者意为接收到完整的8位的数据，也就使接收到一个字节然后RI就被置1.后者意为单片机发送完一个完整的字节了，TI就被置1.这些瞬间都需要我们在串口中断函数中让其清零（软件清零），以备下次它们能再次被置1。

下面实现的功能是电脑端通过串口发送一个数据给单片机，这个数据被单片机接收到之后，让这个数据再加1，然后单片机再通过串口把加1后的数据发送回去给电脑端让它在窗口上显示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <reg52.h>
#include "function.h"
#include "timer.h"

u8 RXDBUF; //缓存接收到的数据
void ConfigUART(u16 baud) {
    SCON = 0x50; //配置串口为模式1
    TMOD &= 0x0F; //清零T1的控制位
    TMOD |= 0x20; //配置T1为模式2
    
    TH1 = 256 - (11059200/12/32)/baud; //计算T1的重载值
    TL1 = TH1; //初值为重载值
    
    ET1 = 0; //禁止T1中断
    ES = 1; //使能串口中断
    TR1 = 1; //开启定时器1
}

void main() {
    LED_Init(); //初始化LED硬件模块
    EA = 1; //闭合总中断开关
    ConfigUART(9600); //串口波特率设置为9600
    while(1);
}

void InterruptUART() interrupt 4 {
    if (RI) { //RI等于1就满足if条件语句，意为接收到一个字节
        RI = 0; //软件清零接受中断标志位
        RXDBUF = SBUF; //接收到的数据保存到接收缓存变量中
        SBUF = RXDBUF + 1; //发送回去给电脑端的数据
    }
    if (TI) {
        TI = 0; //软件清零发送中断标志位
    }
}

这里的串口中断函数，像if(RI)TR=0;和if(TI)TI=0;这些都是在串口中断函数中必须要执行的任务，当然如果在其他函数里有清零这两个位，可以不用在串口中断函数中书写，但是一定要保证每次都要清0。

SBUF是名字相同但作用不同的缓冲区，SBUF=RXDBUF+1;SBUF在等于号前面意为这个是单片机发送给电脑端数据的缓冲区，一旦出现SBUF=xxxx;这样的语句，那就是单片机开始通过串口发送数据出去。上图可以看见现象。

1.11.4 ASCII码与通信数据

通过实验操作来熟悉ASCII码与通信数据之间的关系。

现在实现这样的功能：在电脑端上发送“十六进制”模式或“字符格式”模式的字节给单片机，数码管则显示出这些数据的十进制值，然后观察数码管上显示的数值与发送数据的关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <reg52.h>
#include "function.h"
#include "timer.h"

u8 RXDBUF; //缓存接收到的数据
void ConfigUART(u16 baud) {
    SCON = 0x50; //配置串口为模式1
    TMOD &= 0X0F; //清零T1的控制位
    TMOD |= 0x20; //配置T1为模式2
    
    TH1 = 256 - (11059200/12/32)/baud; //计算重载值
    TL1 = TH1; //初始值为重载值
    
    ET1 = 0; //禁止T1中断
    ES = 1; //使能串口中断
    TR1 = 1; //启动定时器1
}

void main() {
    LED_Init(); //初始化LED硬件模块
    EA = 1; //闭合中断总开关
    ConfigUART(9600); //配置波特率为9600
    TIM0_Init(1000, 0); //定时1ms，用来刷新数码管显示，定时精度要求不高可以不使用微调
    
    while(1) {
        ShowNumber(RXDBUF);
    }
}

void TIM0_IRQHandler() interrupt 1 {
    TH0 = T0RH; //重新加载初始值
    TL0 = T0RL;
    SEG_Scan();
}

void InterruptUART() interrupt 4 {
    if(RI) {
        RI = 0; //手动清零接收中断标志位
        RXDBUF = SBUF; //接收到的数据保存到接收缓存变量中
        SBUF = RXDBUF; //接收到的数据又直接发回，叫做-"echo",用以提示用户输入的信息是否以正确接收
    }
    if(TI) {
        TI = 0; //软件清零发送中断标志位
    }
}

在发送窗口和接收窗口都选“十六进制”模式，电脑端发送一个8的数据（也就是0x08）的字节给单片机，然后单片机会发送回来这个数据给电脑端显示在窗口中。此时开发板上的数码管显示的是8。

接着我们在电脑端发送的是10，这是0x10,不要与十进制的10混淆。数码管显示的是16，所以发送的数据用十进制显示在数码管上是正确的。

我们切换到字符格式模式下发送字符A。数码管显示的是65，电脑端接收到单片机发送回来的数据是0x41，也就是十进制下的65。

找到ASCII表，字符“A”对应的数刚好是65。

如果把电脑端接收窗口改为“字符格式”显示，那么显示的内容就跟发送窗口的字符一样了。

如果我们在电脑端发送窗口输入一串字符比如“ABCD123”点击发送给单片机，如果我们看到的是下面这个现象

那么结合以下的程序代码分析RXDBUF = SBUF;SBUF = RXDBUF;也就是电脑端先发送字符A给单片机，单片机马上发送回字符A给电脑端，接着电脑端又发送字符B，如此执行下去，直到发送完最后一个字符4。

这些发送和接收过程是非常快的，因为单片机接收缓存区SBUF每次只能暂存一个字节，所以前面8个字节都会很快被替换，导致数码管在一瞬间里只显示字符4的ASCII码值52。

1.11.5 printf系列的函数实现

懂得了单片机通过串口传输数据给电脑端口窗口查看，那么，有时我们需要发送字符串，有时需要发送一个变量的数值是多少，以及还要发送回车换行这三种情况，所以我们把这三个功能函数封装起来，方便后续的串口使用。

1. void printf_str(u8 *str)函数就是专门用来发送字符串给电脑端的。
2. void printf_num(u32 num)函数发送的变量数值只支持显示十进制数0-4294967295,也就是参数u32类型。
3. void printf_rn()就是发送回车换行符。

这里的代码，我们需要慢慢弄懂，现在不懂也没有关系，后面慢慢消化。我们希望串口这部分功能模块也能像定时器那样封装一个单独文件使用，所以创建号uart.c和uart.h文件，复制以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

// uart.c
#include <reg52.h>
#include <function.h>//详见第六章第8讲
   
void ConfigUART(u16 baud)
{
    SCON  = 0x50;  //配置串口为模式1
    TMOD &= 0x0F;  //清零T1的控制位
    TMOD |= 0x20;  //配置T1为模式2
    TH1 = 256 - (11059200/12/32)/baud;//计算T1重载值
    TL1 = TH1;     //初值等于重载值
    ET1 = 0;       //禁止T1中断
    ES  = 1;       //使能串口中断
    TR1 = 1;       //启动T1
} 
    
void printf_str(u8 *str)
{ 
    while(*str != '\0')//连续发送字符串数据，直到检测到结束符
    {
        SBUF=*str++;
        while(!TI);    //等待字节发送完成TI被置1就退出这个while循环
        TI = 0;        //清0标志位
    }  
}
   
void printf_num(u32 num)
{
    u8 buf[10];
    char i;//取值范围为-128~127
    
    for (i=0; i<10; i++)       //把长整型数转换为10位十进制的数组
    {
        buf[i] = num % 10;
        num = num / 10;        //舍掉个位数，重新装载
    }
    
    for (i=9; i>=1; i--)  
    {
        if (buf[i] != 0)break; //从最高位起，遇到0不理会，遇到非0则退出循环
    }
    
    while(i>=0)          //剩余低位都如实发送出去
    {   
        SBUF='0'+buf[i]; //如果此时的buf[i]的值是1，那么电脑端窗口在“字符格式”模式下要想显示字符“1”，只需'0'+1，因为‘0’就是ASCII码值48
        while(!TI);      //等待字节发送完成TI被置1就退出这个while循环
        TI = 0;          //清0标志位
        i--;   
    }
}
   
void printf_rn() //发送回车换行符
{
    SBUF='\r';
    while(!TI);  //等待字节发送完成TI被置1就退出这个while循环
    TI = 0;      //清0标志位
    
    SBUF='\n';
    while(!TI);  //等待字节发送完成TI被置1就退出这个while循环
    TI = 0;      //清0标志位
}

1
2
3
4
5
6
7
8
9
10

// uart.h
#ifndef __UART_H__
#define __UART_H__
   
void ConfigUART(u16 baud);
void printf_str(u8 *str);//发送字符串
void printf_num(u32 num);//发送参数的数值
void printf_rn();        //发送回车换行符
   
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//main
#include <reg52.h> 
#include <function.h>//详见第六章第8讲
#include <uart.h>
 
void main()
{  
    u8 key;
    u32 value=65535;
    LED_Init();//初始化LED硬件模块
    KEY_Init();//初始化按键模块
    EA = 1;    //闭合总中断开关
    ConfigUART(9600);
   
    while(1)
    {  
        key=KEY_Scan(0,1000);
        if(key==4)
        {
            printf_str("value=");//发送字符串
            printf_num(value);   //发送变量的数值
            printf_rn();         //发送回车换行符
            value++;
        }
    } 
}
  
void InterruptUART() interrupt 4
{
    if (RI)    //接收到字节
    {
        RI = 0;//手动清零接收中断标志位                     
    }
}

在串口中断函数中我们没有再写“if(TI){ TI = 0; }”,那是因为我们在所有的发送函数中都做了TI的清0处理，所以可以在串口中断函数中不用再书写TI。

不断按下Key4按键，可以观察到串口助手出现字符串。

1.12 1602液晶屏

二、实战教学以及作品展示

2.1 LED

2.1.1 点亮第一个LED灯

2.1.1.1 源码

1
2
3
4
5
6
7

// 理论
#include <reg52.h>
sbit LED= P2^0; // 直接使用sbit 控制P0^0一个位
void main() {
	LED = 0; // 低电平点灯
	while(1); // 死循环
}

2.1.1.2 仿真

2.1.1.3 实物

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 实际
#include<reg52.h>

sbit LED = P0^0;
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
   
void main() {
	ENLED = 0; //
	ADDR3 = 1; // 使能三八译码器
	
	ADDR2 = 1; // **************************
	ADDR1 = 1; // 让三八译码器的IO6输出低电平
	ADDR0 = 0; // ***************************
	
	LED = 0; //点亮最右边的灯
	while(1);
}

2.1.2 闪烁的LED灯

2.1.2.1 源码

有了前面的基础，点灯肯定不是问题，这里实现让LED从点亮一段时间到熄灭一段时间再点亮一段时间如此循环下去，实现闪烁LED的功能。为了实现这个目的我们需要实现延迟函数for(i=0;i<30000;i++);是最简单的延时语句。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 理论
#include <reg52.h>

sbit LED = P2^0;

void main() {
	unsigned int i;
	while(1) {
		LED = 0;
		for(i=0; i<3000; i++);
		LED = 1;
		for(i=0; i<3000; i++);
	}
}

2.1.2.2 仿真

2.1.2.3 实物

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 实际
#include <reg52.h>

sbit LED = P0^0;
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

void main() {
		unsigned int i;
		ENLED = 0; //定义一个16位无符号整形变量
		ADDR3 = 1; // 三八译码器使能
		
		ADDR2 = 1; //******************************
		ADDR1 = 1; //使三八译码器的IO6口输出低电平
		ADDR0 = 0; //******************************
	
		while(1) {
			LED = 0; //点亮最右边的小灯
			for(i=0; i<3000; i++); //延迟一段时间
			LED = 1; //熄灭最右边的小灯
			for(i=0; i<3000; i++); //延迟一段时间
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 实际，延迟一秒
#include <reg52.h> 
sbit LED2  = P0^0;
sbit ADDR2 = P1^2;
sbit ADDR1 = P1^1;
sbit ADDR0 = P1^0;
sbit ENLED = P1^4;
sbit ADDR3 = P1^3;
 
void main()
{  
    unsigned int i,j;//定义两个16位的变量  
    ADDR3 = 1;//使能三八译码器
    ENLED = 0;// 
 
    ADDR2 = 1;//**************************
    ADDR1 = 1;//让三八译码器的IO6输出低电平
    ADDR0 = 0;//**************************
 
    while (1)
    {
        LED2=0;//点亮最右端的灯
        for(i=0;i<19601;i++)//延时1s
        {
            for(j=5;j>0;j--);
        }
        LED2=1;//熄灭最右端的灯
        for(i=0;i<19601;i++)//延时1s
        {
            for(j=5;j>0;j--);
        }
    }
}

2.1.3 三个小灯同时闪烁

2.1.3.1 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 理论
// 原理很简单控制P2^0,P2^1,P2^2口的高低电平即可
#include "reg52.h" // 引入8051单片机头文件

sbit LED1 = P2^0; // 定义LED1引脚为P1.0
sbit LED2 = P2^1; // 定义LED2引脚为P1.1
sbit LED3 = P2^2; // 定义LED3引脚为P1.2

void main()
{
		int i=0;
    while(1) // 无限循环
    {
        LED1 = 0;
        LED2 = 0;
        LED3 = 0;
			
				// 延时一段时间，使LED保持熄灭状态
        // 可根据需要调整延时时间
        for(i = 0;i < 500;i++);
        
        LED1 = 1;// 将LED1引脚置为高电平，熄灭LED1
        LED2 = 1;// 将LED2引脚置为高电平，熄灭LED2
        LED3 = 1;// 将LED3引脚置为高电平，熄灭LED3
        
        // 延时一段时间，使LED保持熄灭状态
        // 可根据需要调整延时时间
        for(i = 0; i < 500;i++);
    }
}

2.1.3.2 仿真

2.1.3.3 实物

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// 实际
#include "reg52.h" // 引入8051单片机头文件

sbit LED1 = P0^0; // 定义LED1引脚为P1.0
sbit LED2 = P0^1; // 定义LED2引脚为P1.1
sbit LED3 = P0^2; // 定义LED3引脚为P1.2

// 开启总开关
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

void main()
{
		int i=0;
	
		ENLED = 0;
		ADDR3 = 1;
		ADDR2 = 1;
		ADDR1 = 1;
		ADDR0 = 0;
	
    while(1) // 无限循环
    {
        LED1 = 0;
        LED2 = 0;
        LED3 = 0;
			
				// 延时一段时间，使LED保持熄灭状态
        // 可根据需要调整延时时间
        for(i = 0;i < 5000;i++);
        
        LED1 = 1;// 将LED1引脚置为高电平，熄灭LED1
        LED2 = 1;// 将LED2引脚置为高电平，熄灭LED2
        LED3 = 1;// 将LED3引脚置为高电平，熄灭LED3
        
        // 延时一段时间，使LED保持熄灭状态
        // 可根据需要调整延时时间
        for(i = 0; i < 5000;i++);
    }
}

2.1.3.4 优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 理论，通过控制P0
// 通过P0
#include <reg52.h>

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

void main() {
	P2 = 0xF8; // 1111 1000 -> 0xF8
	delay(500);
	P2 = 0xFF;
	delay(500);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 实际
#include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;


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

void main() {
	ENLED = 0;
	ADDR3 = 1;
	
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;
	
	P0 = 0xF8; // 1111 1000 -> 0xF8
	delay(500);
	P0 = 0xFF;
	delay(500);
}

2.1.4 流水灯

实现流水灯的代码我们在第一章的教学中就已经给出了，这里给出使用P0口实现的方式，我们知道到P0控制的是8个IO端口，我们使用0xFF等控制语句能实现控制八个端口输出不同的高低电平，那么我们来使用P0来实现一下。

2.1.4.1 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 理论
#include <reg52.h>

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

void main() {
	while(1) {
		P2 = 0xFE; // 0xFE -> 1111 1110 -> 只有最右边亮
		delay(500); // 延迟
		P2 = 0xFD; // 0xFD -> 1111 1101 *********************
		delay(500); // 延迟
		P2 = 0xFB; // 0xFB -> 1111 1011
		delay(500); // 延迟
		P2 = 0xF7; // 0xF7 -> 1111 0111
		delay(500); // 延迟
		P2 = 0xEF; // 0xEF -> 1110 1111 低电平依次向右移动，控制不同的灯亮
		delay(500); // 延迟
		P2 = 0xDF; // 0xDF -> 1101 1111
		delay(500); // 延迟
		P2 = 0xBF; // 0xBF -> 1011 1111
		delay(500); // 延迟
		P2 = 0x7F; // 0x7F -> 0111 1111 **********************
		delay(500);
	}

}

2.1.4.2 仿真

2.1.4.3 实物

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// 实际
# include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

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

void main() {
	ENLED = 0;
	ADDR3 = 1; // 使能三八译码器
	
	ADDR2 = 1; // ***************************
	ADDR1 = 1; // 使三八译码器IO6口输出低电平
	ADDR0 = 0; // ***************************
	
	while(1) {
		P0 = 0xFE; // 0xFE -> 1111 1110 -> 只有最右边亮
		delay(500); // 延迟
		P0 = 0xFD; // 0xFD -> 1111 1101 *********************
		delay(500); // 延迟
		P0 = 0xFB; // 0xFB -> 1111 1011
		delay(500); // 延迟
		P0 = 0xF7; // 0xF7 -> 1111 0111
		delay(500); // 延迟
		P0 = 0xEF; // 0xEF -> 1110 1111 低电平依次向右移动，控制不同的灯亮
		delay(500); // 延迟
		P0 = 0xDF; // 0xDF -> 1101 1111
		delay(500); // 延迟
		P0 = 0xBF; // 0xBF -> 1011 1111
		delay(500); // 延迟
		P0 = 0x7F; // 0x7F -> 0111 1111 **********************
		delay(500);
	}
}

2.1.4.4 优化

① Switch case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// 理论，使用switch case语句使程序更加公正
#include <reg52.h>

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

void main() {
	unsigned char i=1; //定义新的变量用来轮流调用不同的case语句
	while (1) {
		switch(i) {
			case 1: P2 = 0xFE; break;
			case 2: P2 = 0xFD; break;
			case 3: P2 = 0xFB; break;
			case 4: P2 = 0xF7; break;
			case 5: P2 = 0xEF; break;
			case 6: P2 = 0xDF; break;
			case 7: P2 = 0xBF; break;
			case 8: P2 = 0x7F; i=0; break; //小细节
		}
		i++;
		delay(500);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// 实际
#include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

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

void main() {
	unsigned char i=0;
	ENLED = 0;
	ADDR3 = 1; // 使能三八译码器
	
	ADDR2 = 1; //*****************************
	ADDR1 = 1; //使三八译码器的IO6口输出低电平
	ADDR0 = 0; //*****************************	
	
	while(1) {
		switch(i) {
			case 1: P0 = 0xFE; break;
			case 2: P0 = 0xFD; break;
			case 3: P0 = 0xFB; break;
			case 4: P0 = 0xF7; break;
			case 5: P0 = 0xEF; break;
			case 6: P0 = 0xDF; break;
			case 7: P0 = 0xBF; break;
			case 8: P0 = 0x7F; break;
		}
		i++;
		delay(500);
	}
}

② 数组