基于FPGA的数字秒表设计

硬件平台:DE2-115

软件环境:Quartus II 15.1

采样了较为简单的计数方法,详细代码就不讲解了,分为三个模块,一个是计数模块 count.v,一个是显示模块 disp.v,还有一个是顶层模块 miaobiao.v。有清零按键和暂停拨码开关。

顶层模块:

 1 module miaobiao(
 2   clk,
 3   rst_n,
 4   pause,
 5
 6   Hex0,
 7   Hex1,
 8   Hex2,
 9   Hex3,
10   Hex4,
11   Hex5,
12 );
13
14 input clk;
15 input rst_n;
16 input pause;
17
18 output[6:0] Hex0;
19 output[6:0] Hex1;
20 output[6:0] Hex2;
21 output[6:0] Hex3;
22 output[6:0] Hex4;
23 output[6:0] Hex5;
24
25  wire[3:0]h_sec_h;
26  wire[3:0]h_sec_l;
27
28  wire[3:0]sec_h;
29  wire[3:0]sec_l;
30
31  wire[3:0]fen_h;
32  wire[3:0]fen_l;
33
34 count u0(
35   .clk(clk),
36   .rst_n(rst_n),
37   .pause(pause),
38
39   .h_sec_h(h_sec_h),
40   .h_sec_l(h_sec_l),
41
42   .sec_h(sec_h),
43   .sec_l(sec_l),
44
45   .fen_h(fen_h),
46   .fen_l(fen_l)
47 );
48
49 disp u1(
50
51   .h_sec_l(h_sec_l),
52   .h_sec_h(h_sec_h),
53
54   .sec_l(sec_l),
55   .sec_h(sec_h),
56
57   .fen_l(fen_l),
58   .fen_h(fen_h),
59
60   .Hex0(Hex0),
61   .Hex1(Hex1),
62   .Hex2(Hex2),
63   .Hex3(Hex3),
64   .Hex4(Hex4),
65   .Hex5(Hex5)
66 );
67
68 endmodule

miaobiao.v

计数模块:

  1 module count(
  2   clk,
  3   rst_n,
  4   pause,
  5
  6   h_sec_h,
  7   h_sec_l,
  8
  9   sec_h,
 10   sec_l,
 11
 12   fen_h,
 13   fen_l
 14 );
 15
 16 input clk;
 17 input rst_n;
 18 input pause;              //pause为0时正常计数,为1时暂停计数
 19
 20 output reg[3:0] h_sec_h;  //百分秒低位
 21 output reg[3:0] h_sec_l;  //百分秒高位
 22
 23 output reg[3:0] sec_h;    //秒高位
 24 output reg[3:0] sec_l;    //秒低位
 25
 26 output reg[3:0] fen_h;    //分低位
 27 output reg[3:0] fen_l;    //分高位
 28
 29 reg flag1;       //flag1为百分秒向秒的进位
 30 reg flag2;       //flag2为秒向分的进位
 31 reg[27:0] cnt;   //
 32 reg clk_100hz;
 33
 34 /*  100hz 分频  */
 35 always@(posedge clk or negedge rst_n)
 36   if(!rst_n)
 37     cnt <= 28‘d0;
 38   else if(cnt == 249999)
 39     cnt <= 28‘d0;
 40   else
 41     cnt <= cnt + 1‘b1;
 42
 43 always@(posedge clk or negedge rst_n)
 44   if(!rst_n)
 45     clk_100hz <= 1‘b0;
 46   else if(cnt == 249999)
 47     clk_100hz <= !clk_100hz;
 48   else
 49     clk_100hz <= clk_100hz;
 50
 51 /* 百分秒计数进程,每计满100,flag1产生一个进位 */
 52 always@(posedge clk_100hz or negedge rst_n)
 53   begin
 54     if(!rst_n) begin
 55        {h_sec_h,h_sec_l} <= 8‘h00;
 56         flag1 <= 1‘b0;
 57         end
 58      else if(!pause) begin
 59        if(h_sec_l == 9) begin
 60           h_sec_l <= 4‘d0;
 61           if(h_sec_h == 9) begin
 62             h_sec_h <= 4‘d0;
 63              flag1 <= 1‘b1;
 64              end
 65           else
 66             h_sec_h <= h_sec_h + 1‘b1;
 67         end
 68      else begin
 69        h_sec_l <= h_sec_l + 1‘b1;
 70        flag1 <= 1‘b0;
 71        end
 72      end
 73   end
 74
 75 /* 秒计数进程,每计满60,flag2产生一个进位 */
 76 always@(posedge flag1 or negedge rst_n)
 77   begin
 78     if(!rst_n) begin
 79        {sec_h,sec_l} <= 8‘h00;
 80         flag2 <= 0;
 81         end
 82      else if(sec_l == 9) begin
 83        sec_l <= 4‘d0;
 84         if(sec_h == 5) begin
 85           sec_h <= 4‘d0;
 86           flag2 <= 1‘b1;
 87           end
 88         else
 89           sec_h <= sec_h + 1‘b1;
 90        end
 91      else begin
 92        sec_l <= sec_l + 1‘b1;
 93         flag2 <= 1‘b0;
 94      end
 95   end
 96
 97 /* 分计数进程,每计数满60,系统自动清零 */
 98 always@(posedge flag2 or negedge rst_n)
 99   begin
100     if(!rst_n) begin
101        {fen_h,fen_l} <= 8‘h00;
102         end
103      else if(fen_l == 9) begin
104        fen_l <= 4‘d0;
105         if(fen_h == 5)
106           fen_h <= 4‘d0;
107         else
108           fen_h <= fen_h + 1‘b1;
109         end
110      else
111        fen_l <= fen_l + 1‘b1;
112     end
113 endmodule
114
115
116
117
118       

count.v

显示模块:

  1 module disp(
  2
  3   h_sec_l,
  4   h_sec_h,
  5
  6   sec_l,
  7   sec_h,
  8
  9   fen_l,
 10   fen_h,
 11
 12   Hex0,
 13   Hex1,
 14   Hex2,
 15   Hex3,
 16   Hex4,
 17   Hex5,
 18 );
 19
 20 input[3:0] h_sec_h;
 21 input[3:0] h_sec_l;
 22
 23 input[3:0] sec_h;
 24 input[3:0] sec_l;
 25
 26 input[3:0] fen_h;
 27 input[3:0] fen_l;
 28
 29 output reg[6:0] Hex0;
 30 output reg[6:0] Hex1;
 31 output reg[6:0] Hex2;
 32 output reg[6:0] Hex3;
 33 output reg[6:0] Hex4;
 34 output reg[6:0] Hex5;
 35
 36 always@(*)    //百分秒个位控制
 37   begin
 38     case(h_sec_l)
 39        0:Hex0 <= 7‘b1000000;  //0
 40       1:Hex0 <= 7‘b1111001;  //1
 41       2:Hex0 <= 7‘b0100100;  //2
 42       3:Hex0 <= 7‘b0110000;  //3
 43       4:Hex0 <= 7‘b0011001;  //4
 44       5:Hex0 <= 7‘b0010010;  //5
 45       6:Hex0 <= 7‘b0000010;  //6
 46       7:Hex0 <= 7‘b1111000;  //7
 47       8:Hex0 <= 7‘b0000000;  //8
 48       9:Hex0 <= 7‘b0010000;  //9
 49         default:Hex0 <= 7‘b1000000;  //0
 50      endcase
 51   end
 52
 53 always@(*)    //百分秒十位控制
 54   begin
 55     case(h_sec_h)
 56        0:Hex1 <= 7‘b1000000;  //0
 57       1:Hex1 <= 7‘b1111001;  //1
 58       2:Hex1 <= 7‘b0100100;  //2
 59       3:Hex1 <= 7‘b0110000;  //3
 60       4:Hex1 <= 7‘b0011001;  //4
 61       5:Hex1 <= 7‘b0010010;  //5
 62       6:Hex1 <= 7‘b0000010;  //6
 63       7:Hex1 <= 7‘b1111000;  //7
 64       8:Hex1 <= 7‘b0000000;  //8
 65       9:Hex1 <= 7‘b0010000;  //9
 66         default:Hex1 <= 7‘b1000000;  //0
 67      endcase
 68   end
 69
 70 always@(*)    //
 71   begin
 72     case(sec_l)
 73        0:Hex2 <= 7‘b1000000;  //0
 74       1:Hex2 <= 7‘b1111001;  //1
 75       2:Hex2 <= 7‘b0100100;  //2
 76       3:Hex2 <= 7‘b0110000;  //3
 77       4:Hex2 <= 7‘b0011001;  //4
 78       5:Hex2 <= 7‘b0010010;  //5
 79       6:Hex2 <= 7‘b0000010;  //6
 80       7:Hex2 <= 7‘b1111000;  //7
 81       8:Hex2 <= 7‘b0000000;  //8
 82       9:Hex2 <= 7‘b0010000;  //9
 83         default:Hex2 <= 7‘b1000000;  //0
 84     endcase
 85   end
 86
 87 always@(*)    //
 88   begin
 89     case(sec_h)
 90        0:Hex3 <= 7‘b1000000;  //0
 91       1:Hex3 <= 7‘b1111001;  //1
 92       2:Hex3 <= 7‘b0100100;  //2
 93       3:Hex3 <= 7‘b0110000;  //3
 94       4:Hex3 <= 7‘b0011001;  //4
 95       5:Hex3 <= 7‘b0010010;  //5
 96         default:Hex3 <= 7‘b1000000;  //0
 97     endcase
 98   end
 99
100 always@(*)    //
101   begin
102     case(fen_l)
103        0:Hex4 <= 7‘b1000000;  //0
104       1:Hex4 <= 7‘b1111001;  //1
105       2:Hex4 <= 7‘b0100100;  //2
106       3:Hex4 <= 7‘b0110000;  //3
107       4:Hex4 <= 7‘b0011001;  //4
108       5:Hex4 <= 7‘b0010010;  //5
109       6:Hex4 <= 7‘b0000010;  //6
110       7:Hex4 <= 7‘b1111000;  //7
111       8:Hex4 <= 7‘b0000000;  //8
112       9:Hex4 <= 7‘b0010000;  //9
113         default:Hex4 <= 7‘b1000000;  //0
114     endcase
115   end
116
117 always@(*)    //
118   begin
119     case(fen_h)
120        0:Hex5 <= 7‘b1000000;  //0
121       1:Hex5 <= 7‘b1111001;  //1
122       2:Hex5 <= 7‘b0100100;  //2
123       3:Hex5 <= 7‘b0110000;  //3
124       4:Hex5 <= 7‘b0011001;  //4
125       5:Hex5 <= 7‘b0010010;  //5
126         default:Hex5 <= 7‘b1000000;  //0
127     endcase
128   end
129
130 endmodule

disp.v

仿真用的是Modelsim SE-64 10.4,只对计数模块进行了仿真,不是很直观,代码如下:

 1 `timescale 1ns/1ns
 2 `define clk_period 20
 3 module count_tb;
 4   reg clk;
 5   reg rst_n;
 6   reg pause;
 7   wire[3:0] h_sec_h;
 8   wire[3:0] h_sec_l;
 9   wire[3:0] sec_l;
10   wire[3:0] sec_h;
11   wire[3:0] fen_h;
12   wire[3:0] fen_l;
13 count u0(
14   .clk(clk),
15   .rst_n(rst_n),
16   .pause(pause),
17   .h_sec_h(h_sec_h),
18   .h_sec_l(h_sec_l),
19   .sec_h(sec_h),
20   .sec_l(sec_l),
21   .fen_h(fen_h),
22   .fen_l(fen_l)
23 );
24
25 initial
26   clk = 0;
27   always#(`clk_period/2) clk = ~clk;
28
29 initial
30   begin
31     rst_n = 1‘b0;
32      #(`clk_period);
33      rst_n = 1‘b1;
34      pause = 1‘b1;
35      #(`clk_period*5);
36      pause = 1‘b0;
37      #(`clk_period*1000000);
38      $stop;
39   end
40 endmodule

count_tb.v

由于分频为100hz进行百分秒计数,Modelsim跑的比较慢,所以我将百分秒计数模块,秒计数模块,分计数模块一个个单独来进行仿真,这样速度较快,容易找到问题,功能上是可以完全实现的。

原文地址:https://www.cnblogs.com/571328401-/p/11626094.html

时间: 2024-10-17 05:40:02

基于FPGA的数字秒表设计的相关文章

基于FPGA的数字频率计(设计全过程)

小序: 前几天看全国大学生电子设计竞赛历年试题,无意间发现了一道题目<简易数字频率计>,跟之前我用verilog写的一个频率计差不多,于是想尝试做一下,题目具体要求如下图中所示,我所用的开发板为 xilinx spartan 3ES, 最后结果还算理想,在要求的范围内的频率测量精度比较高,但是由于板子的限制没能实现脉冲宽度测量等功能,但是其原理比较简单,下文中将会给出设计过程,结果展示图片以及整个工程代码的下载链接. 数字频率计总体设计采用分块的思想,自底向上设计方向,三个子模块包括频率测量模

基于FPGA的VGA显示设计(二)

上一篇:基于FPGA的VGA显示设计(一)     参照 CrazyBingo 的 基于FPGA的VGA可移植模块终极设计代码  的工程代码风格,模块化处理了上一篇的代码,并增加了一点其它图形. 顶层模块: 1 /**************************************************** 2 * Module Name : VGA_color_all.v 3 * Author : yllinux 博客:http://www.cnblogs.com/yllinux/

基于FPGA的RGB图像转灰度图像算法实现

一.前言 最近学习牟新刚编著<基于FPGA的数字图像处理原理及应用>的第六章直方图操作,由于需要将捕获的图像转换为灰度图像,因此在之前代码的基础上加入了RGB图像转灰度图像的算法实现. 2020-02-29 10:38:40 二.RGB图像转灰度图像算法原理 将彩色图像转换为灰度图像的方法有两种,一个是令RGB三个分量的数值相等.输出后便可以得到灰度图像,另一种是转换为YCbCr格式,将Y分量提取出来,YCbCr格式中的Y分量表示的是图 像的亮度和浓度,所以只输出Y分量,得到图像就是灰度图像.

基于FPGA的简易数字时钟

基于FPGA的可显示数字时钟,设计思路为自底向上,包含三个子模块:时钟模块,进制转换模块.led显示模块.所用到的FPGA晶振频率为50Mhz,首先利用它得到1hz的时钟然后然后得到时钟模块.把时钟模块输出的时.分.秒输入到进制转换模块后得到十进制的值再输入到led显示模块,该project已经在FPGA开发板上亲測可用. 下图为模块示意图(实际project中并没有採用原理图的输入方法.这里仅作示意). 以下分模块说明: clk1:  时钟模块,设计思路为首先依据50M晶振得到1hz的时钟,然

基于FPGA的VGA可移植模块终极设计【转】

本文转载自:http://www.cnblogs.com/lueguo/p/3373643.html 略过天涯 基于FPGA的VGA可移植模块终极设计 一.VGA的诱惑 首先,VGA的驱动,这事,一般的单片机是办不到的:由于FPGA的速度,以及并行的优势,加上可现场配置的优势,VGA的配置,只有俺们FPGA可以胜任,也只有FPGA可以随心所欲地配置(当然ARM也可以,应用比较高吧). 初学者就是喜欢看炫的效果,往往会忍不住想玩.尤其玩FPGA的,没玩VGA就感到跟单片机没啥提升,因此VGA的驱动

基于FPGA的高速图像处理平台设计_爱学术

[摘要]针对传统图像处理平台采集.处理速度慢,显示分辨率低,不方便携带等问题,设计了一个基于FPGA的高速图像处理平台,包含高速图像的采集.处理.及显示.图像采集通过Camera Link接口采集图像,图像处理部分利用乒乓操作对图像数据进行高速存储,FPGA完成图像预处理,DSP进行运算复杂的图像处理,图像显示部分输出标准的视频信号进行DVI显示.实验结果表明,平台完成了对图像的高速处理,体积小,处理数据量大,可以替代传统图像处理平台,并应用到多种图像处理领域. [作者] 陈序  卿粼波  何小

基于FPGA的音频信号的FIR滤波(Matlab+Modelsim验证)

1 设计内容 本设计是基于FPGA的音频信号FIR低通滤波,根据要求,采用Matlab对WAV音频文件进行读取和添加噪声信号.FFT分析.FIR滤波处理,并分析滤波的效果.通过Matlab的分析验证滤波效果后,将叠加噪声信号的音频信号输出到txt文件里.然后使用Matlab语言编写滤波器模块和测试模块,通过Modelsim软件读取txt文件的数据,将数据送入滤波模块,最后将滤波的结果输出到txt文件里,最后用Matlab将处理的结果从txt文件读出.显示.FFT分析用Verilog设计的FIR滤

基于FPGA的Sobel边缘检测的实现

前面我们实现了使用PC端上位机串口发送图像数据到VGA显示,通过MATLAB处理的图像数据直接是灰度图像,后面我们在此基础上修改,从而实现,基于FPGA的动态图片的Sobel边缘检测.中值滤波.Canny算子边缘检测.腐蚀和膨胀等.那么这篇文章我们将来实现基于FPGA的Sobel边缘检测. 图像边缘:简言之,边缘就是图像灰度值突变的地方,亦即图像在该部分的像素值变化速度非常之快,这就好比在坐标轴上一条曲线有刚开始的平滑突然来个大转弯,在变化出的导数非常大. Sobel算子主要用作边缘检测,在技术

FPGA与数字信号处理

过去十几年,通信与多媒体技术的快速发展极大地扩展了数字信号处理(DSP)的应用范围.眼下正在发生的是,以更高的速度和更低的成本实现越来越复杂的算法,这是针对高级信息服更高带宽以及增强的多媒体处理能力等需求的日益增加的结果.一些高性能应用正在不断发展,其中包括高级有线和无线音频.数据和视频处理. 通信和多媒体应用的发展,如互联网通信.安全无线通信以及消费娱乐设备,都在驱动着对能够有效实现复数运算和信号处理算法的高性能设备的需求. 这些应用中需要一些典型的DSP算法包括快速傅里叶变换(FFT).离散