学习使用单片机就是理解单片机硬件结构，以及内部资源的应用，在汇编或C语言中学会各种功能的初始化设置，以及实现各种功能的程序编制。

第一步：数字I/O的使用

使用按钮输入信号，发光二极管显示输出电平，就可以学习引脚的数字I/O功能，在按下某个按钮后，某发光二极管发亮，这就是数字电路中组合逻辑的功能，虽然很简单，但是可以学习一般的单片机编程思想，例如，必须设置很多寄存器对引脚进行初始化处理，才能使引脚具备有数字输入和输出输出功能。每使用单片机的一个功能，就要对控制该功能的寄存器进行设置，这就是单片机编程的特点，千万不要怕麻烦，所有的单片机都是这样。要注意的是两个功能使用同一组I/O口，比如LCD和LED例程众都是使用PB这一组的，如果两者结合，会有冲突，达不到预期的效果，建议不同的模块使用不同的IO口。

第二步：定时器的使用

学会定时器的使用，就可以用单片机实现时序电路，时序电路的功能是强大的，在工业、家用电气设备的控制中有很多应用，例如，可以用单片机实现一个具有一个按钮的楼道灯开关，该开关在按钮按下一次后，灯亮3分钟后自动灭，当按钮连续按下两次后，灯常亮不灭，当按钮按下时间超过2s，则灯灭。数字集成电路可以实现时序电路，可编程逻辑器件(PLD)可以实现时序电路，可编程控制器(PLC)也可以实现时序电路，但是只有单片机实现起来最简单，成本最低。

定时器的使用是非常重要的，逻辑加时间控制是单片机使用的基础。

第三步：中断

单片机的特点是一段程序反复执行，程序中的每个指令的执行都需要一定的执行时间，如果程序没有执行到某指令，则该指令的动作就不会发生，这样就会耽误很多快速发生的事情，例如，按钮按下时的下降沿。要使单片机在程序正常运行过程中，对快速动作做出反应，就必须使用单片机的中断功能，该功能就是在快速动作发生后，单片机中断正常运行的程序，处理快速发生的动作，处理完成后，在返回执行正常的程序。

中断功能使用中的困难是需要精确地知道什么时候不允许中断发生(屏蔽中断)、什么时候允许中断发生(开中断)，需要设置哪些寄存器才能使某种中断起作用，中断开始时，程序应该干什么，中断完成后，程序应该干什么等等。中断学会后，就可以编制更复杂结构的程序，这样的程序可以干着一件事，监视着一件事，一旦监视的事情发生，就中断正在干的事情，处理监视的事情，当然也可以监视多个事情，形象的比喻，中断功能使单片机具有吃着碗里的，看着锅里的功能。以上三步学会，就相当于降龙十八掌武功，会了三掌了，可以勉强护身。

第四步：与PC机进行RS232通信

单片机都有USART接口，其中很多型号都具有两个USART接口。USART接口不能直接与PC机的RS232接口连接，它们之间的逻辑电平不同，需要使用一个芯片进行电平转换。USART接口的使用是非常重要的，通过该接口，可以使单片机与PC机之间交换信息，虽然RS232通信并不先进，但是对于接口的学习是非常重要的。正确使用USART接口，需要学习通信协议，PC机的RS232接口编程等等知识。试想，单片机实验板上的数据显示在PC机监视器上，而PC机的键盘信号可以在单片机实验板上得到显示，将是多么有意思的事情啊!

第五步：学会A/D转换

单片机通常带有A/D转换器，通过这些A/D转换器可以使单片机操作模拟量，显示和检测电压、电流等信号。学习时注意模拟地与数字地、参考电压、采样时间，转换速率，转换误差等概念。使用A/D转换功能的简单的例子是设计一个电压表。

第六步：学会PCI、I2C接口和液晶显示器接口

这些接口的使用可以使单片机更容易连接外部设备，在扩展单片机功能方面非常重要。

第七步：学会比较、捕捉、PWM功能

这些功能可以使单片机能够控制电机，检测转速信号，实现电机调速器等控制起功能。如果以上七步都学会，就可以设计一般的应用系统，相当于学会十招降龙十八掌，可以出手攻击了。

第八步：学习USB接口、TCP/IP接口、各种工业总线的硬件与软件设计

学习USB接口、TCP/IP接口、各种工业总线的硬件与软件设计是非常重要的，因为这是当前产品开发的发展方向。

到此为止，相当于学会15招降龙十八掌，但还不到打遍天下无敌手的境界。即使如此，也算是单片机大侠了。

单片机中有象箱子功能一样的地方，我们称为寄存器，用来暂存数据。寄存器的种类有程序计数器、通用寄存器、以及SFR（特殊功能寄存器）等。

SFR主要用来设定外围功能电路（计数器或串行端口、通用I/O等）的工作方式，确认其工作状况，并对其进行控制的。也就是说SFR并非仅仅只是用来保存数据的“箱子”。通过改变保存在“箱子”里的数据，不仅可以改变外围功能电路的动作方式，而且“箱子”里的数据也将随着外围功能电路的工作状況而改变。

控制外围功能电路的基础知识

下面以通用I/O为例来说明单片机对外围功能电路的控制。通用I/O具有以下功能：

输出功能：可以输出高电平电压或低电平电压

输入功能：可以读出输入到引脚的电压电平

首先来看输出功能的控制。图1中的引脚A是一个通用I/O。

如果向引脚A的寄存器（SFR）

写入0，则引脚A的输出电压将为低电平（0V）。

写入1，则引脚A的输出电压将为高电平（5V）。

如果将图1的引脚A连接一个LED，就可以构成一个控制LED的电路（见图2）。此时，向寄存器（SFR）写入0则LED亮灯，输入1则LED熄灭。虽然这是一种很简单的动作，但却反映了单片机对各种外围功能电路进行控制的基本原理。利用这种功能，就可以完成象电机的ON/OFF一样的开关作用（由于通常的单片机上不能流过驱动电机运行的大电流，所以还需另行准备用FET或晶体管作成的电机驱动电路）。另外，如果使用多个通用I/O端口，就可以完成更加复杂的控制。

接下来看输入功能（图3）。

如果向引脚A输入低电平电压（0V），就会从寄存器（SFR）读出0。

如果向引脚A输入高电平电压（5V），就会从寄存器（SFR）读出1。

即，读取寄存器（SFR）的值，就可以判断外部电压是低电平电压还是高电平电压。

使用通用I/O的输入功能构成图4所示的电路，单片机就可以判断出开关（S）的状态。

当开关（S）断开时，电源电压通过上拉电阻（R），连接到引脚A（相当于输入高电平电压），寄存器（SFR）将的值变为1。

当开关（S）关闭时，引脚A被连接到低电平电压，寄存器（SFR）的值变为0。

单片机通过读取引脚A的寄存器（SFR）的值，是“1”还是“0”，可以判断外部开关（S）是断开还是关闭状态。

单片机上搭载了各种功能的SFR。通过程序来更改或读出这些功能寄存器的值，就可获知单片机外围电路的信息，而对外围电路进行控制。所以可以说，SFR就象是单片机的五官或者手脚。

对于每个单片机爱好者及工程开发设计人员，在刚接触单片机的那最初的青葱岁月里，都有过点亮跑马灯的经历。从看到那一排排小灯按着我们的想法在跳动时激动心情。到随着经验越多，越来又会感觉到这个小灯是个好东西，尤其是在调试资源有限的环境中，有时会帮上大忙。

但对于绝大多数人，我们在最最初让灯闪烁起来时大约都会用到阻塞延时实现，会像如下代码的样子：

while(1)
{
LED =OFF;
Delay_ms(500);
LED = ON;
Delay_ms(500);
}

然后，在我们接触到定时器，我们会发现，原来用定时中断来处理会更好。比如我们可以500ms中断一次，让灯亮或灭，其余的时间系统还可以做非常之多的事情，效率一下提升了很多。

这时我们就会慢慢意识到，第一种（阻塞延时）方法效率很低，让芯片在那儿空运行几百毫米，什么也不做，真是莫大的浪费，尤其在芯片频率较高，任务又很多时，这样做就像在平坦宽阔的高速公路上挖了一大坑，出现事故可想而知。

但一个单片机中的定时器毕竟有限，如果我需要几十个或者更多不同时间的定时中断，每一个时间到都完成不同的处理动作，如何去做呢。一般我们会想到在一个定时中断函数中再定义static 变量继续定时，到了所需时间，做不同的动作。而这样又会导致在一个中断里做了很多不同的事情，会抢占主轮询更多时间，有时甚至喧宾夺主，并也不是很如的思维逻辑。

那么有没有更好的方法来实现呢，答案是肯定的。下面介绍我在一个项目中偶遇，一个精妙设计的非阻塞定时延时软件的设计（此设计主要针对于无操作系统的裸机程序）。

比如我要设置其10ms中断一次，如何实现呢？

也很简单，只需调用 core_cm3.h文件中 SysTick_Config 函数 ，当系统时钟为72MHZ，则设置成如下即可 SysTick_Config（720000 ）; (递减计数720000次后中断一次) 。此时SysTick_Handler中断函数就会10ms进入一次；

任务定时用软件是如何设计的呢 ？

且先看其数据结构，这也是精妙所在之处，在此作自顶向下的介绍：

其定义结构体类型如：

typedef struct
{
uint8_t Tick10Msec;
Char_Field Status;
} Timer_Struct;
其中Char_Field 为一联合体，设计如下：
typedef union
{
unsigned char byte;
Timer_Bit field;
} Char_Field

而它内部的Timer_Bit是一个可按位访问的结构体：

typedef struct
{
unsigned char bit0: 1;
unsigned char bit1: 1;
unsigned char bit2: 1;
unsigned char bit3: 1;
unsigned char bit4: 1;
unsigned char bit5: 1;
unsigned char bit6: 1;
unsigned char bit7: 1;
} Timer_Bit

此联合体的这样设计的目的将在后面的代码中体现出来。
如此结构体的设计就完成了。

然后我们定义的一全局变量，Timer_Struct gTimer;

并在头文件中宏定义如下：

#define bSystem10Msec gTimer.Status.field.bit0
#define bSystem50Msec gTimer.Status.field.bit1
#define bSystem100Msec gTimer.Status.field.bit2
#define bSystem1Sec gTimer.Status.field.bit3
#define bTemp10Msec gTimer.Status.field.bit4
#define bTemp50Msec gTimer.Status.field.bit5
#define bTemp100Msec gTimer.Status.field.bit6
#define bTemp1Sec gTimer.Status.field.bit

另外为了后面程序清晰，再定义一状态指示：

typedef enum
{
TIMER_RESET = 0,
TIMER_SET = 1,
} TimerStatus;

至此，准备工作就完成了。下面我们就开始大显神通了！

首先，10ms定时中断处理函数如，可以看出，每到达10ms 将把bTemp10Msec置1，每50ms 将把bTemp50Msec 置1，每100ms 将把bTemp100Msec 置1，每1s 将把bTemp1Sec 置1，
void SysTick_Handler(void)
{

bTemp10Msec = TIMER_SET;

++gTimer.Tick10Msec;
if (0 == (gTimer.Tick10Msec % 5))
{
bTemp50Msec = TIMER_SET;
}

if (0 == (gTimer.Tick10Msec % 10))
{
bTemp100Msec = TIMER_SET;
}

if (100 == gTimer.Tick10Msec)
{
gTimer.Tick10Msec = 0;
bTemp1Sec = TIMER_SET;
}
}

而这又有什么用呢 ？

这时，我们需在主轮询while(1)内最开始调用一个定时处理函数如下：

void SysTimer _Process(void)
{
gTimer.Status.byte &= 0xF0;

if (bTemp10Msec)
{
bSystem10Msec = TIMER_SET;
}

if (bTemp50Msec)
{
bSystem50Msec = TIMER_SET;
}

if (bTemp100Msec)
{
bSystem100Msec = TIMER_SET;
}

if (bTemp1Sec)
{
bSystem1Sec = TIMER_SET;
}

gTimer.Status.byte &= 0x0F;
}

此函数开头与结尾两句

gTimer.Status.byte &= 0xF0;
gTimer.Status.byte &= 0x0F

就分别巧妙的实现了bSystemXXX （低4位） 和 bTempXXX（高4位）的清零工作，不用再等定时到达后还需手动把计数值清零。此处清零工作用到了联合体中的变量共用一个起始存储空间的特性。

但要保证while(1)轮询时间要远小于10ms，否则将导致定时延时不准确。这样，在每轮询一次，就先把bSystemXXX ，再根据bTempXXX判断是否时间到达，并把对应的bSystemXXX 置1，而后面所有的任务就都可以通过bSystemXXX 来进行定时延时，在最后函数退出时，又会把bTempXXX清零，为下一次时间到达后查询判断作好了准备。

说了这么多，举例说明一下如何应用：

void Task_A_Processing(void)
{
if(TIMER_SET == bSystem50Msec){
//do something
}
}

void Task_B_Processing(void)
{
if(TIMER_SET == bSystem100Msec){
//do something
}
}

void Task_C_Processing(void)
{
static uint8_t ticks = 0;
if(TIMER_SET == bSystem100Msec){
ticks ++ ;
}

if(5 == ticks){
ticks = 0;
//do something
}

}

void Task_D_Processing(void)
{
if(TIMER_SET == bSystem1Sec){
//do something
}
}

以上示例四个任务进程，

在主轮询里可进行如下处理：

int main(void)
{
while(1)
{
SysTimer _Process();

Task_A_Processing();
Task_B_Processing();
Task_C_Processing();
Task_D_Processing();

}
}

这样，就可以轻松且清晰实现了多个任务，不同时间内处理不同事件。（但注意，每个任务处理中不要有阻塞延时，也不要处理过多的事情，以致处理时间较长。可设计成状态机来处理不同任务。）

作者：zhangren_ham

初学者在编写单片机程序时经常会用到延时函数，但是当系统逐步复杂以后(没有复杂到使用操作系统)延时会因为延时降低MCU的利用率，更严重的会影响系统中的“并行”操作例如一个既有按键又有蜂鸣器的系统中，如果要求按下按键发出不同的声音，每次发声时间在1秒-2秒之间， 如果用延时来做代码很简单：

//蜂鸣器发出“哔-哔-哔”声音时间约1s
void BeepFuction(void)
{
unsigned char i;
for(i=0;i<3;i=++)
{
BeepEn（）； //开启蜂鸣器
Delayms（220）；//延时220ms
BeepDis（）；//关闭蜂鸣器
Delayms（110）；//延时110ms
}
}

当这段代码执行时MCU不可能同时处理按键检查程序因为它大部分时间在执行Delayms()函数中的nop指令，这样就不可能去执行检查按键了(不使用中断时)，如果把程序改成流程形式的写法则结果会大为不同，下面先介绍一下基本原理。

我们都知道一般的定时器为16位或8位循环计数，例如对于16位的计数器当计数器数值从0增加到65535时再加一就会回到0那么我们来比较下面两种情况(不考虑计数器在记录当前时刻T后再次回到或超过T这种情况我暂且称它为“压圈”)：

情况1：

T1时刻计数器数值为300

T2时刻计数器数值为400

则T1时刻到T2为100个计数单位。

这段时间差也为100个计数单位。

情况2：

T1时刻计数器数值为65535

T2时刻计数器数值为99

则T1到T2 可以算出为65535到0的1个计数单位再加上 0到99的99个计数单位总共为100个计数单位。

所以时间差还是100个计数单位。

在C语言中如果使用两个无符号数作减法会得到如下结果：99-65535=100，这个很好理解就和10进制的借位一样只不过借位后不用管高位了也就相当于99+65536-65535结果是100了，当然这些前提条件都是计数器不会出现“压圈”。

有了上面对定时器的了解就可以从新写这个Beep函数了

//蜂鸣器发出“哔-哔-哔”声音时间约1s
bit BeepFlag = 0;//蜂鸣流程忙标志位
bit BeepCtrl = 0;//蜂鸣器流程控制标志位
void BeepProc(void)
{
static unsigned int BeepTimer;
static unsigned char BeepStatus = 0;
static unsigned char i;
switch(BeepStatus)
{
case 0://
if(BeepCtrl)
{
i = 3;//蜂鸣次数
BeepFlag = 1;//置位忙标志位
BeepCtrl = 0;//清除控制标志位
BeepTimer = TIMER;//这里TIMER为系统定时器计数时钟为1ms
BeepEn（）； //开启蜂鸣器
BeepStatus = 1;//进入下一个状态
}
break;
case 1://蜂鸣状态
if(TIMER-BeepTimer>220)//220ms
{
BeepDis（）； //关闭蜂鸣器
BeepTimer = TIMER;//记录时刻
BeepStatus = 2;//进入下一个状态
}
break;
case 2://停止蜂鸣状态
if(TIMER-BeepTimer>110)//110ms
{
if(i!=0)
{
i--;
BeepTimer = TIMER;//记录时刻
BeepEn（）； //开启蜂鸣器
BeepStatus = 2;//回到蜂鸣状态
}
else
{
BeepStatus = 0;//回到初始状态
BeepFlag = 0;//清除忙标志位
}
}
break;
default:
BeepFlag = 0;//清除忙标志位
BeepStatus = 0;//回到初始状态
break;
}
}

用这样的方法实现的蜂鸣程序在使用时也有不同的地方，因为使用的switch状态所有在主循环中要一直调用：

void main()
{
SystemInitial();//系统初始化
...............

//主循环
while(1)
{
Fun1Proc();//功能1流程
Fun2Proc();//功能2流程
....
BeepProc();//蜂鸣流程
....
}

}

在别的函数中需要使蜂鸣器工作时只需要下面代码即可：

if(!BeepFlag)//检查是否忙
BeepCtrl = 1;//启动蜂鸣器

用这种方法能充分利用MCU，在蜂鸣器发声或发声间隔的等待时间MCU可以处理别的函数，但是还要有几点需要注意

第一，主循环while(1)的循环周期最好小于定时器计数时钟周期

第二，主循环中尽量不要使用硬延时Delayms

第三，代码中如果存在多个地方需要控制一个流程时一定要先读取标志位再控制

单片机（Microcontrollers）是一种集成电路芯片，是采用超大规模集成电路技术把具有数据处理能力的中央处理器CPU、随机存储器RAM、只读存储器ROM、多种I/O口和中断系统、定时器/计数器等功能（可能还包括显示驱动电路、脉宽调制电路、模拟多路转换器、A/D转换器等电路）集成到一块硅片上构成的一个小而完善的微型计算机系统，在工业控制领域广泛应用。从上世纪80年代，由当时的4位、8位单片机，发展到现在的300M的高速单片机。