devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

FPGA数字钟系统设计——VHDL语言_在六个led数码管上分别显示“时”、“分”、“秒”的时间,“时”采用二十四进制。

作者：寸_铁 | 2024-07-11 18:56:38

赞

踩

在六个led数码管上分别显示“时”、“分”、“秒”的时间,“时”采用二十四进制。

一、设计任务与要求

设计一个数字时钟系统，该系统应包含准确的计时、直观的显示、方便的校时和复位功能。采用EDA自顶向下的设计方法，在Quartus II环境中，结合原理图和VHDL文本混合输入，完成数字时钟系统的整体设计、各功能模块的程序编写、仿真验证，并在FPGA实验开发板上实现。系统需实现时、分、秒的计时，通过6个LED七段数码管显示时间，支持通过按键进行小时和分钟的单独调整，以及通过按键进行系统复位。

二、数字钟系统设计分析

在数字钟系统设计中，我们采用了自顶向下的方法，将系统划分为多个子模块以实现所需功能。主要模块设计概述如下：

1、分频器模块：用于降低时钟频率，生成1Hz的时钟信号和1KHz的刷新信号，分别用于时间计量和数码管刷新。

2、信号分配模块：负责将1Hz时钟信号和复位信号分发至秒、分、时计时器，确保同步计时和复位。

3、计时器模块：采用24进制和60进制计数器分别记录小时、分钟和秒数，通过进位信号实现连续计时。

4、数据选择器与消抖模块：选择时间调整模式，并使用D触发器型电路消除按键抖动，确保输入信号的稳定性。

5、数码管译码器模块：将计时器的二进制输出转换为数码管可显示的编码，并行输出到显示模块。

6、显示与提醒模块：通过1KHz刷新信号驱动数码管动态显示时间，同时实现闹钟提醒功能，当时间达到预设值时触发蜂鸣器。

7、模块整合：通过原理图设计连接各模块，优化信号传输路径，形成完整的数字钟系统。

三、管脚配置及程序下载硬件验证

1、管脚配置

在FPGA设计流程中，管脚配置是确保设计正确映射到物理硬件的关键步骤。针对选用的FPGA开发板型号（EP4CE10F17C8），进行了精确的管脚分配。

（1）了解开发板资源：查阅FPGA开发板的用户手册文档，详细了解了开发板上的各种资源。根据数字钟系统的设计需求，我们规划了所需使用的IO引脚，包括用于连接数码管显示的时间显示引脚、用于接收按键输入的引脚等。

（2）Quartus II环境下的管脚分配：在明确资源规划后，打开了Quartus II软件，在项目中进行了管脚配置。通过软件提供的图形化界面，逐一将VHDL代码中定义的信号与实际硬件的引脚进行对应。

2、程序下载硬件验证

在完成管脚配置后，将VHDL代码编译生成的二进制文件（如“MARQUEE.sof”）通过FPGA开发板的下载工具（如USB-Blaster）下载到FPGA开发板中，进行硬件验证。

（1）时间显示验证：在正常运行状态下，观察数字钟是否能够准确无误地显示当前的时间，包括小时、分钟和秒数。通过长时间运行和多次观察，验证了时间显示的准确性，确保每个时间单位的更新都是准确无误的。

（2）复位功能验证：按下“复位”键，数字钟迅速且完全地重置为初始状态。这时所有时间单位（小时、分钟、秒）都归零。当松开“复位”键时，系统从初始时间开始计时。

（3）闹钟功能验证：在闹钟功能验证环节，设定了特定的时间（如“00:00:00”和“12:00:00”）作为触发蜂鸣器响起的条件。当达到这些特定时间时，观察到蜂鸣器按预期响起2秒，从而验证了闹钟功能的实现。

（4）时间调分功能验证：按下“调分”键。当按下“调分”键时，数字钟的分钟显示将按照预设的1Hz速度递增。当松开“调分”键，时间又按照正常时间开始进行计时。

（5）时间调时功能验证：按下“调时”键。当按下“调时”键时，数字钟的小时显示将按照预设的1Hz速度递增。当松开“调时”键，时间又按照正常时间开始进行计时。

三、代码与原理图连接

1、CLOCKDIVIDER：

  1. LIBRARY IEEE;    
  2. USE IEEE.STD_LOGIC_1164.ALL;    
  3.   
  4. ENTITY CLOCKDIVIDER IS    
  5.     PORT (     
  6.         CLK_IN  : IN  STD_LOGIC;    
  7.         CLK_1KHZ : OUT STD_LOGIC;    
  8.         CLK_1HZ  : OUT STD_LOGIC    
  9.     );    
  10. END CLOCKDIVIDER;    
  11.   
  12. ARCHITECTURE BEHAVIORAL OF CLOCKDIVIDER IS    
  13.     SIGNAL COUNT_1KHZ : INTEGER RANGE 0 TO 24999 := 0;    
  14.     SIGNAL COUNT_1HZ  : INTEGER RANGE 0 TO 24999999 := 0;    
  15.     SIGNAL TEMP_1KHZ  : STD_LOGIC := '0';    
  16.     SIGNAL TEMP_1HZ   : STD_LOGIC := '0';    
  17. BEGIN     
  18.     PROCESS(CLK_IN)    
  19.     BEGIN    
  20.         IF CLK_IN = '1' AND CLK_IN'EVENT THEN    
  21.             IF COUNT_1KHZ = 24999 THEN    
  22.                 COUNT_1KHZ <= 0;    
  23.                 TEMP_1KHZ <= NOT TEMP_1KHZ;    
  24.             ELSE    
  25.                 COUNT_1KHZ <= COUNT_1KHZ + 1;    
  26.             END IF;    
  27.         END IF;    
  28.     END PROCESS;    
  29.     
  30.     CLK_1KHZ <= TEMP_1KHZ;    
  31.       
  32.     PROCESS(CLK_IN)    
  33.     BEGIN    
  34.         IF CLK_IN = '1' AND CLK_IN'EVENT THEN   
  35.             IF COUNT_1HZ = 24999999 THEN    
  36.                 COUNT_1HZ <= 0;    
  37.                 TEMP_1HZ <= NOT TEMP_1HZ;    
  38.             ELSE    
  39.                 COUNT_1HZ <= COUNT_1HZ + 1;    
  40.             END IF;    
  41.         END IF;    
  42.     END PROCESS;    
  43.     
  44.     CLK_1HZ <= TEMP_1HZ;    
  45.     
  46. END BEHAVIORAL;

2、MUX_TWO_ONE：

  1. LIBRARY IEEE;  
  2. USE IEEE.STD_LOGIC_1164.ALL;  
  3. USE IEEE.STD_LOGIC_UNSIGNED.ALL; 
  4.  
  5. ENTITY MUX_TWO_ONE IS
  6. PORT(
  7. 	 KEY       : IN STD_LOGIC;  -- 选择信号
  8.     CLK_1HZ  : IN  STD_LOGIC;  -- 1HZ时钟输入
  9.     CLK_QOUT  : IN  STD_LOGIC; -- 时钟输入
  10.     CLK_OUT    : OUT STD_LOGIC -- 输出时钟
  11. );
  12. END MUX_TWO_ONE; 
  13.  
  14. ARCHITECTURE MUX OF MUX_TWO_ONE IS
  15.     SIGNAL D1 : STD_LOGIC:='1';
  16. 	 SIGNAL D2 : STD_LOGIC:='1';
  17. 	 SIGNAL D3 : STD_LOGIC:='1';
  18.     SIGNAL OUT_KEY : STD_LOGIC; 
  19. BEGIN
  20.     P1: PROCESS(CLK_1HZ)  
  21.     BEGIN  
  22. 	 IF CLK_1HZ'EVENT AND CLK_1HZ = '1' THEN 
  23. 		D1<=KEY;
  24. 		D2<=D1;
  25. 		D3<=D2;
  26. 	 END IF;
  27. 		OUT_KEY<=D1 OR D2 OR D3;
  28.     END PROCESS P1;
  30.     P2:PROCESS(OUT_KEY)
  31.     BEGIN
  32.     IF OUT_KEY = '0' THEN
  33. 		CLK_OUT <= CLK_1HZ;
  34.     ELSE
  35. 		CLK_OUT <= CLK_QOUT;
  36.     END IF;
  37.     END PROCESS P2;
  38. END MUX;

3、SPLITTER_ONE_THREE：

  1. LIBRARY IEEE;  
  2. USE IEEE.STD_LOGIC_1164.ALL;  
  3. USE IEEE.STD_LOGIC_UNSIGNED.ALL; 
  4.  
  5. ENTITY SPLITTER_ONE_THREE IS
  6. PORT(
  7.     INPUT  : IN  STD_LOGIC;    -- 输入
  8.     OUTPUTONE  : OUT  STD_LOGIC;    -- 输出1
  9.     OUTPUTTWO   : OUT STD_LOGIC;    -- 输出2
  10.     OUTPUTTHREE    : OUT STD_LOGIC -- 输出3
  11. );
  12. END SPLITTER_ONE_THREE; 
  13.  
  14. ARCHITECTURE SPLITTER OF SPLITTER_ONE_THREE IS    
  15. BEGIN
  16. PROCESS(INPUT)
  17. BEGIN
  18. IF INPUT='1' THEN
  19. 	OUTPUTONE<='1';
  20. 	OUTPUTTWO<='1';
  21. 	OUTPUTTHREE<='1';
  22. 	ELSE
  23. 		OUTPUTONE<='0';
  24. 	OUTPUTTWO<='0';
  25. 	OUTPUTTHREE<='0';
  26. 	END IF;
  27. 	END PROCESS;
  28. END SPLITTER;

4、clock_display_24：

  1. library ieee;  
  2. use ieee.std_logic_1164.all;  
  3. use ieee.numeric_std.all;  
  4.   
  5. entity clock_display_24 is  
  6.     Port (  
  7.         seconds : in  std_logic_vector(4 downto 0); -- 输入的秒数（0-59）  
  8.         seg_ten : out std_logic_vector(6 downto 0); -- 十位数码管段  
  9.         seg_one : out std_logic_vector(6 downto 0));  -- 个位数码管段   
  10. end clock_display_24;  
  11. architecture Behavioral of clock_display_24 is  
  12.     -- 七段数码管译码函数  
  13.     function seven_seg_decode(num : integer range 0 to 9) return std_logic_vector is  
  14.         variable seg : std_logic_vector(6 downto 0);  
  15.     begin  
  16.         case num is  
  17.             when 0 => seg := "1000000"; -- A到G（DP省略）  
  18.             when 1 => seg := "1111001";  
  19. 				when 2 => seg := "0100100"; 
  20. 				when 3 => seg := "0110000"; 
  21. 				when 4 => seg := "0011001"; 
  22. 				when 5 => seg := "0010010"; 
  23. 				when 6 => seg := "0000010"; 
  24. 				when 7 => seg := "1111000"; 
  25. 				when 8 => seg := "0000000"; 
  26.             when 9 => seg := "0010000";  
  27.             when others => seg := "1111111"; -- 错误指示  
  28.         end case;  
  29.         return seg;  
  30.     end function;  
  31.   
  32.     -- 声明变量来存储十位和个位的值  
  33.     signal ten_val, one_val : integer range 0 to 9;  
  34.   
  35. begin  
  36.     process(seconds)  
  37.     begin  
  38.             -- 计算十位 
  39.             ten_val <= to_integer(unsigned(seconds)) / 10;  
  40.             -- 调用译码函数并更新输出  
  41.             seg_ten <= seven_seg_decode(ten_val);    
  42.     end process;    
  43.     process(seconds)  
  44.     begin  
  45.             -- 计算个位  
  46.             one_val <= to_integer(unsigned(seconds)) mod 10;  
  47.       
  48.             -- 调用译码函数并更新输出   
  49.             seg_one <= seven_seg_decode(one_val);  
  50.     end process;  
  51. end Behavioral;

5、CLOCK_24：

  1. LIBRARY IEEE;  
  2. USE IEEE.STD_LOGIC_1164.ALL;  
  3. USE IEEE.STD_LOGIC_UNSIGNED.ALL; 
  4.   
  5. ENTITY CLOCK_24 IS
  6. PORT(
  7.     CLK  : IN  STD_LOGIC;    -- 时钟输入
  8.     RST  : IN  STD_LOGIC;    -- 重置输入
  9.     CLK_M    : OUT STD_LOGIC_VECTOR(4 DOWNTO 0) -- 当前时间
  10. );
  11. END CLOCK_24; 
  12.   
  13. ARCHITECTURE CLOCK2 OF CLOCK_24 IS    
  14.   SIGNAL TEM_CLK_M : STD_LOGIC_VECTOR(4 DOWNTO 0) := (OTHERS => '0');
  15. BEGIN
  16.   PROCESS(CLK, RST)
  17.   BEGIN
  18.     IF RST = '0' THEN
  19.       TEM_CLK_M <= (OTHERS => '0');
  20.     ELSIF CLK'EVENT AND CLK = '1' THEN
  21.         IF TEM_CLK_M = "11000" THEN
  22.           TEM_CLK_M <= (OTHERS => '0');
  23.         ELSE
  24.           TEM_CLK_M <= TEM_CLK_M + 1;
  25.         END IF;
  26.       END IF;
  27.   END PROCESS;
  28.   CLK_M <= TEM_CLK_M;  
  29. END CLOCK2;

6、CLOCK_60：

  1. LIBRARY IEEE;  
  2. USE IEEE.STD_LOGIC_1164.ALL;  
  3. USE IEEE.STD_LOGIC_UNSIGNED.ALL; 
  4.   
  5. ENTITY CLOCK_60 IS
  6. PORT(
  7.     CLK  : IN  STD_LOGIC;    -- 时钟输入
  8.     RST  : IN  STD_LOGIC;    -- 重置输入
  9.     QOUT     : OUT STD_LOGIC;    -- 进位输出信号
  10.     CLK_M    : OUT STD_LOGIC_VECTOR(5 DOWNTO 0) -- 当前时间
  11. );
  12. END CLOCK_60; 
  13.   
  14. ARCHITECTURE CLOCK1 OF CLOCK_60 IS    
  15.   SIGNAL TEM_CLK_M : STD_LOGIC_VECTOR(5 DOWNTO 0) := (OTHERS => '0');
  16. BEGIN
  17.   PROCESS(CLK, RST)
  18.   BEGIN
  19.     IF RST = '0' THEN
  20.       TEM_CLK_M <= (OTHERS => '0');
  21.       QOUT <= '0';
  22.     ELSIF CLK'EVENT AND CLK = '1' THEN
  23.         IF TEM_CLK_M = "111011" THEN
  24.           QOUT <= '1';
  25.           TEM_CLK_M <= (OTHERS => '0');
  26.         ELSE
  27.           TEM_CLK_M <= TEM_CLK_M + 1;
  28.           QOUT <= '0';
  29.         END IF;
  30.       END IF;
  31.   END PROCESS;
  32.   CLK_M <= TEM_CLK_M;  
  33. END CLOCK1;

7、clock_display ：

  1. library ieee;  
  2. use ieee.std_logic_1164.all;  
  3. use ieee.numeric_std.all;  
  4.   
  5. entity clock_display is  
  6.     Port (  
  7.         seconds : in  std_logic_vector(5 downto 0); -- 输入的秒数（0-59）  
  8.         seg_ten : out std_logic_vector(6 downto 0); -- 十位数码管段  
  9.         seg_one : out std_logic_vector(6 downto 0));  -- 个位数码管段  
  10.  
  11. end clock_display;  
  12. architecture Behavioral of clock_display is  
  13.     -- 七段数码管译码函数  
  14.     function seven_seg_decode(num : integer range 0 to 9) return std_logic_vector is  
  15.         variable seg : std_logic_vector(6 downto 0);  
  16.     begin  
  17.         case num is  
  18.             when 0 => seg := "1000000"; -- A到G（DP省略）  
  19.             when 1 => seg := "1111001";  
  20. 				when 2 => seg := "0100100"; 
  21. 				when 3 => seg := "0110000"; 
  22. 				when 4 => seg := "0011001"; 
  23. 				when 5 => seg := "0010010"; 
  24. 				when 6 => seg := "0000010"; 
  25. 				when 7 => seg := "1111000"; 
  26. 				when 8 => seg := "0000000"; 
  27.             when 9 => seg := "0010000";  
  28.             when others => seg := "1111111"; -- 错误指示  
  29.         end case;  
  30.         return seg;  
  31.     end function;  
  32.   
  33.     -- 声明变量来存储十位和个位的值  
  34.     signal ten_val, one_val : integer range 0 to 9;  
  35.   
  36. begin  
  37.     process(seconds)  
  38.     begin  
  39.             -- 计算十位 
  40.             ten_val <= to_integer(unsigned(seconds)) / 10;  
  41.             -- 调用译码函数并更新输出  
  42.             seg_ten <= seven_seg_decode(ten_val);    
  43.     end process;    
  44.     process(seconds)  
  45.     begin  
  46.             -- 计算个位  
  47.             one_val <= to_integer(unsigned(seconds)) mod 10;  
  48.       
  49.             -- 调用译码函数并更新输出   
  50.             seg_one <= seven_seg_decode(one_val);  
  51.     end process;  
  52. end Behavioral;

8、TUBE：

  1. LIBRARY IEEE;  
  2. USE IEEE.STD_LOGIC_1164.ALL;  
  3. USE IEEE.STD_LOGIC_UNSIGNED.ALL;   
  4.   
  5. ENTITY TUBE IS  
  6.     PORT (  
  7.         CLK            : IN  STD_LOGIC;  
  8.         TUBE_SIX       : IN  STD_LOGIC_VECTOR(6 DOWNTO 0);  
  9.         TUBE_FIVE      : IN  STD_LOGIC_VECTOR(6 DOWNTO 0);  
  10.         TUBE_FOUR      : IN  STD_LOGIC_VECTOR(6 DOWNTO 0);  
  11.         TUBE_THREE     : IN  STD_LOGIC_VECTOR(6 DOWNTO 0);  
  12.         TUBE_TWO       : IN  STD_LOGIC_VECTOR(6 DOWNTO 0);  
  13.         TUBE_ONE       : IN  STD_LOGIC_VECTOR(6 DOWNTO 0);  
  14.         TUBE_NOW       : OUT STD_LOGIC_VECTOR(6 DOWNTO 0);  
  15.         TIME_CLOCK     : OUT STD_LOGIC;  
  16.         EN             : OUT STD_LOGIC_VECTOR(5 DOWNTO 0)  
  17.     );  
  18. END TUBE;  
  19.   
  20. ARCHITECTURE ONE OF TUBE IS  
  21.     SIGNAL TEM_EN            : STD_LOGIC_VECTOR(5 DOWNTO 0) := "011111";  
  22.     SIGNAL TEM_TIME_CLOCK    : STD_LOGIC := '1';  
  23.     SIGNAL FLAG              : STD_LOGIC := '0';  
  24.     SIGNAL TEM_TUBE_SIX      : STD_LOGIC_VECTOR(6 DOWNTO 0) := "0000000";  
  25.     SIGNAL TEM_TUBE_FIVE     : STD_LOGIC_VECTOR(6 DOWNTO 0) := "0000000";  
  26.     SIGNAL TEM_TUBE_FOUR     : STD_LOGIC_VECTOR(6 DOWNTO 0) := "0000000";  
  27.     SIGNAL TEM_TUBE_THREE    : STD_LOGIC_VECTOR(6 DOWNTO 0) := "0000000";  
  28.     SIGNAL TEM_TUBE_TWO      : STD_LOGIC_VECTOR(6 DOWNTO 0) := "0000000";  
  29.     SIGNAL TEM_TUBE_ONE      : STD_LOGIC_VECTOR(6 DOWNTO 0) := "0000000";  
  30. BEGIN 
  31. P1: PROCESS(CLK)  
  32. BEGIN  
  33.     IF CLK'EVENT AND CLK = '1' THEN  
  34.         TEM_EN <= TEM_EN(4 DOWNTO 0) & TEM_EN(5);  
  35.         EN <= TEM_EN;  
  36.     END IF;  
  37. END PROCESS P1;  
  38.   
  39. P2: PROCESS(TEM_EN, TUBE_ONE, TUBE_TWO, TUBE_THREE, TUBE_FOUR, TUBE_FIVE, TUBE_SIX)  
  40. BEGIN  
  41.     CASE TEM_EN IS  
  42.         WHEN "111101" => TUBE_NOW <= TUBE_ONE;  
  43.         WHEN "111011" => TUBE_NOW <= TUBE_TWO;  
  44.         WHEN "110111" => TUBE_NOW <= TUBE_THREE;  
  45.         WHEN "101111" => TUBE_NOW <= TUBE_FOUR;  
  46.         WHEN "011111" => TUBE_NOW <= TUBE_FIVE;  
  47.         WHEN "111110" => TUBE_NOW <= TUBE_SIX;  
  48.         WHEN OTHERS  => TUBE_NOW <= (OTHERS => '0');  
  49.     END CASE;  
  50. END PROCESS P2;
  51. P3: PROCESS(CLK)  
  52. VARIABLE COUNTER : INTEGER RANGE 0 TO 1000;  
  53. BEGIN  
  54.     TEM_TUBE_SIX <= TUBE_SIX;  
  55.     TEM_TUBE_FIVE <= TUBE_FIVE;  
  56.     TEM_TUBE_FOUR <= TUBE_FOUR;  
  57.     TEM_TUBE_THREE <= TUBE_THREE;  
  58.     TEM_TUBE_TWO <= TUBE_TWO;  
  59.     TEM_TUBE_ONE <= TUBE_ONE;  
  60.   
  61.     IF (  
  62.         TEM_TUBE_ONE = "1000000" AND TEM_TUBE_TWO = "1000000" AND TEM_TUBE_THREE = "1000000" AND TEM_TUBE_FOUR = "1000000" AND TEM_TUBE_FIVE = "0100100" AND TEM_TUBE_SIX = "1111001"  
  63.     ) THEN  
  64.         COUNTER := 0;  
  65.         TEM_TIME_CLOCK <= '0';  
  66.         FLAG <= '1';  
  67.     ELSIF (  
  68.         TEM_TUBE_ONE = "1000000" AND TEM_TUBE_TWO = "1000000" AND TEM_TUBE_THREE = "1000000" AND TEM_TUBE_FOUR = "1000000" AND TEM_TUBE_FIVE = "1000000" AND TEM_TUBE_SIX = "1000000"  
  69.     ) THEN  
  70.         COUNTER := 0;  
  71.         TEM_TIME_CLOCK <= '0';  
  72.         FLAG <= '1';  
  73.     ELSIF FLAG = '1' THEN  
  74.         IF CLK'EVENT AND CLK = '1' THEN  
  75.             COUNTER := COUNTER + 1;  
  76.         END IF;  
  77.         IF COUNTER = 1000 THEN  
  78.             TEM_TIME_CLOCK <= '1';  
  79.             FLAG <= '0';  
  80.         END IF;  
  81.     END IF;  
  82. END PROCESS P3;  
  83.   
  84. TIME_CLOCK <= TEM_TIME_CLOCK; 
  85. END ONE;

9、原理图连接：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/811254
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号