数字电路课程设计报告

题目：数字电子钟的设计

         姓    名：   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进制计数器上面花了很久的时间，才知道原来是可以有两种方法的，一种是在用复位端（清零端）置零，还有一种是置数端置零。彻底理解了任意进制计数器。 

任何事情都是一步一步来的，希望从这次课程设计中我可以冷静分析，慢慢纠错，不慌不忙地做好任何一件事情。

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();	

 

主要功能要求：

1、电子时钟。要求用 24 时制显示。分屏显示“时、分”和“分、秒”，即 4 个数码管不能同时显示“时、分、秒”，但可以只显示“时、分”，或只显示“分、秒”，通过按键来切换这两种显示方式。用数码管的小数点“.”代替时、分、秒的分隔符“：”。可设置时间。设置时间时，当前设置的“时”/“分”，相应的数码管应闪烁。 

2、秒表（计时器）。秒表精度为 0.01 秒，计时范围 0~99.99 秒，用 4 个数码管显示，两个显示秒，两个显示百分秒，有暂停/继续、重置（清零）按钮。 

3、定时器。可以实现 0~9999 秒定时。设置一定时值，当计时到达设定值时输出 LED 闪烁。有设置、暂停/继续、清零定时按钮。



参考思路：


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

以上方案共需：5 个按键： MOD、SET、↑、OK、CLR




硬件实物图：





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

设计方案

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