单片机编程实例大全

描述

 

*实例1:

使用P3口流水点亮8位LED

#include //包含单片机寄存器的头文件 / 函数功能:延时一段时间

void delay(void)

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

;

}

/ 函数功能:主函数

void main(void)

{

while(1)

{

P3=0xfe; //第一个灯亮

delay(); //调用延时函数

P3=0xfd; //第二个灯亮

delay(); //调用延时函数

P3=0xfb; //第三个灯亮

delay(); //调用延时函数

P3=0xf7; //第四个灯亮

delay(); //调用延时函数

P3=0xef; //第五个灯亮

delay(); //调用延时函数

P3=0xdf; //第六个灯亮

delay(); //调用延时函数

P3=0xbf; //第七个灯亮

delay(); //调用延时函数

P3=0x7f; //第八个灯亮

delay(); //调用延时函数

} / /

}

 

 

*实例2:

通过对P3口地址的操作流水点亮8位LED

#include //包含单片机寄存器的头文件

sfr x=0xb0; //P3口在存储器中的地址是b0H, 通过sfr可定义8051内核单片机

//的所有内部8位特殊功能寄存器,对地址x的操作也就是对P1口的操作

/

函数功能:延时一段时间

/

void delay(void)

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

; //利用循环等待若干机器周期,从而延时一段时间

}

/

函数功能:主函数

/

void main(void)

{

while(1)

{

x=0xfe; //第一个灯亮

delay(); //调用延时函数

x=0xfd; //第二个灯亮

delay(); //调用延时函数

x=0xfb; //第三个灯亮

delay(); //调用延时函数

x=0xf7; //第四个灯亮

delay(); //调用延时函数

x=0xef; //第五个灯亮

delay(); //调用延时函数

x=0xdf; //第六个灯亮

delay(); //调用延时函数

x=0xbf; //第七个灯亮

delay(); //调用延时函数

x=0x7f; //第八个灯亮

delay(); //调用延时函数

}

}

 

*实例3:用不同数据类型控制灯闪烁时间

#include //包含单片机寄存器的头文件

/

函数功能:用整形数据延时一段时间

/

void int_delay(void) //延时一段较长的时间

{

unsigned int m; //定义无符号整形变量,双字节数据,值域为0~65535 for(m=0;m<36000;m++)

; //空操作

}

/

函数功能:用字符型数据延时一段时间

/

void char_delay(void) //延时一段较短的时间

{

unsigned char i,j; //定义无符号字符型变量,单字节数据,值域0~255 for(i=0;i<200;i++)

for(j=0;j<180;j++)

; //空操作

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

while(1)

{

for(i=0;i<3;i++)

{

P1=0xfe; //P1.0口的灯点亮

int_delay(); //延时一段较长的时间

P1=0xff; //熄灭

int_delay(); //延时一段较长的时间

}

for(i=0;i<3;i++)

{

P1=0xef; //P1.4口的灯点亮

char_delay(); //延时一段较长的时间

} P1=0xff; //熄灭 char_delay(); //延时一段较长的时间 } }

 

*实例4:用单片机控制第一个灯亮

#include //包含51单片机寄存器定义的头文件

void main(void)

{

P1=0xfe; //P1=1111 1110B,即P1.0输出低电平

}

 

*实例5:用单片机控制一个灯闪烁:认识单片机的工作频率 #include //包含单片机寄存器的头文件

/

函数功能:延时一段时间

/

void delay(void) //两个void意思分别为无需返回值,没有参数传递 {

unsigned int i; //定义无符号整数,最大取值范围65535 for(i=0;i<20000;i++) //做20000次空循环

; //什么也不做,等待一个机器周期

}

/ 函数功能:主函数 (C语言规定必须有也只能有1个主函数) / void main(void)

{

while(1) //无限循环

{

P1=0xfe; //P1=1111 1110B, P1.0输出低电平

delay(); //延时一段时间

P1=0xff; //P1=1111 1111B, P1.0输出高电平

delay(); //延时一段时间

}

}

 

*实例6:将 P1口状态分别送入P0、P2、P3口:认识I/O口

的引脚功能

#include //包含单片机寄存器的头文件

/ 函数功能:主函数 (C语言规定必须有也只能有1个主函数) /

void main(void)

{

while(1) //无限循环

{

P1=0xff; // P1=1111 1111B,熄灭LED

P0=P1; // 将 P1口状态送入P0口

P2=P1; // 将 P1口状态送入P2口

P3=P1; // 将 P1口状态送入P3口

}

}

 

*实例7:用P0口、P1 口分别显示加法和减法运算结果 #include

void main(void)

{

unsigned char m,n;

m=43; //即十进制数2x16+11=43

n=60; //即十进制数3x16+12=60

P1=m+n; //P1=103=0110 0111B,结果P1.3、P1.4、P1.7 口的灯被点亮 P0=n-m; //P0=17=0001 0001B,结果P0.0、P0.4的灯被熄灭 }

 

*实例8:用P0、P1口显示乘法运算结果

#include //包含单片机寄存器的头文件

void main(void)

{

unsigned char m,n;

unsigned int s;

m=64;

n=71;

s=m n; //s=64 71=4544,需要16位二进制数表示,高8位送P1口,低8位送P0口

//由于4544=17 256+192=H3 16 16 16+H2 16 16+H1 16+H0

//两边同除以256,可得17+192/256=H3 16+H2+(H1 16+H0)/256

//因此,高8位16进制数H3 16+H2必然等于17,即4544除以256的商

//低8位16进制数H1 16+H0必然等于192,即4544除以256的余数

P1=s/256; //高8位送P1口 ,P1=17=11H=0001 0001B, P1.0和P1.4口灭,其余亮

P0=s%256; //低8位送P0口 , P3=192=c0H=1100 0000B,P3.1,P3.6,P3.7口灭,其余亮

}

 

*实例9:用P1、P0口显示除法运算结果

#include //包含单片机寄存器的头文件

void main(void)

{

P1=36/5; //求整数

P0=((36%5) 10)/5; //求小数

while(1)

; //无限循环防止程序“跑飞”

}

 

*实例10:用自增运算控制P0口8位LED流水花样

#include //包含单片机寄存器的头文件

/

函数功能:延时一段时间

/

void delay(void)

{

unsigned int i;

for(i=0;i<20000;i++)

;

}

/ 函数功能?:主函数

/ void main(void)

{

unsigned char i;

for(i=0;i<255;i++) //注意i的值不能超过255

{

P0=i; //将i的值送P0口

delay(); //调用延时函数

}

}

 

*实例11:用P0口显示逻辑"与"运算结果 #include //包含单片机寄存器的头文件 void main(void)

{

P0=(4>0)&&(9>0xab);//将逻辑运算结果送P0口

while(1)

; //设置无限循环,防止程序“跑飞”

}

 

*实例12:用P0口显示条件运算结果

#include //包含单片机寄存器的头文件 void main(void)

{

P0=(8>4)?8:4;//将条件运算结果送P0口,P0=8=0000 1000B while(1)

; //设置无限循环,防止程序“跑飞”

}

 

*实例13:用P0口显示按位"异或"运算结果 #include //包含单片机寄存器的头文件 void main(void)

{

P0=0xa2^0x3c;//将条件运算结果送P0口,P0=8=0000 1000B while(1)

; //设置无限循环,防止程序“跑飞”

}

 

*实例16:用P0显示左移运算结果

#include //包含单片机寄存器的头文件 void main(void)

{

P0=0x3b<<2;//将左移运算结果送P0口,P0=1110 1100B=0xec while(1)

; //无限循环,防止程序“跑飞”

}

 

*实例17:"万能逻辑电路"实验

#include //包含单片机寄存器的头文件

sbit F=P1^4; //将F位定义为 P1.4

sbit X=P1^5; //将X位定义为 P1.5

sbit Y=P1^6; //将Y位定义为 P1.6

sbit Z=P1^7; //将Z位定义为 P1.7

void main(void)

{

while(1)

{

F=((~X)&Y)|Z; //将逻辑运算结果赋给F

;

}

}

 

*实例18:用右移运算流水点亮P1口8位LED #include //包含单片机寄存器的头文件

/

函数功能:延时一段时间

/

void delay(void)

{

unsigned int n;

for(n=0;n<30000;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

while(1)

{

P1=0xff;

delay();

for(i=0;i<8;i++)//设置循环次数为8

{

P1=P1>>1; //每次循环P1的各二进位右移1位,高位补0 delay(); //调用延时函数

}

}

}

 

*实例19:用if语句控制P0口8位LED的流水方向 #include //包含单片机寄存器的头文件

sbit S1=P1^4; //将S1位定义为P1.4

sbit S2=P1^5; //将S2位定义为P1.5

/

函数功能:主函数

/

void main(void)

{

while(1)

}

{ if(S1==0) //如果按键S1按下 P0=0x0f; //P0口高四位LED点亮 if(S2==0) //如果按键S2按下 P0=0xf0; //P0口低四位LED点亮 }

 

*实例20:用swtich语句的控制P0口8位LED的点亮状态 #include //包含单片机寄存器的头文件

sbit S1=P1^4; //将S1位定义为P1.4

/

函数功能:延时一段时间

/

void delay(void)

{

unsigned int n;

for(n=0;n<10000;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

i=0; //将i初始化为0

while(1)

{

if(S1==0) //如果S1键按下

{

delay(); //延时一段时间

if(S1==0) //如果再次检测到S1键按下

i++; //i自增1

if(i==9) //如果i=9,重新将其置为1

i=1;

}

switch(i) //使用多分支选择语句

{

}

} case 1: P0=0xfe; //第一个LED亮 break; case 2: P0=0xfd; //第二个LED亮 break; case 3:P0=0xfb; //第三个LED亮 break; case 4:P0=0xf7; //第四个LED亮 break; case 5:P0=0xef; //第五个LED亮 break; case 6:P0=0xdf; //第六个LED亮 break; case 7:P0=0xbf; //第七个LED亮 break; case 8:P0=0x7f; //第八个LED亮 break; default: //缺省值,关闭所有LED P0=0xff; }

 

*实例21:用for语句控制蜂鸣器鸣笛次数

#include //包含单片机寄存器的头文件 sbit sound=P3^7; //将sound位定义为P3.7 / 函数功能:延时形成1600Hz音频

/ void delay1600(void)

{

unsigned char n;

for(n=0;n<100;n++)

;

}

/ 函数功能:延时形成800Hz音频

/ void delay800(void)

{

unsigned char n;

for(n=0;n<200;n++)

;

}

/ 函数功能:主函数

/ void main(void)

{

unsigned int i;

while(1)

{

for(i=0;i<830;i++)

{

sound=0; //P3.7输出低电平 delay1600();

sound=1; //P3.7输出高电平 delay1600();

}

for(i=0;i<200;i++)

{

sound=0; //P3.7输出低电平 delay800();

sound=1; //P3.7输出高电平 delay800();

}

}

}

 

*实例22:用while语句控制LED

#include //包含单片机寄存器的头文件 / 函数功能:延时约60ms (3 100 200=60000μs) / void delay60ms(void)

{

unsigned char m,n;

for(m=0;m<100;m++)

for(n=0;n<200;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

while(1) //无限循环

{

i=0; //将i初始化为0

while(i<0xff) //当i小于0xff(255)时执行循环体 {

P0=i; //将i送P0口显示

delay60ms(); //延时

i++; //i自增1

}

}

}

 

*实例23:用do-while语句控制P0口8位LED流水点亮 #include //包含单片机寄存器的头文件

/

函数功能:延时约60ms (3 100 200=60000μs)

/

void delay60ms(void)

{

unsigned char m,n;

for(m=0;m<100;m++)

for(n=0;n<200;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

do

{

P0=0xfe; //第一个LED亮

delay60ms();

}

P0=0xfd; //第二个LED亮 delay60ms(); P0=0xfb; //第三个LED亮 delay60ms(); P0=0xf7; //第四个LED亮 delay60ms(); P0=0xef; //第五个LED亮 delay60ms(); P0=0xdf; //第六个LED亮 delay60ms(); delay60ms(); P0=0xbf; //第七个LED亮 delay60ms(); P0=0x7f; //第八个LED亮 delay60ms(); }while(1); //无限循环,使8位LED循环流水点亮

 

*实例24:用字符型数组控制P0口8位LED流水点亮 #include //包含单片机寄存器的头文件

/

函数功能:延时约60ms (3 100 200=60000μs)

/

void delay60ms(void)

{

unsigned char m,n;

for(m=0;m<100;m++)

for(n=0;n<200;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

unsigned char code Tab[ ]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f}; //定义无符号字符型数组

while(1)

{

for(i=0;i<8;i++)

{

P0=Tab[i];//依次引用数组元素,并将其送P0口显示

delay60ms();//调用延时函数

}

}

}

 

*实例25:用P0口显示字符串常量

#include //包含单片机寄存器的头文件

/

函数功能:延时约150ms (3 200 250=150 000μs=150ms

/

void delay150ms(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char str[]={"Now,Temperature is :"}; //将字符串赋给字符型全部元素赋值

unsigned char i;

while(1)

{

i=0; //将i初始化为0,从第一个元素开始显示

while(str[i]!='�') //只要没有显示到结束标志'�'

{

P0=str[i]; //将第i个字符送到P0口显示

delay150ms(); //调用150ms延时函数

i++; //指向下一个待显字符

}

}

}

 

*实例26:用P0 口显示指针运算结果

#include

void main(void)

{

unsigned char p1, p2; //定义无符号字符型指针变量p1,p2 unsigned char i,j; //定义无符号字符型数据

i=25; //给i赋初值25

j=15;

p1=&i; //使指针变量指向i ,对指针初始化

p2=&j; //使指针变量指向j ,对指针初始化

P0= p1+ p2; // p1+ p2相当于i+j,所以P0=25+15=40=0x28

//则P0=0010 1000B,结果P0.3、P0.5引脚LED熄灭,其余点亮 while(1)

; //无限循环,防止程序“跑飞”

}

 

*实例27:用指针数组控制P0口8位LED流水点亮 #include

/

函数功能:延时约150ms (3 200 250=150 000μs=150ms

/

void delay150ms(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char code Tab[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};

unsigned char p[ ]={&Tab[0],&Tab[1],&Tab[2],&Tab[3],&Tab[4],&Tab[5], &Tab[6],&Tab[7]};

unsigned char i; //定义无符号字符型数据

while(1)

{

for(i=0;i<8;i++)

{

P0= p[i];

delay150ms();

}

}

}

 

*实例28:用数组的指针控制P0 口8 位LED流水点亮 #include

/

函数功能:延时约150ms (3 200 250=150 000μs=150ms

/

void delay150ms(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

unsigned char Tab[ ]={0xFF,0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF, 0x7F,0xBF,0xDF,0xEF,0xF7,0xFB,0xFD,0xFE, 0xFE,0xFC,0xFB,0xF0,0xE0,0xC0,0x80,0x00, 0xE7,0xDB,0xBD,0x7E,0x3C,0x18,0x00,0x81, 0xC3,0xE7,0x7E,0xBD,0xDB,0xE7,0xBD,0xDB}; //流水灯控制码

unsigned char p; //定义无符号字符型指针

p=Tab; //将数组首地址存入指针p

while(1)

{

for(i=0;i<32;i++) //共32个流水灯控制码

{

P0= (p+i); // (p+i)的值等于a[i]

}

delay150ms(); //调用150ms延时函数 } }

 

*实例29:用P0 、P1口显示整型函数返回值 #include

/ 函数功能:计算两个无符号整数的和

/ unsigned int sum(int a,int b)

{

unsigned int s;

s=a+b;

return (s);

}

/ 函数功能:主函数

/ void main(void)

{

unsigned z;

z=sum(2008,2009);

P1=z/256; //取得z的高8位

P0=z%256; //取得z的低8位

while(1)

;

}

*实例30:用有参函数控制P0口8位LED流水速度 #include

/ 函数功能:延时一段时间

/ void delay(unsigned char x)

{

unsigned char m,n;

for(m=0;m

for(n=0;n<200;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

unsigned char code Tab[ ]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}; //流水灯控制码

while(1)

{

//快速流水点亮LED

for(i=0;i<8;i++) //共8个流水灯控制码

{

P0=Tab[i];

delay(100); //延时约60ms, (3 100 200=60 000μs) }

//慢速流水点亮LED

for(i=0;i<8;i++) //共8个流水灯控制码

{

P0=Tab[i];

delay(250); //延时约150ms, (3 250 200=150 000μs) }

}

}

 

*实例31:用数组作函数参数控制流水花样

#include

/

函数功能:延时约150ms

/

void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/

函数功能:流水点亮P0口8位LED

/

void led_flow(unsigned char a[8])

{

unsigned char i;

for(i=0;i<8;i++)

{

P0=a[i];

delay();

}

}

/

函数功能:主函数

/

void main(void)

{

unsigned char code Tab[ ]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}; //流水灯控制码

led_flow(Tab);

}

 

*实例32:用指针作函数参数控制P0口8位LED流水点亮 #include

/

函数功能:延时约150ms

/

void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/

函数功能:流水点亮P0口8位LED

/

void led_flow(unsigned char p) //形参为无符号字符型指针

{

unsigned char i;

while(1)

{

i=0; //将i置为0,指向数组第一个元素

while( (p+i)!='�') //只要没有指向数组的结束标志

{

P0= (p+i);// 取的指针所指变量(数组元素)的值,送P0口 delay(); //调用延时函数

i++; //指向下一个数组元素

}

}

}

/

函数功能:主函数

/

void main(void)

{

unsigned char code Tab[ ]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F, 0x7F,0xBF,0xDF,0xEF,0xF7,0xFB,0xFD,0xFE,

0xFF,0xFE,0xFC,0xFB,0xF0,0xE0,0xC0,0x80,

0x00,0xE7,0xDB,0xBD,0x7E,0xFF,0xFF,0x3C,

0x18,0x0,0x81,0xC3,0xE7,0xFF, 0xFF,0x7E};

//流水灯控制码

unsigned char pointer;

pointer=Tab;

led_flow(pointer);

}

 

*实例33:用函数型指针控制P1口灯花样

#include //包含51单片机寄存器定义的头文件

unsigned char code Tab[]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}; //流水灯控制码,该数组被定义为全局变量

/

函数功能:延时约150ms

/ void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:流水灯左移

/ void led_flow(void)

{

unsigned char i;

for(i=0;i<8;i++) //8位控制码

{

P0=Tab[i];

delay();

}

}

/ 函数功能:主函数

/ void main(void)

{

void ( p)(void); //定义函数型指针,所指函数无参数,无返回值 p=led_flow; //将函数的入口地址赋给函数型指针p

while(1)

( p)(); //通过函数的指针p调用函数led_flow()

}

 

*实例34:用指针数组作为函数的参数显示多个字符串 #include //包含51单片机寄存器定义的头文件

unsigned char code str1[ ]="Temperature is tested by DS18B20";//C语言中,字符串是作为字符数组来处理的

unsigned char code str2[ ]="Now temperature is:"; //所以,字符串的名字就是字符串的首地址

unsigned char code str3[ ]="The Systerm is designed by Zhang San";

unsigned char code str4[ ]="The date is 2008-9-30";

unsigned char p[ ]={str1,str2,str3,str4}; //定义p[4]为指向4个字符串的字符型指针数组

/ 函数功能:延时约150ms

/ void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:流水点亮P0口8位LED

/ void led_display(unsigned char x[ ]) //形参必须为指针数组

{

unsigned char i,j;

for(i=0;i<4;i++) //有4个字符串要显示

{

j=0; //指向待显字符串的第0号元素

while( (x[i]+j)!='�') //只要第i个字符串的第j号元素不是结束标志 {

P0= (x[i]+j); //取得该元素值送到P0口显示

delay(); //调用延时函数

j++; //指向下一个元素

}

}

}

/ 函数功能:主函数

/ void main(void)

{

unsigned char i;

while(1)

{

for(i=0;i<4;i++)

led_display(p); //将指针数组名作实际参数传递

}

}

 

*实例35:字符函数ctype.h应用举例

#include //包含51单片机寄存器定义的头文件 #include

void main(void)

{

while(1)

{

P3=isalpha('_')?0xf0:0x0f;//条件运算,若'_'是英文字母,P3=0xf0 }

}

 

*实例36:内部函数intrins.h应用举例

#include //包含51单片机寄存器定义的头文件 #include //包含函数isalpha()声明的头文件 / 函数功能:延时约150ms

/ void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:主函数

/ void main(void)

{

P3=0xfe; //P3=1111 1110B

while(1)

{

P3=_crol_(P3,1);// 将P3的二进制位循环左移1位后再赋给P3 delay(); //调用延时函数

}

}

 

*实例37:标准函数stdlib.h应用举例

#include //包含51单片机寄存器定义的头文件 #include //包含函数isalpha()声明的头文件 / 函数功能:延时约150ms

/ void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:主函数

/ void main(void)

{

unsigned char i;

while(1)

{

for(i=0;i<10;i++) //产生10个随机数

{

P3=rand()/160; //将产生的随机数缩小160倍后送P3显示 delay();

}

}

}

 

*实例38:字符串函数string.h应用举例

#include //包含51单片机寄存器定义的头文件 #include //包含函数isalpha()声明的头文件 void main(void)

{

unsigned char str1[ ]="Now, The temperature is :";

unsigned char str2[ ]="Now, The temperature is 36 Centgrade:"; unsigned char i;

i=strcmp(str1,str2); //比较两个字符串,并将结果存入i

if(i==0) //str1=str2

P3=0x00;

else

if(i<0) //str1

P3=0xf0;

else //str1>str2

P3=0x0f;

while(1)

; //防止程序“跑飞”

}

 

*实例39:宏定义应用举例2

#include //包含51单片机寄存器定义的头文件

# define F(a,b) (a)+(a) (b)/256+(b) //带参数的宏定义,a和b为形参 void main(void)

{

unsigned char i,j,k;

i=40;

j=30;

k=20;

P3=F(i,j+k); //i和j+k分别为实参,宏展开时,实参将替代宏定义中的形参

while(1)

;

}

 

*实例40:宏定义应用举例2

#include

#include

void main(void)

{

P3_0=0; //将P3.0引脚置低电平,LED点亮

P3_1=0; //将P3.0引脚置低电平,LED点亮

P3_2=0; //将P3.0引脚置低电平,LED点亮

P3_3=0; //将P3.0引脚置低电平,LED点亮

P3_4=1; //将P3.4引脚置高电平,LED熄灭

}

P3_5=1; //将P3.5引脚置高电平,LED熄灭 P3_6=1; //将P3.7引脚置高电平,LED熄灭 P3_7=1; //将P3.7引脚置高电平,LED熄灭 while(1) ;

 

*实例41:宏定义应用举例3

#include //包含51单片机寄存器定义的头文件

#define MAX 100 //将MAX宏定义为字符串100

void main(void)

{

#if MAX>80 //如果字符串100大于80

P3=0xf0; //P3口低四位LED点亮

#else

P3=0x0f; //否则,P3口高四位LED点亮

#endif //结束本次编译

}

/ 中断、定时器 中断、定时器

中断、定时器 中断、定时器 /

 

*实例42:用定时器T0查询方式P2口8位控制LED闪烁

#include // 包含51单片机寄存器定义的头文件

/

函数功能:主函数

/ void main(void)

{

// EA=1; //开总中断

// ET0=1; //定时器T0中断允许 TMOD=0x01; //使用定时器T0的模式1

TH0=(65536-46083)/256; //定时器T0的高8位赋初值

TL0=(65536-46083)%256; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

TF0=0;

P2=0xff;

while(1)//无限循环等待查询

{

while(TF0==0)

;

TF0=0;

P2=~P2;

TH0=(65536-46083)/256; //定时器T0的高8位赋初值 TL0=(65536-46083)%256; //定时器T0的高8位赋初值 }

}

 

*实例43:用定时器T1查询方式控制单片机发出1KHz音频 #include // 包含51单片机寄存器定义的头文件 sbit sound=P3^7; //将sound位定义为P3.7引脚

/ 函数功能:主函数

/ void main(void)

{

// EA=1; //开总中断

// ET0=1; //定时器T0中断允许 TMOD=0x10; //使用定时器T1的模式1

TH1=(65536-921)/256; //定时器T1的高8位赋初值

TL1=(65536-921)%256; //定时器T1的高8位赋初值

TR1=1; //启动定时器T1

TF1=0;

while(1)//无限循环等待查询

{

while(TF1==0)

;

TF1=0;

sound=~sound; //将P3.7引脚输出电平取反

TH1=(65536-921)/256; //定时器T0的高8位赋初值 TL1=(65536-921)%256; //定时器T0的高8位赋初值 }

}

 

*实例44:将计数器T0计数的结果送P1口8位LED显示 #include // 包含51单片机寄存器定义的头文件 sbit S=P3^4; //将S位定义为P3.4引脚

/ 函数功能:主函数

/ void main(void)

{

// EA=1; //开总中断

// ET0=1; //定时器T0中断允许 TMOD=0x02; //使用定时器T0的模式2

TH0=256-156; //定时器T0的高8位赋初值

TL0=256-156; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

while(1)//无限循环等待查询

{

while(TF0==0) //如果未计满就等待

{

if(S==0) //按键S按下接地,电平为0

P1=TL0; //计数器TL0加1后送P1口显示

}

TF0=0; //计数器溢出后,将TF0清0

}

}

 

*实例45:用定时器T0的中断控制1位LED闪烁 #include // 包含51单片机寄存器定义的头文件

sbit D1=P2^0; //将D1位定义为P2.0引脚

/ 函数功能:主函数

/ void main(void)

{

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TMOD=0x01; //使用定时器T0的模式2

TH0=(65536-46083)/256; //定时器T0的高8位赋初值

TL0=(65536-46083)%256; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

while(1)//无限循环等待中断

;

}

/ 函数功能:定时器T0的中断服务程序

/ void Time0(void) interrupt 1 using 0 //“interrupt”声明函数为中断服务函数 //其后的1为定时器T0的中断编号;0表示使用第0组工作寄存器

{

D1=~D1; //按位取反操作,将P2.0引脚输出电平取反

TH0=(65536-46083)/256; //定时器T0的高8位重新赋初值

TL0=(65536-46083)%256; //定时器T0的高8位重新赋初值

}

 

*实例46:用定时器T0的中断实现长时间定时

#include // 包含51单片机寄存器定义的头文件

sbit D1=P2^0; //将D1位定义为P2.0引脚

unsigned char Countor; //设置全局变量,储存定时器T0中断次数

/ 函数功能:主函数

/ void main(void)

{

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TMOD=0x01; //使用定时器T0的模式2

TH0=(65536-46083)/256; //定时器T0的高8位赋初值

TL0=(65536-46083)%256; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

Countor=0; //从0开始累计中断次数

while(1)//无限循环等待中断

;

}

/ 函数功能:定时器T0的中断服务程序

/ void Time0(void) interrupt 1 using 0 //“interrupt”声明函数为中断服务函数

//其后的1为定时器T0的中断编号;0表示使用第0组工作寄存器

{

Countor++; //中断次数自加1

if(Countor==20) //若累计满20次,即计时满1s

{

D1=~D1; //按位取反操作,将P2.0引脚输出电平取反

Countor=0; //将Countor清0,重新从0开始计数

}

TH0=(65536-46083)/256; //定时器T0的高8位重新赋初值

TL0=(65536-46083)%256; //定时器T0的高8位重新赋初值

}

 

*实例47:用定时器T1中断控制两个LED以不同周期闪烁 #include // 包含51单片机寄存器定义的头文件

sbit D1=P2^0; //将D1位定义为P2.0引脚

sbit D2=P2^1; //将D2位定义为P2.1引脚

unsigned char Countor1; //设置全局变量,储存定时器T1中断次数

unsigned char Countor2; //设置全局变量,储存定时器T1中断次数

/ 函数功能:主函数

/ void main(void)

{

EA=1; //开总中断

ET1=1; //定时器T1中断允许

TMOD=0x10; //使用定时器T1的模式1

TH1=(65536-46083)/256; //定时器T1的高8位赋初值

TL1=(65536-46083)%256; //定时器T1的高8位赋初值

TR1=1; //启动定时器T1

Countor1=0; //从0开始累计中断次数

Countor2=0; //从0开始累计中断次数

while(1)//无限循环等待中断

;

}

/ 函数功能:定时器T1的中断服务程序

/ void Time1(void) interrupt 3 using 0 //“interrupt”声明函数为中断服务函数 //其后的3为定时器T1的中断编号;0表示使用第0组工作寄存器

{

Countor1++; //Countor1自加1

Countor2++; //Countor2自加1

if(Countor1==2) //若累计满2次,即计时满100ms

{

D1=~D1; //按位取反操作,将P2.0引脚输出电平取反 Countor1=0; //将Countor1清0,重新从0开始计数

}

if(Countor2==8) //若累计满8次,即计时满400ms

{

D2=~D2; //按位取反操作,将P2.1引脚输出电平取反 Countor2=0; //将Countor1清0,重新从0开始计数

}

TH1=(65536-46083)/256; //定时器T1的高8位重新赋初值

TL1=(65536-46083)%256; //定时器T1的高8位重新赋初值

}

 

*实例48:用计数器T1的中断控制蜂鸣器发出1KHz音频 #include // 包含51单片机寄存器定义的头文件

sbit sound=P3^7; //将sound位定义为P3.7引脚

/ 函数功能:主函数

/ void main(void)

{

EA=1; //开总中断

ET1=1; //定时器T1中断允许

TMOD=0x10; //TMOD=0001 000B,使用定时器T1的模式1 TH1=(65536-921)/256; //定时器T1的高8位赋初值

TL1=(65536-921)%256; //定时器T1的高8位赋初值

TR1=1; //启动定时器T1

while(1)//无限循环等待中断

;

}

/ 函数功能:定时器T1的中断服务程序

/ void Time1(void) interrupt 3 using 0 //“interrupt”声明函数为中断服务函数 {

sound=~sound;

TH1=(65536-921)/256; //定时器T1的高8位重新赋初值

TL1=(65536-921)%256; //定时器T1的高8位重新赋初值

}

 

*实例49:用定时器T0的中断实现"渴望"主题曲的播放 #include //包含51单片机寄存器定义的头文件

sbit sound=P3^7; //将sound位定义为P3.7

unsigned int C; //储存定时器的定时常数

//以下是C调低音的音频宏定义

#define l_dao 262 //将“l_dao”宏定义为低音“1”的频率262Hz #define l_re 286 //将“l_re”宏定义为低音“2”的频率286Hz #define l_mi 311 //将“l_mi”宏定义为低音“3”的频率311Hz #define l_fa 349 //将“l_fa”宏定义为低音“4”的频率349Hz #define l_sao 392 //将“l_sao”宏定义为低音“5”的频率392Hz #define l_la 440 //将“l_a”宏定义为低音“6”的频率440Hz #define l_xi 494 //将“l_xi”宏定义为低音“7”的频率494Hz //以下是C调中音的音频宏定义

#define dao 523 //将“dao”宏定义为中音“1”的频率523Hz #define re 587 //将“re”宏定义为中音“2”的频率587Hz #define mi 659 //将“mi”宏定义为中音“3”的频率659Hz #define fa 698 //将“fa”宏定义为中音“4”的频率698Hz #define sao 784 //将“sao”宏定义为中音“5”的频率784Hz #define la 880 //将“la”宏定义为中音“6”的频率880Hz

#define xi 987 //将“xi”宏定义为中音“7”的频率523H //以下是C调高音的音频宏定义

#define h_dao 1046 //将“h_dao”宏定义为高音“1”的频率1046Hz #define h_re 1174 //将“h_re”宏定义为高音“2”的频率1174Hz #define h_mi 1318 //将“h_mi”宏定义为高音“3”的频率1318Hz #define h_fa 1396 //将“h_fa”宏定义为高音“4”的频率1396Hz

#define h_sao 1567 //将“h_sao”宏定义为高音“5”的频率1567Hz #define h_la 1760 //将“h_la”宏定义为高音“6”的频率1760Hz #define h_xi 1975 //将“h_xi”宏定义为高音“7”的频率1975Hz /

函数功能:1个延时单位,延时200ms

/

void delay()

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i,j;

//以下是《渴望》片头曲的一段简谱

unsigned int code f[]={re,mi,re,dao,l_la,dao,l_la, //每行对应一小节音符 l_sao,l_mi,l_sao,l_la,dao,

l_la,dao,sao,la,mi,sao,

re,

mi,re,mi,sao,mi,

l_sao,l_mi,l_sao,l_la,dao,

l_la,l_la,dao,l_la,l_sao,l_re,l_mi,

l_sao,

re,re,sao,la,sao,

fa,mi,sao,mi,

la,sao,mi,re,mi,l_la,dao,

re,

mi,re,mi,sao,mi,

l_sao,l_mi,l_sao,l_la,dao,

l_la,dao,re,l_la,dao,re,mi,

re,

l_la,dao,re,l_la,dao,re,mi,

re,

0xff}; //以0xff作为音符的结束标志

//以下是简谱中每个音符的节拍

//"4"对应4个延时单位,"2"对应2个延时单位,"1"对应1个延时单位 unsigned char code JP[ ]={4,1,1,4,1,1,2,

2,2,2,2,8,

4,2,3,1,2,2,

10,

4,2,2,4,4,

2,2,2,2,4,

2,2,2,2,2,2,2,

10,

4,4,4,2,2,

4,2,4,4,

4,2,2,2,2,2,2,

10,

4,2,2,4,4,

2,2,2,2,6,

4,2,2,4,1,1,4,

10,

4,2,2,4,1,1,4,

10

};

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TMOD=0x00; // 使用定时器T0的模式1(13位计数器)

while(1) //无限循环

{

i=0; //从第1个音符f[0]开始播放

while(f[i]!=0xff) //只要没有读到结束标志就继续播放 {

C=460830/f[i];

TH0=(8192-C)/32; //可证明这是13位计数器TH0高8位的赋初值方法

TL0=(8192-C)%32; //可证明这是13位计数器TL0低5位的赋初值方法

TR0=1; //启动定时器T0

for(j=0;j

delay(); //延时1个节拍单位

TR0=0; //关闭定时器T0

i++; //播放下一个音符

}

}

}

/ 函数功能:定时器T0的中断服务子程序,使P3.7引脚输出音频的方波 / void Time0(void ) interrupt 1 using 1

{

sound=!sound; //将P3.7引脚输出电平取反,形成方波

TH0=(8192-C)/32; //可证明这是13位计数器TH0高8位的赋初值方法 TL0=(8192-C)%32; //可证明这是13位计数器TL0低5位的赋初值方法 }

 

*实例50-1:输出50个矩形脉冲

#include //包含51单片机寄存器定义的头文件

sbit u=P1^4; //将u位定义为P1.4

/

函数功能:延时约30ms (3 100 100=30 000μs =30m

/

void delay30ms(void)

{

unsigned char m,n;

for(m=0;m<100;m++)

for(n=0;n<100;n++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

u=1; //初始化输出高电平

for(i=0;i<50;i++) //输出50个矩形脉冲

{

u=1;

delay30ms();

u=0;

delay30ms();

}

while(1)

; //无限循环,防止程序“跑飞”

}

 

*实例50-2:计数器T0统计外部脉冲数

#include //包含51单片机寄存器定义的头文件

/

函数功能:主函数

/

void main(void)

{

TMOD=0x06; // TMOD=0000 0110B,使用计数器T0的模式2 EA=1; //开总中断

ET0=0; //不使用定时器T0的中断

TR0=1; //启动T0

TH0=0; //计数器T0高8位赋初值

TL0=0; //计数器T0低8位赋初值

while(1) //无限循环,不停地将TL0计数结果送P1口

P1=TL0;

}

 

*实例51-2:定时器T0的模式2测量正脉冲宽度

#include //包含51单片机寄存器定义的头文件

sbit ui=P3^2; //将ui位定义为P3.0(INT0)引脚,表示输入电压

/

函数功能:主函数

/

void main(void)

{

TMOD=0x0a; // TMOD=0000 1010B,使用定时器T0的模式2,GATE置1 EA=1; //开总中断

ET0=0; //不使用定时器T0的中断

TR0=1; //启动T0

TH0=0; //计数器T0高8位赋初值

TL0=0; //计数器T0低8位赋初值

while(1) //无限循环,不停地将TL0计数结果送P1口 {

while(ui==0) //INT0为低电平,T0不能启动

;

TL0=0; //INT0为高电平,启动T0计时,所以将TL0清0 while(ui==1) //在INT0高电平期间,等待,计时

;

P1=TL0; //将计时结果送P1口显示

}

}

 

*实例52:用定时器T0控制输出高低宽度不同的矩形波 #include //包含51单片机寄存器定义的头文件

sbit u=P3^0; //将u位定义为P3.0,从该引脚输出矩形脉冲 unsigned char Countor; //设置全局变量,储存负跳变累计数 / 函数功能:延时约30ms (3 100 100=30 000μs =30ms) / void delay30ms(void)

{

unsigned char m,n;

for(m=0;m<100;m++)

for(n=0;n<100;n++)

;

}

/

函数功能:主函数

/ void main(void)

{

unsigned char i;

EA=1; //开放总中断

EX0=1; //允许使用外中断

IT0=1; //选择负跳变来触发外中断

Countor=0;

for(i=0;i<100;i++) //输出100个负跳变

{

u=1;

delay30ms();

u=0;

delay30ms();

}

while(1)

; //无限循环, 防止程序跑飞

}

/ 函数功能:外中断T0的中断服务程序

void int0(void) interrupt 0 using 0 //外中断0的中断编号为0 /

{

Countor++;

P1=Countor;

}

 

*实例53:用外中断0的中断方式进行数据采集 #include //包含51单片机寄存器定义的头文件

sbit S=P3^2; //将S位定义为P3.2,

/

函数功能:主函数

/

void main(void)

{

EA=1; //开放总中断

EX0=1; //允许使用外中断

IT0=1; //选择负跳变来触发外中断

P1=0xff;

while(1)

; //无限循环, 防止程序跑飞

}

/ 函数功能:外中断T0的中断服务程序

/ void int0(void) interrupt 0 using 0 //外中断0的中断编号为0

{

P1=~P1; //每产生一次中断请求,P1取反一次。

}

 

*实例54-1:输出负脉宽为200微秒的方波

#include //包含51单片机寄存器定义的头文件

sbit u=P1^4; //将u位定义为P1.4

/

函数功能:主函数

/

void main(void)

{

TMOD=0x02; //TMOD=0000 0010B,使用定时器T0的模式2 EA=1; //开总中断

ET0=1; //定时器T0中断允许

TH0=256-200; //定时器T0的高8位赋初值

TL0=256-200; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

while(1) //无限循环,等待中断

;

}

/ 函数功能:定时器T0的中断服务程序

/ void Time0(void) interrupt 1 using 0 //"interrupt"声明函数为中断服务函数 {

u=~u; //将P1.4引脚输出电平取反,产生方波

}

 

*实例54-2:测量负脉冲宽度

#include //包含51单片机寄存器定义的头文件

sbit u=P3^2; //将u位定义为P3.2

/

函数功能:主函数

/

void main(void)

{

TMOD=0x02; //TMOD=0000 0010B,使用定时器T0的模式2

EA=1; //开放总中断

EX0=1; //允许使用外中断

IT0=1; //选择负跳变来触发外中断

ET0=1; //允许定时器T0中断

TH0=0; //定时器T0赋初值0

TL0=0; //定时器T0赋初值0

TR0=0; //先关闭T0

while(1)

; //无限循环, 不停检测输入负脉冲宽度

}

/ 函数功能:外中断0的中断服务程序

/ void int0(void) interrupt 0 using 0 //外中断0的中断编号为0

{

TR0=1; //外中断一到来,即启动T0计时

TL0=0; //从0开始计时

while(u==0) //低电平时,等待T0计时

;

P1=TL0; //将结果送P1口显示

TR0=0; //关闭T0

}

 

*实例55:方式0控制流水灯循环点亮

#include //包含51单片机寄存器定义的头文件

#include //包含函数_nop_()定义的头文件

unsigned char code Tab[]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F};//流水灯控制码,该数组被定义为全局变量

sbit P17=P1^7;

/ 函数功能:延时约150ms

/ void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:发送一个字节的数据

/ void Send(unsigned char dat)

{

P17=0; //P1.7引脚输出清0信号,对74LS164清0

_nop_(); //延时一个机器周期

_nop_(); //延时一个机器周期,保证清0完成

P17=1; //结束对74LS164的清0

SBUF=dat; //将数据写入发送缓冲器,启动发送

while(TI==0) //若没有发送完毕,等待

;

TI=0; //发送完毕,TI被置“1”,需将其清0

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

SCON=0x00; //SCON=0000 0000B,使串行口工作于方式0 while(1)

{

for(i=0;i<8;i++)

{

Send(Tab[i]); //发送数据

delay(); //延时

}

}

}

 

*实例56-1:数据发送程序

#include //包含单片机寄存器的头文件

unsigned char code Tab[ ]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}; //流水灯控制码,该数组被定义为全局变量

/ 函数功能:向PC发送一个字节数据

/ void Send(unsigned char dat)

{

SBUF=dat;

while(TI==0)

;

TI=0;

}

/ 函数功能:延时约150ms

void delay(void)

{ /

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:主函数

/ void main(void)

{

unsigned char i;

TMOD=0x20; //TMOD=0010 0000B,定时器T1工作于方式2 SCON=0x40; //SCON=0100 0000B,串口工作方式1 PCON=0x00; //PCON=0000 0000B,波特率9600

TH1=0xfd; //根据规定给定时器T1赋初值

TL1=0xfd; //根据规定给定时器T1赋初值

TR1=1; //启动定时器T1

while(1)

{

for(i=0;i<8;i++) //模拟检测数据

{

Send(Tab[i]); //发送数据i

delay(); //50ms发送一次检测数据 }

}

}

 

*实例56-2:数据接收程序

#include //包含单片机寄存器的头文件

/ 函数功能:接收一个字节数据

/ unsigned char Receive(void)

{

unsigned char dat;

while(RI==0) //只要接收中断标志位RI没有被置“1” ; //等待,直至接收完毕(RI=1)

RI=0; //为了接收下一帧数据,需将RI清0 dat=SBUF; //将接收缓冲器中的数据存于dat

return dat;

}

/

函数功能:主函数

/

void main(void)

{

TMOD=0x20; //定时器T1工作于方式2

SCON=0x50; //SCON=0101 0000B,串口工作方式1,允许接收(REN=1) PCON=0x00; //PCON=0000 0000B,波特率9600

TH1=0xfd; //根据规定给定时器T1赋初值

TL1=0xfd; //根据规定给定时器T1赋初值

TR1=1; //启动定时器T1

REN=1; //允许接收

while(1)

{

P1=Receive(); //将接收到的数据送P1口显示

}

}

 

*实例57-1:数据发送程序

#include //包含单片机寄存器的头文件

sbit p=PSW^0;

unsigned char code Tab[ ]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}; //流水灯控制码,该数组被定义为全局变量

/

函数功能:向PC发送一个字节数据

/

void Send(unsigned char dat)

{

ACC=dat;

TB8=p;

SBUF=dat;

while(TI==0)

;

TI=0;

}

/ 函数功能:延时约150ms

/

void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:主函数

/ void main(void)

{

unsigned char i;

TMOD=0x20; //TMOD=0010 0000B,定时器T1工作于方式2 SCON=0xc0; //SCON=1100 0000B,串口工作方式3, //SM2置0,不使用多机通信,TB8置0 PCON=0x00; //PCON=0000 0000B,波特率9600

TH1=0xfd; //根据规定给定时器T1赋初值

TL1=0xfd; //根据规定给定时器T1赋初值

TR1=1; //启动定时器T1

while(1)

{

for(i=0;i<8;i++) //模拟检测数据

{

Send(Tab[i]); //发送数据i

delay(); //50ms发送一次检测数据 }

}

}

 

*实例57-2:数据接收程序

#include //包含单片机寄存器的头文件 sbit p=PSW^0;

/ 函数功能:接收一个字节数据

/ unsigned char Receive(void)

{

unsigned char dat;

while(RI==0) //只要接收中断标志位RI没有被置"1"

; //等待,直至接收完毕(RI=1)

RI=0; //为了接收下一帧数据,需将RI清0

ACC=SBUF; //将接收缓冲器中的数据存于dat

if(RB8==p)

{

dat=ACC;

return dat;

}

}

/

函数功能:主函数

/

void main(void)

{

TMOD=0x20; //定时器T1工作于方式2

SCON=0xd0; //SCON=1101 0000B,串口工作方式1,允许接收(REN=1) PCON=0x00; //PCON=0000 0000B,波特率9600

TH1=0xfd; //根据规定给定时器T1赋初值

TL1=0xfd; //根据规定给定时器T1赋初值

TR1=1; //启动定时器T1

REN=1; //允许接收

while(1)

{

P1=Receive(); //将接收到的数据送P1口显示

}

}

 

*实例58:单片机向PC发送数据

#include //包含单片机寄存器的头文件

unsigned char code Tab[ ]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F}; //流水灯控制码,该数组被定义为全局变量

/

函数功能:向PC发送一个字节数据

/

void Send(unsigned char dat)

{

SBUF=dat;

while(TI==0)

;

TI=0;

}

/ 函数功能:延时约150ms

/ void delay(void)

{

unsigned char m,n;

for(m=0;m<200;m++)

for(n=0;n<250;n++)

;

}

/ 函数功能:主函数

/

void main(void)

{

unsigned char i;

TMOD=0x20; //TMOD=0010 0000B,定时器T1工作于方式2 SCON=0x40; //SCON=0100 0000B,串口工作方式1

PCON=0x00; //PCON=0000 0000B,波特率9600

TH1=0xfd; //根据规定给定时器T1赋初值

TL1=0xfd; //根据规定给定时器T1赋初值

TR1=1; //启动定时器T1

while(1)

{

for(i=0;i<8;i++) //模拟检测数据

{

Send(Tab[i]); //发送数据i

delay(); //150ms发送一次数据

}

}

}

 

*实例59:单片机接收PC发出的数据

#include //包含单片机寄存器的头文件

/ 函数功能:接收一个字节数据

/

unsigned char Receive(void)

{

unsigned char dat;

while(RI==0) //只要接收中断标志位RI没有被置“1”

; //等待,直至接收完毕(RI=1)

RI=0; //为了接收下一帧数据,需将RI清0

dat=SBUF; //将接收缓冲器中的数据存于dat

return dat;

}

/

函数功能:主函数

/

void main(void)

{

TMOD=0x20; //定时器T1工作于方式2

SCON=0x50; //SCON=0101 0000B,串口工作方式1,允许接收(REN=1)

PCON=0x00; //PCON=0000 0000B,波特率9600

TH1=0xfd; //根据规定给定时器T1赋初值

TL1=0xfd; //根据规定给定时器T1赋初值

TR1=1; //启动定时器T1

REN=1; //允许接收

while(1)

{

P1=Receive(); //将接收到的数据送P1口显示

}

}

/ 数码管显示 数码管显示 数

码管显示 数码管显示 /

 

*实例60:用LED数码显示数字5

#include // 包含51单片机寄存器定义的头文件

void main(void)

{

P2=0xfe; //P2.0引脚输出低电平,数码显示器接通电源准备点亮

P0=0x92; //让P0口输出数字"5"的段码92H

}

 

*实例61:用LED数码显示器循环显示数字0~9

#include // 包含51单片机寄存器定义的头文件

/

函数功能:延时函数,延时一段时间

/

void delay(void)

{

unsigned char i,j;

for(i=0;i<255;i++)

for(j=0;j<255;j++)

;

}

/

函数功能:主函数

/

void main(void)

{

unsigned char i;

unsigned char code

Tab[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};

//数码管显示0~9的段码表,程序运行中当数组值不发生变化

时,

//前面加关键字code ,可以大大节约单片机的存储空间 P2=0xfe; //P2.0引脚输出低电平,数码显示器DS0接通电源工作

while(1) //无限循环

{

for(i=0;i<10;i++)

{

P0=Tab[i]; //让P0口输出数字的段码92H

delay(); //调用延时函数

}

}

}

 

*实例62:用数码管慢速动态扫描显示数字"1234" #include // 包含51单片机寄存器定义的头文件 void delay(void) //延时函数,延时一段时间

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

;

}

void main(void)

{

while(1) //无限循环

{

P2=0xfe; //P2.0引脚输出低电平,DS0点亮

P0=0xf9; //数字1的段码

delay();

P2=0xfd ; //P2.1引脚输出低电平,DS1点亮

P0=0xa4; //数字2的段码

delay();

P2=0xfb; //P2.2引脚输出低电平,DS2点亮

P0=0xb0; //数字3的段码

delay();

P2=0xf7; //P2.3引脚输出低电平,DS3点亮

P0=0x99; //数字4的段码

delay();

P2=0xff;

}

}

 

*实例63:用LED数码显示器伪静态显示数字1234 #include // 包含51单片机寄存器定义的头文件 void delay(void) //延时函数,延时约0.6毫秒

{

unsigned char i;

for(i=0;i<200;i++)

;

}

void main(void)

{

while(1) //无限循环

{

P2=0xfe; //P2.0引脚输出低电平,DS0点亮

P0=0xf9; //数字1的段码

delay();

P2=0xfd ; //P2.1引脚输出低电平,DS1点亮

P0=0xa4; //数字2的段码

delay();

P2=0xfb; //P2.2引脚输出低电平,DS2点亮

P0=0xb0; //数字3的段码

delay();

P2=0xf7; //P2.3引脚输出低电平,DS3点亮

P0=0x99; //数字4的段码

delay();

P2=0xff;

}

}

 

*实例64:用数码管显示动态检测结果

#include // 包含51单片机寄存器定义的头文件

#include //包含随机函数rand()的定义文件

unsigned char i; //记录中断次数

unsigned int x; //随机检测的数据

unsigned char code Tab[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; //数码管显示0~9的段码表

/ 函数功能:快速动态扫描延时,延时约0.9毫秒

/

void delay(void)

{

unsigned int i;

for(i=0;i<300;i++)

;

}

/

函数功能:4位数的数码显示器显示

入口参数:k

出口参数:无

/

void display(unsigned int k)

{

P2=0xfe; //即P2=1111 1110B,P2.0引脚输出低电平,数码显示器DS0接通电源

P0=Tab[k/1000]; //显示千位

delay();

P2=0xfd ; //即P2=1111 1101B,P2.1引脚输出低电平,数码显示器DS1接通电源

P0=Tab[(k%1000)/100]; //显示百位

delay();

P2=0xfb; //即P2=1111 1011B,P2.2引脚输出低电平,数码显示器DS2接通电源

P0=Tab[(k%100)/10]; //显示十位

delay();

P2=0xf7; //即P2=1111 0111B ,P2.3引脚输出低电平,数码显示器DS3接通电源

P0=Tab[k%10];//显示个位

delay();

P2=0xff; //关闭所有显示器

}

void main(void) //主函数

{

TMOD=0x01; //使用定时器T0

TH0=(65536-46083)/256; //将定时器计时时间设定为46083×1.085微秒=50000微秒=50毫秒

TL0=(65536-46083)%256;

EA=1; //开启总中断

ET0=1; //定时器T0中断允许

TR0=1; //启动定时器T0开始运行

while(1)

{

display(x); //调用检测结果的显示程序

}

}

/

函数功能:定时器T0的中断服务程序

/

void Time0(void) interrupt 1 using 1

{

TR0=0; //关闭定时器T0

i++; //每来一次中断,i自加1

if(i==20) //够20次中断,即1秒钟进行一次检测结果采样

{

x=rand()/10; //随机产生一个从0到32767的整数,再将其除以10,获得一个随机4位数,模拟检测结果

i=0; //将i清0,重新统计中断次数

}

TH0=(65536-46083)/256; //重新给计数器T0赋初值

TL0=(65536-46083)%256;

TR0=1; //启动定时器T0

}

 

*实例65:数码秒表设计

#include // 包含51单片机寄存器定义的头文件

unsigned char code Tab[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; //数码管显示0~9的段码表

unsigned char int_time; //记录中断次数

unsigned char second; //储存秒

/ 函数功能:快速动态扫描延时,延时约0.6毫秒

/

void delay(void)

{

unsigned char i;

for(i=0;i<200;i++)

;

}

/ 函数功能:显示秒

入口参数:k

出口参数:无

/

void DisplaySecond(unsigned char k)

{

P2=0xfb; //P2.6引脚输出低电平, DS6点亮

P0=Tab[k/10]; //显示十位

delay();

P2=0xf7; //P2.7引脚输出低电平, DS7点亮

P0=Tab[k%10]; //显示个位

delay();

P2=0xff; //关闭所有数码管

}

void main(void) //主函数

{

TMOD=0x01; //使用定时器T0

TH0=(65536-46083)/256; //将定时器计时时间设定为46083×1.085微秒

//=50000微秒=50毫秒

TL0=(65536-46083)%256;

EA=1; //开启总中断

ET0=1; //定时器T0中断允许

TR0=1; //启动定时器T0开始运行

int_time=0; //中断次数初始化

second=0; //秒初始化

while(1)

{

DisplaySecond(second); //调用秒的显示子程序

}

}

//

//函数功能:定时器T0的中断服务程序

//

void interserve(void ) interrupt 1 using 1

{

TR0=0; //关闭定时器T0

int_time ++; //每来一次中断,中断次数int_time自加1

if(int_time==20) //够20次中断,即1秒钟进行一次检测结果采样 {

int_time=0; //中断次数清0

second++; //秒加1

if(second==60)

second =0; //秒等于60就返回0

}

TH0=(65536-46083)/256; //重新给计数器T0赋初值

TL0=(65536-46083)%256;

TR0=1; //启动定时器T0

}

 

*实例66:数码时钟设计

#include // 包含51单片机寄存器定义的头文件

unsigned char Tab[ ]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; //control shape

unsigned char port[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f}; unsigned char int_time ; //中断次数计数变量

unsigned char second; //秒计数变量

unsigned char minute; //分钟计数变量

unsigned char hour; //小时计数变量

/////////////////////////////////////////////////////

void delay(void) //延时函数,延时约0.6ms

{

unsigned char j;

for(j=0;j<200;j++)

;

}

/ 函数功能:显示秒的子程序

入口参数:s

void DisplaySecond(unsigned char s)

{

P2=0xbf; //P2.6引脚输出低电平, DS6点亮

P0=Tab[s/10]; //显示十位

delay();

P2=0x7f; //P2.7引脚输出低电平, DS7点亮

P0=Tab[s%10]; //显示个位 /

delay();

P2=0xff; //关闭所有数码管

}

/ 函数功能:显示分钟的子程序

入口参数:m

/ void DisplayMinute(unsigned char m)

{

P2=0xf7; // P2.3引脚输出低电平, DS3点亮

P0=Tab[m/10];//显示个位

delay();

P2=0xef; // P2.4引脚输出低电平, DS4点亮

P0=Tab[m%10];

delay();

P2=0xdf; //P2.5引脚输出低电平, DS5点亮

P0=0xbf; //分隔符“-”的段码

delay();

P2=0xff; //关闭所有数码管

}

/ 函数功能:显示小时的子程序

入口参数:h

void DisplayHour(unsigned char h)

{

P2=0xfe; //P2.0引脚输出低电平, DS0点亮

P0=Tab[h/10]; //显示十位

delay();

P2=0xfd; //P2.1引脚输出低电平, DS1点亮

P0=Tab[h%10]; //显示个位

delay();

P2=0xfb; //P2.2引脚输出低电平, DS2点亮

P0=0xbf; //分隔符“-”的段码

delay();

P2=0xff; //关闭所有数码管

/

}

/ 函数功能:主函数

/

void main(void)

{

TMOD=0x01; //使用定时器T0

EA=1; //开中断总允许

ET0=1; //允许T0中断

TH0=(65536-46083)/256; //定时器高八位赋初值

TL0=(65536-46083)%256; //定时器低八位赋初值

TR0=1;

int_time=0; //中断计数变量初始化

second=0; //秒计数变量初始化

minute=0; //分钟计数变量初始化

hour=0; //小时计数变量初始化

while(1)

{

DisplaySecond(second); //调用秒显示子程序 delay();

DisplayMinute(minute); //调用分钟显示子程序 delay();

DisplayHour(hour);

delay();

}

}

/ 函数功能:定时器T0的中断服务子程序

void interserve(void ) interrupt 1 using 1 //using Time0

{

int_time++;

if(int_time==20)

{

int_time=0; //中断计数变量清0

second++; //秒计数变量加1

}

if(second==60)

{

second=0; //如果秒计满60,将秒计数变量清0 /

清0

清0

}

} minute++; //分钟计数变量加1 if(minute==60) { minute=0; //如果分钟计满60,将分钟计数变量 hour++; //小时计数变量加1 } if(hour==24) { hour=0; //如果小时计满24,将小时计数变量 } TH0=(65536-46083)/256; //定时器重新赋初值 TL0=(65536-46083)%256;

 

*实例67:用LED数码管显示计数器T0的计数值

#include //包含51单片机寄存器定义的头文件

sbit S=P3^2 ; //将S位定义为P3.2引脚

unsigned char Tab[ ]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; //段码表

unsigned char x;

/ 函数功能: 延时约0.6ms

/ void delay(void)

{

unsigned char j;

for(j=0;j<200;j++)

;

}

/ 函数功能:显示计数次数的子程序

入口参数:x

/ void Display(unsigned char x)

{

P2=0xf7; //P2.6引脚输出低电平,DS6点亮

P0=Tab[x/10]; //显示十位

delay();

P2=0xfb; //P2.7引脚输出低电平,DS7点亮

P0=Tab[x%10]; //显示个位

delay();

}

/

函数功能:主函数

/

void main(void)

{

EA=1; //开放总中断

EX0=1; //允许使用外中断

IT0=1; //选择负跳变来触发外中断

x=0;

while(1)

Display(x);

}

/ 函数功能:外中断T0的中断服务程序

void int0(void) interrupt 0 using 0 //外中断0的中断编号为0

{

x++;

if(x==100)

x=0;

}

 

*实例68:静态显示数字“59”

#include //包含51单片机寄存器定义的头文件

/ /

函数功能:主函数

/

void main(void)

{

P0=0x92; //将数字5的段码送P0口

P1=0x90; //将数字9的段码送P1口

while(1) //无限循环,防止程序跑飞

;

}

 

*实例69:无软件消抖的独立式键盘输入实验 #include // 包含51单片机寄存器定义的头文件 sbit S1=P1^4; //将S1位定义为P1.4引脚

sbit LED0=P3^0; //将LED0位定义为P3.0引脚 void main(void) //主函数

{

LED0=0; //P3.0引脚输出低电平

while(1)

{

if(S1==0) //P1.4引脚输出低电平,按键S1被按下 LED0=!LED0; //P3.0引脚取反

}

}

*实例70:软件消抖的独立式键盘输入实验

#include // 包含51单片机寄存器定义的头文件 sbit S1=P1^4; //将S1位定义为P1.4引脚

sbit LED0=P3^0; //将LED0位定义为P3.0引脚

/ 函数功能:延时约30ms

/ void delay(void)

{

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<100;j++)

;

}

/ 函数功能:主函数

/ void main(void) //主函数

{

LED0=0; //P3.0引脚输出低电平

while(1)

{

if(S1==0) //P1.4引脚输出低电平,按键S1被按下 {

delay(); //延时一段时间再次检测

if(S1==0) // 按键S1的确被按下

LED0=!LED0; //P3.0引脚取反

}

}

}

 

*实例71:CPU控制的独立式键盘扫描实验

#include //包含51单片机寄存器定义的头文件 sbit S1=P1^4; //将S1位定义为P1.4引脚 sbit S2=P1^5; //将S2位定义为P1.5引脚 sbit S3=P1^6; //将S3位定义为P1.6引脚 sbit S4=P1^7; //将S4位定义为P1.7引脚 unsigned char keyval; //储存按键值

/ 函数功能:流水灯延时

/ void led_delay(void)

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

;

}

/ 函数功能:软件消抖延时

/

void delay30ms(void)

{

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<100;j++)

;

}

/ 函数功能:正向流水点亮LED

void forward(void)

{

P3=0xfe; //第一个灯亮

led_delay();

P3=0xfd; //第二个灯亮

led_delay();

P3=0xfb; //第三个灯亮 led_delay();

P3=0xf7; //第四个灯亮 led_delay();

P3=0xef; //第五个灯亮

led_delay();

P3=0xdf; //第六个灯亮

led_delay();

P3=0xbf; //第七个灯亮

led_delay();

P3=0x7f; //第八个灯亮

led_delay();

P3=0xff;

P3=0xfe; //第一个灯亮

led_delay();

}

/ 函数功能:反向流水点亮LED

void backward(void)

{

P3=0x7f; //第八个灯亮

led_delay();

P3=0xbf; //第七个灯亮

led_delay();

P3=0xdf; //第六个灯亮

led_delay();

P3=0xef; //第五个灯亮 / /

led_delay();

P3=0xf7; //第四个灯亮

led_delay();

P3=0xfb; //第三个灯亮

led_delay();

P3=0xfd; //第二个灯亮

led_delay();

P3=0xfe; //第一个灯亮

led_delay();

}

/ 函数功能:关闭所有LED

/ void stop(void)

{

P3=0xff;

}

/ 函数功能:闪烁点亮LED

/ void flash(void)

{

P3=0xff;

led_delay();

P3=0x00;

led_delay();

}

/ 函数功能:键盘扫描子程序

/ void key_scan(void)

{

if((P1&0xf0)!=0xf0) //第一次检测到有键按下 {

delay30ms(); //延时20ms再去检测 if(S1==0) //按键S1被按下 keyval=1;

if(S2==0) //按键S2被按下 keyval=2;

if(S3==0) //按键S3被按下 keyval=3;

if(S4==0) //按键S4被按下 keyval=4;

}

}

/ 函数功能:主函数

/ void main(void) //主函数

{

keyval=0; //按键值初始化为0,什么也不做 while(1)

{

key_scan();

switch(keyval)

{

case 1:forward();

break;

case 2:backward();

break;

case 3:stop();

break;

case 4: flash();

break;

}

}

}

 

*实例72:定时器中断控制的独立式键盘扫描实验 #include //包含51单片机寄存器定义的头文件 sbit S1=P1^4; //将S1位定义为P1.4引脚

sbit S2=P1^5; //将S2位定义为P1.5引脚

sbit S3=P1^6; //将S3位定义为P1.6引脚

sbit S4=P1^7; //将S4位定义为P1.7引脚

unsigned char keyval; //储存按键值

/ 函数功能:流水灯延时

/ void led_delay(void)

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

;

}

/ 函数功能:软件消抖延时

/ void delay20ms(void)

{

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<60;j++)

;

}

/ 函数功能:正向流水点亮LED

void forward(void)

{

P3=0xfe; //第一个灯亮

led_delay();

P3=0xfd; //第二个灯亮

led_delay();

P3=0xfb; //第三个灯亮

led_delay();

P3=0xf7; //第四个灯亮

led_delay();

P3=0xef; //第五个灯亮

led_delay();

P3=0xdf; //第六个灯亮

led_delay();

P3=0xbf; //第七个灯亮

led_delay();

P3=0x7f; //第八个灯亮

led_delay();

P3=0xff;

P3=0xfe; //第一个灯亮

led_delay();

}

/ 函数功能:反向流水点亮LED

void backward(void) / /

{

P3=0x7f; //第八个灯亮 led_delay();

P3=0xbf; //第七个灯亮 led_delay();

P3=0xdf; //第六个灯亮 led_delay();

P3=0xef; //第五个灯亮 led_delay();

P3=0xf7; //第四个灯亮 led_delay();

P3=0xfb; //第三个灯亮 led_delay();

P3=0xfd; //第二个灯亮 led_delay();

P3=0xfe; //第一个灯亮 led_delay();

}

/ 函数功能:关闭所有LED

void stop(void)

{

P3=0xff; //关闭8个LED }

/ 函数功能:闪烁点亮LED

void flash(void)

{

P3=0xff; //关闭8个LED

led_delay();

P3=0x00; //点亮8个LED

led_delay();

}

/ 函数功能:主函数

void main(void) //主函数

{

TMOD=0x01; //使用定时器T0的模式1 / / /

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TR0=1; //启动定时器T0

TH0=(65536-1000)/256; //定时器T0赋初值,每计数200次(217微秒)发送一次中断请求

TL0=(65536-1000)%256; //定时器T0赋初值

keyval=0; //按键值初始化为0,什么也不做

while(1)

{

switch(keyval)

{

case 1:forward();

break;

case 2:backward();

break;

case 3:stop();

break;

case 4: flash();

break;

}

}

}

/

函数功能:定时器T0的中断服务子程序

/

void Time0_serve(void) interrupt 1 using 1

{

if((P1&0xf0)!=0xf0) //第一次检测到有键按下

{

delay20ms(); //延时20ms再去检测

if(S1==0) //按键S1被按下

keyval=1;

if(S2==0) //按键S2被按下

keyval=2;

if(S3==0) //按键S3被按下

keyval=3;

if(S4==0) //按键S4被按下

keyval=4;

}

TH0=(65536-1000)/256;

TL0=(65536-1000)%256;

}

 

*实例73:独立式键盘控制的4级变速流水灯 #include // 包含51单片机寄存器定义的头文件 unsigned char speed; //储存流水灯的流动速度

sbit S1=P1^4; //位定义S1为P1.4

sbit S2=P1^5; //位定义S2为P1.5

sbit S3=P1^6; //位定义S3为P1.6

sbit S4=P1^7; //位定义S4为P1.7

/ 函数功能:延时20ms的子程序

void delay20ms(void) //3 i j+2 i=3 100 60+2 100=20000μs=20ms; {

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<60;j++)

;

}

/ 函数功能:延时可调子程序

入口参数:x

void delay(unsigned char x)

{

unsigned char k;

for(k=0;k

delay20ms();

}

/ 函数功能:主函数

void main(void)

{

TMOD=0x02; //使用定时器T0的模式2

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TR0=1; //定时器T0开始运行

TH0=256-200; //定时器T0赋初值,每200微妙来1次中断请求 TL0=256-200;

speed=3; //默认流水灯流水点亮延时20ms×3=60ms / / /

while(1)

{

P3=0xfe; //第一个灯亮

delay(speed); //调用延时可调子程序

P3=0xfd; //第二个灯亮

delay(speed);

P3=0xfb; //第三个灯亮

delay(speed);

P3=0xf7; //第四个灯亮

delay(speed);

P3=0xef; //第五个灯亮

delay(speed);

P3=0xdf; //第六个灯亮

delay(speed);

P3=0xbf; //第七个灯亮

delay(speed);

P3=0x7f; //第八个灯亮

delay(speed);

P3=0xff;

}

}

/ 函数功能:定时器T0的中断服务子程序,进行键盘扫描

/ void intersev(void) interrupt 1 using 1

{

TR0=0; //关闭定时器T0/

P1=0xff; //将P1口的均置高电平"1"

if((P1&0xf0)!=0xf0) //如果有键按下

{

delay20ms(); //延时20ms,软件消抖

if((P1&0xf0)!=0xf0) //确实有键按下

{

if(S1==0) //如果是按键S1按下

speed=5; //流水灯流水点亮延时20ms×5=100ms if(S2==0) //如果是按键S2按下

speed=10; //流水灯流水点亮延时20ms×10=200ms if(S3==0) //如果是按键S3按下

speed=25; //流水灯流水点亮延时20ms×25=500ms if(S4==0) //如果是按键S4按下

speed=50; //流水灯流水点亮延时20ms×50=1000ms }

}

TR0=1; //启动定时器T0

}

 

*实例74:独立式键盘的按键功能扩展:"以一当四" #include // 包含51单片机寄存器定义的头文件 unsigned char ID; //储存流水灯的流动速度

sbit S1=P1^4; //位定义S1为P1.4

/ 函数功能:延时子程序

/ void delay(void) //因为仅对一个按键扫描,所以延时时间较长约200ms {

unsigned char i,j;

for(i=0;i<200;i++)

for(j=0;j<100;j++)

;

}

/ 函数功能:主函数

/ void main(void)

{

TMOD=0x02; //使用定时器T0的模式2

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TR0=1; //定时器T0开始运行

TH0=256-200; //定时器T0赋初值,每200微妙来1次中断请求 TL0=256-200;

ID=0;

while(1)

{

switch(ID)

{

case 0: P3=0xfe;

break;

case 1: P3=0xfd;

break;

case 2: P3=0xfb;

break;

case 3: P3=0xf7;

break;

}

}

}

/ 函数功能:定时器T0的中断服务子程序,进行键盘扫描

/ void intersev(void) interrupt 1 using 1

{

TR0=0; //关闭定时器T0

P1=0xff;

if(S1==0) //如果是按键S1按下

{

delay(); //延时20ms,软件消抖

if(S1==0) //如果是按键S1按下

ID=ID+1;

}

if(ID==4)

ID=0;

TR0=1; //启动定时器T0

}

 

*实例75:独立式键盘调时的数码时钟实验

#include // 包含51单片机寄存器定义的头文件

unsigned char code Tab[ ]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; //数字0~9的段码

unsigned char int_time ; //中断次数计数变量

unsigned char second; //秒计数变量

unsigned char minute; //分钟计数变量

unsigned char hour; //小时计数变量

sbit S1=P1^4; //将S1位定义为P1.4

sbit S2=P1^5; //将S2位定义为P1.5

sbit S3=P1^6; //将S3位定义为P1.6

sbit S4=P1^7; //将S4位定义为P1.7

/ 函数功能:数码管扫描延时

/ void delay(void)

{

unsigned char j;

for(j=0;j<200;j++)

;

}

/ 函数功能:键盘扫描延时

void delay60ms(void)

{

unsigned char i,j;

for(i=0;i<200;i++)

for(j=0;j<100;j++)

;

}

/ 函数功能:显示秒

入口参数:s

void DisplaySecond(unsigned char s)

{

P2=0xbf; //P2.6引脚输出低电平, DS6点亮

P0=Tab[s/10]; //显示十位

delay();

P2=0x7f; //P2.7引脚输出低电平, DS7点亮

P0=Tab[s%10]; //显示个位

delay();

P2=0xff; //关闭所有数码管

}

/ 函数功能:显示分钟

入口参数:m

void DisplayMinute(unsigned char m)

{ / / /

P2=0xf7; // P2.3引脚输出低电平, DS3点亮 P0=Tab[m/10];//显示个位

delay();

P2=0xef; // P2.4引脚输出低电平, DS4点亮 P0=Tab[m%10];

delay();

P2=0xdf; //P2.5引脚输出低电平, DS5点亮 P0=0xbf; //分隔符“-”的段码

delay();

P2=0xff; //关闭所有数码管

}

/ 函数功能:显示小时的子程序

入口参数:h

void DisplayHour(unsigned char h)

{

P2=0xfe; //P2.0引脚输出低电平, DS0点亮 P0=Tab[h/10]; //显示十位

delay();

P2=0xfd; //P2.1引脚输出低电平, DS1点亮 P0=Tab[h%10]; //显示个位

delay();

P2=0xfb; //P2.2引脚输出低电平, DS2点亮 P0=0xbf; //分隔符“-”的段码

delay();

P2=0xff; //关闭所有数码管

}

/ 函数功能:键盘扫描

void key_scan(void)

{

P1=0xf0; //将P1口高4位置高电平“1”

if((P1&0xf0)!=0xf0) //有键按下

{

delay60ms(); //延时60ms再检测

if((P1&0xf0)!=0xf0) //确实有键按下 {

if(S1==0) //如果是S1键按下 second++; //秒加1 / /

if(S2==0) //如果是S2键按下 minute++; //分钟加1

if(S3==0) //如果是S3键按下 hour++; //小时加1

if(S4==0) //如果是S4键按下 {

second=0; //秒清0

minute=0; //分钟清0

hour=0; //小时清0

}

}

}

}

/ 函数功能:主函数

void main(void)

{

TMOD=0x01; //使用定时器T0 EA=1; //开中断总允许

ET0=1; //允许T0中断

TH0=(65536-46083)/256; //定时器高八位赋初值 TL0=(65536-46083)%256; //定时器低八位赋初值 TR0=1; //启动定时器T0

int_time=0; //中断计数变量初始化

second=0; //秒计数变量初始化

minute=0; //分钟计数变量初始化

hour=0; //小时计数变量初始化

while(1)

{

DisplaySecond(second); //调用秒显示子程序 DisplayMinute(minute); //调用分钟显示子程序 DisplayHour(hour); //调用小时显示子程序

}

}

/ 函数功能:定时器T0的中断服务子程序

/ /

void interserve(void ) interrupt 1 using 1 //using Time0

{

TR0=0; //关闭定时器T0

int_time++; //中断次数加1

if(int_time==20) //如果中断次数满20

{

int_time=0; //中断计数变量清0

second++; //秒计数变量加1

}

if(second==60) //如果秒计满60

{

second=0; //如果秒计满60,将秒计数变量清0 minute++; //分钟计数变量加1

}

if(minute==60) //如果分钟计满60

{

minute=0; //如果分钟计满60,将分钟计数变量清0 hour++; //小时计数变量加1

}

if(hour==24) //如果小时计满24

{

hour=0; //如果小时计满24,将小时计数变量清0 }

key_scan(); //执行键盘扫描

TH0=(65536-46083)/256; //定时器T0高四位赋值

TL0=(65536-46083)%256; //定时器T0低四位赋值

TR0=1; //启动定时器T0

}

 

*实例76:独立式键盘控制步进电机实验

#include //包含51单片机寄存器定义的头文件

sbit S1=P1^4; //将S1位定义为P1.4引脚

sbit S2=P1^5; //将S2位定义为P1.5引脚

sbit S3=P1^6; //将S3位定义为P1.6引脚

unsigned char keyval; //储存按键值

unsigned char ID; //储存功能标号

/

函数功能:软件消抖延时(约50ms)

/

void delay(void)

{

unsigned char i,j;

for(i=0;i<150;i++)

for(j=0;j<100;j++)

;

}

/ 函数功能:步进电机转动延时,延时越长,转速越慢

void motor_delay(void)

{

unsigned int i;

for(i=0;i<2000;i++)

;

}

/

函数功能:步进电机正转

void forward( )

{

P0=0xfc;

motor_delay();

P0=0xf6;

motor_delay();

P0=0xf3;

motor_delay();

P0=0xf9;

motor_delay();

}

/

函数功能:步进电机反转

void backward()

{

P0=0xfc;

motor_delay();

P0=0xf9;

motor_delay();

P0=0xf3;

motor_delay();

P0=0xf6;

motor_delay();

} //P0口低四位脉冲1100 //P0口低四位脉冲0110 //P0口低四位脉冲0011 //P0口低四位脉冲1001 //P0口低四位脉冲1100 //P0口低四位脉冲1001 //P0口低四位脉冲0011 //P0口低四位脉冲0110 / / /

/

函数功能:步进电机停转

/

void stop(void)

{

P0=0xff ; //停止输出脉冲

}

/

函数功能:主函数

/

void main(void)

{

TMOD=0x01; //使用定时器T0的模式1

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TR0=1; //启动定时器T0

TH0=(65536-500)/256; //定时器T0赋初值,每计数200次(217微秒)发送一次中断请求

TL0=(65536-500)%256; //定时器T0赋初值

keyval=0; //按键值初始化为0,什么也不做

ID=0;

while(1)

{

switch(keyval) //根据按键值keyval选择待执行的功能 {

case 1:forward(); //按键S1按下,正转

break;

case 2:backward(); //按键S2按下 ,反转

break;

case 3:stop(); //按键S3按下,停转

break;

}

}

}

/

函数功能:定时器T0的中断服务子程序

/

void Time0_serve(void) interrupt 1 using 1

{

TR0=0; //关闭定时器T0

if((P1&0xf0)!=0xf0) //第一次检测到有键按下

{

delay(); //延时一段时间再去检测

if((P1&0xf0)!=0xf0) //确实有键按下

{

if(S1==0) //按键S1被按下

keyval=1;

if(S2==0) //按键S2被按下

keyval=2;

if(S3==0) //按键S3被按下

keyval=3;

}

}

TH0=(65536-200)/256; //定时器T0的高8位赋初值

TL0=(65536-200)%256; //定时器T0的低8位赋初值

TR0=1; //启动定时器T0

}

 

*实例77:矩阵式键盘按键值的数码管显示实验

#include //包含51单片机寄存器定义的头文件

sbit P14=P1^4; //将P14位定义为P1.4引脚

sbit P15=P1^5; //将P15位定义为P1.5引脚

sbit P16=P1^6; //将P16位定义为P1.6引脚

sbit P17=P1^7; //将P17位定义为P1.7引脚

unsigned char code Tab[ ]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; //数字0~9的段码

unsigned char keyval; //定义变量储存按键值

/ 函数功能:数码管动态扫描延时

/ void led_delay(void)

{

unsigned char j;

for(j=0;j<200;j++)

;

}

/ 函数功能:按键值的数码管显示子程序

/ void display(unsigned char k)

{

P2=0xbf; //点亮数码管DS6

P0=Tab[k/10]; //显示十位

led_delay(); //动态扫描延时

P2=0x7f; //点亮数码管DS7

P0=Tab[k%10]; //显示个位

led_delay(); //动态扫描延时

}

/ 函数功能:软件延时子程序

/ void delay20ms(void)

{

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<60;j++)

;

}

/ 函数功能:主函数

/ void main(void)

{

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TMOD=0x01; //使用定时器T0的模式1

TH0=(65536-500)/256; //定时器T0的高8位赋初值

TL0=(65536-500)%256; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

keyval=0x00; //按键值初始化为0

while(1) //无限循环

{

display(keyval); //调用按键值的数码管显示子程序

}

}

/ 函数功能:定时器0的中断服务子程序,进行键盘扫描,判断键位

/

void time0_interserve(void) interrupt 1 using 1 //定时器T0的中断编号为1,使用第一组寄存器

{

TR0=0; //关闭定时器T0

P1=0xf0; //所有行线置为低电平“0”,所有列线置为高电平“1”

if((P1&0xf0)!=0xf0) //列线中有一位为低电平“0”,说明有键按下 delay20ms(); //延时一段时间、软件消抖

if((P1&0xf0)!=0xf0) //确实有键按下

{

P1=0xfe; //第一行置为低电平“0”(P1.0输出低电平“0”)

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0” keyval=1; //可判断是S1键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0”

keyval=2; //可判断是S2键被按下

if(P16==0)

“0”

keyval=3;

if(P17==0)

“0”

keyval=4;

P1=0xfd;

“0”)

if(P14==0)

keyval=5;

if(P15==0)

“0”

keyval=6;

if(P16==0)

“0”

keyval=7;

if(P17==0)

“0”

keyval=8;

P1=0xfb;

“0”)

if(P14==0)

keyval=9;

if(P15==0)

keyval=10;

if(P16==0)

keyval=11;

if(P17==0)

keyval=12;

P1=0xf7;

“0”)

if(P14==0) //如果检测到接P1.6引脚的列线为低电平 //可判断是S3键被按下 //如果检测到接P1.7引脚的列线为低电平 //可判断是S4键被按下 //第二行置为低电平“0”(P1.1输出低电平 //如果检测到接P1.4引脚的列线为低电平“0” //可判断是S5键被按下 //如果检测到接P1.5引脚的列线为低电平 //可判断是S6键被按下 //如果检测到接P1.6引脚的列线为低电平 //可判断是S7键被按下 //如果检测到接P1.7引脚的列线为低电平 //可判断是S8键被按下 //第三行置为低电平“0”(P1.2输出低电平//如果检测到接P1.4引脚的列线为低电平“0” //可判断是S9键被按下 //如果检测到接P1.5引脚的列线为低电平“0” //可判断是S10键被按下 //如果检测到接P1.6引脚的列线为低电平“0” //可判断是S11键被按下 //如果检测到接P1.7引脚的列线为低电平“0” //可判断是S12键被按下 //第四行置为低电平“0”(P1.3输出低电平//如果检测到接P1.4引脚的列线为低电平“0”

keyval=13; //可判断是S13键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0” keyval=14; //可判断是S14键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0” keyval=15; //可判断是S15键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0” keyval=16; //可判断是S16键被按下 }

TR0=1; //开启定时器T0

TH0=(65536-500)/256; //定时器T0的高8位赋初值 TL0=(65536-500)%256; //定时器T0的高8位赋初值 }

*实例78:矩阵式键盘按键音

#include //包含51单片机寄存器定义的头文件 sbit sound=P3^7; //将sound位定义为P3.7

/ 函数功能:蜂鸣器发声延时约120ms

void delay_sound(void) {

unsigned char i; for(i=0;i<250;i++) ; }

/ 函数功能:软件延时子程序约20ms

void delay20ms(void) {

unsigned char i,j; for(i=0;i<100;i++) for(j=0;j<60;j++) ; }

/ 函数功能:主函数

void main(void)

/ / /

{

EA=1; //开总中断

ET0=1; //定时器T0中断允许

TMOD=0x01; //使用定时器T0的模式1

TH0=(65536-500)/256; //定时器T0的高8位赋初值

TL0=(65536-500)%256; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

while(1) //无限循环,等待键盘按下

;

}

/ 函数功能:定时器0的中断服务子程序,进行键盘扫描,判断键位

/

void time0_interserve(void) interrupt 1 using 1 //定时器T0的中断编号为1,使用第一组寄存器

{

unsigned char i;

TR0=0; //关闭定时器T0

P1=0xf0; //所有行线置为低电平“0”,所有列线置为高电平“1”

if((P1&0xf0)!=0xf0) //列线中有一位为低电平“0”,说明有键按下 delay20ms(); //延时一段时间、软件消抖

if((P1&0xf0)!=0xf0) //确实有键按下

{

for(i=0;i<200;i++) //让P3.7引脚电平不断取反输出音频

{

sound=0;

delay_sound();

sound=1;

delay_sound();

}

}

TR0=1; //开启定时器T0

TH0=(65536-500)/256; //定时器T0的高8位赋初值

TL0=(65536-500)%256; //定时器T0的高8位赋初值 }

 

*实例79:简易电子琴

#include //包含51单片机寄存器定义的头文件

sbit P14=P1^4; //将P14位定义为P1.4引脚

sbit P15=P1^5; //将P15位定义为P1.5引脚

sbit P16=P1^6; //将P16位定义为P1.6引脚

sbit P17=P1^7; //将P17位定义为P1.7引脚

unsigned char keyval; //定义变量储存按键值

sbit sound=P3^7; //将sound位定义为P3.7

unsigned int C; //全局变量,储存定时器的定时常数

unsigned int f; //全局变量,储存音阶的频率

//以下是C调低音的音频宏定义

#define l_dao 262 //将“l_dao”宏定义为低音“1”的频率262Hz #define l_re 286 //将“l_re”宏定义为低音“2”的频率286Hz #define l_mi 311 //将“l_mi”宏定义为低音“3”的频率311Hz #define l_fa 349 //将“l_fa”宏定义为低音“4”的频率349Hz #define l_sao 392 //将“l_sao”宏定义为低音“5”的频率392Hz #define l_la 440 //将“l_a”宏定义为低音“6”的频率440Hz #define l_xi 494 //将“l_xi”宏定义为低音“7”的频率494Hz

//以下是C调中音的音频宏定义

#define dao 523 //将“dao”宏定义为中音“1”的频率523Hz #define re 587 //将“re”宏定义为中音“2”的频率587Hz #define mi 659 //将“mi”宏定义为中音“3”的频率659Hz #define fa 698 //将“fa”宏定义为中音“4”的频率698Hz #define sao 784 //将“sao”宏定义为中音“5”的频率784Hz #define la 880 //将“la”宏定义为中音“6”的频率880Hz #define xi 987 //将“xi”宏定义为中音“7”的频率53

//以下是C调高音的音频宏定义

#define h_dao 1046 //将“h_dao”宏定义为高音“1”的频率1046Hz #define h_re 1174 //将“h_re”宏定义为高音“2”的频率1174Hz #define h_mi 1318 //将“h_mi”宏定义为高音“3”的频率1318Hz #define h_fa 1396 //将“h_fa”宏定义为高音“4”的频率1396Hz #define h_sao 1567 //将“h_sao”宏定义为高音“5”的频率1567Hz #define h_la 1760 //将“h_la”宏定义为高音“6”的频率1760Hz #define h_xi 1975 //将“h_xi”宏定义为高音“7”的频率1975Hz / 函数功能:软件延时子程序

/ void delay20ms(void)

{

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<60;j++)

;

}

/

函数功能:节拍的延时的基本单位,延时200ms

/

void delay()

{

unsigned char i,j;

for(i=0;i<250;i++)

for(j=0;j<250;j++)

;

}

/

函数功能:输出音频

入口参数:F

/

void Output_Sound(void)

{

C=(46083/f) 10; //计算定时常数

TH0=(8192-C)/32; //可证明这是13位计数器TH0高8位的赋初值方法 TL0=(8192-C)%32; //可证明这是13位计数器TL0低5位的赋初值方法 TR0=1; //开定时T0

delay(); //延时200ms,播放音频

TR0=0; //关闭定时器

sound=1; //关闭蜂鸣器

keyval=0xff; //播放按键音频后,将按键值更改,停止播放 }

/

函数功能:主函数

/

void main(void)

{

EA=1; //开总中断

ET0=1; //定时器T0中断允许

ET1=1; //定时器T1中断允许

TR1=1; //定时器T1启动,开始键盘扫描

TMOD=0x10; //分别使用定时器T1的模式1,T0的模式0 TH1=(65536-500)/256; //定时器T1的高8位赋初值

TL1=(65536-500)%256; //定时器T1的高8位赋初值

while(1) //无限循环

{

switch(keyval)

{

case 1:f=dao; //如果第1个键按下,将中音1的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 2:f=l_xi; //如果第2个键按下,将低音7的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 3:f=l_la; //如果第3个键按下,将低音6的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 4:f=l_sao; //如果第4个键按下,将低音5的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 5:f=sao; //如果第5个键按下,将中音5的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 6:f=fa; //如果第6个键按下,将中音4的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 7:f=mi; //如果第7个键按下,将中音3的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 8:f=re; //如果第8个键按下,将中音2的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 9:f=h_re; //如果第9个键按下,将高音2的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 10:f=h_dao; //如果第10个键按下,将高音1的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 11:f=xi; //如果第11个键按下,将中音7的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 12:f=la; //如果第12个键按下,将中音6的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 13:f=h_la; //如果第13个键按下,将高音6的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 14:f=h_sao; //如果第14个键按下,将高音5的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 15:f=h_fa; //如果第15个键按下,将高音4的频率赋给f

Output_Sound(); //转去计算定时常数 break;

case 16:f=h_mi; //如果第16个键按下,将高音3的频率赋给f

Output_Sound(); //转去计算定时常数 break;

}

}

}

/ 函数功能:定时器T0的中断服务子程序,使P3.7引脚输出音频方波

/

void Time0_serve(void ) interrupt 1 using 1

{

TH0=(8192-C)/32; //可证明这是13位计数器TH0高8位的赋初值方法

TL0=(8192-C)%32; //可证明这是13位计数器TL0低5位的赋初值方法

sound=!sound; //将P3.7引脚取反,输出音频方波

}

/ 函数功能:定时器T1的中断服务子程序,进行键盘扫描,判断键位

/

void time1_serve(void) interrupt 3 using 2 //定时器T1的中断编号为3,使用第2组寄存器 {

TR1=0; //关闭定时器T0

P1=0xf0; //所有行线置为低电平“0”,所有列线置为高电平“1” if((P1&0xf0)!=0xf0) //列线中有一位为低电平“0”,说明有键按下 { delay20ms(); //延时一段时间、软件消抖 if((P1&0xf0)!=0xf0) { P1=0xfe; 输出低电平“0”) if(P14==0) 为低电平“0” keyval=1; if(P15==0) 线为低电平“0” keyval=2; if(P16==0) 线为低电平“0” keyval=3; if(P17==0) 线为低电平“0” keyval=4; P1=0xfd; 输出低电平“0”) if(P14==0) 低电平“0” keyval=5; if(P15==0) 线为低电平“0” keyval=6; if(P16==0) 线为低电平“0” keyval=7; if(P17==0) 线为低电平“0” keyval=8; P1=0xfb; 输出低电平“0”)

//确实有键按下 //第一行置为低电平“0”(P1.0 //如果检测到接P1.4引脚的列线 //可判断是S1键被按下 //如果检测到接P1.5引脚的列 //可判断是S2键被按下 //如果检测到接P1.6引脚的列 //可判断是S3键被按下 //如果检测到接P1.7引脚的列 //可判断是S4键被按下 //第二行置为低电平“0”(P1.1 //如果检测到接P1.4引脚的列线为 //可判断是S5键被按下 //如果检测到接P1.5引脚的列 //可判断是S6键被按下 //如果检测到接P1.6引脚的列 //可判断是S7键被按下 //如果检测到接P1.7引脚的列 //可判断是S8键被按下 //第三行置为低电平“0”(P1.2

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0”

keyval=9; //可判断是S9键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0”

keyval=10; //可判断是S10键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0”

keyval=11; //可判断是S11键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0”

keyval=12; //可判断是S12键被按下

P1=0xf7; //第四行置为低电平“0”(P1.3输出低电平“0”)

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0”

keyval=13; //可判断是S13键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0”

keyval=14; //可判断是S14键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0”

keyval=15; //可判断是S15键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0”

keyval=16; //可判断是S16键被按下 }

}

TR1=1; //开启定时器T1

TH1=(65536-500)/256; //定时器T1的高8位赋初值

TL1=(65536-500)%256; //定时器T1的高8位赋初值

}

 

*实例80:矩阵式键盘实现的电子密码锁

#include //包含51单片机寄存器定义的头文件

sbit P14=P1^4; //将P14位定义为P1.4引脚

sbit P15=P1^5; //将P15位定义为P1.5引脚

sbit P16=P1^6; //将P16位定义为P1.6引脚

sbit P17=P1^7; //将P17位定义为P1.7引脚

sbit sound=P3^7; //将sound位定义为P3.7

unsigned char keyval; //储存按键值

/ 函数功能:延时输出音频

/ void delay(void)

{

unsigned char i;

for(i=0;i<200;i++)

;

}

/ 函数功能:软件延时子程序

void delay20ms(void)

{

unsigned char i,j;

for(i=0;i<100;i++)

for(j=0;j<60;j++)

;

}

/ 函数功能:主函数

void main(void)

{

unsigned char D[ ]={0,8,0,8,7,4,11}; //设定密码

EA=1; //开总中断

ET0=1; //定时器T0中断允许 TMOD=0x01; //使用定时器T0的模式1

TH0=(65536-500)/256; //定时器T0的高8位赋初值

TL0=(65536-500)%256; //定时器T0的高8位赋初值

TR0=1; //启动定时器T0

keyval=0xff; //按键值初始化

while(keyval!=D[0]) //第一位密码输入不正确,等待

;

while(keyval!=D[1]) //第二位密码输入不正确,等待

;

while(keyval!=D[2]) //第三位密码输入不正确,等待

;

while(keyval!=D[3]) //第四位密码输入不正确,等待 / /

;

while(keyval!=D[4]) //第五位密码输入不正确,等待

;

while(keyval!=D[5]) //第六位密码输入不正确,等待

;

while(keyval!=D[6]) //没有输入“OK”,等待

;

P3=0xfe; //P3.0引脚输出低电平,点亮LED

}

/ 函数功能:定时器0的中断服务子程序,进行键盘扫描,判断键位

/

void time0_interserve(void) interrupt 1 using 1 //定时器T0的中断编号为1,使用第一组寄存器

{

unsigned char i;

TR0=0; //关闭定时器T0

P1=0xf0; //所有行线置为低电平“0”,所有列线置为高电平“1”

if((P1&0xf0)!=0xf0) //列线中有一位为低电平“0”,说明有键按下 delay20ms(); //延时一段时间、软件消抖

if((P1&0xf0)!=0xf0) //确实有键按下

{

P1=0xfe; //第一行置为低电平“0”(P1.0输出低电平“0”)

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0” keyval=1; //可判断是S1键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0”

keyval=2; //可判断是S2键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0”

keyval=3; //可判断是S3键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0”

keyval=4; //可判断是S4键被按下

P1=0xfd; //第二行置为低电平“0”(P1.1输出低电平“0”)

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0” keyval=5; //可判断是S5键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0”

keyval=6; //可判断是S6键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0”

keyval=7; //可判断是S7键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0”

keyval=8; //可判断是S8键被按下

P1=0xfb; //第三行置为低电平“0”(P1.2输出低电平“0”)

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0” keyval=9; //可判断是S9键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0” keyval=0; //可判断是S10键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0” keyval=11; //可判断是S11键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0” keyval=12; //可判断是S12键被按下

P1=0xf7; //第四行置为低电平“0”(P1.3输出低电平“0”)

if(P14==0) //如果检测到接P1.4引脚的列线为低电平“0”

keyval=13; //可判断是S13键被按下

if(P15==0) //如果检测到接P1.5引脚的列线为低电平“0”

keyval=14; //可判断是S14键被按下

if(P16==0) //如果检测到接P1.6引脚的列线为低电平“0”

keyval=15; //可判断是S15键被按下

if(P17==0) //如果检测到接P1.7引脚的列线为低电平“0”

keyval=16; //可判断是S16键被按下 for(i=0;i<200;i++) //让P3.7引脚电平不断取反输出音频

{

sound=0;

delay();

sound=1;

delay();

}

}

TR0=1; //开启定时器T0

TH0=(65536-500)/256; //定时器T0的高8位赋初值

TL0=(65536-500)%256; //定时器T0的高8位赋初值

 

 

  审核编辑:汤梓红


打开APP阅读更多精彩内容
声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉

全部0条评论

快来发表一下你的评论吧 !

×
20
完善资料,
赚取积分