模拟时针电路

❶ 时钟电路的工作原理以及作用是什么菜鸟求解释

时钟电路的工作原理是单片机外部接上振荡器（也可以是内部振荡器）提供高频脉冲经过分频处理后，成为单片机内部时钟信号，作为片内各部件协调工作的控制信号。作用是来配合外部晶体实现振荡的电路，这样可以为单片机提供运行时钟。

以MCS一5l单片机为例随明：MCS一51单片机为l2个时钟周期执行一条指令。也就是说单片机运行一条指令，必须要用r2个时钟周期。没有这个时钟，单片机就跑不起来了，也没有办法定时和进行和时间有关的操作。

时钟电路是微型计算机的心脏，它控制着计算机的二个节奏。CPU就是通过复杂的时序电路完成不同的指令功能的。

MCS一51的时钟信号可以由两种方式产生：一种是内部方式，利用芯片内部的振荡电路，产生时钟信号：另一种为外部方式，时钟信号由外部引入。

如果没有时钟电路来产生时钟驱动单片机，单片机是无法工作的。

(1)模拟时针电路扩展阅读

在内部方式时钟电路中，必须在XTAL1和XTAL2引脚两端跨接石英晶体振荡器和两个微调电容构成振荡电路，通常C1和C2一般取30pF，晶振的频率取值在1.2MHz～12MHz之间。

对于外接时钟电路，要求XTAL1接地，XTAL2脚接外部时钟，对于外部时钟信号并无特殊要求，只要保证一定的脉冲宽度，时钟频率低于12MHz即可。

晶体振荡器的振荡信号从XTAL2端送入内部时钟电路，它将该振荡信号二分频，产生一个两相时钟信号P1和P2供单片机使用。

时钟信号的周期称为状态时间S，它是振荡周期的2倍，P1信号在每个状态的前半周期有效，在每个状态的后半周期P2信号有效。CPU就是以两相时钟P1和P2为基本节拍协调单片机各部分有效工作的。

❷ 8051单片机时钟电路

呵呵，这个不是很难的。实现时钟有两种方案：
1。 用8051的定时器实现，定时器为1S，每1S加一，满60清零，分钟加一，满60清零，小时加一。
2。用8051+时间芯片，例如DS1302，DS12887等。
我手上没有现成的例子。不过你可以参考一下郭天祥十天学会单片机和C语言编程。第10讲介绍了 第一种方案，第十一讲介绍了第二种方案。你可以参考一下，希望对你有帮助。

❸ 时钟IC指什么IC用在什么方面

时钟IC属于模拟集成电路，因为是小型芯片，可适用于显示时针或进行时间控制的场合

❹ 在模拟电路里面怎么通过数字的计时器来控制某个时间

数字的计时器是通过对标准时钟脉冲计数来计时的，在充电器电路里可以用市电的频率作为时钟脉冲基准，用运放做一个50H过零检测电路即可，简单方案只要对变压器次级低压整流就行，或者用一片555集成块做振荡器。
补充：
计数器有预置端子（管脚），可以预置计数值，开始计数时，计数器做减法计数（加法也行），计数器为零时，计数时间到，就会输出一个控制（进位）脉冲，用控制脉冲去触发下一级电路。如：市电做时钟，20MS脉冲，减法计数器，预置500D(十进制)，定时10秒。

❺ 单片机制作的电子时钟电路，无法正常工作，求教

P0口接200欧上拉电阻，作为数码管显示驱动端口

上拉要改成10K就OK了。电阻太小，根本不可能出现低电平，严重时还会烧单片机的IO口

希望可以帮到你

❻ 哪位清楚555时钟电路的原理是怎样的

555定时器原理： 555集成时基电路称为集成定时器，是一种数字、模拟混合型的中规模集成电路，其应用十分广泛。该电路使用灵活、方便，只需外接少量的阻容元件就可以构成单稳、多谐和施密特触发器，因而广泛用于信号的产生、变换、控制与检测。

❼ 电子时钟设计 要求：1.用单片机完成时钟功能，并通过LED数码管显示出来。 2.可通过键盘来修改时、分、秒。

只有程序，从程序中可以看出电路图。不过使用1602显示的，可以显示年，月，日，星期，时，分秒，同时可以修改。
#include "stc12c5a.h"
#include "intrins.h"
#define uchar unsigned char
#define uint unsigned int

sbit sda=P2^3;//;模拟I2C 数据传送位
sbit scl=P2^4;//;模拟I2C 时钟控制状态标志
sbit lcrs=P2^2;//数据/命令
sbit lcwr=P2^1;//读/写
sbit lcden=P2^0;//使能
sbit key1=P4^4;
sbit key2=P4^5;
sbit key3=P2^7;
sbit key4=P4^6;

uchar now[7];
uchar code table[]={48,49,50,51,52,53,54,55,56,57};
uchar code nl[]={"alarm clock"};
uchar code on[]={"ON "};
uchar code off[]={"OFF"};
uchar dis[16];
uchar H=19;//定义小时
uchar Mi=15;//定义分钟
uchar S=0;//定义秒
uchar Y=12;//定义年
uchar Mo=4;//定义月
uchar D=21;//定义日期
uchar W=6;//定义星期
uchar ke1,ke2,ke3,ke4;
uchar nl1h=0,nl1m=0,nl2h=0,nl2m=0;
uchar bcdto(uchar temp);

////////////////////// 延时子程序/////////////////////////////
void delayms(uint ms) //在11.0592M晶振下，单周期指令的ms级延时
{
uint i;
while(ms--)
{
for(i = 0; i < 850; i++);
}
}

void delay()//5us延时
{
_nop_(); _nop_(); _nop_();_nop_();_nop_();_nop_();
_nop_();_nop_();
}

//////1062/////////
void ydelay(uchar x)
{
uint a,b;
for(a=x;a>0;a--)
for(b=10;b>0;b--);
}
void write_com(uchar com)
{
P0=com;
delay();
lcwr=0;
delay();
lcrs=0;
delay();
lcden=0;
ydelay(40);
lcden=1;
ydelay(40);
lcden=0;
delay();
lcwr=1;
}

void write_date(uchar date)
{
P0=date;
delay();
lcwr=0;
delay();
lcrs=1;
delay();
lcden=0;
ydelay(40);
lcden=1;
ydelay(40);
lcden=0;
delay();
lcwr=1;
}

void init1602()
{
write_com(0x38);//设置显示模式
ydelay(40);
write_com(0x0c);//开显示
ydelay(40);
write_com(0x06);//指针和光标自动加一
ydelay(40);
write_com(0x01);//清屏指令
ydelay(40);
}

void display(uchar a)//显示
{
uint i,j;
if(ke2==0)
{
j=W;
if(j==7)
j=8;
dis[0]='2';dis[1]='0';dis[2]=table[Y/10];dis[3]=table[Y%10];
dis[4]='.';dis[5]=table[Mo/10];dis[6]=table[Mo%10];
dis[7]='.';dis[8]=table[D/10];dis[9]=table[D%10];dis[10]=' ';
dis[11]='W';dis[12]='e';dis[13]='e';dis[14]=' ';
dis[15]=table[j];
if(a==3)
{dis[2]=' ';dis[3]=' ';}
else if(a==4)
{dis[5]=' ';dis[6]=' ';}
else if(a==5)
{dis[8]=' ';dis[9]=' ';}
else if(a==6)
{dis[15]=' ';}

write_com(0xc0);
for(i=0;i<16;i++)
write_date(dis[i]);

dis[0]=table[H/10];dis[1]=table[H%10];dis[2]=':';
dis[3]=table[Mi/10]; dis[4]=table[Mi%10];dis[5]=':';
dis[6]=table[S/10];dis[7]=table[S%10];dis[8]=' ';

if(a==1)
{
dis[0]=' ';dis[1]=' ';
}
else if(a==2)
{
dis[3]=' ';dis[4]=' ';
}
write_com(0x84);
for(i=0;i<9;i++)
write_date(dis[i]);
}
else
{
write_com(0x80);
for(i=0;i<11;i++)
write_date(nl[i]);

if((ke2==1)||(ke2==2))
dis[0]=table[1];
else if((ke2==3)||(ke2==4))
dis[0]=table[2];
write_com(0x8c);
write_date(dis[0]);

if((ke2==1)||(ke2==2))
{
dis[0]=table[nl1h/10];dis[1]=table[nl1h%10];dis[2]=':';
dis[3]=table[nl1m/10];dis[4]=table[nl1m%10];
if(ke3==0)
{
write_com(0xcb);
for(i=0;i<3;i++)
write_date(off[i]);
}
else if(ke3==1)
{
write_com(0xcb);
for(i=0;i<3;i++)
write_date(on[i]);
}
}

else if((ke2==3)||(ke2==4))
{
dis[0]=table[nl2h/10];dis[1]=table[nl2h%10];dis[2]=':';
dis[3]=table[nl2m/10];dis[4]=table[nl2m%10];
if(ke4==0)
{
write_com(0xcb);
for(i=0;i<3;i++)
write_date(off[i]);
}
else if(ke4==1)
{
write_com(0xcb);
for(i=0;i<3;i++)
write_date(on[i]);
}
}

if(a==1)
{dis[0]=' ';dis[1]=' ';}
else if(a==2)
{dis[3]=' ';dis[4]=' ';}
write_com(0xc4);
for(i=0;i<5;i++)
write_date(dis[i]);
}
}

///////////IIC//////////////////
void init() //初始化
{
sda=1;
delay();
scl=1;
delay();
}

void start() //开始信号
{
sda=1;
delay();
scl=1;
delay();
sda=0;
delay();
}

void stop() //停止
{
sda=0;
delay();
scl=1;
delay();
sda=1;
delay();
}

void respons() //应答
{
uchar i;
scl=1;
delay();
while((sda==1)&&(i<250))i++;
scl=0;
delay();
}

void write_byte(uchar date) // 写数据子函数
{
uchar i,temp;
temp=date;
for(i=0;i<8;i++)
{
temp=temp<<1;
scl=0;
delay();
sda=CY;
delay();
scl=1;
delay();
}
scl=0;
delay();
sda=1;
delay();
}

uchar read_byte() // 读数据子函数
{
uchar i,k;
scl=0;
delay();
sda=1;
delay();
for(i=0;i<8;i++)
{
scl=1;
delay();
k=(k<<1)|sda;
scl=0;
delay();
}
return k;
}

void write(uchar address,uchar date,uchar add) // 写数据函数
{
start();
write_byte(add);
respons();
write_byte(address);
respons();
write_byte(date);
respons();
stop();
}

uchar read(uchar address,uchar addw,uchar addr) //读数据函数
{
uchar date;
start();
write_byte(addw);
respons();
write_byte(address);
respons();
start();
write_byte(addr);
respons();
date=read_byte();
stop();
return date;
}

uchar Decimal_to_BCD(uchar temp)//十进制转换成BCD码
{
uchar a,b,c;
a=temp;
b=0;
if(a>=10)
{
while(a>=10)
{
a=a-10;
b=b+16;
c=a+b;
temp=c;
}
}
return temp;
}
uchar BCD_to_Decimal(uchar temp)//BCD码转换成十进制
{
uchar a,b,c;
a=temp;
b=0;
if(a>=16)
{
while(a>=16)
{
a=a-16;
b=b+10;
c=a+b;
temp=c;
}
}
return temp;
}
void keyf(uchar *num,uchar up,uchar )
{
uint z;
if(key2==0)
{
delayms(10);
if(key2==0)
{
if(*num>=up)
{
if((ke1==4)||(ke1==5)||(ke1==6))
*num=1;
else
*num=0;
}
else
*num=*num+1;
for(z=0;z<50;z++)
{
display(0);
if(key2!=0)
break;
}
while(!key2)
{
for(z=0;z<25;z++)
{display(0);}
if(*num>=up)
{
if((ke1==4)||(ke1==5)||(ke1==6))
*num=1;
else
*num=0;
}
else
*num=*num+1;
}

}
}
if(key3==0)
{
delayms(10);
if(key3==0)
{
if(*num==)
{
if((ke1==1)||(ke2==1)||(ke2==3))
*num=23;
else if((ke1==2)||(ke2==2)||(ke2==4))
*num=59;
else if(ke1==3)
*num=99;
else if(ke1==4)
*num=12;
else if(ke1==5)
*num=31;
else if(ke1==6)
*num=7;
}
else
*num=*num-1;
for(z=0;z<50;z++)
{
display(0);
if(key3!=0)
break;
}
while(!key3)
{
for(z=0;z<25;z++)
display(0);
if(*num==)
{
if((ke1==1)||(ke2==1)||(ke2==3))
*num=23;
else if((ke1==2)||(ke2==2)||(ke2==4))
*num=59;
else if(ke1==3)
*num=99;
else if(ke1==4)
*num=12;
else if(ke1==5)
*num=31;
else if(ke1==6)
*num=7;
}
else
*num=*num-1;
}
}
}
}

void keyjc()
{
uint i,j;
if(key1==0)
{
for(i=0;i<30;i++)
display(0);
if(key1==0)
ke1++;
if(ke1>=7)
{
ke1=0;
display(0);
}
while(!key1);
if(ke1==1)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(1);
if((key2==0)||(key3==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&H,23,0);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
ke1=2;
while(!key1);
break;
}
}
}
}
if(ke1==2)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(2);
if((key2==0)||(key3==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&Mi,59,0);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
ke1=3;
while(!key1);
break;
}

}
}
}
if(ke1==3)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(3);
if((key2==0)||(key3==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&Y,99,0);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
ke1=4;
while(!key1);
break;
}

}
}
}
if(ke1==4)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(4);
if((key2==0)||(key3==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&Mo,12,1);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
ke1=5;
while(!key1);
break;
}

}
}
}
if(ke1==5)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(5);
if((key2==0)||(key3==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&D,31,1);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
ke1=6;
while(!key1);
break;
}

}
}
}
if(ke1==6)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(6);
if((key2==0)||(key3==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&W,7,1);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
ke1=0;
while(!key1);
break;
}

}
}
}
Mi=Decimal_to_BCD(Mi);
write(0x01,Mi,0xd0);//写入分
H=Decimal_to_BCD(H);
write(0x02,H,0xd0);//写入时
W=Decimal_to_BCD(W);
write(0x03,W,0xd0);//写入星期
D=Decimal_to_BCD(D);
write(0x04,D,0xd0);//写入日期
Mo=Decimal_to_BCD(Mo);
write(0x05,Mo,0xd0);//写入月
Y=Decimal_to_BCD(Y);
write(0x06,Y,0xd0);//写入年
S=Decimal_to_BCD(S);
write(0x00,S,0xd0);//写入秒
ke1=0;
}
if(key4==0)
{
for(i=0;i<30;i++)
display(0);
if(key4==0)

ke2++;
if(ke2>=5)
ke2=0;
while(!key4);
write_com(0x01);
}
if(ke2==1)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(1);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&nl1h,23,0);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
if(ke3==0)
ke3=1;
else
ke3=0;
while(!key1);
}
}
if(key4==0)
{
delayms(10);
if(key4==0)
{
ke2=2;
while(!key4);
break;
}
}
}
write_com(0x01);
}
if(ke2==2)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(2);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&nl1m,59,0);
}
}

if(key1==0)
{
delayms(10);
if(key1==0)
{
if(ke3==0)
ke3=1;
else
ke3=0;
while(!key1);
}
}
if(key4==0)
{
delayms(10);
if(key4==0)
{
ke2=3;
while(!key4);
break;
}
}
}
write_com(0x01);
}
if(ke2==3)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(1);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&nl2h,23,0);
}
}

if(key1==0)
{
delayms(10);
if(key1==0)
{
if(ke4==0)
ke4=1;
else
ke4=0;
while(!key1);
}
}
if(key4==0)
{
delayms(10);
if(key4==0)
{
ke2=4;
while(!key4);
break;
}
}
}
write_com(0x01);
}
if(ke2==4)
{
for(i=0;i<25;i++)
{
for(j=0;j<20;j++)
{
display(2);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
for(j=0;j<20;j++)
{
display(0);
if((key2==0)||(key3==0)||(key4==0)||(key1==0))
break;
}
if((key2==0)||(key3==0))
{
delayms(10);
if((key2==0)||(key3==0))
{
i=0;
keyf(&nl2m,59,0);
}
}
if(key1==0)
{
delayms(10);
if(key1==0)
{
if(ke4==0)
ke4=1;
else
ke4=0;
while(!key1);
}
}

if(key4==0)
{
delayms(10);
if(key4==0)
{
ke2=0;
while(!key4);
break;
}
}
}
write(0x00,nl1h,0xa0);
delayms(10);
write(0x01,nl1m,0xa0);
delayms(10);
write(0x02,nl2h,0xa0);
delayms(10);
write(0x03,nl2m,0xa0);
delayms(10);
write(0x04,ke3,0xa0);
delayms(10);
write(0x05,ke4,0xa0);
write_com(0x01);
}
}
void nz()
{
if(ke3==1)
{
if(nl1h==H)
{
if(nl1m==Mi)
key1=1;
else;
}
}
if(ke4==1)
{
if(nl2h==H)
{
if(nl2m==Mi)
key1=1;
else;
}
}
}

void main()
{
P4SW=0x70;
init1602();
init();
write(0x07,0x10,0xd0);
delayms(11);
nl1h=read(0x00,0xa0,0xa1);
delayms(11);
nl1m=read(0x01,0xa0,0xa1);
delayms(11);
nl2h=read(0x02,0xa0,0xa1);
delayms(11);
nl2m=read(0x03,0xa0,0xa1);
delayms(11);
ke3=read(0x04,0xa0,0xa1);
delayms(11);
ke4=read(0x05,0xa0,0xa1);
while(1)
{
S=read(0x00,0xd0,0xd1);
S=BCD_to_Decimal(S); //BCD码转换成十进制
Mi=read(0x01,0xd0,0xd1);
Mi=BCD_to_Decimal(Mi); //BCD码转换成十进制
H=read(0x02,0xd0,0xd1);
H=BCD_to_Decimal(H); //BCD码转换成十进制
W=read(0x03,0xd0,0xd1); //星期为：1~7 不需要进制的转换
W=BCD_to_Decimal(W);
D=read(0x04,0xd0,0xd1);
D=BCD_to_Decimal(D); //BCD码转换成十进制
Mo=read(0x05,0xd0,0xd1);
Mo=BCD_to_Decimal(Mo); //BCD码转换成十进制
Y=read(0x06,0xd0,0xd1);
Y=BCD_to_Decimal(Y); //BCD码转换成十进制
display(0); //显示
keyjc();
nz();
delayms(10);
}
}

❽ 谁能帮我解决一下，Proteus的模拟钟的电路中：74LS160的各引脚功能，和与非门和非门的作用，谢谢

74LS160的各引脚功能可看书后的的路图，与非门1、1为0。1、0为1。0、1为1,。0、0为1.
非门的作用1为0.。0为1·。

❾ 急需一个电子时钟的程序， 哪位高手请帮帮忙！！！,

一功能模、设计指标：
1. 显示时、分、秒。
2. 可以24小时制或12小时制。
3. 具有校时功能，可以对小时和分单独校时，对分校时的时候，停止分向小时进位。校时时钟源可以手动输入或借用电路中的时钟。
4. 具有正点报时功能，正点前10秒开始，蜂鸣器1秒响1秒停地响5次。
5. 为了保证计时准确、稳定，由晶体振荡器提供标准时间的基准信号。
二、设计要求：
1. 画出总体设计框图，以说明数字钟由哪些相对独立的块组成，标出各个模块之间互相联系，时钟信号传输路径、方向和频率变化。并以文字对原理作辅助说明。
2. 设计各个功能模块的电路图，加上原理说明。
3. 选择合适的元器件，在面包上接线验证、调试各个功能模块的电路，在接线验证时设计、选择合适的输入信号和输出方式，在充分电路正确性同时，输入信号和输出方式要便于电路的测试和故障排除。
4. 在验证各个功能模块基础上，对整个电路的元器件和布线，进行合理布局，进行整个数字钟电路的接线调试。

三、制作要求：
自行装配、接线和调试，并能检查和发现问题，根据原理、现象和测量的数据分析问题所在，加以解决。学生要解决的问题包括元器件和面包板故障引起的问题。
四、设计报告内容要求：
1. 目的。
2. 设计指标。
3. 画出设计的原理框图，并要求说明该框图的工作过程及每个模块的功能。
4. 元器件清单。
5. 设计制作的进程，考虑时钟及控制信号的关系、测试、验证的顺序，写出自己的工作进程。
6. 画出各功能模块的电路图，加上原理说明（如2、5进制到10进制转换，10进制到6进制转换的原理，个位到十位的进位信号选择和变换等）。
7. 画出总布局接线图（集成块按实际布局位置画，关键的连接单独应画出，计数器到译码器的数据线、译码器到数码管的数据线可以简化画法，但集成块的引脚须按实际位置画，并注明名称。）
8. 描述设计制作的数字钟的运行结果和操作。
9. 总结。
  设计过程中遇到的问题及解决办法
  课程设计过程体会
对课程设计内容、方式、要求等各方面的建议。

五、实验仪器、工具：
1. 5V电源（或实验箱）4个人合用1个。
2. 四连面包板1块。
3. 示波器2个（每班）
4. 万用表5个（每班）。
5. 镊子1把。
6. 剪刀1把。

六、实验器件

1. 网络线2米/人。
2. 共阴八段数码管6个。
3. CD4511集成块6块。
4. CD4060集成块1块。
5. 74HC390集成块3块。
6. 74HC51集成块1块。
7. 74HC00集成块4块。
8. 74HC30集成块1块。
9. 10MΩ电阻5个。
10. 500Ω电阻14个。
11. 30p电容2个。
12. 32.768k时钟晶体1个。
13. 蜂鸣器10个（每班）

七、设计过程的日程安排

6月28日
1. 分发仪器、工具、器件
2. 讲解总体设计的过程，明确数字钟实现的功能，由哪些相对独立的功能模块组成，各个模块之间互相联系，时钟信号传输路径、方向和频率变化。
3. 讲解面包板的结构和使用方法，连接导线的要点，包括导线剥线头、插线方法、要求，检查面包板，如面包板中的导电铜片变形或移位，更换导电铜片。
4. 七段数码引脚排列测试，验证每段显示为一个发光二极管，同时完成对每个数码管的检查。
6月29日～7月2日
分功能讲解各个模块功能实现原理、实现，搭建实际电路一个个验证。在接线时注意合理布线和接线的可靠性。

6月29日

a) 数码管的译码驱动电路接线、测试、译码器控制功能测试（手工输入测试电平）。
除了进一步熟悉原理外，主要练习接线合理布局，走线整齐、美观，用手指触动导线时也能正常工作。可以静态显示学号的后几位。然选一个可正常工作的译码、显示电路，分别测试译码器的3个控制引脚的作用。

6月30日
b) 晶体震荡电路接线、测试（用示波器测量4060输入时钟，每一路分频输出的频率）。
c) 5进制计数器接线，输入用4060的2Hz，输出用数码管显示。

7月1日
d) 10进制计数器接线、测试。
e) 6进制计数器接线、测试（在10进制基础上改）。

7月2日
f) 60进制计数器接线、测试。
g) 24进制计数器、测试（在60进制基础上改）。
h) 校时电路接线（用RS触发器实现锁定、防抖动功能），用示波器观察电路的信号选择功能。

7月5～7日
5. 在熟悉各个功能模块基础上，结合对总体框图的理解，设计总接线图。
6. 根据总接线图中各种元器件数量、连线，确定所有元器件布局。
7. 按以下顺序接线：晶体震荡、秒电路、分电路、时电路。
8. 如时间允许加接校时电路和报时电路（整点报时）。

7月8～9日

9. 写课程设计报告。
a) 设计的目的、要求。
b) 总体框图设计。
c) 功能模块设计（对所用元器件使用作一些说明）。
d) 总电路图设计。
e) 总结：遇到的问题和解决办法、体会、意见、建议等。

八、Multisim2001软件部分集成块引脚图
集成块引脚图
九、部分原理仿真模块电路

4511构成译码驱动电路

4060构成脉冲发生及分频电路

74390 构成十进制计数器

74390构成六进制计数器

74390构成六十进制计数器

校时电路（分校时时，不会进位到小时）
十、数字钟的设计与制作原理
具体参照：
数字电子技术课程设计讲义－数字钟的设计与制作
（电子信息学院，2004年6月）
十一、Multisim2001软件及其参考仿真电路
自己在对应位置下载。

十二、设计经验总结：
1. 要求学生根据原理和芯片引脚图，分功能设计原理图，并根据接线顺序分步骤验证。
2. 容易出现故障为接触不良。
a) 集成块引脚方向预先弯好对准面包板的金属孔，再小心插入。
b) 导线的剥线长度与面包板的厚度相适应（比板的厚度稍短）。
c) 导线的裸线部分不要露在板的上面，以防短路。
d) d) 导线要插入金属孔中央。
3. 按照原理图接线时首先确保可靠的电源和接地。
4. 注意芯片的控制引脚必须正确接好。
5. 检查故障时除测试输入、输出信号外，要注意电源、接地和控制引脚。
6. 要注意芯片引脚上的信号与面包板上插座上信号是否一致（集成块引脚与面包板常接触不良）。
7. 为了便于测试，可将2Hz信号直接输入到各级计数器。
8. 接校时电路时可接模拟信号输入（如1Hz和2Hz）测试输出信号的切换正确后，再将秒进位和分进位信号接到校时电路，再接校时电路输出到分计数器和时计数器。
从较时电路接入信号时，必须将原进位信号拔掉。