devbox
代码吟游诗人
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Verilog语言fpga小脚丫数字时钟（整点报时，调时，显示秒钟等功能）_verilog实现时钟计时功能

作者：代码吟游诗人 | 2024-01-14 22:07:28

赞

踩

verilog实现时钟计时功能

学弟加油！                                                                       ———来自科大焯人

最近刚好学习了数电有关知识，就做了这个项目（闹钟过于繁琐就没有做了）

希望给还在学习的大伙一点参考，完整代码在最后

在这里先附上两串代码分别是debounce（按键消抖）和divide（分频）

这两个在小脚丫的示例中都可以找到，但我还是先附在这

  1. //按键消抖
  2. module debounce (clk,rst,key,key_pulse);
  3.  
  4.         parameter       N  =  1;                      //要消除的按键的数量
  5.  
  6. 	input             clk;
  7.     input             rst;
  8.     input 	[N-1:0]   key;                        //输入的按键					
  9. 	output  [N-1:0]   key_pulse;                  //按键动作产生的脉冲	
  10.  
  11.         reg     [N-1:0]   key_rst_pre;                //定义一个寄存器型变量存储上一个触发时的按键值
  12.         reg     [N-1:0]   key_rst;                    //定义一个寄存器变量储存储当前时刻触发的按键值
  13.  
  14.         wire    [N-1:0]   key_edge;                   //检测到按键由高到低变化是产生一个高脉冲
  15.  
  16.         //利用非阻塞赋值特点，将两个时钟触发时按键状态存储在两个寄存器变量中
  17.         always @(posedge clk  or  negedge rst)
  18.           begin
  19.              if (!rst) begin
  20.                  key_rst <= {N{1'b1}};                //初始化时给key_rst赋值全为1，{}中表示N个1
  21.                  key_rst_pre <= {N{1'b1}};
  22.              end
  23.              else begin
  24.                  key_rst <= key;                     //第一个时钟上升沿触发之后key的值赋给key_rst,同时key_rst的值赋给key_rst_pre
  25.                  key_rst_pre <= key_rst;             //非阻塞赋值。相当于经过两个时钟触发，key_rst存储的是当前时刻key的值，key_rst_pre存储的是前一个时钟的key的值
  26.              end    
  27.            end
  28.  
  29.         assign  key_edge = key_rst_pre & (~key_rst);//脉冲边沿检测。当key检测到下降沿时，key_edge产生一个时钟周期的高电平
  30.  
  31.         reg	[17:0]	  cnt;                       //产生延时所用的计数器，系统时钟12MHz，要延时20ms左右时间，至少需要18位计数器     
  32.  
  33.         //产生20ms延时，当检测到key_edge有效是计数器清零开始计数
  34.         always @(posedge clk or negedge rst)
  35.            begin
  36.              if(!rst)
  37.                 cnt <= 18'h0;
  38.              else if(key_edge)
  39.                 cnt <= 18'h0;
  40.              else
  41.                 cnt <= cnt + 1'h1;
  42.              end  
  43.  
  44.         reg     [N-1:0]   key_sec_pre;                //延时后检测电平寄存器变量
  45.         reg     [N-1:0]   key_sec;                    
  46.  
  47.  
  48.         //延时后检测key，如果按键状态变低产生一个时钟的高脉冲。如果按键状态是高的话说明按键无效
  49.         always @(posedge clk  or  negedge rst)
  50.           begin
  51.              if (!rst) 
  52.                  key_sec <= {N{1'b1}};                
  53.              else if (cnt==18'h3ffff)
  54.                  key_sec <= key;  
  55.           end
  56.        always @(posedge clk  or  negedge rst)
  57.           begin
  58.              if (!rst)
  59.                  key_sec_pre <= {N{1'b1}};
  60.              else                   
  61.                  key_sec_pre <= key_sec;             
  62.          end      
  63.        assign  key_pulse = key_sec_pre & (~key_sec);     
  64.  
  65. endmodule
  1. //分频
  2. module divide (	clk,rst_n,clkout);
  3.  
  4.         input 	clk,rst_n;                       //输入信号，其中clk连接到FPGA的C1脚，频率为12MHz
  5.         output	clkout;                          //输出信号，可以连接到LED观察分频的时钟
  6.  
  7.         //parameter是verilog里常数语句
  8. 	parameter	WIDTH	= 24;             //计数器的位数，计数的最大值为 2**WIDTH-1
  9. 	parameter	N	= 12_000_000;             //分频系数，请确保 N < 2**WIDTH-1，否则计数会溢出
  10.  
  11. 	reg 	[WIDTH-1:0]	cnt_p,cnt_n;     //cnt_p为上升沿触发时的计数器，cnt_n为下降沿触发时的计数器
  12. 	reg			clk_p,clk_n;     //clk_p为上升沿触发时分频时钟，clk_n为下降沿触发时分频时钟
  13.  
  14. 	//上升沿触发时计数器的控制
  15. 	always @ (posedge clk or negedge rst_n )         //posedge和negedge是verilog表示信号上升沿和下降沿
  16.                                                          //当clk上升沿来临或者rst_n变低的时候执行一次always里的语句
  17. 		begin
  18. 			if(!rst_n)
  19. 				cnt_p<=0;
  20. 			else if (cnt_p==(N-1))
  21. 				cnt_p<=0;
  22. 			else cnt_p<=cnt_p+1;             //计数器一直计数，当计数到N-1的时候清零，这是一个模N的计数器
  23. 		end
  24.  
  25.          //上升沿触发的分频时钟输出,如果N为奇数得到的时钟占空比不是50%；如果N为偶数得到的时钟占空比为50%
  26.          always @ (posedge clk or negedge rst_n)
  27. 		begin
  28. 			if(!rst_n)
  29. 				clk_p<=0;
  30. 			else if (cnt_p<(N>>1))          //N>>1表示右移一位，相当于除以2去掉余数
  31. 				clk_p<=0;
  32. 			else 
  33. 				clk_p<=1;               //得到的分频时钟正周期比负周期多一个clk时钟
  34. 		end
  35.  
  36.         //下降沿触发时计数器的控制        	
  37. 	always @ (negedge clk or negedge rst_n)
  38. 		begin
  39. 			if(!rst_n)
  40. 				cnt_n<=0;
  41. 			else if (cnt_n==(N-1))
  42. 				cnt_n<=0;
  43. 			else cnt_n<=cnt_n+1;
  44. 		end
  45.  
  46.         //下降沿触发的分频时钟输出，和clk_p相差半个时钟
  47. 	always @ (negedge clk)
  48. 		begin
  49. 			if(!rst_n)
  50. 				clk_n<=0;
  51. 			else if (cnt_n<(N>>1))  
  52. 				clk_n<=0;
  53. 			else 
  54. 				clk_n<=1;                //得到的分频时钟正周期比负周期多一个clk时钟
  55. 		end
  56.  
  57.         assign clkout = (N==1)?clk:(N[0])?(clk_p&clk_n):clk_p;      //条件判断表达式
  58.                                                                     //当N=1时，直接输出clk
  59.                                                                     //当N为偶数也就是N的最低位为0，N（0）=0，输出clk_p
  60.                                                                     //当N为奇数也就是N最低位为1，N（0）=1，输出clk_p&clk_n。正周期多所以是相与
  61. endmodule

将上述两个代码文件准备好就可以开始编写我们的主体程序了。

既然是数字时钟，首先我们应当通过分频器产生1s中的信号，代码中的clk1h是我用分频器产生的1Hz信号。每经过1Hz的上升沿秒钟进一位，在秒钟个位为9且十位不为5时，下一次进位个位要变为0，十位要加1，若是59秒时则应当都置零。同时，分钟的计时和时钟的计时实现思路与秒钟计时类似，但需要额外进行判断，比如说分钟进位要在秒钟均为0时才产生进位，时钟进位要在分钟秒钟全为0时才进位。

时钟和分钟的敏感信号为clk，这是小脚丫自带的时钟信号12MHz。由于clk频率极高，在1s中内能够触发分钟和时钟计时模块多次，为实现分钟和时钟在进位时仅进位一次，我额外增加了两个判断位，分别为pan（分钟）和pan1（时钟）。在pan和pan1为0时才能分别触发分钟和时钟进位，并且触发一次进位后pan或pan1置1，直到秒钟或者分钟不全为0时pan或pan1才会重新置0。

具体代码如下

  1. //60秒计时控制
  2. 	always @ (posedge clk1h ) begin
  3.         if(cnt_shi==5 && cnt_ge==9) begin
  4. 			cnt_shi <= 0;
  5. 			cnt_ge <= 0;
  6. 			end
  7. 		else if(cnt_shi==0 && cnt_ge==0) begin
  8. 			cnt_shi <= 0;
  9. 			cnt_ge <= 1;
  10. 			end
  11. 		else if(cnt_ge==9)begin
  12. 			cnt_ge <= 0;
  13. 			cnt_shi <= cnt_shi+1;
  14. 			end
  15. 		else
  16. 			cnt_ge <= cnt_ge +1;
  17. 		end
  18. //60分计时控制
  19. 	always @ (posedge clk)begin
  20. 	    if((cnt_ge==0)&&(cnt_shi==0)&&(pan==0))begin
  21. 	       pan<=1;
  22. 	       if(minute_shi==5 && minute_ge==9) begin
  23. 			    minute_shi <= 0;
  24. 			    minute_ge <= 0;
  25. 			    end
  26. 		   else if(minute_ge==9)begin
  27. 			    minute_ge <= 4'd0;
  28. 			    minute_shi <= minute_shi+1;
  29. 			    end
  30. 		   else
  31. 			    minute_ge <= minute_ge +1;
  32. 		   end
  33. 		else
  34. 		    if((cnt_ge!=0) || (cnt_shi!=0))begin
  35. 		        pan<=0;
  36. 		    end
  37. //24小时计时与加减法模块
  38. 	always @ (posedge clk ) begin
  39. 		if ((minute_ge==0)&&(minute_shi==0)&&(pan1==0)&&(cnt_shi==0)&&(cnt_ge==0)) begin
  40. 		    pan1<=1;
  41. 			if(hour_shi==2 && hour_ge==3) begin
  42. 			    hour_shi <= 0;
  43. 			    hour_ge <= 0;
  44. 			    end
  45. 		    else if(hour_ge==9)begin
  46. 			    hour_ge <= 4'd0;
  47. 			    hour_shi <= hour_shi+1;
  48. 			    end
  49. 		    else
  50. 			    hour_ge <= hour_ge +1;
  51. 		    end
  52. 		else
  53. 		    if((minute_ge!=0) || (minute_shi!=0))begin
  54. 		        pan1<=0;
  55. 		        end

至此，我们已经基本实现了数字时钟的运行，但还需要将时钟信息显示在数码管上。

我将按键触发的信号位记作change和change2。当change2为高电平且change为低电平时，数码管显示分钟；当change2为高电平且change为高电平时，数码管显示时钟；而当change2为低电平时，不论change电平，均显示秒钟。

  1. //数码管显示数字
  2. 		seg[0] = 7'h3f;	   //  0
  3. 		seg[1] = 7'h06;	   //  1
  4. 		seg[2] = 7'h5b;	   //  2
  5. 		seg[3] = 7'h4f;	   //  3
  6. 		seg[4] = 7'h66;	   //  4
  7. 		seg[5] = 7'h6d;	   //  5
  8. 		seg[6] = 7'h7d;	   //  6
  9. 		seg[7] = 7'h07;	   //  7
  10. 		seg[8] = 7'h7f;	   //  8
  11. 		seg[9] = 7'h6f;	   //  9
  12.         
  13. //选择显示
  14. 	always @ (posedge clk)begin
  15. 	    if((change==0)&&(change2==1))begin
  16.             seg_led_1<= seg[hour_ge];
  17.             seg_led_2<= seg[hour_shi];
  18.             end
  19.         else if((change==1)&&(change2==1))
  20.             begin
  21. 	        seg_led_1<= seg[minute_ge];
  22.             seg_led_2<= seg[minute_shi];
  23.             end
  24.         else if(change2==0)begin
  25.             seg_led_1<= seg[cnt_ge];
  26.             seg_led_2<= seg[cnt_shi];
  27.             end
  28.         end

所有基础功能都已经实现，现在还需要进阶，也就是调时和整点报时的实现。

我们先讲调时的实现

我在实现加减法的时候均用了两个计数器add、add1和jian、jian1。

add和jian分别为按键按下次数的计数器，而add1和jian1则分别为add和jian的匹配计数器。

当add1不等于add时，将时钟进一位，并且add1+1；当jian1不等于jian时，将时钟退一位，再将jian1+1，便可以实现调时的功能。

我在写代码的时候是将调时模块整合在计时模块中的，时钟调时与分钟调时的原理是相同的。

  1.         if((add1!=add)&&(change==1)) begin
  2.             add1<=add1+1;
  3.             if(minute_shi==5 && minute_ge==9) begin
  4. 			    minute_shi <= 0;
  5. 			    minute_ge <= 0;
  6. 			    end
  7. 		    else if(minute_ge==9)begin
  8. 			    minute_ge <= 4'd0;
  9. 			    minute_shi <= minute_shi+1;
  10. 			    end
  11. 		    else
  12. 			    minute_ge <= minute_ge +1;
  13. 		    end
  14.         if((jian1!=jian)&&(change==1))begin
  15.             jian1<=jian1+1;
  16.             if(minute_shi==0 && minute_ge==0)begin
  17.                 minute_ge<=9;
  18.                 minute_shi<=5;
  19.                 end
  20.             else if(minute_ge==0)begin
  21.                 minute_ge<=9;
  22.                 minute_shi<=minute_shi-1;
  23.                 end
  24.             else
  25.                 minute_ge<=minute_ge-1;
  26.             end

最后便是整点报时的实现

整点报时需要让灯光按照1Hz的频率闪烁，那么我们便可以用一个2Hz的时钟信号作为敏感信号来触发灯光闪烁。

首先只有在秒钟分钟均为0时才算作整点，在这个条件下我又用到了两个计数器cnt、cnt1与加减法的计数器功能一致，cnt1为当前整点数的两倍（因为一亮一灭需要灯光反转两次），cnt为匹配计数器，当cnt不等于cnt1时灯光反转一次，并且cnt＋1。具体代码实现如下。

  1.  //整点报时
  2.     always @(posedge clk0)begin
  3.         led=~led;
  4.         if((minute_shi==0)&&(minute_ge==0)&&(cnt_shi==0)&&(cnt_ge==0))begin
  5.             cnt1=2*(10*hour_shi+hour_ge);
  6.             end
  7.         if(cnt!=cnt1)begin
  8.             rgb=~rgb;
  9.             cnt<=cnt+1;
  10.             end
  11.         else if(cnt==cnt1)begin
  12.             cnt<=0;
  13.             cnt1<=0;
  14.             end
  15.         end

以上就是整个数字时钟的设计，最后附上数字时钟的全部代码（记得把文首的debounce和devide两个代码也装上，不然数字时钟代码无法成功编译）

  1. module counter
  2. (
  3. 	clk				,    //时钟
  4. 	rst				,    //复位
  5. 	plus            ,    //加法为
  6. 	cut             ,    //减法位
  7. 	change			,    //显示转化按键1
  8. 	change2         ,    //显示转化按键2
  9. 	seg_led_1		,    //数码管1
  10. 	seg_led_2		,    //数码管2
  11. 	rgb             ,    //rgb灯光
  12. 	led                  //led
  13. );
  14.  
  15. 	input 	clk,rst;
  16. 	input	change;
  17. 	input   change2;
  18.     input   plus,cut;
  19. 	output 	reg [8:0]	seg_led_1,seg_led_2;
  20. 	output 	reg	[7:0]	led;
  21. 	output  reg [5:0]   rgb;
  22.     wire        clk0;         //0.5秒时钟
  23. 	wire		clk1h;        //1秒钟时钟
  24. 	wire		change_pulse; //转换按键消抖后信号
  25. 	wire        plus_pulse;   //加法按键消抖后信号
  26. 	wire        cut_pulse;    //减法按键消抖后信号
  27. 	reg			change_flag;  //转换按键标志位
  28. 	reg         plus_flag;    //加法按键标志位
  29. 	reg         cut_flag;     //减法按键标志位
  30. 	reg         pan;          //判断分钟进位
  31. 	reg         pan1;         //判断时钟进位     
  32. 	reg         add;          //分钟加法按键按下计数
  33. 	reg         add1;         //分钟加法按键匹配计数
  34. 	reg         add10;        //时钟加法按键按下计数     
  35. 	reg         add11;        //时钟加法按键匹配计数
  36. 	reg         jian10;       //时钟减法按键按下计数  
  37. 	reg         jian11;       //时钟减法按键匹配计数  
  38. 	reg         jian;         //分钟减法按键按下计数
  39. 	reg         jian1;        //分钟减法按键匹配计数
  40. 	reg         [5:0]   cnt=0;          //记录当前小时数
  41. 	reg         [5:0]   cnt1=0;         //小时匹配数
  42. 	reg   		[6:0]   seg		[9:0];  //数码管
  43. 	reg			[3:0]	cnt_ge;         //秒钟个位
  44. 	reg			[3:0]	cnt_shi;        //秒钟十位
  45. 	reg			[3:0]	minute_ge;      //分钟个位
  46. 	reg			[3:0]	minute_shi;     //分钟十位
  47. 	reg			[3:0]	hour_ge;        //小时个位
  48. 	reg			[3:0]	hour_shi;       //小时十位 
  49. 	initial 
  50. 	begin
  51. 		seg[0] = 7'h3f;	   //  0
  52. 		seg[1] = 7'h06;	   //  1
  53. 		seg[2] = 7'h5b;	   //  2
  54. 		seg[3] = 7'h4f;	   //  3
  55. 		seg[4] = 7'h66;	   //  4
  56. 		seg[5] = 7'h6d;	   //  5
  57. 		seg[6] = 7'h7d;	   //  6
  58. 		seg[7] = 7'h07;	   //  7
  59. 		seg[8] = 7'h7f;	   //  8
  60. 		seg[9] = 7'h6f;	   //  9
  61.         
  62. 	end
  63.  
  64.  
  65.  
  66. 	// 启动/暂停按键进行消抖
  67. 	debounce  U2 (
  68. 				.clk(clk),
  69. 				.rst(rst),
  70. 				.key(change),
  71. 				.key_pulse(change_pulse)
  72. 				);
  73. 	debounce  U6 (
  74. 				.clk(clk),
  75. 				.rst(rst),
  76. 				.key(plus),
  77. 				.key_pulse(plus_pulse)
  78. 				);
  79. 	debounce  U7 (
  80. 				.clk(clk),
  81. 				.rst(rst),
  82. 				.key(cut),
  83. 				.key_pulse(cut_pulse)
  84. 				);
  85. 	// 用于分出一个1Hz的频率	
  86. 	divide #(.WIDTH(32),.N(12000000)) U1 ( 
  87. 			.clk(clk),
  88. 			.rst_n(rst),      
  89. 			.clkout(clk1h)
  90. 			);
  91. 	// 用于分出一个2Hz的频率
  92. 	divide #(.WIDTH(32),.N(6000000)) U5 ( 
  93. 			.clk(clk),
  94. 			.rst_n(rst),      
  95. 			.clkout(clk0)
  96. 			);
  97.     //按键动作标志信号产生
  98. 	always @ (posedge change_pulse)begin	
  99. 	    if(!rst==1)
  100. 			change_flag <= 0;
  101. 		else
  102. 		    change_flag <= ~change_flag;
  103. 		end
  104. 	always @ (posedge plus_pulse)begin	
  105. 	    if(!rst==1)
  106. 			plus_flag <= 0;
  107. 		else
  108. 		    plus_flag <= ~plus_flag;
  109. 		    if(change==1)begin
  110. 		        add<=add+1;
  111. 		        end
  112. 		    else if(change==0)begin
  113. 		        add10<=add10+1;
  114. 		        end
  115. 		end
  116. 	always @ (posedge cut_pulse)begin	
  117. 	    if(!rst==1)
  118. 			cut_flag <= 0;
  119. 		else
  120. 		    cut_flag <= ~cut_flag;
  121. 		    if(change==1)begin
  122. 		        jian<=jian+1;
  123. 		        end
  124. 		    else if(change==0)begin
  125. 		        jian10<=jian10+1;
  126. 		        end
  127. 		end
  128.     //60秒计时控制
  129. 	always @ (posedge clk1h ) begin
  130.         if(cnt_shi==5 && cnt_ge==9) begin
  131. 			cnt_shi <= 0;
  132. 			cnt_ge <= 0;
  133. 			end
  134. 		else if(cnt_shi==0 && cnt_ge==0) begin
  135. 			cnt_shi <= 0;
  136. 			cnt_ge <= 1;
  137. 			end
  138. 		else if(cnt_ge==9)begin
  139. 			cnt_ge <= 0;
  140. 			cnt_shi <= cnt_shi+1;
  141. 			end
  142. 		else
  143. 			cnt_ge <= cnt_ge +1;
  144. 		end
  145. 	//60分钟计时与加减法模块
  146. 	always @ (posedge clk)begin
  147. 	    if((cnt_ge==0)&&(cnt_shi==0)&&(pan==0))begin
  148. 	       pan<=1;
  149. 	       if(minute_shi==5 && minute_ge==9) begin
  150. 			    minute_shi <= 0;
  151. 			    minute_ge <= 0;
  152. 			    end
  153. 		   else if(minute_ge==9)begin
  154. 			    minute_ge <= 4'd0;
  155. 			    minute_shi <= minute_shi+1;
  156. 			    end
  157. 		   else
  158. 			    minute_ge <= minute_ge +1;
  159. 		   end
  160. 		else
  161. 		    if((cnt_ge!=0) || (cnt_shi!=0))begin
  162. 		        pan<=0;
  163. 		    end
  164.         if((add1!=add)&&(change==1)) begin
  165.             add1<=add1+1;
  166.             if(minute_shi==5 && minute_ge==9) begin
  167. 			    minute_shi <= 0;
  168. 			    minute_ge <= 0;
  169. 			    end
  170. 		    else if(minute_ge==9)begin
  171. 			    minute_ge <= 4'd0;
  172. 			    minute_shi <= minute_shi+1;
  173. 			    end
  174. 		    else
  175. 			    minute_ge <= minute_ge +1;
  176. 		    end
  177.         if((jian1!=jian)&&(change==1))begin
  178.             jian1<=jian1+1;
  179.             if(minute_shi==0 && minute_ge==0)begin
  180.                 minute_ge<=9;
  181.                 minute_shi<=5;
  182.                 end
  183.             else if(minute_ge==0)begin
  184.                 minute_ge<=9;
  185.                 minute_shi<=minute_shi-1;
  186.                 end
  187.             else
  188.                 minute_ge<=minute_ge-1;
  189.             end
  190.         end
  191. 	//24小时计时与加减法模块
  192. 	always @ (posedge clk ) begin
  193. 		if ((minute_ge==0)&&(minute_shi==0)&&(pan1==0)&&(cnt_shi==0)&&(cnt_ge==0)) begin
  194. 		    pan1<=1;
  195. 			if(hour_shi==2 && hour_ge==3) begin
  196. 			    hour_shi <= 0;
  197. 			    hour_ge <= 0;
  198. 			    end
  199. 		    else if(hour_ge==9)begin
  200. 			    hour_ge <= 4'd0;
  201. 			    hour_shi <= hour_shi+1;
  202. 			    end
  203. 		    else
  204. 			    hour_ge <= hour_ge +1;
  205. 		    end
  206. 		else
  207. 		    if((minute_ge!=0) || (minute_shi!=0))begin
  208. 		        pan1<=0;
  209. 		        end
  210. 		if((add11!=add10)&&(change==0))begin
  211. 		    add11<=add11+1;
  212. 		    if(hour_shi==2 && hour_ge==3) begin
  213. 			    hour_shi <= 0;
  214. 			    hour_ge <= 0;
  215. 			    end
  216. 		    else if(hour_ge==9)begin
  217. 			    hour_ge <= 4'd0;
  218. 			    hour_shi <= hour_shi+1;
  219. 			    end
  220. 		    else
  221. 			    hour_ge <= hour_ge +1;
  222. 		    end
  223. 		if((jian11!=jian10)&&(change==0))begin
  224.             jian11<=jian11+1;
  225.             if(hour_shi==0 && hour_ge==0)begin
  226.                 hour_ge<=3;
  227.                 hour_shi<=2;
  228.                 end
  229.             else if(hour_ge==0)begin
  230.                 hour_ge<=9;
  231.                 hour_shi<=hour_shi-1;
  232.                 end
  233.             else
  234.                 hour_ge<=hour_ge-1;
  235.             end
  236.         end
  237. 	//选择显示
  238. 	always @ (posedge clk)begin
  239. 	    if((change==0)&&(change2==1))begin
  240.             seg_led_1<= seg[hour_ge];
  241.             seg_led_2<= seg[hour_shi];
  242.             end
  243.         else if((change==1)&&(change2==1))
  244.             begin
  245. 	        seg_led_1<= seg[minute_ge];
  246.             seg_led_2<= seg[minute_shi];
  247.             end
  248.         else if(change2==0)begin
  249.             seg_led_1<= seg[cnt_ge];
  250.             seg_led_2<= seg[cnt_shi];
  251.             end
  252.         end
  253.     //整点报时
  254.     always @(posedge clk0)begin
  255.         led=~led;
  256.         if((minute_shi==0)&&(minute_ge==0)&&(cnt_shi==0)&&(cnt_ge==0))begin
  257.             cnt1=2*(10*hour_shi+hour_ge);
  258.             end
  259.         if(cnt!=cnt1)begin
  260.             rgb=~rgb;
  261.             cnt<=cnt+1;
  262.             end
  263.         else if(cnt==cnt1)begin
  264.             cnt<=0;
  265.             cnt1<=0;
  266.             end
  267.         end
  268.  
  269. endmodule

管脚分配如下

 

有疑惑或者问题欢迎一起讨论

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号