从单片机基础到程序框架（连载）

单片机

刘华 · 2017-7-30 18:55:02

支持分享！感谢楼主u！

刘华 · 2017-8-1 19:36:01

顶顶顶！！！！！！支持鸿哥！！！！！！！！！！！

db1001001 · 2017-8-6 11:03:57

等待鸿哥更新。

吴坚鸿 · 2017-8-6 11:36:52

第八十一节：时间和速度的起源（指令周期和晶振频率）。

【81.1 节拍。】

   单片机的C语言经过C编译器后，翻译成很多条机器指令，单片机逐条执行这些指令，每执行一条指令都是按照固定的节奏进行的，两条指令之间是存在几乎固定的时间间隔（实际上不是所有指令的间隔时间都绝对一致，这里方便理解暂时看作是一致），这就是节拍，每个节拍之间的时间间隔其实就是指令周期，因此，指令周期越短，节拍就越短，单片机的运算速度就越快。指令周期是由什么决定的呢？指令周期是由“心跳速度”和“心跳个数”决定的。指令周期都是由固定的N个“心跳个数”组成的，指令周期到底由多少个“心跳个数”组成？每种单片机每类指令各不一样。我们用的51系列单片机，最短的单周期指令是由12个“心跳个数”组成，依次类推，双周期指令由24个“心跳个数”组成，4周期指令由48个“心跳个数”组成。但是光有“心跳个数”还不够，还必须搭配知道“心跳速度”才能最终计算出指令周期。这里的“心跳速度”就是晶振的频率，“心跳个数”就是累计晶振的起振次数。比如，假设我们用的51单片机是12MHz（本教程实际用的是11.0592MHz），那么每个单周期的指令执行的时间是：12x(1/12000000)秒=1微秒。这个公式左边的“12”代表“12个晶振起振的次数”，这个公式右边的“(1/12000000)”代表晶振每起振1次所需要的单位时间。二者结合，刚好就是“心跳个数”乘以“单个心跳周期”等于指令周期，而指令周期就是节拍的时间。


            图81.1.1  单片机的晶振

【81.2 累计节拍次数产生延时时间。】

   有了这个最原始的“节拍”概念，现在开始编写一个练习程序，让一个LED灯闪烁，闪烁的本质，就是让一个LED灯先亮一会（“一会”就是延时），然后紧接着让LED灯熄灭一会（“一会”就是延时），依次循环，在视觉上看到的连贯动作就是LED闪烁。这里的关键是如何产生这个“一会”的延时，本节教程所用的就是一个for循环来执行N条空指令，每执行一条空指令就需要消耗掉1个左右的指令周期的时间（大概1微秒左右），空指令执行的循环次数越多，产生的延时时间就越长。例子如下：


               图81.2.1  灌入式驱动8个LED

#include "REG52.H"
***it P0_0=P0^0; //利用***it和符号“^”的组合，把变量名字P0_0与P0.0引脚关联起来
unsigned long i; //for循环用的累计变量
//unsigned int i; //如果把for循环的变量i改成unsigned int类型，闪烁的频率会加快。
void main()
{
while(1)
{
//第（1）步
P0_0=0; //LED灯亮。
//第（2）步
for(i=0;i<5000;i++) //累计的循环次数越大，这里的延时就越长，“亮”持续的时间就越长。
{
; //分号代表一条空指令
}
//第（3）步
P0_0=1; //LED灯灭。
//第（4）步
for(i=0;i<5000;i++) //累计的循环次数越大，这里的延时就越长，“灭”持续的时间就越长。
{
; //分号代表一条空指令
}
//第（5）步：这里已经触碰到主循环while(1)的“底线”，所以接着跳转到第（1）步继续循环
}
}

复制代码

现象分析：
理论上，每执行1条指令大概1微秒左右，但是实际上，我们看到的实验现象，发现累计循环才5000次，按理论计算，应该产生0.005秒左右的延时才合理，但是实际上居然能产生类似0.5秒的闪烁效果，中间相差100倍！为什么？C语言跟机器指令之间是存在翻译的“中间商”环节，一条C指令并不代表一条机器指令，往往一条C指令翻译后产生N条机器指令，比如上面的代码，用到for循环变量i，用的是unsigned long变量，意味4个字节，即使一条C语言赋值指令估计可能也要消耗4条单周期指令，在加上for循环的判断指令，和累加指令，以及跳转指令，所以我们看到的for(i=0;i<5000;i++)并不代表是真正仅仅执行了5000个指令周期，而是有可能执行了500000条指令周期！假如我们把上述代码中的i改成unsigned int变量（2字节），是会看到闪烁的速度明显加快的，其中原因就是C编译器与机器指令之间存在翻译后的“1对N”的关系。

叶宇 · 2017-8-8 20:41:03

师傅，我又来啦，下载了好多，准备空闲的时间看，谢谢师傅的分享，受益良多！！

吴坚鸿 · 2017-8-13 12:23:25

第八十二节： Delay阻塞延时控制LED闪烁。

【82.1 “阻塞”与“非阻塞”。】

   做项目写程序，大框架大思路上就是在“阻塞”与“非阻塞”这两种模式下不断切换。“阻塞”可以理解成“单任务处理”模式，“非阻塞”可以理解成“多任务并行处理”模式。“阻塞”的优点是它全神贯注不分心地专注于当下这一件事，它等待某个事件的响应速度是最快的，同时省去了“来回切换、反复扫描”的额外开销，而且在编程思路上不用太费脑力只需“记流水账式”的编程即可，但是它的缺点是当下只能干一件事，其它事情无法兼顾，做不到多任务并行处理。而“非阻塞”恰恰相反，它的有优点就是“阻塞”的缺点，它的缺点就是“阻塞”的优点，对于“非阻塞”本节暂时不多讲。在实际项目中，有时候“大阻塞”中分支了N个“小非阻塞”，也有时候“大非阻塞”中分支了N个“小阻塞”。能在“阻塞”与“非阻塞”之间运用自如者，谓之神。
   “阻塞等待”是指单片机在某个死循环里（比如“while(1)”这类）一直不断循环地在等待某个标志变量的状态，如果这个标志变量满足条件才会跳出这个死循环然后才能干其它的事情，否则一直在死循环里死等，给人一种全神贯注心无旁骛的感觉，
   “阻塞延时”是指单片机在产生“延时时间”的时候做不了别的事，延时多久它就要被“阻塞”多久，只有延时过后它才能解脱去干别的事。比如，在编程上，常用for循环产生N个空指令来达到产生“延时时间”的目的，这种编程方式就是最常见的“阻塞延时”。

【82.2 Delay阻塞延时的一个例子。】

      现在利用“Delay阻塞延时”编写一个练习程序，让一个LED灯闪烁。例子如下：


               图82.2.1  灌入式驱动8个LED

#include "REG52.H"
void Delay(unsigned long u32DelayTime); //函数的声明
***it P0_0=P0^0; //利用***it和符号“^”的组合，把变量名字P0_0与P0.0引脚关联起来
void Delay(unsigned long u32DelayTime) //产生“阻塞延时”的延时函数
{
static unsigned long i; //函数在频繁调用时，加static可以省去一条额外的初始化语句的开销。
for(i=0;i
}
void main()
{
while(1)
{
//第（1）步
P0_0=0; //LED灯亮。
//第（2）步
Delay(5000); //这里就是阻塞延时，时间就越长，“亮”持续的时间就越长。
//第（3）步
P0_0=1; //LED灯灭。
//第（4）步
Delay(5000); //这里就是阻塞延时，时间就越长，“灭”持续的时间就越长。
//第（5）步：这里已经触碰到主循环while(1)的“底线”，所以接着跳转到第（1）步继续循环
}
}

复制代码

【82.3 累加型和累减型的两种Delay函数，哪家强？】

上述82.2例子中，用到一个Delay函数，该函数内部的for循环用的是“累加型”的，比如：

void Delay(unsigned long u32DelayTime)
{
static unsigned long i; //“累加型”函数内部多开销了一个变量i。
for(i=0;i
}

复制代码

现在在跟大家分享一种“累减型”的Delay函数，例子如下：

void Delay(unsigned long u32DelayTime)
{
//“累减型”函数内部节省了一个变量i。
for(;u32DelayTime>0;u32DelayTime--); //“u32DelayTime--”意味着“累减型”。
}

复制代码

      仔细对比“累加型”和“累减型”，会发现在实现同样“阻塞延时”的功能下，因为“累减型”巧妙的借用了函数入口的局部变量u32DelayTime来充当for循环的变量，而省去了一个i变量。因此，“累减型”比“累加型”强一点。

【82.4 Delay函数让初学者容易犯的错误。】

      初学者刚接触Delay函数，常常容易犯的错误就是忽略了for循环变量的类型，for循环变量的类型决定了你能输入的数值范围，比如上面例子中用到的是unsigned long变量，因此可以最大输入Delay(4294967295)。如果是unsigned int变量，最大可以输入Delay(65535)。如果是unsigned  char变量，最大可以输入Delay(255)。

【82.5 Delay内部的for循环嵌套可产生无穷长的时间。】

      刚才讲到，如果用最大的变量类型unsigned long ，最大的输入是Delay(4294967295)，那么问题来，难道Delay函数的阻塞延时的时间有最大极限？其实不存在最大极限，理论上，你要多大的延时都可以，只需要在Delay函数内部用上for循环的嵌套，就可以产生“乘法级”的无穷长的时间，例子如下：

void Delay(unsigned long u32DelayTime)
{
static unsigned long i;
static unsigned long k;
for(i=0;i
{
for(k=0;k<5000;k++); //内部嵌套的for循环，意味着乘法的关系u32DelayTime的5000倍!
}
}

复制代码

【82.6 “阻塞延时”与“非阻塞延时”的各自应用范围。】

   “阻塞延时”一般应用在两个地方，一个是上电初始化进入主循环之前的延时，另一个是进入主循环之后，跟外部驱动芯片通信时候产生的时钟节拍小延时，而这个类延时一般是低于1ms的小延时。
   “非阻塞延时”在项目中是被大量应用的，进入主循环之后，只要大于或等于1ms的延时，大多数都采样“非阻塞延时”，因为进入“任务框架级”的层面，只有“非阻塞延时”才能保证项目可以继续“多任务并行处理”。“非阻塞延时”的方式后续章节会讲到。
   综上所述，1ms是“阻塞延时”与“非阻塞延时”的一个分解线，1ms这个时间不是绝对的，只是一个经验值。

陈生 · 2017-8-19 10:13:28

必须顶！！！！！！！！！！！！！！！！！！！！

2017-8-19 13:11:31

支持支持对小白帮助很大

吴坚鸿 · 2017-8-20 09:37:06

本帖最后由 jianhong_wu 于 2017-8-20 09:43 编辑

第八十三节：累计主循环的“非阻塞”延时控制LED闪烁。

【83.1 累计主循环的“非阻塞”。】

   上一节提到，当Delay的“阻塞”时间超过1ms并且被频繁调用的时候，由于Delay做“独占式无用功”而消耗的延时太长，会影响其它任务的并行处理，整个系统给人的感觉非常卡顿不流畅。为了解决此问题，本节引入累计主循环的“非阻塞”，同时，希望通过此例子，让大家第一次感受到switch语句在多任务并行处理时候的优越性。switch的精髓在于“根据某个判断条件实现步骤之间的灵活跳转”，这个思路是以后做所有大项目的框架性思路。
   为什么“累计主循环”可以兼顾到其它任务的并行处理？因为单片机进入main函数以后，在一个主循环里要扫描N个任务，从头到尾，把N个任务扫描一遍，每扫描一遍算“一次主循环”，每一次“主循环”都是要消耗一点时间，累计的“主循环”次数越多，所要消耗的时间就越长，但是跟Delay唯一的差别是，Delay做延时的时候没有办法扫描其它任务，而“累计主循环”内部本身就是在不断扫描其它任务，产生时间越长扫描其它任务的次数就越多，两者是完全相互促进而没有矛盾的。具体内容，请看下面的例子。

【83.2 累计主循环“非阻塞”的一个例子。】

   现在利用“累计主循环非阻塞”编写一个练习程序，让一个LED灯闪烁。例子如下：


               图83.2.1  灌入式驱动8个LED

#include "REG52.H"
#define CYCLE_SUM 5000 //累计主循环次数的设定阀值，该值决定了LED闪烁频率
***it P0_0=P0^0; //利用***it和符号“^”的组合，把变量名字P0_0与P0.0引脚关联起来
unsigned char Gu8CycleStep=0; //switch的跳转步骤
unsigned long Gu32CycleCnt=0; //累计主循环的计数器
void main()
{
while(1)
{
switch(Gu8CycleStep)
{
case 0:
Gu32CycleCnt++; //这里就是累计main函数内部的主循环while(1)的次数
if(Gu32CycleCnt>=CYCLE_SUM) //累计的次数达到设定值CYCLE_SUM就跳到下一步骤
{
Gu32CycleCnt=0; //及时清零计数器，为下一步骤的新一轮计数准备
P0_0=0; //LED灯亮。
Gu8CycleStep=1; //跳到下一步骤
}
break;
case 1:
Gu32CycleCnt++; //这里就是累计main函数内部的主循环while(1)的次数
if(Gu32CycleCnt>=CYCLE_SUM) //累计的次数达到设定值CYCLE_SUM就返回上一步骤
{
Gu32CycleCnt=0; //及时清零计数器，为返回上一步骤的新一轮计数准备
P0_0=1; //LED灯灭。
Gu8CycleStep=0; //返回到上一个步骤
}
break;
}
}
}

复制代码

【83.3 累计主循环的不足。】

上述83.2例子中，“累计主循环次数”实现时间延时是一个不错的选择。这种方法能胜任多任务处理的程序框架，但是本身也有一个小小的不足，比如“阀值CYCLE_SUM到底应该取多少才能产生多长的时间”是没有标准的，只能依靠不断上机实验来拿到一个你所需要的数值，这种“不规范”，当程序要移植到其它单片机平台上的时候就特别麻烦，需要重新修正阀值CYCLE_SUM。除此之外，哪怕在同样的一个单片机里，随着主函数里任务量的增加，累计一次主循环所消耗的时间长度也会发生变化，意味着靠“累计主循环次数”所获得的时间也会发生变化而导致不准确，此时，为了保证延时时间的准确性，必须要做的就是再一次修正“设定累计主循环次数”的阀值CYCLE_SUM，这样显然给我们带来了一丝不便，怎么办？假设单片机没有“定时中断”这个资源，那么这种“累计主循环次数”在多任务处理中确实是不二之选，但是，因为现在几乎所有的单片机内部都有“定时中断”这个资源，所以，大家不用为这个“不足”而烦恼，我们只要用上本节的switch思路，再外加一个“定时中断”，就可以轻松解决此问题，下一节就跟大家讲“定时中断”的内容。

2017-8-20 10:39:28

谢谢了，刚接触单片机正不知道怎么下手。。

lb · 2017-8-25 13:12:40

hao

db1001001 · 2017-8-27 13:21:29

还没更新啊，鸿哥，加油。

db1001001 · 2017-8-27 13:22:51

有些东西，经过鸿哥讲解，清晰了不少

吴坚鸿 · 2017-8-27 21:51:17

第八十四节：中断与中断函数。

【84.1 中断。】

   单片机的“中断”跟日常生活的“中断”差不多，你正在做“常事”的时候，突然遇到优先级更高的“急事”，这时你必须先暂停手上的“常事”，马上去处理突如其来的“急事”，处理完“急事”再返回来继续做“常事”。要理解单片机的“中断”，有六个关键点，第一点是“配置中断”，第二点是“做常事”，第三点是“中断请求”，第四点是“保护中断现场”，第五点是“处理急事”，第六点是“返回中断现场”。举个例子如下：
   第一点：你老婆随时都会打电话给你，所以你把你的手机24小时都打开处于待机的状态。（配置中断）
   第二点：你正在读一本书《道德经》（做常事）。
   第三点：当你读到第18页的时候，你老婆突然给你打电话，让你去幼儿园帮接一下小孩（中断请求）。
   第四点：你在第18页里夹了一张书签做标记（保护中断现场）。
   第五点：你放下手上的书去幼儿园接小孩（处理急事）。
   第六点：接了小孩，你回来继续打开《道德经》，找到书签标记的第18页（返回中断现场），继续阅读。
   上述六点，在单片机的C语言里，“配置中断”放在主函数的初始化那里，“做常事”放在主函数的主循环里（main函数内部的while(1)循环），“中断请求”单片机内部硬件检测到符合发生中断的条件，“保护中断现场”是单片机内部硬件电路自动处理的（不需要我们软件干涉），“处理急事”是单片机自动跳转到另外开辟的一个特殊中断函数处理（自动跳转是单片机的硬件自动完成不需要我们软件干涉），执行完一次中断函数后单片机再自动跳转到主函数的主循环的现场点继续从现场点开始继续做常事（返回中断现场）。在这六点中，其中第四点的“保护中断现场”与第六点的“返回中断现场”是要特别强调的，单片机从main函数的主循环while(1)准备跳转到中断函数之前，它会自动记录当前的位置（做好路标），以便处理完中断函数后再返回main函数的主循环while(1)时，能找到之前的被中断跳转前的位置，这样就可以接上原来的步骤去处理原来的“常事”，在步骤上既不提前也不滞后恰到好处，中断就不会影响到常事的完整性。代码分布图的模板描述如下：

void main()
{
配置中断;
while(1)
{
处理常事;
}
}
void 中断函数() interrupt 序号 //中断函数后缀带“interrupt 序号”特别修饰
{
急事;
}

复制代码

   奇怪！上述代码，为什么“main函数”与“中断函数”在软件上看不到任何关联，既不存在“main函数”调用“中断函数”，也不存在“中断函数”调用“main函数”的情况，在观感上，“main函数”与“中断函数”仿佛是隔离的毫无“物理连接”的，为什么单片机还能在“main函数”与“中断函数”两者中切换自如？没错，确实，“main函数”与“中断函数”在书写上是隔离的毫无关联的，但是它们之间之所以能相互切换，是因为背后有一只无形的手在自动操控这一切，这只手就是单片机硬件自身，这是一种特殊机制，也可以理解成一种特殊的游戏规则，我们只要遵守就好了，除了普通函数，其它凡是中断函数的，都不用跟main函数发生软件上的关联调用，它们之间的切换都是硬件自动完成的，这就是main函数与中断函数的特殊跳转机制（或者称为游戏规则也可以）。

【84.2 常用的中断函数有哪三类？】

      单片机的中断有很多，但常用在项目上的有三类：
      第一类是定时中断。配置中断后，使其每隔一段时间就产生一次中断，比如“1ms一次的定时中断”几乎是所有的系统里的标配，因为它对程序框架起到一个时间节拍的作用。
      第二类是通讯中断。比如串口每接收完一个字节就会产生一个中断通知我们去处理。
      第三类是电平变化的中断。下降沿或者上升沿的中断，常常用在采集高速的脉冲信号。

【84.3 我们如何操控中断？】

      刚才84.1提到“单片机硬件自动”这个概念，但是说它“硬件自动”并不意味着它不可控。单片机本身出厂的时候内部就携带了很多种类的中断，这些中断是否开启取决于你的“配置中断”代码，你要开启或者关闭某类中断，只需编写对应的“配置中断”代码就可以，而“配置中断”的代码本质就是填写某些寄存器数值。

小学生 · 2017-8-28 16:49:45

从程序框架到单片机基础，到现在的新贴，一路学习过来收获颇多，谢谢鸿哥的无私奉贤！！

db1001001 · 2017-9-3 20:02:23

又到周末了，支持鸿哥！

吴坚鸿 · 2017-9-4 19:32:22

第八十五节：定时中断的寄存器配置。

【85.1 寄存器配置的本质。】

      单片机内部可供我们选择的资源非常丰富，有定时器，有串口，有外部中断，等等。这些丰富的资源，就像你进入一家超市，你只需选择你所需要的东西就可以了，所以配置寄存器的关键在于选择，所谓选择就是往寄存器里面做填空题，单片机系统内部再根据你的“选择清单”，去启动对应的资源。那么我们怎么知道某个型号的单片机内部有哪些资源呢？看该型号“单片机的说明书”呀，“单片机的说明书”就是我们通常所说的“芯片的datasheet”，或者说是“芯片的数据手册”，这些资料单片机厂家会提供的。
      跟单片机打交道，其实跟人打交道没什么区别，你要让单片机按照你的“意愿”走，你首先要把你的“意愿”表达清楚，这个“意愿”就是信息，信息要具备准确性和唯一性，不能模凌两可。比如，现在要让单片机“每1ms产生一次中断”，你想想你可能需要给单片机提供哪些信息？
   （1）51单片机有2个定时器，一个是0号定时器，一个是1号定时器，我们要面临“二选一”的选择，本例子中用的是“0号定时器”。
   （2）0号定时器内部又有4种工作方式：方式0，方式1，方式2，方式3，本例子中用的是“方式1”。
   （3）定时器到底多长时间中断一次，这就涉及到填充与中断时间有关的寄存器的数值，该数值是跟时间成比例关系，本例子中配置的是1ms中断，就要填充对应的数值。
   （4）默认状态下，定时器是不会被开启的，如果要开启，这里就是涉及到定时器的“开关”，本例子要开启此开关。
   （5）定时器时间到了就要产生中断，中断也有“总开关”和“定时器的局部开关”，这两个开关都必须同时打开，中断才会有效。
      要配置定时器“每1ms产生一次中断”，大概就上述这些信息，根据这些信息提示，下面开始讲解一下寄存器的具体内容。

【85.2  定时器/计数器的模式控制寄存器TMOD。】

      寄存器TMOD是一个8位的特殊变量，里面每一位都代表了不同的功能选择。根据芯片的说明书，TMOD的8位从左到右依次对应从D7到D0（左高位，右低位），定义如下：

      GATE C/T M1    M0 GATE C/T M1 M0

      仔细观察，发现左4位与右4位是对称的，分别都是“GATE，C/T ， M1 ， M0”，左4位控制的是“定时器1”，右4位控制的是“定时器0”，因为本例子用的是“定时器0”，因此“定时器1”的左4位都设置为0的默认数值，我们只需重点关注右4位的“定时器0”即可。
      GATE：定时器是否受“其它外部开关”的影响的标志位。定时器的开启或者停止，受到两个开关的影响，第一个开关是“自身原配开关”，第二个开关是“其它外部开关”。GATE取1代表定时器受“其它外部开关”的影响，取0代表定时器不受“其它外部开关”的影响。本例子中，定时器只受到“自身原配开关”的影响，而不受到“其它外部开关”的影响，因此，GATE取0。
      C/T：定时器有两种模式，该位取1代表“计数器模式”，取0代表“定时器模式”。本例子是“定时器模式”，因此，C/T取0。
      M1与M0：工作方式的选择。M1与M0这两位的01搭配，可以有4种组合（00,01,10,11），每一种组合就代表一种工作方式。本例子选用“方式1”，因此M1与M0取“01”的组合。
      综上所述，TMOD的配置代码是：TMOD=0x01;

【85.3  决定时间长度的寄存器TH0与TL0。】

      TH0与TL0，T代表定时器英文单词TIME的T，H代表高位，L代表低位，0代表定时器0。
      TH0是一个8位宽度的寄存器，TL0也是一个8位宽度的寄存器，两者合并起来成为一个整体，实际上就是一个16位宽度的寄存器，TH0是高8位，TL0是低8位，它们合并后的数值范围是：0到65535。该16位寄存器取值越大，定时中断一次的时间反倒越小，为什么？TH0与TL0的初始值，就像一个水桶里装的水。如果这个桶是空桶（取值为0），“雨水”想把这个桶“滴满溢出”所需要的时间就很大。如果里面已经装了大半的水（取值为大于32767），“雨水”想把这个桶“滴满溢出”所需要的时间就很小。这里的关键词“滴满溢出”的“滴”与“满溢出”，“滴”的速度是由单片机晶振决定的，而“满溢出”一次就代表产生一次中断，执行完中断函数在即将返回主函数之前，我们重新装入特定容量的水（重装初值），为下一次的“滴满溢出”做准备，依次循环，从而连续不断地产生间歇的定时中断。
      配置中断时间的大小是需要经验的，因为，每次定时中断的时间太长，就意味着时间的可分度太粗，而如果每次定时中断的时间太短，则会产生很频繁的中断，势必会影响主函数main()的执行效率，而且累记中断次数的时间误差也会增大。因此，配置中断时间是需要经验的，根据经验，定时中断取1ms一次，是几乎所有单片机项目的最佳选择，按我的理解，“1ms定时中断一次”已经是单片机界公认的一种“标配”。
      要配置1ms定时中断，TH0与TL0如何取值？刚才提到一个形象的例子“桶，滴，满溢出”。TH0与TL0的最大取值范围是65535，可以理解成为最大65535“滴”，如果超过65535“滴”(比如加1“滴”后变成65536“滴”)就会“满溢出”，从而产生一次中断（65536是中断发生的临界值）。而“滴一次的时间”就刚好是单片机执行“一次单指令的时间”，“一次单指令的时间”等于12个晶振周期，比如12MHz的晶振，晶振周期是（1/12000000）秒，而“一次单指令的时间”就等于12乘以（1/12000000）秒，等于0.000001秒，也就是1us。1us“滴”一次，要产生1ms的时间就需要“滴”1000次。“满溢出”的前提条件是“桶里”一共需要装入65536滴才溢出，因此，在12MHz的晶振下要产生1ms的定时中断，TH0与TL0的初值应该是64536（65536减去1000等于64536），而64536变成十六进制0xfc17，再分解到高8位TH0为0xfc，低8位TL0为0x17。
      刚才的例子是假如晶振在12MHz的情况下所计算出来的结果，而本教程所用的晶振是11.0592MHz，根据11.0592MHz产生1ms的定时中断，TH0与TL0应该取值多少？根据刚才的计算方式:

初值=[溢出值]-([0.001秒]/([晶振周期的12个]*([1秒]/[晶振频率])))
初值=65536-(0.001/(12*(1/11059200)))
初值=65536-922 (注：922是921.6的四舍五入)
初值=64614
初值=64614
初值=0xfc66
初值TH0=0xfc
初值TL0=0x66

复制代码

【85.4  中断的总开关EA与局部开关ET0。】

      EA：中断的总开关。宽度是1位的位变量。此开关如果取0，就会强行屏蔽所有的中断，因此，只要用到中断，此开关必须取1。
      ET0：专门针对定时器0中断的局部开关。宽度是1位的位变量。此开关如果取0，则会屏蔽定时器0的中断，如果取1则允许定时器0中断。如果要定时器0能产生中断，那么总开关EA与ET0必须同时都打开（都取1），两者缺一不可。

【85.5  定时器0的“自身原配开关”TR0。】

      TR0：定时器的“自身原配开关”。宽度是1位的位变量。很多初学者会把EA，ET0，TR0三者搞不清。定时器可以工作在“查询标志位”和“中断”这两种状态，也就是说在没有中断的情况下定时器也可以单独使用的。TR0是定时器0自身的发动引擎，要不要把这个发动引擎所产生的能量传输到中断的渠道，则取决于中断开关EA和ET0。TR0是源头开关，EA是中断总渠道开关，ET0是中断分支渠道的定时器0开关。TR0取1表示启动定时器0，取0表示关闭定时器0。

【85.6  定时器0的中断函数的书写格式。】

void 函数名() interrupt 1
{
...中断程序内容;
...此处省去若干代码
...中断程序内容;
...最后面的代码，要记得重装TH0与TL0的初值;
}

复制代码

      函数名可以随便取，只要不是编译器已经征用的关键字。这里的1是定时器0的中断号。不同的中断号代表不同类型的中断，至于哪类中断对应哪个中断号，大家可以查找相关书籍和资料。本节用的定时器0处于工作方式1的情况下，在即将退出中断之前，需要重装TH0与TL0的初始值。

【85.7  寄存器的名字来源。】

      前面讲的寄存器都有固定的名字，而且这些名字都是唯一的，拼写的时候少一个字母或者多一个字母，C编译器都会报错不让你通过，因此问题来了，初学者刚接触一款单片机的时候，如何知道某个寄存器它特定的唯一的名字？有两个来源。
      第一个来源，可以打开C编译器的某个头文件（.h格式）查看这些寄存器的名字。比如51单片机可以查看REG52.H这个头文件。如何打开REG52.H这个文件？在keil源代码编辑器界面下，选中上面REG52.H这几个字符，在右键弹出的菜单下点击Open ducument“REG52.H”即可。
      第二个来源是直接参考一些现成的范例程序，这些范例程序网上很多，有的是原厂提供的，有的是热心网友的分享，有的是技术书籍或者学习板开发板厂家提供的。

【85.8  如何快速配置寄存器。】

      建议一边阅读芯片的数据手册，一边参考一些现成的范例程序，这些范例程序网上很多，有的是原厂提供的，有的是热心网友的分享，有的是技术书籍或者学习板开发板厂家提供的。

【85.9  练习例程。】

      现在编写一个定时中断程序，让两个LED灯闪烁，一个是在主函数里用累计主循环次数的方式实现（P0.0控制），另一个是在定时中断函数里用累计定时中断次数的方式实现（P0.1控制）。这两个闪烁的LED灯，一个在main函数，一个是在中断函数，两路任务互不干涉独立运行，并行处理的“雏形”略显出来。


      图85.9.1  灌入式驱动8个LED

#include "REG52.H"
#define CYCLE_SUM 5000 //主循环的次数
#define INTERRUPT_SUM 500 //中断的次数
***it P0_0=P0^0; //在主循环里的LED灯
***it P0_1=P0^1; //在定时中断里的LED灯
unsigned char Gu8CycleStep=0;
unsigned long Gu32CycleCnt=0; //累计主循环的计数器
unsigned char Gu8InterruptStep=0;
unsigned long Gu32InterruptCnt=0; //累计定时中断次数的计数器
void main()
{
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfc; //产生1ms中断的TH0初始值
TL0=0x66; //产生1ms中断的TL0初始值
EA=1; //开总中断
ET0=1; //允许定时0的中断
TR0=1; //启动定时0的中断
while(1) //主循环
{
switch(Gu8CycleStep)
{
case 0:
Gu32CycleCnt++;
if(Gu32CycleCnt>=CYCLE_SUM)
{
Gu32CycleCnt=0;
P0_0=0; //主循环的LED灯亮。
Gu8CycleStep=1;
}
break;
case 1:
Gu32CycleCnt++;
if(Gu32CycleCnt>=CYCLE_SUM)
{
Gu32CycleCnt=0;
P0_0=1; //主循环的LED灯灭。
Gu8CycleStep=0;
}
break;
}
}
}
void T0_time() interrupt 1 //定时器0的中断函数，每1ms单片机自动执行一次此函数
{
switch(Gu8InterruptStep)
{
case 0:
Gu32InterruptCnt++; //累计中断次数的次数
if(Gu32InterruptCnt>=INTERRUPT_SUM) //次数达到设定值就跳到下一步骤
{
Gu32InterruptCnt=0; //及时清零计数器，为下一步骤的新一轮计数准备
P0_1=0; //定时中断的LED灯亮。
Gu8InterruptStep=1; //跳到下一步骤
}
break;
case 1:
Gu32InterruptCnt++; //累计中断次数的次数
if(Gu32InterruptCnt>=INTERRUPT_SUM) //次数达到设定值就返回上一步骤
{
Gu32InterruptCnt=0; //及时清零计数器，为返回上一步骤的新一轮计数准备
P0_1=1; //定时中断的LED灯灭。
Gu8InterruptStep=0; //返回到上一个步骤
}
break;
}
TH0=0xfc; //重装初值，不能忘。
TL0=0x66; //重装初值，不能忘。
}

复制代码

db1001001 · 2017-9-4 19:53:31

支持。

南风不竞物语 · 2017-9-4 19:55:04

感谢楼主分享

吴坚鸿 · 2017-9-10 10:51:39

第八十六节：定时中断的“非阻塞”延时控制LED闪烁。

【86.1 定时中断应用的四大关键词。】

   本节主要内容有四大个关键词：1ms，互斥量，volatile，switch。
   （1）1ms。把定时中断设置为1ms中断一次，几乎是单片机界公认的“标配”。这个1 ms是系统时间的节拍来源，有了1ms“标配”意识，你的程序在不同单片机平台上移植的时候会得心应手运用自如。
   （2）互斥量。“主函数”与“定时中断函数”，本质上是两个独立进程在不断切换并行运行，两个进程之间不断切换，就会涉及到数据的安全保护，数据的安全保护主要是针对多字节的变量，比如int类型(2个字节)，long类型(4个字节)。但是单字节的char变量不用额外保护，因为“字节”是变量中的最小单位（在不考虑“位”的情况下），这里的“最小单位不可分”就像“原子是最小单位不可分”一样，因此也有很多前辈把“互斥量”称为“原子锁”。为什么要用互斥量？因为，在多个线程同时访问同一个全局变量的时候，如果双方都是“读操作”，则不会出现问题，但是，如果双方都是“既有写操作也有读操作”的情况下，比如，我在主函数里正在修改（写操作）一个unsigned int类型的变量，unsigned int类型的变量占用2个字节，在更改数据的时候至少需要2条指令，当我刚执行完第1条指令还没来得及执行第2指令的时候，突然来了一个定时中断，并且在定时中断函数里也对这个变量进行了修改（写操作）并且还进行了读取判断操作，这个瞬间就可能给程序带来了隐患。话说回来，互斥量到底有没有必要，其实还是有点争议的，我曾经为这个问题纠结过很久，毕竟，如果不用互斥量，这么微观的隐患到底存不存在，目前很难做一个“让故障重现”的实验去证明，最后，我是本着“宁可信其有不可信其无”的态度，把互斥量应用在了我的工作中。
   （3）volatile。volatile是一个前缀的修饰关键词，也是用来保护主函数与中断函数共用的全局变量的，只不过，volatile是针对C编译器的，预防“C编译器在优化代码的时候误伤一些重要的共享数据”，就像预防杀毒软软件用力过猛把一些合法软件当作病毒而误杀。加了volatile修饰的全局变量，就能提醒C编译器不要对这类特殊变量擅作主张去优化。
   （4）switch。switch是“非阻塞程序框架”的核心语句，在以switch为核心的框架下，进行不同步骤之间的程序跳转，是做大型裸机程序的常态。

【86.2  主函数与定时中断函数的程序框架。】

      主函数与定时中断函数之间相互配合，主函数负责做什么，中断函数负责做什么，对于初学者来说可能是一头雾水，但是对于像我这种在单片机界深耕多年即将修炼成精的工程师来说，我心中是有很清晰的模板和套路的，这种模板和套路是经过多年沉淀下来的经验。比如，定时中断函数尽量放一些精简的计时器代码，一般不调用函数，但是“输入IO口的消抖动”(按键扫描)以及“蜂鸣器鸣叫”这两类特殊函数我是喜欢破例放在定时中断函数里调用的。定时中断如何产生时间，这个时间如何跟主函数关联起来，请看下面的框架代码：

volatile unsigned char vGu8TimeFlag=0; //互斥量变量标志
volatile unsigned int vGu16TimeCnt=0; //计时器变量
void main()
{
vGu8TimeFlag=0; //在“写操作”vGu16TimeCnt全局变量之前，互斥量vGu8TimeFlag的“加锁”
vGu16TimeCnt=1000; //全局变量的赋值，就是“写操作”
vGu8TimeFlag=1; //互斥量vGu8TimeFlag的“解锁”。同时也起到“启动计时器”的开关作用
while(1) //主循环
{
if(0==vGu16TimeCnt) //时间变量为0则表示时间到了
{
...在这里执行具体的功能代码
}
}
}
void T0_time() interrupt 1 //每1ms中断一次的定时中断函数
{
if(1==vGu8TimeFlag&&vGu16TimeCnt>0) //判断vGu8TimeFlag是否等于1，就是互斥量的判断。
{
vGu16TimeCnt--; //“自减一”的操作
}
}

复制代码

      分析：上述代码中，vGu8TimeFlag是一箭双雕，既起到互斥量的作用，也起到了计数器vGu16TimeCnt开始计时的启动开关作用。

【86.3  练习例程。】

      现在根据上述程序框架，编写一个LED灯闪烁的程序。

   图86.3.1  灌入式驱动8个LED

#include "REG52.H"
#define BLINK_TIME 500 //时间是500ms
***it P0_0=P0^0;
volatile unsigned char vGu8TimeFlag=0; //互斥量变量标志
volatile unsigned int vGu16TimeCnt=0; //计时器变量
unsigned char Gu8Step=0; //switch的切换步骤
void main()
{
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfc; //产生1ms中断的TH0初始值
TL0=0x66; //产生1ms中断的TL0初始值
EA=1; //开总中断
ET0=1; //允许定时0的中断
TR0=1; //启动定时0的中断
while(1) //主循环
{
switch(Gu8Step)
{
case 0:
if(0==vGu16TimeCnt) //时间到
{
P0_0=0; //LED灯亮
vGu8TimeFlag=0; //互斥量“加锁”
vGu16TimeCnt=BLINK_TIME; //计时器的写操作。设定计时的长度
vGu8TimeFlag=1; //互斥量“解锁”，同时蕴含了计时器“启动”的动作
Gu8Step=1; //切换到case 1这个步骤
}
break;
case 1:
if(0==vGu16TimeCnt) //时间到
{
P0_0=1; //LED灯灭。
vGu8TimeFlag=0; //互斥量“加锁”
vGu16TimeCnt=BLINK_TIME; //计时器的写操作。设定计时的长度
vGu8TimeFlag=1; //互斥量“解锁”，同时蕴含了计时器“启动”的动作
Gu8Step=0; //切换到case 0这个步骤，依次循环
}
break;
}
}
}
void T0_time() interrupt 1 //定时器0的中断函数，每1ms单片机自动执行一次此函数
{
if(1==vGu8TimeFlag&&vGu16TimeCnt>0) //判断vGu8TimeFlag是否等于1，就是互斥量的判断
{
vGu16TimeCnt--; //“自减一”的操作
}
TH0=0xfc; //重装初值，不能忘
TL0=0x66; //重装初值，不能忘
}

复制代码

【86.4  解决闪烁出现不规则“非对称感”现象的方法。】

   上述例子，实验现象应该是LED闪烁很有规则的每1s闪烁一次，但是也有一部分初学者可能会遇到闪烁出现不规则“非对称感”的现象，这个问题的解决办法如下：在keil2的project下拉菜单下，选择Options for Target选项，弹出的窗口中，切换到Target选项，在Memory Model选项中选择small:variables in Data。

               图86.4.1  设置窗口

搜索历史

从单片机基础到程序框架（连载）

相关推荐

678 条评论

评论

精选推荐

热门帖

站长推荐 /6