1. 十六进制表示字节 0x5a:二进制为 01011010B;0x6E 为 01101110。
2. 如果将一个 16 位二进数赋给一个 8 位的字节变量,则自动截断为低 8 位,而
丢掉高 8 位。
3. ++var 表示对变量 var 先增一;var—表示对变量后减一。
4. x |= 0x0f;表示为 x = x | 0x0f;
5. TMOD = ( TMOD & 0xf0 ) | 0x05;表示给变量 TMOD 的低四位赋值 0x5,而不
改变 TMOD 的高四位。
6. While( 1 ); 表示无限执行该语句,即死循环。语句后的分号表示空循环体,
也就是{;}
在某引脚输出高电平的编程方法:(比如 P1.3(PIN4)引脚)
代码
1. #include
//该头文档中有单片机内部资源的符号化定义,其中
包含 P1.3
2. void main( void )
片机运行的复位入口
3. {
4.
5.
6. }
//void 表示没有输入参数,也没有函数返值,这入单
//给 P1_3 赋值 1,引脚 P1.3 就能输出高电平 VCC
//死循环,相当 LOOP: goto LOOP;
P1_3 = 1;
While( 1 );
//死循环,相当 LOOP: goto LOOP;
//给 P2_7 赋值 0,引脚 P2.7 就能输出低电平 GND
//void 表示没有输入参数,也没有函数返值,这入单
注意:P0 的每个引脚要输出高电平时,必须外接上拉电阻(如 4K7)至 VCC 电源。
在某引脚输出低电平的编程方法:(比如 P2.7 引脚)
代码
1. #include //该头文档中有单片机内部资源的符号化定义,其中
包含 P2.7
2. void main( void )
片机运行的复位入口
3. {
4.
5.
6. }
在某引脚输出方波编程方法:(比如 P3.1 引脚)
代码
1. #include //该头文档中有单片机内部资源的符号化定义,其中
包含 P3.1
2. void main( void )
片机运行的复位入口
3. {
4.
5.
6. P3_1 = 1;
7.
8.
9. }
//由于一直为真,所以不断输出高、低、高、低……,从而形成方波
//void 表示没有输入参数,也没有函数返值,这入单
//非零表示真,如果为真则执行下面循环体的语句
//给 P3_1 赋值 1,引脚 P3.1 就能输出高电平 VCC
P3_1 = 0;
//给 P3_1 赋值 0,引脚 P3.1 就能输出低电平 GND
P2_7 = 0;
While( 1 );
While( 1 )
{
}
//void 表示没有输入参数,也没有函数返值,这入单
将某引脚的输入电平取反后,从另一个引脚输出:( 比如 P0.4 = NOT( P1.1) )
代码
1. #include
//该头文档中有单片机内部资源的符号化定义,其中
包含 P0.4 和 P1.1
2. void main( void )
片机运行的复位入口
3. {
4.
P1_1 = 1;
5. While( 1 )
6.
7. if( P1_1 == 1 )
电平 VCC
8.
//读取 P1.1,就是认为 P1.1 为输入,如果 P1.1 输入高
} //给 P0_4 赋值 0,引脚 P0.4 就能输出低电平 GND
//非零表示真,如果为真则执行下面循环体的语句
//初始化。P1.1 作为输入,必须输出高电平
{ P0_4 = 0;
{
//否则 P1.1 输入为低电平 GND
} //给 P0_4 赋值 1,引脚 P0.4 就能输出高电平 VCC
} //给 P0_4 赋值 0,引脚 P0.4 就能输出低电平 GND
else
//{ P0_4 = 0;
{ P0_4 = 1;
//由于一直为真,所以不断根据 P1.1 的输入情况,改变 P0.4 的输出
9.
10.
11.
12.
电平
13. }
将某端口 8 个引脚输入电平,低四位取反后,从另一个端口 8 个引脚输出:( 比
如 P2 = NOT( P3 ) )
代码
1. #include //该头文档中有单片机内部资源的符号化定义,其中
包含 P2 和 P3
2. void main( void )
片机运行的复位入口
3. {
4.
个引脚输出高电平
5. While( 1 )
6.
7. P2 = P3^0x0f //读取 P3,就是认为 P3 为输入,低四位异或者 1,即取反,
然后输出
8.
9. }
//初始化。P3 作为输入,必须输出高电平,同时给 P3 口的 8
//void 表示没有输入参数,也没有函数返值,这入单
//取反的方法是异或 1,而不取反的方法则是异或 0
//非零表示真,如果为真则执行下面循环体的语句
//由于一直为真,所以不断将 P3 取反输出到 P2
}
{
}
P3 = 0xff;
注意:一个字节的 8 位 D7、D6 至 D0,分别输出到 P3.7、P3.6 至 P3.0,比如 P3=0x0f,
则 P3.7、P3.6、P3.5、P3.4 四个引脚都输出低电平,而 P3.3、P3.2、P3.1、P3.0
四个引脚都输出高电平。同样,输入一个端口 P2,即是将 P2.7、P2.6 至 P2.0,
读入到一个字节的 8 位 D7、D6 至 D0。
第一节:单数码管按键显示
单片机最小系统的硬件原理接线图:
1. 接电源:VCC(PIN40)、GND(PIN20)。加接退耦电容 0.1uF
2. 接晶体:X1(PIN18)、X2(PIN19)。注意标出晶体频率(选用 12MHz),
还有辅助电容 30pF
3. 接复位:RES(PIN9)。接上电复位电路,以及手动复位电路,分析复位工
作原理
4. 接配置:EA(PIN31)。说明原因。
发光二极的控制:单片机 I/O 输出
将一发光二极管 LED 的正极(阳极)接 P1.1,LED 的负极(阴极)接地 GND。只
要 P1.1 输出高电平 VCC,LED 就正向导通(导通时 LED 上的压降大于 1V),有
电流流过 LED,至发 LED 发亮。实际上由于 P1.1 高电平输出电阻为 10K,起到输
出限流的作用,所以流过 LED 的电流小于(5V-1V)/10K = 0.4mA。只要 P1.1
输出低电平 GND,实际小于 0.3V,LED 就不能导通,结果 LED 不亮。
开关双键的输入:输入先输出高
一个按键 KEY_ON 接在 P1.6 与 GND 之间,另一个按键 KEY_OFF 接 P1.7 与 GND 之
间,按 KEY_ON 后 LED 亮,按 KEY_OFF 后 LED 灭。同时按下 LED 半亮,LED 保持
后松开键的状态,即 ON 亮 OFF 灭。
代码
1. #include
2. #define LED
3. #define KEY_ON P1^6
4. #define KEY_OFF P1^7
5. void main( void )
参数,无返回值
6. {
7.
否则输入为 1
8.
否则输入为 1
9.
10.
11.
12.
灭
13.
14. //同时按下时,LED 不断亮灭,各占一半时间,交替频率很快,由于人眼惯
性,看上去为半亮态
15. }
数码管的接法和驱动原理
if( KEY_ON==0 ) LED=1; //是 KEY_ON 接下,所示 P1.1 输出高,LED 亮
if( KEY_OFF==0 ) LED=0; //是 KEY_OFF 接下,所示 P1.1 输出低,LED
} //松开键后,都不给 LED 赋值,所以 LED 保持最后按键状态。
KEY_ON = 1;
//作为输入,首先输出高,接下 KEY_ON,P1.6 则接地为 0,
While( 1 )
//永远为真,所以永远循环执行如下括号内所有语句
//单片机复位后的执行入口,void 表示空,无输入
KEY_OFF = 1;
//作为输入,首先输出高,接下 KEY_OFF,P1.7 则接地为 0,
{
P1^1
//用符号 LED 代替 P1_1
//用符号 KEY_ON 代替 P1_6
//用符号 KEY_OFF 代替 P1_7
一支七段数码管实际由 8 个发光二极管构成,其中 7 个组形构成数字 8 的七
段笔画,所以称为七段数码管,而余下的 1 个发光二极管作为小数点。作为习惯,
分别给 8 个发光二极管标上记号:a,b,c,d,e,f,g,h。对应 8 的顶上一画,按顺
时针方向排,中间一画为 g,小数点为 h。
我们通常又将各二极与一个字节的 8 位对应,
a(D0),b(D1),c(D2),d(D3),e(D4),f(D5),g(D6),h(D7),相应 8 个发光二极管正
好与单片机一个端口 Pn 的 8 个引脚连接,这样单片机就可以通过引脚输出高低
电平控制 8 个发光二极的亮与灭,从而显示各种数字和符号;对应字节,引脚接
法为:a(Pn.0),b(Pn.1),c(Pn.2),d(Pn.3),e(Pn.4),f(Pn.5),g(Pn.6),
h(Pn.7)。
如果将 8 个发光二极管的负极(阴极)内接在一起,作为数码管的一个引脚,
这种数码管则被称为共阴数码管,共同的引脚则称为共阴极,8 个正极则为段极。
否则,如果是将正极(阳极)内接在一起引出的,则称为共阳数码管,共同的引
脚则称为共阳极,8 个负极则为段极。
以单支共阴数码管为例,可将段极接到某端口 Pn,共阴极接 GND,则可编写
出对应十六进制码的七段码表字节数据
标准的 C 语言中没有空语句。但在单片机的 C 语言编程中,经常需要用几个空指令产生短
延时的效果。
这在汇编语言中很容易实现,写几个 nop 就行了。
在 keil C51 中,直接调用库函数:
#include
_nop_();
// 声明了 void _nop_(void);
// 产生一条 NOP 指令
作用:对于延时很短的,要求在 us 级的,采用“_nop_”函数,这个函数相当汇编 NOP 指
令,延时几微秒。
NOP 指令为单周期指令,可由晶振频率算出延时时间,对于 12M 晶振,延时 1uS。
对于延时比较长的,要求在大于 10us,采用 C51 中的循环语句来实现。
在选择 C51 中循环语句时,要注意以下几个问题
第一、定义的 C51 中循环变量,尽量采用无符号字符型变量。
第二、在 FOR 循环语句中,尽量采用变量减减来做循环。
第三、在 do…while,while 语句中,循环体内变量也采用减减方法。
这因为在 C51 编译器中,对不同的循环方法,采用不同的指令来完成的。
下面举例说明:
unsigned char I;
for(i=0;i<255;i++);
DJNZ 09H,LOOP
unsigned char I;
for(i=255;i>0;i--);
其中,第二个循环语句 C51 编译后,就用 DJNZ 指令来完成,相当于如下指令:
MOV 09H,#0FFH
LOOP:
指令相当简洁,也很好计算精确的延时时间。
同样对 do…while,while 循环语句中,也是如此
例:
unsigned char n;
n=255;
do{n--}
while(n);
或
n=255;
while(n)
{n--};
这两个循环语句经过 C51 编译之后,形成 DJNZ 来完成的方法,
故其精确时间的计算也很方便。
其三:对于要求精确延时时间更长,这时就要采用循环嵌套
的方法来实现,因此,循环嵌套的方法常用于达到 ms 级的延时。
对于循环语句同样可以采用 for,do…while,while 结构来完
成,每个循环体内的变量仍然采用无符号字符变量。
unsigned char i,j
for(i=255;i>0;i--)
for(j=255;j>0;j--);
或
unsigned char i,j
i=255;
do{j=255;
do{j--}
while(j);
i--;
}
while(i);
或
unsigned char i,j
i=255;
while(i)
{j=255;
while(j)
{j--};
i--;
}
这三种方法都是用 DJNZ 指令嵌套实现循环的,由 C51 编
译器用下面的指令组合来完成的
MOV R7,#0FFH
LOOP2:
LOOP1:
DJNZ R7,LOOP2
这些指令的组合在汇编语言中采用 DJNZ 指令来做延时用,
因此它的时间精确计算也是很简单,假上面变量 i 的初
值为 m,变量 j 的初值为 n,则总延时时间为:m×(n×T+T),
其中 T 为 DJNZ 指令执行时间(DJNZ 指令为双周期指令)。
这里的+T 为 MOV 这条指令所使用的时间。
同样对于更长时间的延时,可以采用多重循环来完成。
只要在程序设计循环语句时注意以上几个问题。
MOV R6,#0FFH
DJNZ R6,LOOP1
下面给出有关在 C51 中延时子程序设计时要注意的问题
1、在 C51 中进行精确的延时子程序设计时,尽量不要
或少在延时子程序中定义局部变量,所有的延时子程
序中变量通过有参函数传递。
2、在延时子程序设计时,采用 do…while,结构做循
环体要比 for 结构做循环体好。
3、在延时子程序设计时,要进行循环体嵌套时,采用
先内循环,再减减比先减减,再内循环要好。
unsigned char delay(unsigned char i,unsigned char j,unsigned char k)
{unsigned char b,c;
b="j";
c="k";
do{
do{
do{k--};
while(k);
k="c";
j--;};
while(j);
j=b;
i--;};
while(i);
}
这精确延时子程序就被 C51 编译为有下面的指令组合完成
delay 延时子程序如下:
C0012:
MOV
MOV
DJNZ
MOV
DJNZ
MOV
DJNZ
RET
R6,05H
R4,03H
R3, C0012
R3,04H
R5, C0012
R5,06H
R7, C0012
假设参数变量 i 的初值为 m,参数变量 j 的初值为 n,参数
变量 k 的初值为 l,则总延时时间为:l×(n×(m×T+2T)+2T)+3T,
其中 T 为 DJNZ 和 MOV 指令执行的时间。当 m=n=l 时,精确延时为 9T,最短;
当 m=n=l=256 时,精确延时到 16908803T,最长。
-----------------------------------------------------------------------------------------
采用软件定时的计算方法
利用指令执行周期设定,以下为一段延时程序:
指令
MOV
DJNZ
NOP
采用循环方式定时,有程序:
周期
1
2
1
MOV
R5,#TIME2
LOOP1:
LOOP2:
MOV
NOP
R6,#TIME1
NOP
DJNZ
R6,LOOP2
; 1
; 1
; 2
;周期 1
; 1
DJNZ
R5,LOOP1
; 2
定时数=(TIME1*4+2+1)*TIM2*2+4
刚刚又学了一条,用_nop_();时记得加上#include 头文件
如:
//==================
#include //包含库函数
......
......
//============
......
......
_nop_();
//引用库函数
敬礼。
我一直都是借助仿真软件编。一点一点试时间。
C 语言最大的缺点就是实时性差,我在网上到看了一些关于延时的讨论,其中有篇文章
51 单片机 Keil C 延时程序的简单研究,作者:InfiniteSpace Studio/isjfk
写得不错,他是用 while(--i);产生 DJNZ 来实现精确延时,后来有人说如果 while 里面不能放其
它语句,否则也不行,用 do-while 就可以,具体怎样我没有去试.所有这些都没有给出具体的实
例程序来.还看到一些延时的例子多多少少总有点延时差.为此我用 for 循环写了几个延时的
子程序贴上来,希望能对初学者有所帮助.(晶振 12MHz,一个机器周期 1us.)
一. 500ms 延时子程序
程序:
void delay500ms(void)
{
unsigned char i,j,k;
for(i=15;i>0;i--)
for(j=202;j>0;j--)
for(k=81;k>0;k--);
}
产生的汇编:
C:0x0800
C:0x0802
C:0x0804
C:0x0806 DDFE
C:0x0808 DEFA
C:0x080A DFF6
C:0x080C 22
7F0F MOV
7ECA MOV
7D51 MOV
DJNZ
DJNZ
DJNZ
RET
R7,#0x0F
R6,#0xCA
R5,#0x51
R5,C:0806
R6,C:0804
R7,C:0802
计算分析:
程序共有三层循环
一层循环 n:R5*2 = 81*2 = 162us
二层循环 m:R6*(n+3) = 202*165 = 33330us
三层循环: R7*(m+3) = 15*33333 = 499995us
循环外:
延时总时间 = 三层循环 + 循环外 = 499995+5 = 500000us =500ms
DJNZ 2us
DJNZ 2us + R5 赋值 1us = 3us
DJNZ 2us + R6 赋值 1us = 3us
5us
子程序调用 2us + 子程序返回 2us + R7 赋值 1us = 5us
计算公式:延时时间=[(2*R5+3)*R6+3]*R7+5
二. 200ms 延时子程序
程序:
void delay200ms(void)
{
unsigned char i,j,k;
for(i=5;i>0;i--)
for(j=132;j>0;j--)
for(k=150;k>0;k--);
}
产生的汇编
C:0x0800 7F05 MOV
C:0x0802 7E84 MOV
C:0x0804 7D96 MOV
DJNZ
C:0x0806 DDFE
C:0x0808 DEFA
DJNZ
C:0x080A DFF6
DJNZ
C:0x080C 22
RET
三. 10ms 延时子程序
程序:
void delay10ms(void)
{
unsigned char i,j,k;
for(i=5;i>0;i--)
for(j=4;j>0;j--)
for(k=248;k>0;k--);
}
产生的汇编
C:0x0800 7F05 MOV
C:0x0802 7E04 MOV
R7,#0x05
R6,#0x84
R5,#0x96
R5,C:0806
R6,C:0804
R7,C:0802
R7,#0x05
R6,#0x04