精华内容
下载资源
问答
  • 详细的电路图,还有完整的报告,以及调试好的程序,供你学习和练习。
  • 大学电子电路实验,数字时钟设计报告,本实验要求设计一个数字计时器,可以完成0分00秒~9分59秒的计时功能,并在控制电路的作用下有开机清零、快速校分、整点报时功能
  • 基于C51单片机的多功能电子时钟设计(完美实现版)
  • 多功能数字时钟设计报告 用555定时器 160计时器 仿真图这是我的课程设计报告。可作为参考 含有Multisim仿真图。不过是复制到Word文档里去拉
  • 多功能数字时钟课程设计报告,设计目的: 熟悉数字逻辑设计的基本概念和原理。 掌握计数器、定时器等逻辑芯片的工作原理及应用设计。 熟悉数字逻辑集成芯片的外围电路设计与使用。 设计任务及要求: 设计一个数字电子...
  • 基于DS12887和DS18B20的多功能电子时钟设计,赵春见,张亚鹏,本文介绍了一个基于DS12887和DS18B20的多功能电子时钟设计,采用STC89C52RC作为核心控制芯片,通过液晶1602A实时显示温度和时间。可通过调�
  • C语言 万年历 温控 单片机
  • cpld 多功能 数字 时钟 电子大赛
  • 基于PROTEUS的 多功能数字电子钟设计报告
  • 多功能数字时钟 数字电子技术课程设计 里面包括3个文档和maxplus2仿真文件,非常详细
  • 多功能电子时钟protues仿真图 (1)设计一个具有"星期"“时”、“分”、“秒”的十进制数字显示(小时为24进制)的计 数器。 (2)具有动手校时、校分的功能。 (3)整点能提供自动报时信号,报时声响为四低一高,最后一响...
  • 能进行整点报时并有闹钟功能,闹钟时间可以设置个; 系统关机后时间能继续运行,下次开机时间应准确; 查阅资料,学习STM32F4内部温度传感器的配置,采集、计算片内温度并显示在LCD上; 其他功能,自由发挥扩展。
  • 单片机多功能电子钟设计程序C语言,具有时间显示、闰年识别、闹钟等功能
  • STM32开发板的多功能电子钟设计
  • 电子时钟课程设计报告

    万次阅读 多人点赞 2016-12-20 21:03:22
    数字电路课程设计报告题目:数字电子钟的设计 姓 名: 乔蒙蒙 专 业: 物联网工程 班 级: 中兴物联网一班 学 号: 1506955060 第1章,课程任务设计及要求…………………………………………………3 第2章,

    数字电路课程设计报告

    题目:数字电子钟的设计

             姓    名:   xxx            
             专    业:   物联网工程         
             班    级:   xxx     
             学    号:   xxx        
    

    第1章,课程任务设计及要求…………………………………………………3
    第2章,系统设计 ……………………………………………………………………..3
    2.1方案设计与选择……………………………………………………………..3
    2.2系统设计………………………………………………………………………………….4
    2.2.1数字计时器的设计思想……………………………………………………………4
    2.2.2数字电子时钟总体框架图………………………………………………………..4
    2.3单元电路的设计……………………………………………………………………..5
    2.3.1单元电路的工作原理…………………………………………………………………..5
    2.3.2元件参数的选择………………………………………………………………………….7
    第3章,软件仿真……………………………………………………………………….10
    3.1仿真电路图…………………………………………………………………….10
    3.2仿真过程………………………………………………………………………..11
    3.3仿真结果…………………………………………………………………………………….11
    第4章,故障分析………………………………………………………………………..12
    第5章,结论…………………………………………………………………………………13
    第6章,使用仪器设备清单………………………………………………………13
    主要参考文献………………………………………………………………………………………13
    收获,体会,建议……………………………………….13

    第1章,课程任务设计及要求
    数字电子钟是一种用数字电路技术实现时、分、秒计时的装置,与机械式时钟相比具有更高的准确性和直观性,且无机械装置,具有更更长的使用寿命,因此得到了广泛的使用。数字钟从原理上讲是一种典型的数字电路,其中包括了组合逻辑电路和时序电路。目前,数字钟的功能越来越强,并且有多种专门的大规模集成电路可供选择。本设计采用 74LS160、带有译码器的数码管和适当的门电路构成,可实现对时、分、秒等时间信息的采集和较时功能地实现。
    数字时钟从原理上面来说的话,它是一种典型的数字电路,其中包括了组合逻辑电路和时序逻辑电路
    我们这次设计是为了了解数字时钟的原理,从而学会制作数字电子时钟,再者,我们通过数字时钟的制作进一步的了解各种在制作中能用到的中小规模集成电路的作用及使用方法。
    设计一个数字计时器,可以完成 00:00:00 到 23:59:59 的计时功能,并在控制电路的作用下具有快速校时、快速校分功能。 能进行正常的时分秒计时功能。分另由六个数码管实现时分秒的计时。同时实现报时的功能。
    第2章,系统设计
    2.1方案设计与选择
    方案一:
    脉冲信号源的选择。
    (1)555多谐振荡器产生1khz,用这个做信号发生器,比较稳定。为了得到秒脉冲信号,将分频比设置为1000,正好选用三个十进制计数器(三片74LS160)。
    (2)石英晶体振荡器产生32768hz,而后进行分频即可得到单脉冲信号。
    以上两个得到单脉冲的信号的方法都可以。
    (3)利用数电课本496页和497页可以知道,用CB555定时器设计一个可以产生单脉冲的多谐振荡器,即相当于以上两个方法的脉冲源加上分频的过程,而且比以上两个方法更加的方便,快捷。
    方案二:
    时分秒计数器的选择。
    时分秒计数器的选择是有很多种的74LS160N和74LS160D都是不错的选择,当然了,74LS190和74LS191也是可以的,但是考虑到简单易用加上,课本上面终点内容,而且大多数参考书上面都是用的74LS160,因此本次设计我也采用74LS160作为时分秒计数器。
    方案三:
    译码显示器的选择。因为我看的参考书上面用的就是七段共阴极译码器,于是我就选择了这个,所以对于译码器的别的一些种类没有过多的了解和认识。
    2.2系统设计
    2.2.1数字计时器的设计思想
    可以知道的是数字电子时钟由秒脉冲产生电路,计数电路,校时校分电路还有整点报时电路(不过遗憾的是这个我没有做出来)几个电路构成的。其中秒脉冲是由改装过的CB555定时器,之后,秒信号进入计数器进行计数,把累加的结果以时分秒的数字显示出来,时显示由二十四进制计数器,译码器和显示器构成,分秒显示分别由六十进制计数器,译码器和显示器构成。课进行整点报时,计时出现误差时,可以用校时校分电路
    2.2.2数字电子时钟总体框架图

    2.3单元电路的设计
    2.3.1单元电路工作原理
    1,时功能24进制电路,如下图所示;

    图1,二十四进制计数器

    说明:这个是小时功能的,是二十四进制的,因此可以在十位等于2(QAQBQCQD=0100)个位等于4(QAQBQCQD=0010)的时候进行清零(注意是与非门那一条线同时连接两个芯片的复位端,就是清零端CLR),从而实现24进制,个位的进位输出端接十位的CLK端,从而使小时的个位在进位的时候十位的那个芯片才开始实现计数功能。
    2,秒分功能60进制计数器,如下图所示:

    图2,六十进制计数器
    说明:这个是秒分功能的计数器,跟以上的很一样,只是只需要在十位等于6(QAQBQCQD=0110)的时候,进行清零,同样的个位的进位输出端接十位的CLK端。74LS160构成的60进制计数器和24进制计数器如图1和图2所示。
    小时,分钟,秒钟分别采用60,24,24进制计数器。其中秒钟,分钟的个位是10进制,十位是6进制,共同组成60进制的计数器,和小时计数器一样的是使用的是复位清零。
    3,秒脉冲产生电路

                        图3,秒脉冲产生电路
    

    将电路向导中的555多谐振荡器的R1,R2的电阻值改为48千欧姆C,C2的值也改为10和0.01uF,也就是说可以得到单脉冲,就是1hz的信号。
    2.3.2元件参数的选择
    1,电阻 48千欧,48千欧

    2,电容 10uF 0.01uF

    3,与门

    4,数码管(七段共阴极数码管)

    5,74LS160管脚功能

    6,74LS48功能图

    74LS48除了有实现7段显示译码器基本功能的输入(DCBA)和输出(Ya~Yg)端外,7448还引入了灯测试输入端(LT)和动态灭零输入端(RBI),以及既有输入功能又有输出功能的消隐输入/动态灭零输出(BI/RBO)端。
    由7448真值表可获知7448所具有的逻辑功能:
    (1)7段译码功能(LT=1,RBI=1)
    在灯测试输入端(LT)和动态灭零输入端(RBI)都接无效电平时,输入DCBA经7448译码,输出高电平有效的7段字符显示器的驱动信号,显示相应字符。除DCBA = 0000外,RBI也可以接低电平,见表1中1~16行。
    (2)消隐功能(BI=0)
    此时BI/RBO端作为输入端,该端输入低电平信号时,表1倒数第3行,无论LT 和RBI输入什么电平信号,不管输入DCBA为什么状态,输出全为“0”,7段显示器熄灭。该功能主要用于多显示器的动态显示。
    (3)灯测试功能(LT = 0)
    此时BI/RBO端作为输出端, 端输入低电平信号时,表1最后一行,与 及DCBA输入无关,输出全为“1”,显示器7个字段都点亮。该功能用于7段显示器测试,判别是否有损坏的字段。
    (4)动态灭零功能(LT=1,RBI=1)
    此时BI/RBO端也作为输出端,LT 端输入高电平信号,RBI 端输入低电平信号,若此时DCBA = 0000,表1倒数第2行,输出全为“0”,显示器熄灭,不显示这个零。DCBA≠0,则对显示无影响。该功能主要用于多个7段显示器同时显示时熄灭高位的零。
    第三章,软件仿真
    3.1仿真电路图

                             图11数字电子时钟仿真图
    

    3.2仿真过程
    电路的连接是我们这次课程设计的主要任务之一,也是整个过程的最难阶段。仿真的这部分工作室在multisim仿真软件上进行,对于电路的仿真分为几个部分,分别对电路各个部分的功能都进行仿真调试后,每连接一次都要进行一次调试,才会保证最后的成功。
    说实话,以前对于multisim仿真软件根本就没什么了解,对于它的基本操作一开始也是一头蒙的感觉,不过通过不断地探索和观察,了解的大多数器件的放置位置以及仿真的方法,整个过程进行的特别慢,但是确学到了很多,也感受到了这个仿真软件的神奇之处,有种现实的既视感。
    基本过程:
    1,按照电路原理图将仿真分为几部分依次连接电路并调试;
    2,对于555多谐振荡器进行电阻阻值改变以及电容阻值改变从而使之成为能够产生1hz的信号;
    3,连接60,20,进制的计数器电路并调试,观察是否符合要求;
    4,讲单脉冲信号连接到计数器电路,观察时钟是否正常运行
    3.3仿真结果
    电路成功实现了24小时进制,60分钟,60秒钟进制的电子时钟的功能,可以精确计时,每60秒进一分并清零秒计数器,每60分进一小时并清零分钟计数器,每24个小时清零所有计数器并重新开始计时。仿真结果如图12.

                            图12仿真结果
    

    第四章,故障分析
    如果没有能实现预想的功能,就要一个一个部分的去检查,若哪一功能不能实现,再根据故障分析和排除的方法,找出故障,并加以改进。还有一点是,这次的连线当中发现一个问题就是,会出现仿真错误,在我把所有连线练完了以后,出现了仿真错误,之后呢,我是找了特别的长久,然后我就询问一个班的跟我用一个芯片的人的连线方法,发现还是找不到,甚至跟她改成一样的也不行,最后我百度了一下,然后再数码管和译码器的每个管脚之间加了一个200的电阻,然后就可以了,只是别人的都没有加,经过百度发现是我用的数码管的电压是2V左右的,而电路的电压是5V的,终于知道电阻在那里起的什么作用了。可以知道的是,排除故障,调试并不是一件容易的事情,需要准确找到故障处,否则只能乱碰,却达不到效果,只能是白白浪费时间,经过多次实践,我觉得缩小范围的方法很好用,可以减去很大的工作量,很大程度上,提高了工作效率。
    第五章,结论
    经过一周多的课程设计,我完成了这次的课程设计,尽管过程很艰辛,但是现在还是实现了预想的功能。首先,我觉得最重要的一点是一定要好好学习学习自己的课本真的是很重要,这次的课程设计发型还都是课本上面的内容,上课结束后几乎不看课本的我,这次浪费了很长的时间,在这次课程设计上面特别吃力,我想,如果好好看课本的话,设计起来必定省去很多时间还有精力。总之,学到了特别多,这个是一次全新的体验,特别有意义。
    第六章,使用仪器设备清单
    七段共阴极数码管 6个
    74LS160D芯片 6个
    74LS48D芯片 6个
    555定时器 1个
    5V电源 1个
    74LS00D与非门 3个
    74LS02N 或非门 2个
    74LS04N 非门 2个
    开关 5个
    电阻 若干
    导线 若干
    电容 2个

     参考文献
    

    1,阎石,电子技术基础,北京,高等教育出版社2006
    2,李亚伯,数字电路与系统。电子工业出版社,1998
    3,郭锁利,刘延飞编著,基于Multisim的电子系统设计,仿真与综合应用,人民邮电出版社
    收获,体会和建议
    说实话,整个过程花了我很长的时间,从分析到设计,到调试,到成功,可能说着也就没有多少个字,一开始的时候觉得特别难,觉得自己根本就是无法完成的,但是当自己做完的时候发现,事情并没有自己想象的那么难。在实际的操作中,还要将课堂上学习的知识与这个课程设计结合起来。通过这次的课程设计,我确实学到了很多,跟以往的学习理论知识完全不是一个概念的感觉,这个课程设计追求的是不能有一点点小小的错误,要求你特别的细心,特别的有耐心还要对于设计所要用到的芯片的管脚功能有很深刻的了解,各方面吧,总之,这个课程设计也教会了我仿真软件的使用,同时呢,也了解了不少器件的功能也加深了对数电的理解。
    不过我想说的是我在设计电路之前遇到的两个问题。第一个其实严格来说不算是什么大问题吧,本身的话,用555多谐振荡器产生1000HZ的脉冲信号,然后经过三个十进制计数器(74LS160)连在一块,可以实现千分频的功能,那么这样的话,就可以给计数器提供稳定的1HZ的脉冲信号,但是呢,在连线过程中,总觉得不用这么麻烦,毕竟就只是一个1HZ的信号而已。后来看到数电书上面478页上面有个例子,讲的是CB555定时器改装过可以产生稳定的1HZ的单脉冲信号,而且可以不用那么麻烦了。第二个就是24进制计数器,其实这个不是什么难的问题只是上课听得不认真以至于在设计的时候特别费事,在24进制计数器上面花了很久的时间,才知道原来是可以有两种方法的,一种是在用复位端(清零端)置零,还有一种是置数端置零。彻底理解了任意进制计数器。
    任何事情都是一步一步来的,希望从这次课程设计中我可以冷静分析,慢慢纠错,不慌不忙地做好任何一件事情。

    展开全文
  • 能进行整点报时并有闹钟功能,闹钟时间可以设置个; 系统关机后时间能继续运行,下次开机时间应准确; 查阅资料,学习STM32F4内部温度传感器的配置,采集、计算片内温度并显示在LCD上; 其他功能,自由发挥扩展。
  • 1、采用STC15F2K60S2单片机作为主控芯片,12864液晶模块作为显示界面,显示出电子时钟的所有功能参数; 2、使用DS1302时钟芯片准确显示出年月日时分秒星期,并添加备用电池,防止时钟芯片掉电时停止工作;可实现...

    1、采用STC15F2K60S2单片机作为主控芯片,12864液晶模块作为显示界面,显示出电子时钟的所有功能参数;

    2、使用DS1302时钟芯片准确显示出年月日时分秒星期,并添加备用电池,防止时钟芯片掉电时停止工作;可实现年月日时分秒星期的按键调整,闹钟时间的设定以及闹钟的开关,按键可实现连加、连减功能;

    3、人体热感应功能采用HC-SR501模块检测人体的移动,当人移动时液晶屏亮,否液晶屏延时20s后熄灭,延时时间可以通过程序修改;

    4、采用DS18B20采集温度数据,DHT11采集湿度数据,光敏电阻感应光线变化,PWM调节LCD背光亮度,SYN6288语音合成模块进行整点报时;

    【资源下载】下载地址如下(928):https://docs.qq.com/doc/DTlRSd01BZXNpRUxl

    #include "config.h"
    #include "DS1302.h"
    #include "DS18B20.h"
    #include "Lcd12864.h"
    #include "Time.h"
    #include "key.h"
    #include "Fonts.h"
    #include "DHT11.h"
    #include "SYN6288.h"
    #include "main.h"
    #include "SoundPlay.h"
    #include "UART.h"
    #include "ADC.h"
    #include "PWM.h"
    
    bit flag200ms = 0;
    bit flag1s = 0;
    bit flag2s = 0;
    bit flag4s = 0;
    bit FlagNormal = 1;
    bit flagSR = 1;
    
    void Timer0Init(void);
    void LcdAuto();
    void RefreshTemp();
    void Delay2000ms();		//@11.0592MHz
    void logoflag();
    
    void main()
    {	
    	uint8 cnt = 0;
    	
    	InitADC();
    	IE |= 0x20;   //使能ADC中断
    	
    	PWM_Init();
    	
    	UartIni();
    	
    	InitLcd12864();
    	Start18B20();
    	
    	SYN_FrameInfo(0,"欢迎使用多功能时钟");
    	LcdShowImage(0,16,128,32, hhstu); //黄河科技学院
    	Delay2000ms();
    	LcdClearArea(0,0,128,64);  //液晶清屏	
    	
    	LcdShowString(0, 0,  "基于51单片机的多"); 
    	LcdShowString(0, 16, "功能时钟设计"); 
    	LcdShowString(0, 32, "导师:"); 
    	LcdShowString(0, 48, "学生:"); 
    	Delay2000ms();
    	
    	//液晶清屏
    	LcdShowString(0, 0,  "                ");
    	LcdShowString(0, 16, "                ");
    	LcdShowString(0, 32, "                ");
    	LcdShowString(0, 48, "                ");	
    	LcdClearArea(0,0,128,64);  //液晶清屏
    	
    	InitDS1302();	

     

    展开全文
  • 基于VHDL实现的多功能电子钟设计

    千次阅读 2018-09-09 23:42:38
    1、电子时钟。要求用 24 时制显示。分屏显示“时、分”和“分、秒”,即 4 个数码管不能同时显示“时、分、秒”,但可以只显示“时、分”,或只显示“分、秒”,通过按键来切换这两种显示方式。用数码管的小数点“....

    主要功能要求:

    1、电子时钟。要求用 24 时制显示。分屏显示“时、分”和“分、秒”,即 4 个数码管不能同时显示“时、分、秒”,但可以只显示“时、分”,或只显示“分、秒”,通过按键来切换这两种显示方式。用数码管的小数点“.”代替时、分、秒的分隔符“:”。可设置时间。设置时间时,当前设置的“时”/“分”,相应的数码管应闪烁。
    2、秒表(计时器)。秒表精度为 0.01 秒,计时范围 0~99.99 秒,用 4 个数码管显示,两个显示秒,两个显示百分秒,有暂停/继续、重置(清零)按钮。
    3、定时器。可以实现 0~9999 秒定时。设置一定时值,当计时到达设定值时输出 LED 闪烁。有设置、暂停/继续、清零定时按钮。

    参考思路:

    1. 上电默认显示 “时.分”,依次按下 MOD 按钮,分别显示“分.秒”、“秒表”、“定时器”
    2. 显示 “时.分”时,按下“SET”按钮,最右边的数码管闪烁,表示对这个数设置,按下“”按键加 1,按该数的进制自动翻转;再按下“SET”按键,往左移一个位置的位进入设置状态(闪烁);到达最左侧的数位后,又从最右边的数位开始,如此环。按下“OK”按键退出设置。
    3. 初次显示“秒表”时,显示“0000”,按下“↑”按钮,开始计时,再按一次“↑”则暂停,按下“CLR”按钮重置(清零)。
    4. 初次显示“定时器”时,显示“0000”,按下“SET”按钮,进入设置定时的时间,首次按下“SET”,最右边的数码管闪烁,表设置此数位,再按下“SET”按键,往左移一个位置的位进入设置状态(闪烁);到达最左侧的数位后,又从最右边的数位开始,如此循环。按下“OK”按键退出设置。按下“↑”按钮,开始计时,再按一次“↑”则暂停,按下“CLR”结束计时(回到初次显示定时器的状态,即显示“0000”)。若定时到达设定值,停止计数并闪烁 LED。
      以上方案共需:5 个按键: MOD、SET、↑、OK、CLR

    硬件实物图:

    我也不会用图片.jpg

    1.顶层部分代码:

    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_ARITH.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    
    entity multifunction_electronic_clock is
    port(
        clk:in std_logic;
        mode:in std_logic;
        set:in std_logic;
        step_up:in std_logic;
        ok:in std_logic;
        clr:in std_logic;
        CS:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
        DIS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0);
        led:out std_logic
        );
    end entity;
    
    architecture STRUCT of multifunction_electronic_clock is
    
    component key is
        port(
            clk:in std_logic;
            mode:in std_logic;
            set:in std_logic;
            step_up:in std_logic;
            ok:in std_logic;
            clr:in std_logic;
            mode_out:out std_logic;
            set_out:out std_logic;
            step_up_out:out std_logic;
            ok_out:out std_logic;
            clr_out:out std_logic       
            );
    end component;
    
    
    COMPONENT FENPIN IS
    
        PORT(
            CLK:IN STD_LOGIC;
            C0:buffer STD_LOGIC;--1hz
            C1:buffer STD_LOGIC;--100khz
            C2:buffer STD_LOGIC;--闪烁频率
            C3:BUFfer STD_LOGIC --100hz
            );
    END COMPONENT;
    
    component controller is
        port(
            clk:in std_logic;
            mode:in std_logic;
            set:in std_logic;
            ok:in std_logic;    
            mode_out:out std_LOGIC_VECTOR(1 downto 0);
            flag1,flag2:buffer std_logic_vector(2 downto 0)
            );
    end component;
    
    component clock is
    port(
        clk1:in std_logic;
        clk:in std_LOGIC;
        flag1:in std_logic_vector(2 downto 0);
        step_up:in std_LOGIC;
        D_0,D_1:out std_logic_vector(3 downto 0);
        D_2,D_3:out std_logic_vector(3 downto 0);
        D_4,D_5:out std_logic_vector(3 downto 0)
        );
    end component;
    
    component shining is
    port(
        mode:in std_logic_vector(1 downto 0);
        clk1:in std_logic;
        clk:in std_logic;
        flag1,flag2:in std_logic_vector(2 downto 0);
        D_2_IN,D_3_IN,D_4_IN,D_5_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_10_IN,D_11_IN,D_12_IN,D_13_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)        
        );
    end component;
    
    component selection is
    port(
        clk:in std_logic;
        MODE:IN STD_logic_vector(1 DOWNTO 0);
        D_0,D_1,D_2,D_3,D_4,D_5:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_6,D_7,D_8,D_9:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_10,D_11,D_12,D_13:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_0_OUT,D_1_OUT,D_2_OUT,D_3_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
        );
    end component;
    
    component stopwatch is
        port(
            MODE:IN STD_logic_vector(1 DOWNTO 0);
            CLK:IN STD_LOGIC;
            START:IN STD_LOGIC;
            CLR:IN STD_LOGIC;
            D_6,D_7,D_8,D_9:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
            );
    end component;
    
    component timer is
        port(
            clk:in std_logic;
            MODE:IN STD_logic_vector(1 DOWNTO 0);
            CLK_1hz:IN STD_LOGIC;
            clk_2hz:in std_logic;
            flag2:in std_logic_vector(2 downto 0);
            STEP_UP:IN STD_LOGIC;
            START:IN STD_LOGIC;--OK键
            CLR:IN STD_LOGIC;
            D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
            LED:OUT STD_LOGIC
            );
    end component;
    
    component seg7led is
        PORT(
            mode:in std_logic_vector(1 downto 0);
            CLK4:IN STD_LOGIC;--时钟,复位信号
            CLEAR:in std_logic;
            D_0,D_1,D_2,D_3: IN STD_LOGIC_VECTOR(3 DOWNTO 0);--BCD码输入信号
            CS:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);--数码管位选信号 
            DIS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)--数码管编码信号
        );
    END COMPONENT;      
    
    
    SIGNAL mode_out,set_out,step_up_out,ok_out,clr_out:STD_LOGIC;
    SIGNAL C_1hz,C_100khz,C_2hz,C_100hz,C_1000HZ:STD_LOGIC;
    SIGNAL MODE_STATE:STD_LOGIC_VECTOR(1 DOWNTO 0);
    SIGNAL FLAG1,FLAG2:std_logic_vector(2 downto 0);
    SIGNAL D_CLOCK0,D_CLOCK1,D_CLOCK2,D_CLOCK3,D_CLOCK4,D_CLOCK5:STD_LOGIC_VECTOR(3 
    SIGNAL D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13:STD_LOGIC_VECTOR(3 DOWNTO 0);
    SIGNAL D_S0,D_S1,D_S2,D_S3:STD_LOGIC_VECTOR(3 DOWNTO 0);
    SIGNAL D_6,D_7,D_8,D_9:STD_LOGIC_VECTOR(3 DOWNTO 0);
    SIGNAL D_TIMER10,D_TIMER11,D_TIMER12,D_TIMER13:STD_LOGIC_VECTOR(3 DOWNTO 0);
    
    begin
    
    u1:key port map(clk,mode,set,step_up,ok,clr,mode_out,set_out,step_up_out,ok_out,clr_out);
    u2:fenpin port map(clk,c_1hz,c_100khz,c_2hz,c_100hz);
    u3:controller port map(clk,mode_out,set_out,ok_out,mode_state,flag1,flag2);
    u4:clock port map(clk,c_1hz,flag1,step_up_out,D_CLOCK0,D_CLOCK1,D_CLOCK2,D_CLOCK3,D_CLOCK4,D_CLOCK5);
    u5:shining port map(modE_STATE,clk,c_2hz,flag1,flag2,D_CLOCK2,D_CLOCK3,D_CLOCK4,D_CLOCK5,D_TIMER10,D_TIMER11,D_TIMER12,D_TIMER13,D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13);
    u6:selection port map(clk,MODE_STATE,D_CLOCK0,D_CLOCK1,D_2,D_3,D_4,D_5,D_6,D_7,D_8,D_9,D_10,D_11,D_12,D_13,D_S0,D_S1,D_S2,D_S3);
    u7:stopwatch port map(MODE_STATE,C_100hz,STEP_UP_OUT,clr_out,D_6,D_7,D_8,D_9);
    u8:timer port map(clk,MODE_STATE,C_1hz,c_2hz,FLAG2,STEP_UP_OUT,OK_OUT,clr_out,D_TIMER10,D_TIMER11,D_TIMER12,D_TIMER13,LED);
    u9:seg7led port map(MODE_STATE,C_100khz,clr_out,D_S0,D_S1,D_S2,D_S3,CS,DIS);    
    end strUCT;
    

    2.按键代码

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity key is
    6 port(
    7 clk:in std_logic;-- 系 统 50MHz 率 来 频 进
    8 mode,set,step_up,ok,clr:in std_logic;
    9 mode_out,set_out,step_up_out,ok_out,clr_out:out std_logic
    10 -- 当按 按下后 键 , 出一个上升脉冲 输
    11 );
    12 end key;
    13
    14 architecture behav of key is
    15 begin
    16
    17 PROCESS(CLK,mode,set,step_up,ok,clr)
    18 VARIABLE COUNT1,COUNT2,COUNT3,COUNT4,COUNT5:INTEGER RANGE 0 TO 1000000; --20ms
    19 BEGIN
    20
    21 IF RISING_EDGE(CLK) THEN
    22 IF mode='0' THEN
    23 IF COUNT1<1000000 THEN
    24 COUNT1:=COUNT1+1;
    25 ELSE
    26 COUNT1:=COUNT1;
    27 END IF;
    28
    29 IF COUNT1<=999999 THEN
    30 mode_out<='1';
    31 ELSE
    32 mode_out<='0';
    33 END IF;
    34 ELSE COUNT1:=0;
    35 END IF;
    36
    37 IF set='0' THEN
    38 IF COUNT2<1000000 THEN
    39 COUNT2:=COUNT2+1;
    40 ELSE
    41 COUNT2:=COUNT2;
    42 END IF;
    43
    44 IF COUNT2<=999999 THEN
    45 set_out<='1';
    46 ELSE
    47 set_out<='0';
    48 END IF;
    49 ELSE COUNT2:=0;
    50 END IF;
    51
    52 IF step_up='0' THEN
    53 IF COUNT3<1000000 THEN
    54 COUNT3:=COUNT3+1;
    55 ELSE
    56 COUNT3:=COUNT3;
    57 END IF;
    58
    59 IF COUNT3<=999999 THEN
    60 step_up_out<='1';
    61 ELSE
    62 step_up_out<='0';
    63 END IF;
    64 ELSE COUNT3:=0;
    65 END IF;
    66
    67 IF ok='0' THEN
    68 IF COUNT4<1000000 THEN
    69 COUNT4:=COUNT4+1;
    70 ELSE
    71 COUNT4:=COUNT4;
    72 END IF;
    73
    74 IF COUNT4<=999999 THEN
    75 ok_out<='1';
    76 ELSE
    77 ok_out<='0';
    78 END IF;
    79 ELSE COUNT4:=0;
    80 END IF;
    81
    82 IF clr='0' THEN
    83 IF COUNT5<1000000 THEN
    84 COUNT5:=COUNT5+1;
    85 ELSE
    86 COUNT5:=COUNT5;
    87 END IF;
    88
    89 IF COUNT5<=999999 THEN
    90 clr_out<='1';
    91 ELSE
    92 clr_out<='0';
    93 END IF;
    94 ELSE COUNT5:=0;
    95 END IF;
    96 END IF;
    97
    98 END PROCESS ;
    99 end behav;
    

    3.分频代码

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY FENPIN IS
    6 PORT(
    7 CLK:IN STD_LOGIC;
    8 C0:buffer STD_LOGIC;--1hz
    9 C1:buffer STD_LOGIC;--100khz
    10 C2:buffer STD_LOGIC;-- 率 闪烁频
    11 C3:BUFfer STD_LOGIC;--100hz
    12 C4:buffer std_logic --1000hz
    13 );
    14 END FENPIN;
    15
    16 ARCHITECTURE BEHAVIORAL OF FENPIN IS
    17 SIGNAL COUNTER0:INTEGER RANGE 0 TO 25000000;
    18 SIGNAL COUNTER1:INTEGER RANGE 0 TO 250;
    19 SIGNAL COUNTER2:INTEGER RANGE 0 TO 12500000;
    20 SIGNAL COUNTER3:INTEGER RANGE 0 TO 250000;
    21 SIGNAL COUNTER4:INTEGER RANGE 0 TO 25000;
    22 BEGIN
    23
    24 CTR0:-- 分 出信号 频输 0  1Hz
    25 PROCESS(CLK)
    26 BEGIN
    27
    28 IF(CLK='1' AND CLK'EVENT)THEN
    29 IF(COUNTER0=25000000)THEN
    30 COUNTER0<=0;C0<=NOT C0;
    31 ELSE
    32 COUNTER0<=COUNTER0+1;
    33 END IF;
    34 END IF;
    35 END PROCESS;
    36
    37 CTR1:-- 分 出信号 频输 1 100KHz
    38 PROCESS(CLK)
    39 BEGIN
    40
    41 IF(CLK='1' AND CLK'EVENT)THEN
    42 IF(COUNTER1=250)THEN
    43 COUNTER1<=1;C1<=NOT C1;
    44 ELSE
    45 COUNTER1<=COUNTER1+1;
    46 END IF;
    47 END IF;
    48 END PROCESS;
    49
    50 CTR2:-- 分 出信号 频输 2  2Hz ( 率 闪烁频 )
    51 PROCESS(CLK)
    52 BEGIN
    53
    54 IF(CLK='1' AND CLK'EVENT)THEN
    55 IF(COUNTER2=12500000)THEN
    56 COUNTER2<=0;C2<=NOT C2;
    57 ELSE
    58 COUNTER2<=COUNTER2+1;
    59 END IF;
    60 END IF;
    61 END PROCESS;
    62
    63 CTR3:-- 分 出信号 频输 3  100Hz (秒表 率 频 )
    64 PROCESS(CLK)
    65 BEGIN
    66
    67 IF(CLK='1' AND CLK'EVENT)THEN
    68 IF(COUNTER3=250000)THEN
    69 COUNTER3<=0;C3<=NOT C3;
    70 ELSE
    71 COUNTER3<=COUNTER3+1;
    72 END IF;
    73 END IF;
    74 END PROCESS;
    75
    76 CTR4:-- 分 出信号 频输 4
    77 PROCESS(CLK)
    78 BEGIN
    79
    80 IF(CLK='1' AND CLK'EVENT)THEN
    81 IF(COUNTER4=25000)THEN
    82 COUNTER4<=0;C4<=NOT C4;
    83 ELSE
    84 COUNTER4<=COUNTER4+1;
    85 END IF;
    86 END IF;
    87 END PROCESS;
    88
    89 END BEHAVIORAL;
    

    4.按键控制

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity controller is
    6 port(
    7 clk:in std_logic;
    8 mode:in std_logic;
    9 set:in std_logic;
    10 ok:in std_logic;
    11 mode_out:buffer std_LOGIC_VECTOR(1 downto 0);
    12 flag1,flag2:buffer std_logic_vector(2 downto 0)
    13 );
    14 end controller;
    15
    16 architecture kong of controller is
    17 SIGNAL SET_OK1,SET_OK2: std_logic_vector(2 downto 0):="000";
    18 signal mode_state:std_logic_vector(1 downto 0):="00";
    19 begin
    20
    21 process(mode,set,ok,clk)
    22 begin
    23
    24 if(mode='1'and mode'event)then
    25 if(mode_state="11")then
    26 mode_state<="00";
    27 else
    28 mode_state<=mode_state+1;
    29 end if;
    30 ELSE mode_state<=mode_state;
    31 end if;
    32
    33 if(mode_state="00" or mode_state="01")then
    34
    35 if(set='1'and set'event)then
    36 if(SET_OK1="100")then
    37 SET_OK1<="000";
    38 else
    39 SET_OK1<=SET_OK1+1;
    40 end if;
    41 end if;
    42
    43 -- if(ok='1')then
    44 -- SET_OK1<="000";
    45 -- end if;
    46 -- else SET_OK1<=SET_OK1;
    47 end if;
    48
    49 if(mode_state="11")then
    50 if(set='1'and set'event)then
    51 if(SET_OK2="100")then
    52 SET_OK2<="000";
    53 else
    54 SET_OK2<=SET_OK2+1;
    55 end if;
    56 end if;
    57
    58 -- if(ok='1')then
    59 -- SET_OK2<="000";
    60 -- end if;
    61 -- ELSE SET_OK2<=SET_OK2;
    62 end if;
    63 mode_out<=mode_state;
    64 FLAG1<=SET_OK1;
    65 FLAG2<=SET_OK2;
    66
    67 end process;
    68
    69 end kong;
    

    5.定时器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity clock is
    6 port(
    7 clk1:in std_logic;
    8 clk:in std_LOGIC;
    9 flag1:in std_logic_vector(2 downto 0);
    10 step_up:in std_LOGIC;
    11 D_0,D_1:out std_logic_vector(3 downto 0);
    12 D_2,D_3:out std_logic_vector(3 downto 0);
    13 D_4,D_5:out std_logic_vector(3 downto 0)
    14 );
    15 end clock;
    16
    17 architecture js of clock is
    18
    19 component xuanze4_1 is
    20 port(
    21 clk:in std_logic;
    22 in2,in3,in4,in5:in std_logic;
    23 step_up:in std_logic;
    24 flag1:in std_logic_vector(2 downto 0);
    25 co2,co3,co4,co5:out std_logic
    26 );
    27 end component;
    28
    29 component hour_24 is
    30 port (
    31 clk_l:in std_logic;
    32 clk_h:in std_logic;
    33 D_4,D_5:out std_logic_vector(3 downto 0);
    34 cout_4,cout_5:out std_logic
    35 );
    36 end component;
    37
    38 component fen60 is
    39 port (
    40 clk_l:in std_logic;
    41 clk_h:in std_logic;
    42 D_2,D_3:out std_logic_vector(3 downto 0);
    43 cout_2,cout_3:out std_logic
    44 );
    45 end component;
    46
    47 component sn60 is
    48 port (
    49 clk:in std_logic;
    50 D_0,D_1:out std_logic_vector(3 downto 0);
    51 cout:out std_logic
    52 );
    53 end component;
    54
    55 signal in2,in3,in4,in5,co2,co3,co4,co5,cout_5:std_logic;
    56
    57 begin
    58
    59 u40:xuanze4_1 port map (clk1,in2,in3,in4,in5,step_up,flag1,co2,co3,co4,co5);
    60 u41:sn60 port map(clk,D_0,D_1,in2);
    61 u42:fen60 port map(co2,co3,D_2,D_3,in3,in4);
    62 u43:hour_24 port map(co4,co5,D_4,D_5,in5,cout_5);
    63
    64 end js;
    

    6.4选1

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity xuanze4_1 is
    6 port(
    7 clk:in std_logic;
    8 in2,in3,in4,in5:in std_logic;
    9 step_up:in std_logic;
    10 flag1:in std_logic_vector(2 downto 0);
    11 co2,co3,co4,co5:out std_logic
    12 );
    13 end xuanze4_1;
    14
    15 architecture xuanze of xuanze4_1 is
    16 begin
    17 process(clk,in2,in3,in4,in5,step_up,flag1)
    18 BEGIN
    19 case flag1 is
    20 when "000" => co2<=in2;
    21 co3<=in3;
    22 co4<=in4;
    23 co5<=in5;
    24 when "001" => co2<=step_up;
    25 co3<=in3;
    26 co4<=in4;
    27 co5<=in5;
    28
    29 when "010" => co3<=step_up;
    30 co2<=in2;
    31 co4<=in4;
    32 co5<=in5;
    33 when "011" => co4<=step_up;
    34 co2<=in2;
    35 co3<=in3;
    36 co5<=in5;
    37
    38 when "100" => co2<=in2;
    39 co3<=in3;
    40 co4<=in4;
    41 co5<=step_up;
    42
    43 when others => co2<=in2;
    44 co3<=in3;
    45 co4<=in4;
    46 co5<=in5;
    47 end case;
    48 end process;
    49 end xuanze;
    

    7.60秒计数器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity sn60 is
    6 port (
    7 clk:in std_logic;
    8 D_0,D_1:out std_logic_vector(3 downto 0);
    9 cout:out std_logic
    10 );
    11 end sn60;
    12
    13 architecture fe of sn60 is
    14 signal TEMP1,TEMP2:std_logic_vector(3 downto 0):="0000";
    15 signal co:std_logic:='0';
    16 begin
    17
    18 PROCESS(CLK)
    19 BEGIN
    20
    21 IF(CLK'EVENT AND CLK='1')THEN
    22 IF(TEMP1="1001")THEN
    23 TEMP1<="0000";co<='1';
    24 ELSE
    25 TEMP1<=TEMP1+1;co<='0';
    26 END IF;
    27 END IF;
    28 D_0<=TEMP1;
    29 END PROCESS;
    30
    31 PROCESS(co)
    32 BEGIN
    33
    34 IF(co'EVENT AND co='1')THEN
    35 IF(TEMP2="0101")THEN
    36 TEMP2<="0000";cout<='1';
    37 ELSE
    38 TEMP2<=TEMP2+1;cout<='0';
    39 END IF;
    40 END IF;
    41 D_1<=TEMP2;
    42 END PROCESS;
    43 end fe;
    

    8.60分计数器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity fen60 is
    6 port (
    7 clk_l:in std_logic;
    8 clk_h:in std_logic;
    9 D_2,D_3:out std_logic_vector(3 downto 0);
    10 cout_2,cout_3:out std_logic
    11 );
    12 end fen60;
    13
    14 architecture fen of fen60 is
    15 signal TEMP1,TEMP2:std_logic_vector(3 downto 0);
    16 begin
    17
    18 PROCESS(CLK_L)
    19 BEGIN
    20
    21 IF(CLK_L'EVENT AND CLK_L='1')THEN
    22 IF(TEMP1="1001")THEN
    23 TEMP1<="0000";cout_2<='1';
    24 ELSE
    25 TEMP1<=TEMP1+1;cout_2<='0';
    26 END IF;
    27 END IF;
    28 D_2<=TEMP1;
    29 END PROCESS;
    30
    31 PROCESS(clk_h)
    32 BEGIN
    33
    34 IF(clk_h'EVENT AND clk_h='1')THEN
    35 IF(TEMP2="0101")THEN
    36 TEMP2<="0000";cout_3<='1';
    37 ELSE
    38 TEMP2<=TEMP2+1;cout_3<='0';
    39 END IF;
    40 END IF;
    41 D_3<=TEMP2;
    42 END PROCESS;
    43
    44 end fen;
    

    9.24时计数器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity hour_24 is
    6 port (
    7 clk_l:in std_logic;
    8 clk_h:in std_logic;
    9 D_4,D_5:out std_logic_vector(3 downto 0);
    10 cout_4,cout_5:out std_logic
    11 );
    12 end hour_24;
    13
    14 architecture hour of hour_24 is
    15 signal TEMP1,TEMP2:std_logic_vector(3 downto 0);
    16 begin
    17
    18 PROCESS(CLK_L)
    19 BEGIN
    20
    21 IF(CLK_L'EVENT AND CLK_L='1')THEN
    22 IF(TEMP2="0010")THEN
    23 IF(TEMP1>="0100")THEN
    24 TEMP1<="0000";COUT_4<='1';
    25 ELSE
    26 TEMP1<=TEMP1+1;COUT_4<='0';
    27 END IF;
    28 ELSIF(TEMP1="1001")THEN
    29 TEMP1<="0000";COUT_4<='1';
    30 ELSE
    31 TEMP1<=TEMP1+1;COUT_4<='0';
    32 END IF;
    33 END IF;
    34 D_4<=TEMP1;
    35 END PROCESS;
    36
    37 PROCESS(clk_h)
    38 BEGIN
    39
    40 IF(clk_h'EVENT AND clk_h='1')THEN
    41 IF(TEMP2="0010")THEN
    42 TEMP2<="0000";COUT_5<='1';
    43 ELSE
    44 TEMP2<=TEMP2+1;COUT_5<='0';
    45 END IF;
    46 END IF;
    47 D_5<=TEMP2;
    48 END PROCESS;
    49
    50 end hour;
    

    10.闪烁模块

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity shining is
    6 port(
    7 mode:in std_logic_vector(1 downto 0);
    8 clk1:in std_logic;
    9 clk:in std_logic;
    10 flag1,flag2:in std_logic_vector(2 downto 0);
    11 D_2_IN,D_3_IN,D_4_IN,D_5_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    12 D_10_IN,D_11_IN,D_12_IN,D_13_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
    14 );
    15 end shining;
    16
    17 architecture xia of shining is
    18 begin
    19
    20 process(clk1,mode,flag1,flag2,CLK,D_2_IN,D_3_IN,D_4_IN,D_5_IN,D_10_IN,D_11_IN,D_12
    _IN,D_13_IN)
    21 begin
    22 if(clk1'event and clk1='1')then
    23 case mode is
    24 when "00" =>
    25
    26 case flag1 is
    27 when "000" => D_2<=D_2_IN;
    28 D_3<=D_3_IN;
    29 D_4<=D_4_IN;
    30 D_5<=D_5_IN;
    31
    32 when "001" => IF(CLK='1')THEN
    33 D_2<="1010";
    34 ELSE
    35 D_2<=D_2_IN;
    36 END IF;
    37 D_3<=D_3_IN;
    38 D_4<=D_4_IN;
    39 D_5<=D_5_IN;
    40
    41 when "010" => IF(CLK='1')THEN
    42 D_3<="1010";
    43 ELSE
    44 D_3<=D_3_IN;
    45 END IF;
    46 D_2<=D_2_IN;
    47 D_4<=D_4_IN;
    48 D_5<=D_5_IN;
    49
    50 when "011" => IF(CLK='1')THEN
    51 D_4<="1010";
    52 ELSE
    53 D_4<=D_4_IN;
    54 END IF;
    55 D_2<=D_2_IN;
    56 D_3<=D_3_IN;
    57 D_5<=D_5_IN;
    58
    59 when "100" => IF(CLK='1')THEN
    60 D_5<="1010";
    61 ELSE
    62 D_5<=D_5_IN;
    63 END IF;
    64 D_2<=D_2_IN;
    65 D_3<=D_3_IN;
    66 D_4<=D_4_IN;
    67
    68 when others => D_2<=D_2_IN;
    69 D_3<=D_3_IN;
    70 D_4<=D_4_IN;
    71 D_5<=D_5_IN;
    72 END CASE;
    73
    74 when "01" => D_2<=D_2_IN;
    75 D_3<=D_3_IN;
    76 D_4<=D_4_IN;
    77 D_5<=D_5_IN;
    78 D_10<=D_10_IN;
    79 D_11<=D_11_IN;
    80 D_12<=D_12_IN;
    81 D_13<=D_13_IN;
    82
    83 when "10" => D_2<=D_2_IN;
    84 D_3<=D_3_IN;
    85 D_4<=D_4_IN;
    86 D_5<=D_5_IN;
    87 D_10<=D_10_IN;
    88 D_11<=D_11_IN;
    89 D_12<=D_12_IN;
    90 D_13<=D_13_IN;
    91
    92 when "11" =>
    93
    94 case flag2 is
    95 when "000" => D_10<=D_10_IN;
    96 D_11<=D_11_IN;
    97 D_12<=D_12_IN;
    98 D_13<=D_13_IN;
    99
    100 when "001" => IF(CLK='1')THEN
    101 D_10<="1010";
    102 ELSE
    103 D_10<=D_10_IN;
    104 END IF;
    105 D_11<=D_11_IN;
    106 D_12<=D_12_IN;
    107 D_13<=D_13_IN;
    108
    109 when "010" => IF(CLK='1')THEN
    110 D_11<="1010";
    111 ELSE
    112 D_11<=D_11_IN;
    113 END IF;
    114 D_10<=D_10_IN;
    115 D_12<=D_12_IN;
    116 D_13<=D_13_IN;
    117
    118 when "011" => IF(CLK='1')THEN
    119 D_12<="1010";
    120 ELSE
    121 D_12<=D_12_IN;
    122 END IF;
    123 D_10<=D_10_IN;
    124 D_11<=D_11_IN;
    125 D_13<=D_13_IN;
    126
    127 when "100" => IF(CLK='1')THEN
    128 D_13<="1010";
    129 ELSE
    130 D_13<=D_13_IN;
    131 END IF;
    132 D_10<=D_10_IN;
    133 D_11<=D_11_IN;
    134 D_12<=D_12_IN;
    135
    136 when others => D_10<=D_10_IN;
    137 D_11<=D_11_IN;
    138 D_12<=D_12_IN;
    139 D_13<=D_13_IN;
    140 END CASE;
    141 END CASE;
    142 end if;
    143 END process;
    144 end xia;
    

    11.选择器

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_ARITH.ALL;
    4 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    5
    6 entity selection is
    7 port(
    8 clk:in std_logic;
    9 MODE:IN STD_logic_vector(1 DOWNTO 0);
    10 D_0,D_1,D_2,D_3,D_4,D_5:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    11 D_6,D_7,D_8,D_9:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    12 D_10,D_11,D_12,D_13:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 D_0_OUT,D_1_OUT,D_2_OUT,D_3_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
    14 );
    15 end entity;
    16
    17 architecture behav of selection is
    18 begin
    19 process(clk,mode,D_0,D_1,D_2,D_3,D_4,D_5,D_6,D_7,D_8,D_9,D_10,D_11,D_12,D_13)
    20 BEGIN
    21 if(clk'event and clk='1')then
    22 case mode is
    23 when "00" => D_0_OUT<=D_2;
    24 D_1_OUT<=D_3;
    25 D_2_OUT<=D_4;
    26 D_3_OUT<=D_5;
    27
    28 when "01" => D_0_OUT<=D_0;
    29 D_1_OUT<=D_1;
    30 D_2_OUT<=D_2;
    31 D_3_OUT<=D_3;
    32
    33 when "10" => D_0_OUT<=D_6;
    34 D_1_OUT<=D_7;
    35 D_2_OUT<=D_8;
    36 D_3_OUT<=D_9;
    37
    38 when "11" => D_0_OUT<=D_10;
    39 D_1_OUT<=D_11;
    40 D_2_OUT<=D_12;
    41 D_3_OUT<=D_13;
    42 END case;
    43 end if;
    44 END PROcess;
    45 end behav;
    46
    

    12.秒表

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY stopwatch IS
    6 port(
    7 MODE:IN STD_logic_vector(1 DOWNTO 0);
    8 CLK:IN STD_LOGIC;
    9 START:IN STD_LOGIC;--step_up
    10 CLR:IN STD_LOGIC;
    11 D_6,D_7,D_8,D_9:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
    12 );
    13 END stopwatch;
    14
    15 ARCHITECTURE STRUCT OF stopwatch IS
    16
    17 COMPONENT COUNT_10_D_0 IS
    18
    19 PORT(
    20 mode:in std_logic_vector(1 downto 0);
    21 CLK1,CLEAR,START:IN STD_LOGIC;
    22 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    23 COUT:BUFFER STD_LOGIC);
    24 END COMPONENT;
    25
    26 COMPONENT COUNT_10_D_1 IS
    27 PORT( CLK2,CLEAR:IN STD_LOGIC;
    28 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    29 COUT:BUFFER STD_LOGIC);
    30 END COMPONENT;
    31
    32 COMPONENT COUNT_10_D_2 IS
    33 PORT( CLK3,CLEAR:IN STD_LOGIC;
    34 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    35 COUT:BUFFER STD_LOGIC);
    36 END COMPONENT;
    37
    38 COMPONENT COUNT_10_D_3 IS
    39 PORT( CLK4,CLEAR:IN STD_LOGIC;
    40 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    41 COUT:BUFFER STD_LOGIC);
    42 END COMPONENT;
    43
    44 signal clk1,clk2,clk3,cout:std_logic;
    45
    46 BEGIN
    47
    48 u71:COUNT_10_D_0 port map(mode,clk,clr,start,D_6,clk1);
    49 u72:COUNT_10_D_1 port map(clk1,clr,D_7,clk2);
    50 u73:COUNT_10_D_2 port map(clk2,clr,D_8,clk3);
    51 u74:COUNT_10_D_3 port map(clk3,clr,D_9,cout);
    52
    53
    54 END ARCHITECTURE STRUCT;
    55
    

    13.计数器……

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_0 IS
    6 PORT(
    7 mode:in std_logic_vector(1 downto 0);
    8 CLK1,CLEAR,START:IN STD_LOGIC;
    9 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    10 COUT:BUFFER STD_LOGIC);
    11 END ENTITY COUNT_10_D_0;
    12
    13 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_0 IS
    14 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    15 SIGNAL START_STATE:STD_LOGIC:='1';
    16 BEGIN
    17
    18 PROCESS(START)
    19 BEGIN
    20
    21 IF(START'EVENT AND START='1')THEN
    22 IF(MODE="10")THEN
    23 START_STATE<=NOT START_STATE;
    24 ELSE
    25 START_STATE<='1';
    26 END IF;
    27 ELSE START_STATE<=START_STATE;
    28 END IF;
    29 END PROCESS;
    30
    31 PROCESS(CLK1,CLEAR)IS
    32 BEGIN
    33
    34 IF(CLEAR='1')THEN
    35 TEMP<="0000";COUT<='0';
    36 ELSIF(CLK1'EVENT AND CLK1='1')THEN
    37 IF(START_STATE='0')THEN
    38 IF(TEMP="1001")THEN
    39 TEMP<="0000";COUT<='1';
    40 ELSE
    41 TEMP<=TEMP+1;COUT<='0';
    42 END IF;
    43 ELSE
    44 TEMP<=TEMP;
    45 END IF;
    46 END IF;
    47 BCD_OUT<=TEMP;
    48 END PROCESS;
    49
    50 END ARCHITECTURE BEHAVIORAL;
    

    13.

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_1 IS
    6 PORT(CLK2,CLEAR:IN STD_LOGIC;
    7 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    8 COUT:BUFFER STD_LOGIC);
    9 END ENTITY COUNT_10_D_1;
    10
    11 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_1 IS
    12 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 BEGIN
    14
    15 PROCESS(CLK2,CLEAR)IS
    16 BEGIN
    17
    18 IF(CLEAR='1')THEN
    19 TEMP<="0000";COUT<='0';
    20 ELSIF(CLK2'EVENT AND CLK2='1')THEN
    21 IF(TEMP="1001")THEN
    22 TEMP<="0000";COUT<='1';
    23 ELSE
    24 TEMP<=TEMP+1;COUT<='0';
    25 END IF;
    26 ELSE TEMP<=TEMP;
    27 END IF;
    28 BCD_OUT<=TEMP;
    29 END PROCESS;
    30 END ARCHITECTURE BEHAVIORAL;
    

    13.

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_2 IS
    6 PORT(CLK3,CLEAR:IN STD_LOGIC;
    7 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    8 COUT:BUFFER STD_LOGIC);
    9 END ENTITY COUNT_10_D_2;
    10
    11 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_2 IS
    12 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 BEGIN
    14
    15 PROCESS(CLK3,CLEAR)IS
    16 BEGIN
    17
    18 IF(CLEAR='1')THEN
    19 TEMP<="0000";COUT<='0';
    20 ELSIF(CLK3'EVENT AND CLK3='1')THEN
    21 IF(TEMP="1001")THEN
    22 TEMP<="0000";COUT<='1';
    23 ELSE
    24 TEMP<=TEMP+1;COUT<='0';
    25 END IF;
    26 ELSE TEMP<=TEMP;
    27 END IF;
    28 BCD_OUT<=TEMP;
    29 END PROCESS;
    30 END ARCHITECTURE BEHAVIORAL;
    

    13.

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_3 IS
    6 PORT(CLK4,CLEAR:IN STD_LOGIC;
    7 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    8 COUT:BUFFER STD_LOGIC);
    9 END ENTITY COUNT_10_D_3;
    10
    11 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_3 IS
    12 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 BEGIN
    14
    15 PROCESS(CLK4,CLEAR)IS
    16 BEGIN
    17
    18 IF(CLEAR='1')THEN
    19 TEMP<="0000";COUT<='0';
    20 ELSIF(CLK4'EVENT AND CLK4='1')THEN
    21 IF(TEMP="1001")THEN
    22 TEMP<="0000";COUT<='1';
    23 ELSE
    24 TEMP<=TEMP+1;COUT<='0';
    25 END IF;
    26 ELSE TEMP<=TEMP;
    27 END IF;
    28 BCD_OUT<=TEMP;
    29 END PROCESS;
    30 END ARCHITECTURE BEHAVIORAL;
    31
    

    14.定时器

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 entity timer is
    6 port(
    7 clk:in std_logic;
    8 MODE:IN STD_logic_vector(1 DOWNTO 0);
    9 CLK_1hz:IN STD_LOGIC;
    10 clk_2hz:in std_logic;
    11 flag2:in std_logic_vector(2 downto 0);
    12 STEP_UP:IN STD_LOGIC;
    13 START:IN STD_LOGIC;--OK 键
    14 CLR:IN STD_LOGIC;
    15 D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    16 LED:OUT STD_LOGIC
    17 );
    18 end entity;
    19
    20 architecture struct of timer is
    21
    22
    23 component xuanze_mode_4_1 is
    24 port(
    25 clk:in std_logic;
    26 in2,in3,in4,in5:in std_logic;
    27 step_up:in std_logic;
    28 flag2:in std_logic_vector(2 downto 0);
    29 co2,co3,co4,co5:out std_logic
    30 );
    31 end component;
    32
    33 component count_10000 is
    34 port (
    35 mode:in std_logic_vector(1 downto 0);
    36 flag2:in std_logic_vector(2 downto 0);
    37 clk1,clk2,clk3,clk4:in std_logic;
    38 CLEAR:in std_logic;
    39 step_up:in std_logic;
    40 start:in std_logic;--ok 键
    41 D_10,D_11,D_12,D_13:out std_logic_vector(3 downto 0);
    42 COUT1,COUT2,COUT3,COUT4:buffer std_logic
    43 );
    44 end component;
    45
    46 component alarm is
    47 port(
    48 clk:in std_logic;
    49 c_in:in std_logic;
    50 c_out:out std_logic--led
    51 );
    52 end component;
    53
    54 signal cout1,cout2,cout3,cout4,clk1,clk2,clk3,clk4:STD_LOGIC;
    55
    56 begin
    57
    58 u80:xuanze_mode_4_1 port
    map(clk,CLK_1HZ,COUT1,COUT2,COUT3,STEP_UP,FLAG2,CLK1,CLK2,CLK3,CLK4);
    59 u81:count_10000 port
    map(MODE,FLAG2,CLK1,CLK2,CLK3,CLK4,CLR,STEP_UP,START,D_10,D_11,D_12,D_13,COUT1,COU
    T2,COUT3,COUT4);
    60 u82:alarm port map(CLK_2hz,COUT4,LED);
    61
    62 end struct;
    63
    

    15.选择器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity xuanze_mode_4_1 is
    6 port(
    7 clk:in std_logic;
    8 in2,in3,in4,in5:in std_logic;
    9 step_up:in std_logic;
    10 flag2:in std_logic_vector(2 downto 0);
    11 co2,co3,co4,co5:out std_logic
    12 );
    13 end xuanze_mode_4_1;
    14
    15 architecture xuanze of xuanze_mode_4_1 is
    16 begin
    17 process(clk,flag2,in2,in3,in4,in5,step_up)
    18 BEGIN
    19 case flag2 is
    20 when "000" => co2<=in2;
    21 co3<=in3;
    22 co4<=in4;
    23 co5<=in5;
    24
    25 when "001" => co2<=step_up;
    26 co3<=in3;
    27 co4<=in4;
    28 co5<=in5;
    29
    30 when "010" => co3<=step_up;
    31 -- co2<=in2;
    32 -- co4<=in4;
    33 -- co5<=in5;
    34
    35 when "011" => co4<=step_up;
    36 -- co2<=in2;
    37 -- co3<=in3;
    38 -- co5<=in5;
    39
    40 when "100" => co5<=step_up;
    41 -- co2<=in2;
    42 -- co3<=in3;
    43 -- co4<=in4;
    44
    45 when others => NULL;
    46 end case;
    47 end process;
    48 end xuanze;
    

    16.

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4 entity count_10000 is
    5 port (
    6 mode:in std_logic_vector(1 downto 0);
    7 flag2:in std_logic_vector(2 downto 0);
    8 clk1,clk2,clk3,clk4:in std_logic;
    9 CLEAR:in std_logic;
    10 step_up:in std_logic;
    11 start:in std_logic;
    12 D_10,D_11,D_12,D_13:out std_logic_vector(3 downto 0);
    13 COUT1,COUT2,COUT3,COUT4:buffer std_logic
    14 );
    15 end count_10000;
    16
    17 architecture behav of count_10000 is
    18 signal TEMP1,TEMP2,TEMP3,TEMP4:std_logic_vector(3 downto 0);
    19
    20 SIGNAL START_STATE:STD_LOGIC:='1';
    21 begin
    22
    23 PROCESS(START,COUT4)
    24 BEGIN
    25
    26 IF(START'EVENT AND START='1')THEN
    27 IF(MODE="11" AND FLAG2="000")THEN
    28 START_STATE<=NOT START_STATE;
    29 ELSE
    30 START_STATE<='1';
    31 END IF;
    32 ELSE START_STATE<=START_STATE;
    33 END IF;
    34 IF(COUT4='1')THEN START_STATE<='1';END IF;
    35 END PROCESS;
    36
    37 PROCESS(CLK1,CLEAR)IS
    38 BEGIN
    39
    40 IF(CLEAR='1')THEN
    41 TEMP1<="0000";COUT1<='0';
    42 ELSIF(CLK1'EVENT AND CLK1='1')THEN
    43 -- 倒 计时
    44 IF(START_STATE='0'AND COUT4='0')THEN
    45 IF(FLAG2="000")THEN
    46 IF(TEMP1="0000")THEN
    47 TEMP1<="1001";COUT1<='1';
    48 ELSE
    49 TEMP1<=TEMP1-1;COUT1<='0';
    50 END IF;
    51 END IF;
    52 ELSE
    53 -- 置数字 设
    54 IF(FLAG2/="000")THEN
    55 IF(TEMP1="1001")THEN
    56 TEMP1<="0000";
    57 ELSE
    58 TEMP1<=TEMP1+1;
    59 END IF;
    60 END IF;
    61 END IF;
    62 END IF;
    63 D_10<=TEMP1;
    64 END PROCESS;
    65
    66 PROCESS(CLK2,CLEAR)IS
    67 BEGIN
    68
    69 IF(CLEAR='1')THEN
    70 TEMP2<="0000";COUT2<='0';
    71 ELSIF(CLK2'EVENT AND CLK2='1')THEN
    72 IF(START_STATE='0'AND COUT4='0')THEN
    73 IF(TEMP2="0000")THEN
    74 TEMP2<="1001";COUT2<='1';
    75 ELSE
    76 TEMP2<=TEMP2-1;COUT2<='0';
    77 END IF;
    78 ELSE
    79 IF(FLAG2/="000")THEN
    80 IF(TEMP2="1001")THEN
    81 TEMP2<="0000";
    82 ELSE
    83 TEMP2<=TEMP2+1;
    84 END IF;
    85 ELSE TEMP2<=TEMP2;
    86 END IF;
    87 END IF;
    88 END IF;
    89 D_11<=TEMP2;
    90 END PROCESS;
    91
    92 PROCESS(CLK3,CLEAR)IS
    93 BEGIN
    94
    95 IF(CLEAR='1')THEN
    96 TEMP3<="0000";COUT3<='0';
    97 ELSIF(CLK3'EVENT AND CLK3='1')THEN
    98 IF(START_STATE='0'AND COUT4='0')THEN
    99 IF(TEMP3="0000")THEN
    100 TEMP3<="1001";COUT3<='1';
    101 ELSE
    102 TEMP3<=TEMP3-1;COUT3<='0';
    103 END IF;
    104 ELSE
    105 IF(FLAG2/="000")THEN
    106 IF(TEMP3="1001")THEN
    107 TEMP3<="0000";
    108 ELSE
    109 TEMP3<=TEMP3+1;
    110 END IF;
    111 ELSE TEMP3<=TEMP3;
    112 END IF;
    113 END IF;
    114 END IF;
    115 D_12<=TEMP3;
    116 END PROCESS;
    117
    118 PROCESS(CLK4,CLEAR)IS
    119 BEGIN
    120 IF(FLAG2/="000")THEN
    121 COUT4<='0';
    122 ELSIF(CLEAR='1')THEN
    123 TEMP4<="0000";COUT4<='0';
    124 ELSIF(CLK4'EVENT AND CLK4='1')THEN
    125 IF(START_STATE='0')THEN
    126 IF(TEMP4="0000")THEN
    127 -- TEMP4<="1001";
    128 COUT4<='1';
    129 ELSE
    130 TEMP4<=TEMP4-1;COUT4<='0';
    131 END IF;
    132 ELSE
    133 IF(FLAG2/="000")THEN
    134 IF(TEMP4="1001")THEN
    135 TEMP4<="0000";
    136 ELSE
    137 TEMP4<=TEMP4+1;
    138 END IF;
    139 ELSE TEMP4<=TEMP4;
    140 END IF;
    141 END IF;
    142 END IF;
    143 D_13<=TEMP4;
    144 END PROCESS;
    145
    146 end behav;
    

    17.计时器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity alarm is
    6 port(
    7 clk:in std_logic;
    8 c_in:in std_logic;
    9 c_out:out std_logic--led
    10 );
    11 end entity;
    12
    13 architecture behav of alarm is
    14 signal alarm_state:std_logic:='0';
    15 begin
    16
    17 process(c_in,clk)
    18 begin
    19 if(c_in='1')then
    20 if(clk='1')then c_out<='1';
    21 else c_out<='0';
    22 end if;
    23 else
    24 c_out<='0';
    25 end if;
    26 end process;
    27
    28 end behav;
    

    18.数码管显示

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY seg7led IS
    6 PORT(
    7 mode:in std_logic_vector(1 downto 0);
    8 CLK4,CLEAR:IN STD_LOGIC;-- 时钟 ,复位信号
    9 D_0,D_1,D_2,D_3: IN STD_LOGIC_VECTOR(3 DOWNTO 0);-- 制 数器 进 计 BCD 入信号 码输
    10 DIS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0);-- 数 管 信号 码 编码
    11 CS:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)-- 数 管片 信号 码 选
    12 );
    13 END seg7led;
    14
    15 ARCHITECTURE XIANSHI OF seg7led IS
    16 SIGNAL DAKEY:STD_LOGIC_VECTOR(3 DOWNTO 0);-- 定 程 用来 的信号量 义进 间 传值
    17 SIGNAL CA:INTEGER RANGE 0 TO 3;
    18 BEGIN
    19
    20 -- 器 译码
    21 -- 实现 4 个数 管的 描 码 动态扫
    22 N0:PROCESS(CLK4,CLEAR)
    23 VARIABLE CAL:INTEGER RANGE 0 TO 3;
    24 BEGIN
    25
    26 IF(CLEAR='1')THEN
    27 CAL:=0;
    28 ELSIF RISING_EDGE(CLK4)THEN
    29 IF(CAL=3)THEN
    30 CAL:=0;
    31 ELSE
    32 CAL:=CAL+1;
    33 END IF;
    34 END IF;
    35 CA<=CAL;
    36 END PROCESS N0;
    37
    38 -- 当前 示的数 管 选择 显 码
    39 N1:PROCESS(CA)
    40 VARIABLE SS:STD_LOGIC_VECTOR(3 DOWNTO 0);
    41 BEGIN
    42
    43 CASE CA IS
    44 WHEN 0 =>SS:=D_0(3 DOWNTO 0);CS<="1110";DIS(7)<='1';
    45 WHEN 1 =>SS:=D_1(3 DOWNTO 0);CS<="1101";DIS(7)<='1';
    46 WHEN 2 =>SS:=D_2(3 DOWNTO 0);CS<="1011";if(mode/="11")then
    DIS(7)<='0';else dis(7)<='1';end if;
    47 WHEN 3 =>SS:=D_3(3 DOWNTO 0);CS<="0111";DIS(7)<='1';
    48 WHEN OTHERS => SS:="ZZZZ";CS<="1111";
    49 END CASE;
    50 DAKEY<=SS;
    51 END PROCESS N1;
    52
    53 -- 当前 示的数字 选择 显
    54 N2:PROCESS(DAKEY)
    55 BEGIN
    56 CASE DAKEY IS
    57 WHEN "0000" => DIS(6 DOWNTO 0) <= "1000000"; -- 0
    58 WHEN "0001" => DIS(6 DOWNTO 0) <= "1111001"; -- 1
    59 WHEN "0010" => DIS(6 DOWNTO 0) <= "0100100"; -- 2
    60 WHEN "0011" => DIS(6 DOWNTO 0) <= "0110000"; -- 3
    61 WHEN "0100" => DIS(6 DOWNTO 0) <= "0011001"; -- 4
    62 WHEN "0101" => DIS(6 DOWNTO 0) <= "0010010"; -- 5
    63 WHEN "0110" => DIS(6 DOWNTO 0) <= "0000010"; -- 6
    64 WHEN "0111" => DIS(6 DOWNTO 0) <= "1111000"; -- 7
    65 WHEN "1000" => DIS(6 DOWNTO 0) <= "0000000"; -- 8
    66 WHEN "1001" => DIS(6 DOWNTO 0) <= "0010000"; -- 9
    67 WHEN OTHERS => DIS(6 DOWNTO 0) <= "1111111";
    68 END CASE;
    69 END PROCESS;
    70
    71 END XIANSHI;
    

    复制完代码发现有点烦了。。。

    如果需要稍后可以自行下载文件(完整工程及技术报告)QAQ

    https://download.csdn.net/download/u012579502/10655901

    展开全文
  • 电子时钟实验报告

    2012-05-28 21:29:38
    华中科大的电子时钟实验报告,写的很详细,对于VHDL之类的IC课程设计很有用处
  • 嵌入式系统多功能数字时钟设计(毕业设计)
  • 电子时钟以成为人们常生活中数字电子钟一般由振荡器,分频器,译码器,显示器等部分组成。电子时钟的应用非常广泛,应用于人家庭或车站、剧场、办公室等公共场所,给人们的生活,学习,工作,娱乐带来极大的便利, ...
  • 单片机课程设计-多功能电子钟 电子钟具有显示年、月、日、时、分、秒及星期功能,可识别闰年(可用实验板上的I2C接口日历时钟芯片,或用软件方式模拟I2C接口日历时钟芯片功能)。 具有星期报警功能;可在一天内设置...
  • 多功能时钟_需求分析报告编写规范c++版,绝对试用
  • 数字逻辑 课程设计 多功能电子钟 Quartus II

    万次阅读 多人点赞 2014-09-27 15:00:31
    设计方案 1.系统功能描述 (1) 系统输入:系统状态及校时、定时转换的控制信号为k、set;...(3) 多功能数字控制器的状态图如图所示 图中:S0:显示计时器时间 T0:显示闹铃时间  S1:调计

    设计方案

    1.系统功能描述

                                     (1)      系统输入:系统状态及校时、定时转换的控制信号为k、set;时钟信号clk,采用1024Hz;系统复位信号为reset。输入信号由按键产生。

                                     (2)      系统输出:LED显示输出;蜂鸣器声音信号输出。

                                     (3)      多功能数字钟控制器的状态图如图所示

                                                    图中:S0:显示计时器时间     T0:显示闹铃时间

                                                                S1:调计时的时         T1:调闹铃的时

                                                                S2:调计时的分         T2:调闹铃的分

                                                                S3:调计时的秒         T3:调闹铃的秒

                                      (4)      计时:正常工作状态下,按下“set键”,进入“小时”校准状态,之后按下“k键”则进入“分”校准状态,继续按下“k键”则进入“秒复零”状态,第三次按下“k                                                    键”又恢复到正常计时显示状态。

                                      (5)      ”小时“校准状态:在“小时”校准状态下,显示”小时的数码管闪烁,通过按下”p键“使其递增计数。

                                      (6)      ”分“校准状态:在“分”校准状态下,显示“分”的数码管闪烁,通过按下”p键“使其递增计数。

                                      (7)      “秒”复零状态:在:“秒复零”状态下,显示“秒”的数码管闪烁并复零。

                                      (8)      整点报时:蜂鸣器在“59”分钟的第51、53、55、57秒发出频率为512Hz的低音,在“59”秒发出频率为1024Hz的高音,结束时为整点。

                                      (9)      显示:要求采用扫描显示方式驱动8个LED数码管分别显示时、分、秒并且他们之间用“—”隔开。

                                      (10)  闹钟:闹钟定时时间到,蜂鸣器发出周期为1s的滴、滴声,持续时间为10秒;闹钟定时显示。

                                      (11)  闹钟定时设置:在闹钟显示状态下,按下“set键”,进入“小时”校时状态,之后按下“k键”,进入“分”校时状态,继续按下“k键”,进入“秒”校时状态,第                                                   三次按下“k键”又恢复到闹钟显示状态。

                                      (12)  闹钟的时、分、秒设置过程和计时设置相同。



    整体效果图:


    1.控制器


    library ieee;
    use ieee.std_logic_1164.all;
    entity ctr is
         port(p:in std_logic;
              cp:in std_logic;
              k:in std_logic;
              set:in std_logic;
              reset:in std_logic;
              resec:out std_logic;
    
              rehour:out std_logic;
              setmin:out std_logic;
              setminen:out std_logic;
              sethour:out std_logic;
              sethouren:out std_logic;
              hourflash:out std_logic;
              minflash:out std_logic;
              secflash:out std_logic;
              ahourflash:out std_logic;
              aminflash:out std_logic;
              asecflash:out std_logic;
              changemode:out std_logic;
              setclksec:out std_logic;
              setclkmin:out std_logic;
              setclkhour:out std_logic);
    end ctr;
    architecture rtl of ctr is
    type state is(s0,s1,s2,s3,t0,t1,t2,t3);
    signal clock_s:state;
          begin 
            process(cp,k,set,reset,p)
               begin
                  if(reset='0') then
                       resec<='1';remin<='1';rehour<='1';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';clock_s<=s0;
                  elsif(rising_edge(cp)) then
                     case clock_s is
                       when s0=>changemode<='0';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0') then
                               clock_s<=t0;
                            elsif(set='0')then
                               clock_s<=s1;
                            else
                               clock_s<=s0;
                          end if;
                       when s1=>changemode<='0';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='1';sethour<=p;hourflash<='1';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s2;
                            else
                               clock_s<=s1;
                          end if;
                       when s2=>changemode<='0';
                       resec<='0';remin<='0';rehour<='0';setminen<='1';setmin<=p;sethouren<='0';sethour<='0';hourflash<='0';minflash<='1';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s3;
                            else
                               clock_s<=s2;
                          end if;
                       when s3=>changemode<='0';
                       resec<=p;remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='1';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s0;
                            else
                               clock_s<=s3;
                          end if;
                       when t0=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s0;
                            elsif(set='0') then
                               clock_s<=t1;
                            else
                               clock_s<=t0;
                          end if;
                       when t1=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='1';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<=p;
                            if(k='0')then
                               clock_s<=t2;
                            else
                               clock_s<=t1;
                          end if;
                       when t2=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='1';asecflash<='0';setclksec<='0';setclkmin<=p;setclkhour<='0';
                            if(k='0')then
                               clock_s<=t3;
                            else
                               clock_s<=t2;
                          end if;
                       when t3=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='1';setclksec<=p;setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=t0;
                            else
                               clock_s<=t3;
                          end if;
                       when others=>clock_s<=s0;
                   end case;
              end if;
           end process;
    end rtl;
    

    2.60进制计数器


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    USE IEEE.STD_LOGIC_ARITH.ALL;
    ENTITY counter_60 IS
           PORT(rs,cp:IN STD_LOGIC;
                co   :OUT STD_LOGIC;
                ql,qh   :OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
        END counter_60;
    ARCHITECTURE rtl OF counter_60 IS
        SIGNAL ql_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        SIGNAL qh_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        BEGIN
            PROCESS (rs,cp,qh_temp,ql_temp)
              BEGIN
                  if(rs='1') then
                       qh_temp<="0000";
                       ql_temp<="0000";
                       co<='0';
                elsIF(rising_edge(cp)) then
                   
                   if(qh_temp="0101" and ql_temp="1001") then
                       ql_temp<="0000";
                       qh_temp<="0000";
                       co<='1';
                   elsif(qh_temp<="0101" and ql_temp<"1001") then
                       ql_temp<=ql_temp+'1';
                       co<='0';
                   elsif(qh_temp<="0101" and ql_temp="1001") then
                       qh_temp<=qh_temp+'1';
                       ql_temp<="0000";
                       co<='0';
                end if;
              end if;
              qh<=qh_temp;
              ql<=ql_temp;
            END PROCESS;
    END rtl;
    

    3.24进制计数器


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    USE IEEE.STD_LOGIC_ARITH.ALL;
    ENTITY counter_24 IS
           PORT(rs,cp:IN STD_LOGIC;
                ql,qh   :OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
        END counter_24;
    ARCHITECTURE rtl OF counter_24 IS
        SIGNAL ql_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        SIGNAL qh_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        SIGNAL rs_temp:STD_LOGIC;
        BEGIN
            PROCESS (rs,cp)
              BEGIN
                   if(rs='1') then
                       qh_temp<="0000";
                       ql_temp<="0000";
                elsIF(rising_edge(cp)) then
                   if(qh_temp="0010" and ql_temp="0011") then
                       qh_temp<="0000";
                       ql_temp<="0000";
                   elsif(qh_temp<="0010" and ql_temp<"1001") then
                       ql_temp<=ql_temp+'1';
                   elsif(qh_temp<="0010" and ql_temp="1001") then
                       qh_temp<=qh_temp+'1';
                       ql_temp<="0000";
                end if;
              end if;
            END PROCESS;
              qh<=qh_temp;
              ql<=ql_temp;
    END rtl;
    

    4.模1024计数器(分频器)


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.std_logic_unsigned.all;
    entity counter_10 is
          port(cp:in std_logic;
               d :out std_logic_vector(9 downto 0));
    end counter_10;
    architecture rtl of counter_10 is
    signal d_temp:std_logic_vector(9 downto 0):="0000000000";
       begin
        process(cp)
          begin
           if(rising_edge(cp)) then
               if(d_temp="1111111111") then
                  d_temp<="0000000000";
               else 
                  d_temp<=d_temp+'1';
               end if;
           end if;
        end process;
    d<=d_temp;
    end rtl;
    

    5.模8计数器(数码管扫描动态显示)


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.std_logic_unsigned.all;
    entity counter_8 is
       port(cp,en:in std_logic;
            a: out std_logic_vector(2 downto 0));
    end counter_8;
    architecture rtl of counter_8 is
         signal a_temp:std_logic_vector(2 downto 0):="000";
        begin
          process(cp,en)
            begin
             if(rising_edge(cp) and en='1') then
                 if(a_temp="111") then
                    a_temp<="000";
                 else
                    a_temp<=a_temp+'1';
                end if;
             end if;
           end process;
          a<=a_temp;
    end rtl;
    

    6.数据通断器(闪烁)


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.std_logic_unsigned.all;
    entity d_ff is
        port(en:in std_logic;
             q0 :out std_logic_vector(3 downto 0);
             q1 :out std_logic_vector(3 downto 0);
             d0 :in std_logic_vector(3 downto 0);
             d1 :in std_logic_vector(3 downto 0));
    end d_ff;
    architecture rtl of d_ff is
         begin 
           process(en,d0,d1)
              begin
                if(en='1') then
                 q0<=d0;
                 q1<=d1;
                else
                 q0<="1110";
                 q1<="1110";
              end if;
           end process;
    end rtl;
    

    7.48译码器(驱动数码管显示)


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    ENTITY decode_48 IS
        PORT(d:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
             y:OUT STD_LOGIC_VECTOR(6 DOWNTO 0));
    END decode_48;
    ARCHITECTURE rtl OF decode_48 IS
           BEGIN
             PROCESS(d)
             BEGIN
             CASE d IS
                WHEN "0000"=>y<="1111110";
                WHEN "0001"=>y<="0110000";
                WHEN "0010"=>y<="1101101";
                WHEN "0011"=>y<="1111001";
                WHEN "0100"=>y<="0110011";
                WHEN "0101"=>y<="1011011";
                WHEN "0110"=>y<="1011111";
                WHEN "0111"=>y<="1110000";
                WHEN "1000"=>y<="1111111";
                WHEN "1001"=>y<="1111011";
                WHEN "1111"=>y<="0000001";
                WHEN OTHERS=>y<="0000000";
             END CASE;
           END PROCESS;
    END rtl;
     
    

    8.响铃模块


    library ieee;
    use ieee.std_logic_1164.all;
    entity ring is
            port(cp1,cp512,cp1024,en:in std_logic;
                 hourh,hourl,ahourh,ahourl,minh,minl,aminh,aminl,sech,secl,asech,asecl:in std_logic_vector(3 downto 0);
                 r:out std_logic);
    end ring;
    architecture rtl of ring is
          begin
            process(en,hourh,hourl,ahourh,ahourl,minh,minl,aminh,aminl,sech,secl,asech,asecl,cp1,cp512,cp1024)
               begin
                  if(en='1')then
                    if(hourh=ahourh and hourl=ahourl and minh=aminh and minl=aminl)then
                        if(cp1='1')then
                           r<=cp512;
                        else
                           r<='0';
                       end if;
                    elsif(minh="0101" and minl="1001" and sech="0101")then
                       if(secl="0001" or secl="0011" or secl="0101" or secl="0111")then
                           r<=cp512;
                       elsif(secl="1001")then
                           r<=cp1024;
                       else
                           r<='0';
                       end if;
                    else
                         r<='0';
                    end if;
                 end if;
            end process;
    end rtl;
    

    9.8选1数据选择器


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    ENTITY sel_81 IS
          PORT(a:IN STD_LOGIC_VECTOR(2 DOWNTO 0);
               y:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
               d0:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d1:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d2:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d3:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d4:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d5:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d6:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d7:IN STD_LOGIC_VECTOR(3 DOWNTO 0));
               
    END sel_81;
    ARCHITECTURE rtl OF sel_81 IS
          BEGIN
            PROCESS(d0,d1,d2,d3,d4,d5,d6,d7,a)
              BEGIN
                CASE a IS
                   WHEN "000"=>y<=d7;
                   WHEN "001"=>y<=d6;
                   WHEN "010"=>y<=d5;
                   WHEN "011"=>y<=d4;
                   WHEN "100"=>y<=d3;
                   WHEN "101"=>y<=d2;
                   WHEN "110"=>y<=d1;
                   WHEN "111"=>y<=d0;
                END CASE;
            END PROCESS;
    END rtl;
    

    10.一位二选一数据选择器


    library ieee;
    use ieee.std_logic_1164.all;
    entity sel_21 is 
           port(a:in std_logic;
                y:out std_logic_vector(3 downto 0);
                d0:in  std_logic_vector(3 downto 0);
                d1:in  std_logic_vector(3 downto 0));
    end sel_21;
    architecture rtl of sel_21 is
          begin
             process(a,d0,d1)
              begin
                case a is
                 when '0'=>y<=d0;
                 when '1'=>y<=d1;
                end case;
             end process;
    end rtl;
    

    11.四位二选一数据选择器


    library ieee;
    use ieee.std_logic_1164.all;
    entity selone_21 is 
           port(a:in std_logic;
                y:out std_logic;
                d0:in  std_logic;
                d1:in  std_logic);
    end selone_21;
    architecture rtl of selone_21 is
          begin
             process(a,d0,d1)
              begin
                case a is
                 when '0'=>y<=d0;
                 when '1'=>y<=d1;
                end case;
             end process;
    end rtl;
    
    心得体会:

    在课程设计开始之前,我便对电子钟的制作产生了兴趣,通过在课堂上和老师一起学习VHDL语言的使用方法,以及课下上机进行练习,我已经初步掌握了通过该语言编写程序的方法,如编写底层程序,编译,仿真,生成模块,顶层连接等。并在几次实验课上分别上机连接硬件验证了自己编写的程序的正确性,为课程设计的实现打下了基础。在课程设计的实现过程中,我也遇到了很多问题,一开始是软件使用不够熟练,经常忘记某些步骤,甚至还发生过代码被覆盖的情况,其次是我才用了从中心向四周扩散的设计思路,即首先实现基本的时钟计数和显示的功能,然后再分别添加调节时钟的功能,显示闪烁的功能,闹钟的功能等,这种方法有利有弊,好处是一开始不用想太多,不用管整体是怎样的,只要将各个模块做好即可,所以很适合在知识储备不足的情况下进行设计,但缺点就是最后会发现控制端口很多,导致控制器非常庞大,整个电路的布线较乱,集成度低,最后就是考虑问题不够周全,比如我一开始在连线测试的时候发现数字显示是反着的,但是由于电路基本已经成型,模块多,不便于查错,在一个星期的制作当中,我利用中午,晚上以及平时上机时空闲的时间进行制作,由于只有一个人,所以不会因为思路的冲突而和搭档发生争论,但由于精力有限,所以花的时间非常多,但是对于自己感兴趣的事情,即使很累依然开心。通过课程设计,我觉得自己独立思考的能力和模块化的思维有了提高,在给同学的改错和讲解过程中,我也了解了很多常见的错误以及解决方法,积累了知识和经验,同时也体现了同学之间互帮互助的精神。我还要非常感谢指导老师对我的细心指导,在老师的帮助下,我不仅顺利完成了课程设计,还体会到了作为老师的不易之处,每天面对相同的问题,几百个学生,压力和焦虑都是在所难免的,所以在以后的学习过程中,我会更加从老师的立场思考,不给老师带来额外的压力。





    展开全文
  • 可以作为兴趣爱好去做,也可以做为课设,毕设,我做过,可以实现的,有问题Q我
  • 2.1 设计题目:基于PIC16F877A单片机的多功能电子时钟2.2 功能实现:实时时钟显示,时间可调;实时温度显示,并具有超限报警功能。输出显示采用LCD1602或LED七段数码显示器。2.3 设计要求:自己设计硬件和程序编程,...
  • EDA电子时钟设计

    2012-12-16 21:53:13
    这是基于EDA的电子时钟开发设计 计数部分:由两个60进制计数器和一个24 进制计数器组成,其中60 进制计数器可用6 进制计数器和10 进制计数器构成;24 进制的小时计数同样可用6 进制计数器和10 进制计数器得到:当...
  • 电子时钟设计资料,包括简易电子钟设计,单片机控电子时钟设计,S1307的多功能时钟系统。
  • 首先分析了多功能数字设计要求、所需实现的功能,然后分析了实现每个功能所需要的基础模块,最后进一步分析了各种基础模块。在具体设计时,采用的是自底向上的设计方法。首先设计各种基础模块,然后设计各种功能...
  • 课程设计毕业设计用的到的程序,汇编语言。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,198
精华内容 10,879
关键字:

多功能电子时钟设计报告