用51单片机实现时钟功能程序？？？

怎样利用51单片机实现时钟功能程序？~

#define uchar unsigned char // （先定义一下方便使用）
#define uint unsigned int
#define ulong unsigned long
#include //包括一个52标准内核的头文件
uchar code zixing[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
uchar code ziwei[]={0x10,0x20,0x40,0x80};
uchar *h,*m;
uchar hour=12,min=0,sec=0,h_ding,m_ding,count=0,ms_50,ms_10,miaobiao_sec;
sbit dp=P0^7;
sbit k1=P3^2;
sbit k2=P3^3;
sbit k3=P3^4;
sbit sound=P2^3;
sfr ZIXING=0x80; //p0口输出字形
sfr ZIWEI=0xa0; //P2口输出字位
typedef enum //枚举类型：4种状态//
{
CLOCK,
SET_RING1,
SET_RING2,
MIAOBIAO_RUN,
}STATE;
STATE status;
typedef struct //定时时间的数据结构//
{
uchar hour;
uchar min;
}DINGSHI_TIME;
DINGSHI_TIME dingshi_time[2];
#define NO_KEY -1 //定义一下方便使用
#define KEY_1 1
#define KEY_2 2
#define KEY_3 3
bit show_on_flag;
//#######定时器T0中断服务程序########//
Timer0() interrupt 1
{
TH0=0x3c;TL0=0xb4; //50ms
ms_50++;
if(ms_50==20) {sec++;ms_50=0;}
if(sec==60) {sec=0;min++;}
if(min==60) {min=0;hour++;}
if(hour==24) {hour=0;}
}
//#######定时器T1中断服务程序########//
Timer1() interrupt 3
{
TH1=0xd8;TL1=0xf4; //10ms
ms_10++;
if(ms_10==100)
{
miaobiao_sec++;
ms_10=0;
}
if(miaobiao_sec==60)
miaobiao_sec=0;
}
//##############数码管显示#####################//
show(uchar time_high,uchar time_low)
{
uchar m;
uint n,k;
k=time_high*1000/10+time_low;
for(m=0;m<4;m++)
{
ZIXING=zixing[k%10];
if(ms_50<10)
dp=0;
ZIWEI=~ziwei[m];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<100;n++);
k=k/10;
}
}
//显示 on 定时编号//
show_on(uchar id) //id：定时编号//
{
uchar m;
uint n;
for(m=0;m<2;m++)
{
ZIXING=zixing[id%10];
dp=0;
ZIWEI=~ziwei[m];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<80;n++);
id=id/10;
}
ZIXING=0xc8; //字母n//
ZIWEI=~ziwei[2];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<200;n++);
ZIXING=0xc0; //字母0//
ZIWEI=~ziwei[3];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<200;n++);
}
/*************启动秒表***************/
void run_miaobiao()
{
ms_10=0;
miaobiao_sec=0;
TH1=0xd8; //标准是0xd8e4
TL1=0xf4;
// TR1=1; //启动定时器1
}
显示秒表：
void show_miaobiao()
{
show(miaobiao_sec,ms_10);
}

我给你个，你试试把。
#include //包含头文件，一般情况不需要改动，头文件包含特殊功能寄存器的定义
#include

sbit SCK=P3^6; //时钟
sbit SDA=P3^4; //数据
sbit RST = P3^5;// DS1302复位

sbit LS138A=P2^2;
sbit LS138B=P2^3;
sbit LS138C=P2^4;

bit ReadRTC_Flag;//定义读DS1302标志

unsigned char l_tmpdate[7]={0,0,12,15,5,3,8};//秒分时日月周年08-05-15 12:00:00
unsigned char l_tmpdisplay[8];

code unsigned char write_rtc_address[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c}; //秒分时日月周年 最低位读写位
code unsigned char read_rtc_address[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};



code unsigned char table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x40};
//共阴数码管 0-9 '-' '熄灭‘表

/******************************************************************/
/* 函数声明 */
/******************************************************************/
void Write_Ds1302_byte(unsigned char temp);
void Write_Ds1302( unsigned char address,unsigned char dat );
unsigned char Read_Ds1302 ( unsigned char address );
void Read_RTC(void);//read RTC
void Set_RTC(void); //set RTC
void InitTIMER0(void);//inital timer0
/******************************************************************/
/* 主函数 */
/******************************************************************/
void main(void)
{
InitTIMER0(); //初始化定时器0
Set_RTC(); //写入时钟值，如果使用备用电池时候，不需要没每次上电写入，此程序应该屏蔽

while(1)
{
if(ReadRTC_Flag)
{
ReadRTC_Flag=0;
Read_RTC();

l_tmpdisplay[0]=l_tmpdate[2]/16; //数据的转换，因我们采用数码管0~9的显示,将数据分开
l_tmpdisplay[1]=l_tmpdate[2]&0x0f;
l_tmpdisplay[2]=10; //加入"-"
l_tmpdisplay[3]=l_tmpdate[1]/16;
l_tmpdisplay[4]=l_tmpdate[1]&0x0f;
l_tmpdisplay[5]=10;
l_tmpdisplay[6]=l_tmpdate[0]/16;
l_tmpdisplay[7]=l_tmpdate[0]&0x0f;

}
}
}
/******************************************************************/
/* 定时器0初始化 */
/******************************************************************/
void InitTIMER0(void)
{
TMOD|=0x01;//定时器设置 16位
TH0=0xef;//初始化值
TL0=0xf0;
ET0=1;
TR0=1;
EA=1;
}


/******************************************************************/
/* 写一个字节 */
/******************************************************************/
void Write_Ds1302_Byte(unsigned char temp)
{
unsigned char i;
for (i=0;i<8;i++) //循环8次 写入数据
{
SCK=0;
SDA=temp&0x01; //每次传输低字节
temp>>=1; //右移一位
SCK=1;
}
}
/******************************************************************/
/* 写入DS1302 */
/******************************************************************/
void Write_Ds1302( unsigned char address,unsigned char dat )
{
RST=0;
_nop_();
SCK=0;
_nop_();
RST=1;
_nop_(); //启动
Write_Ds1302_Byte(address); //发送地址
Write_Ds1302_Byte(dat); //发送数据
RST=0; //恢复
}
/******************************************************************/
/* 读出DS1302数据 */
/******************************************************************/
unsigned char Read_Ds1302 ( unsigned char address )
{
unsigned char i,temp=0x00;
RST=0;
_nop_();
_nop_();
SCK=0;
_nop_();
_nop_();
RST=1;
_nop_();
_nop_();
Write_Ds1302_Byte(address);
for (i=0;i<8;i++) //循环8次 读取数据
{
if(SDA)
temp|=0x80; //每次传输低字节
SCK=0;
temp>>=1; //右移一位
_nop_();
_nop_();
_nop_();
SCK=1;
}
RST=0;
_nop_(); //以下为DS1302复位的稳定时间
_nop_();
RST=0;
SCK=0;
_nop_();
_nop_();
_nop_();
_nop_();
SCK=1;
_nop_();
_nop_();
SDA=0;
_nop_();
_nop_();
SDA=1;
_nop_();
_nop_();
return (temp); //返回
}
/******************************************************************/
/* 读时钟数据 */
/******************************************************************/
void Read_RTC(void) //读取 日历
{
unsigned char i,*p;
p=read_rtc_address; //地址传递
for(i=0;i<7;i++) //分7次读取 秒分时日月周年
{
l_tmpdate[i]=Read_Ds1302(*p);
p++;
}
}
/******************************************************************/
/* 设定时钟数据 */
/******************************************************************/
void Set_RTC(void) //设定 日历
{
unsigned char i,*p,tmp;
for(i=0;i<7;i++){ //BCD处理
tmp=l_tmpdate[i]/10;
l_tmpdate[i]=l_tmpdate[i]%10;
l_tmpdate[i]=l_tmpdate[i]+tmp*16;
}
Write_Ds1302(0x8E,0X00);

p=write_rtc_address; //传地址
for(i=0;i<7;i++) //7次写入 秒分时日月周年
{
Write_Ds1302(*p,l_tmpdate[i]);
p++;
}
Write_Ds1302(0x8E,0x80);
}
/******************************************************************/
/* 定时器中断函数 */
/******************************************************************/
void tim(void) interrupt 1 using 1
//中断，用于数码管扫描
{

static unsigned char i,num;
TH0=0xf5;
TL0=0xe0;

P0=table[l_tmpdisplay[i]]; //查表法得到要显示数字的数码段

switch(i)
{
case 0:LS138A=0; LS138B=0; LS138C=0; break;
case 1:LS138A=1; LS138B=0; LS138C=0; break;
case 2:LS138A=0; LS138B=1; LS138C=0; break;
case 3:LS138A=1; LS138B=1; LS138C=0; break;
case 4:LS138A=0; LS138B=0; LS138C=1; break;
case 5:LS138A=1; LS138B=0; LS138C=1; break;
case 6:LS138A=0; LS138B=1; LS138C=1; break;
case 7:LS138A=1; LS138B=1; LS138C=1; break;

}
i++;
if(i==8)
{
i=0;
num++;
if(10==num) //隔段时间读取1302的数据。时间间隔可以调整
{
ReadRTC_Flag=1; //使用标志位判断
num=0;
}
}
}

duanEQUP0;

weiEQUP2;

keyBITP3.7;

ORG0000H

AJMPMAIN;绝对转移指令，2kb范围（11位）内跳转LJMP16位64kb范围内跳转

;短转移指令的功能是先使程序计数器PC加1两次（即：取出指令码），然后把加2后的地址和rel相加作为目标转移地址。因此，短转移指令是一条相对转移指令，是一条双字节双周期指令

ORG0030H;指明后面的程序从程序存储器的0030H单元开始存放

DELAY200US:;@11.0592MHz

NOP

NOP

NOP

PUSH30H

PUSH31H

MOV30H,#2

MOV31H,#179

NEXT:

DJNZ31H,NEXT

DJNZ30H,NEXT

POP31H

POP30H

RET

ORG0060H

;DISPLAY子程序

DISPLAY:

PUSHACC;不能写A，此处ACC代表地址，push后跟地址，代表把地址内的内容压入栈中

PUSH00H;R0

PUSH06H;R6

PUSH07H;R7

PUSH83H;DPH

PUSH82H;DPL

MOVR6,#01H;位选数据,01指的是缓冲区最低位数据

MOVR7,#08H;循环次数

FLAG:

MOVduan,#0x00;消影

MOVA,R6

CPLA;取反

MOVwei,A;位选

MOVA,#disBufDat

ADDA,R7

SUBBA,#0X08

MOVR0,A

MOVA,@R0;读出要显示的数据到A

MOVDPTR,#disTab

MOVCA,@A+DPTR;从rom取数据,取出要显示的数据对应的段码

MOVduan,A;段选

MOVA,R6

RLA

MOVR6,A;更新下一次位选

LCALLDELAY200US

DJNZR7,FLAG

POP82H;DPL

POP83H;DPH

POP07H

POP06H

POP00H

POPACC

RET

ORG0100H

;定时器中断0初始化

T0_INIT:

MOVTMOD,#0X01

MOVTH0,#0X3C

MOVTL0,#0XB0

SETBEA

SETBTR0

SETBET0

RET

ORG0130H

;T0中断处理程序

INT_TIMERE0:

PUSHACC

SETBRS0

MOVTH0,#0X3C

MOVTL0,#0XB0

INCR0

MOVA,R0

SUBBA,#0X14

JBCY,SECFLAG

MOVR0,#0x00

INCsec

SECFLAG:

CLRRS0

POPACC

RETI

ORG000BH;定时器/计数器T0入口地址

LJMPINT_TIMERE0;跳转到定时器/计数器中断服务程序中去

disTab:DB0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00,0x40;0-f,空白，横杠的段选数据

disBufDatEQU47H;定义显示缓冲数据变量区,8个

disBufDatHeadEQU40H//单片机上显示在最左边

secEQU48H

;主程序

ORG0180H

MAIN:

MOVSP,#0X60;将0x60到0x7f设为堆栈区

LCALLT0_INIT

MOVdisBufDatHead,#0X00

MOVdisBufDatHead+1,#0X00

MOVdisBufDatHead+2,#0X11

MOVdisBufDatHead+3,#0X11

MOVdisBufDatHead+4,#0X11

MOVdisBufDatHead+5,#0X11

MOVdisBufDatHead+6,#0X11

MOVdisBufDatHead+7,#0X11

MOVsec,#0X3A

WHILE:

JBkey,KEYSCAN

MOVsec,0x00

KEYSCAN:

MOVA,sec

SUBBA,#3CH;超过60s归零

JBCY,CLEAR

MOVsec,#0X00;clr加ram地址无效

CLEAR:

MOVA,sec

MOVB,#0AH

DIVAB;A/B,商存到A中，余数存B中

MOVdisBufDatHead,A

MOVdisBufDatHead+1,B

LCALLDISPLAY

LJMPWHILE;循环

END;

扩展资料

51机器周期和指令周期

1、机器周期是指单片机完成一个基本操作所花费的时间，一般使用微秒来计量单片机的运行速度，51单片机的一个机器周期包括12个时钟振荡周期，也就是说如果51单片机采用12MHz晶振，那么执行一个机器周期就只需要1μs;如果采用的是6MHz的晶振，那么执行一个机器周期就需要2μs。

2、指令周期是指单片机执行一条指令所需要的时间，一般利用单片机的机器周期来计量指令周期。在51单片机里有单周期指令(执行这条指令只需一个机器周期)，双周期指令(执行这条指令只需要两个机器周期)，四周期指令(执行这条指令需要四个机器周期)。

除了乘、除两条指令是四周期指令，其余均为单周期或双周期指令。也就是说，如果51单片机采用的是12MHz晶振，那么它执行一条指令一般只需1~2微秒的时间;如果采用的是6MH晶振，执行一条指令一般就需2~4微秒的时间。

这个功能建议你用DS1302时钟芯片实现！编程就容易多了，至于程序就自己编写吧，这样才有意义！

#define uchar unsigned char //定义一下方便使用
#define uint unsigned int
#define ulong unsigned long
#include <reg52.h> //包括一个52标准内核的头文件

uchar code zixing[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
uchar code ziwei[]={0x10,0x20,0x40,0x80};
uchar *h,*m;
uchar hour=12,min=0,sec=0,h_ding,m_ding,count=0,ms_50,ms_10,miaobiao_sec;
sbit dp=P0^7;
sbit k1=P3^2;
sbit k2=P3^3;
sbit k3=P3^4;
sbit sound=P2^3;
sfr ZIXING=0x80; //p0口输出字形
sfr ZIWEI=0xa0; //P2口输出字位

typedef enum //枚举类型：4种状态//
{
CLOCK,
SET_RING1,
SET_RING2,
MIAOBIAO_RUN,
}STATE;
STATE status;

typedef struct //定时时间的数据结构//
{
uchar hour;
uchar min;
}DINGSHI_TIME;
DINGSHI_TIME dingshi_time[2];

#define NO_KEY -1 //定义一下方便使用
#define KEY_1 1
#define KEY_2 2
#define KEY_3 3

bit show_on_flag;

//#######定时器T0中断服务程序########//
Timer0() interrupt 1
{
TH0=0x3c;TL0=0xb4; //50ms
ms_50++;
if(ms_50==20) {sec++;ms_50=0;}
if(sec==60) {sec=0;min++;}
if(min==60) {min=0;hour++;}
if(hour==24) {hour=0;}
}

//#######定时器T1中断服务程序########//
Timer1() interrupt 3
{
TH1=0xd8;TL1=0xf4; //10ms
ms_10++;
if(ms_10==100)
{
miaobiao_sec++;
ms_10=0;
}
if(miaobiao_sec==60)
miaobiao_sec=0;
}

//##############数码管显示#####################//
show(uchar time_high,uchar time_low)
{
uchar m;
uint n,k;
k=time_high*1000/10+time_low;
for(m=0;m<4;m++)
{
ZIXING=zixing[k%10];
if(ms_50<10)
dp=0;
ZIWEI=~ziwei[m];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<100;n++);
k=k/10;
}
}
//显示 on 定时编号//
show_on(uchar id) //id：定时编号//
{
uchar m;
uint n;

for(m=0;m<2;m++)
{
ZIXING=zixing[id%10];
dp=0;
ZIWEI=~ziwei[m];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<80;n++);
id=id/10;
}
ZIXING=0xc8; //字母n//
ZIWEI=~ziwei[2];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<200;n++);

ZIXING=0xc0; //字母0//
ZIWEI=~ziwei[3];
for(n=0;n<500;n++);
ZIXING=0xff;
for(n=0;n<200;n++);
}

/*************启动秒表***************/
void run_miaobiao()
{
ms_10=0;
miaobiao_sec=0;
TH1=0xd8; //标准是0xd8e4
TL1=0xf4;
// TR1=1; //启动定时器1
}

/*************显示秒表***************/
void show_miaobiao()
{
show(miaobiao_sec,ms_10);
}

/*********** 检测按键动作函数 *************/
int get_key()
{
uchar d;
if(!k1)
{
for(d=0;d<50;d++);
if(!k1)
{
while(!k1);
return(KEY_1);
}
}
if(!k2)
{
for(d=0;d<50;d++);
if(!k2)
{
while(!k2);
return(KEY_2);
}
}
if(!k3)
{
for(d=0;d<50;d++);
if(!k3)
{
while(!k3);
return(KEY_3);
}
}
else return NO_KEY;
}
/*****************************************

各状态下按键处理函数

******************************************/

void key_process_clock() // 处理时钟状态下的按键和显示//
{
switch(get_key())
{
case KEY_1:
status=SET_RING1; ;//切换状态
show_on_flag=1;
show_on(1);
break;
case KEY_2:
hour++;
if(hour==24) hour=0;
show(hour,min);
break;
case KEY_3:
min++;
if(min==60) min=0;
show(hour,min);
break;
case NO_KEY: //没有按键操作//
show(hour,min);
break;
}

}

/****************设定时1或2状态下的按键处理及显示*****************/
void key_process_set_dingshi()
{
switch(get_key())
{
case KEY_1:
if(status==SET_RING1)
{
status=SET_RING2; //切换设第二段定时状态
show_on_flag=1;
show_on(2);
}
else if(status==SET_RING2)
{
status=MIAOBIAO_RUN; //切换到秒表运行状态
run_miaobiao();
show_miaobiao();
}
break;
case KEY_2:
dingshi_time[status-1].hour++;
if(dingshi_time[status-1].hour==24)
dingshi_time[status-1].hour=0;
show(dingshi_time[status-1].hour,dingshi_time[status-1].min);
show_on_flag=0;
break;
case KEY_3:
dingshi_time[status-1].min++;
if(dingshi_time[status-1].min==60)
dingshi_time[status-1].min=0;
show(dingshi_time[status-1].hour,dingshi_time[status-1].min);
show_on_flag=0;
break;
case NO_KEY: //没有按键操作//
if(show_on_flag)
show_on(status);
else
show(dingshi_time[status-1].hour,dingshi_time[status-1].min);
break;
}
}

/********秒表运行状态按键处理及显示*********/
void key_process_miaobiao_run()
{
switch(get_key())
{
case KEY_1:
TR1=0;
status=CLOCK; //回到时钟显示状态
break;

case KEY_2:
TR1=!TR1; //定时器1暂停、继续
break;

case KEY_3:
TR1=0; //秒表复位
miaobiao_sec=0;
ms_10=0;
break;

case NO_KEY: //无按键操作//
show_miaobiao();
break;
}
}

//############主程序#######################//
void main(void)
{ sound=1;
TH0=0x3c;
TL0=0xb4;
TMOD=0x11;
TR0=1;
ET0=1;

TR1=0;
ET1=1;

EA=1;
status=CLOCK;

dingshi_time[0].hour=0;
dingshi_time[0].min=0;
dingshi_time[1].hour=0;
dingshi_time[1].min=0;

while(1) //程序循环
{
switch(status)
{
case CLOCK:
key_process_clock(); // 处理时钟状态下的按键和显示//
break;

case SET_RING1:

case SET_RING2:
key_process_set_dingshi(); //处理设置定时状态下的按键和显示//
break;

case MIAOBIAO_RUN:
key_process_miaobiao_run(); //处理秒表状态下的按键和显示//
break;
}
if(
((hour==dingshi_time[0].hour) //定时响铃//
&&(min==dingshi_time[0].min)
&&(sec<5))
||
((hour==dingshi_time[1].hour) //定时响铃//
&&(min==dingshi_time[1].min)
&&(sec<5))
)
sound=0;
else sound=1;
}
}

---

沁水县15157986954： 如何利用51单片机实现一个计时器? - ？
第浩赛奇： 方法一:用定时器中断计时模式循环计时.方法二:用CPU消耗时钟周期指令计时(浪费资源).思路:用定时器中断计时,溢出时形成中断信号,标识为一个基本周期t,所定时间T/t=n为周期循环数,到时形成定时触发信号.

沁水县15157986954： 怎么用51单片机做一个时钟 - ？
第浩赛奇： 一片单片机+一个LED数码模块或LCD液晶模块+一段简单的程序=一个简单的时钟. 一片单片机+一片DS1302或其他的时基芯片+一个LED数码模块或LCD液晶模块+一段简单的程序=一个实用的时钟. 系统构成确定了以后,程序就有现成的了,可以移步到百度网页“百度一下”里搜索,资源多如牛毛.

沁水县15157986954： 用51单片机实现时钟功能程序??? - ？
第浩赛奇： #define uchar unsigned char //定义一下方便使用 #define uint unsigned int #define ulong unsigned long #include <reg52.h> //包括一个52标准内核的头文件uchar code zixing[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; uchar code ...

沁水县15157986954： 用C语言编写AT89C51单片机程序,设计一个智能数字钟. - ？
第浩赛奇： 基本要求:1.C语言程序要求是模块化设计.2.该闹钟基于AT89C51单片机及相关外围电路进行设计.3.该闹钟有6个数码管(共阳极),可分别显示时间(时、分、秒)、及定时时间(分、秒).4.该闹钟有4个按钮,S1是切换显示按键,该键按下时可分别实现切换正常走时显示、设定走时显示、设置定时时间,启动定时,回到正常状态等功能.S2是设定键,即该键按下,将分别选中需要设定的选项.S3键是加键,即按下去表示相应选项加1.S4键是减键,即按下去表示相应的选项减1.5.该闹钟可以定时时间到,LED将发出提示闪光,且持续30s.发挥要求:1.定时时间可被打断,即打断后恢复时继续计时.2.设置闹钟报警功能;3.能切换显示年月日等信息.

沁水县15157986954： 急求单片机51c编写的时钟显示程序 - ？
第浩赛奇： #include<reg51.h> #define uchar unsigned char sbit set=P1^0; sbit setsecond=P1^1; sbit setminute=P1^2; uchar temp,second,minute; void task1() {if(set==1) {delay(10); if(set==1) { while(1) {if(setsecond==1){second++; while(setsecond);}if(...

沁水县15157986954： 急求基于51单片机数字电子钟的汇编程序 - ？
第浩赛奇： #include<reg51.h>#include<absacc.h>#define uchar unsigned char#define uint unsigned int/*七段共阴管显示定义*/ uchar code dispcode[ ]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F, 0xBF,0x86,0xCB,0xCF,0xEF,0xED,0xFD,0x87,0...

沁水县15157986954： 关于单片机实现时钟功能？
第浩赛奇： 这么简单还用问?51单片机C语言程序四人抢个定时器定时中断就可以实现时钟的功能(不过这个方法时间很难做到精确的)显示部分用查表法输出你要显示的数据就行至于闹钟,那就看是不是要求从键盘上可调的了如果是,那你还要做一人键盘,对于初学这个比较难(键盘建议用中断查询方式)至于蜂鸣器最好是找一个有PWM输出的(没有也可以用定时器实现)答器

沁水县15157986954： 怎样使用51单片机的定时器? - ？
第浩赛奇： 1. 设定工作方式TMOD=..... 2. 装入初值 TH0=...TL0=....TH1=....TL1=..... 3.开启定时器中断和总中断ET0=1或ET1=1 EA=1 4.启动时器 TR0=1 TR1=1 5.写中断服务程序 其中 3和5可以没有

沁水县15157986954： 急需一个51单片机C语言编的时钟程序？
第浩赛奇： 下面的程序我写的时候把电路图弄丢了,你自己看程序可以知道电路图的 其实不同的电路图他的程序肯定不一样.你可以依据自己的电路图修改一下程序 希望可以帮到你 #include<reg52.h>unsigned char t=0;unsigned char second=0;unsigned ...

沁水县15157986954： 谁能给个c51单片机的时钟程序 - ？
第浩赛奇： 下面是在网上找的.供参考uchar code seven_seg[] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7C,0x39,0x5e,0x79,0x71};uchar keyState = 0 ; // 0表示没有操作 1 修改秒 2 修改分钟 3 修改小时 4 定闹 小时 5定闹分钟uint ledState ...