【HDLBits习题 2】Circuit - Sequential Logic（2）Counters

已于 2023-09-21 17:03:29 修改
阅读量141 收藏
点赞数
文章标签： fpga开发
于 2023-05-18 17:06:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZEROZibER/article/details/130748304
版权

1. Count15（Four-bit binary counter）

        由于输出q为4-bit，当执行到15+1时，会自动回到0，故不需要设计清零步骤。

module top_module (
    input        clk, reset, 
    output [3:0] q
);
    always @(posedge clk) begin
        if (reset) begin
            q <= 0;
        end
        else begin
            q <= q + 1'b1;
        end
    end
endmodule

2. Count10（Decade counter）

        由于我们要用十六进制计数器设计十进制计数器，故要设计清零步骤。这里采用清零法，当技术到9时，在下一个时钟信号上升沿对q进行清零。

module top_module (
    input        clk, reset, 
    output [3:0] q
);
    always @(posedge clk) begin
        if (reset || q==4'h9) begin
            q <= 0;
        end
        else begin
            q <= q + 1'b1;
        end
    end
endmodule

3. Count1to10（Decade counter again）

        虽同为十进制计数器，但与上一个不同，前者为0-9计数，后者为1-10计数。故这里使用置数法设计清零步骤，当计数到10时，在下一个时钟信号上升沿将q置数为1。

module top_module (
    input        clk, reset,
    output [3:0] q
);
    always @(posedge clk) begin
        if (reset || q==4'ha) begin
            q <= 4'h1;
        end
        else begin
            q <= q + 1'b1;
        end
    end
endmodule

4. Countslow（Slow decade counter）

        该题的清零步骤（不考虑reset清零）又与第二题的设计有所不同，此题的清零需要在slowena处于高电平时才能执行，否则q的值保持不变。

module top_module (
    input        clk, slowena, reset,
    output [3:0] q
);
    always @(posedge clk) begin
        if (reset) begin
            q <= 0;
        end
        else if (slowena && q<4'h9) begin
            q <= q + 1'b1;
        end
        else if (slowena && q==4'h9) begin
            q <= 0;
        end
    end
endmodule

5. Exams/ece241 2014 q7a（Counter 1-12）

module top_module (
    input clk,
    input reset,
    input enable,
    output [3:0] Q,
    output c_enable,
    output c_load,
    output [3:0] c_d
);

    count4 the_counter ( clk, c_enable, c_load, c_d, Q );

    assign c_enable = enable;
    assign c_load   = reset || ((Q==4'd12) && (enable==1'b1));
    assign c_d		= c_load ? 4'd1 : 4'd0;
endmodule

6. Exams/ece241 2014 q7b（Counter 1000）

  方法1：

module top_module (
    input        clk, 
    input        reset, 
    output       OneHertz, 
    output [2:0] c_enable
);
    wire [3:0] a, b, c;
    
    assign c_enable	= { (a==4'd9)&&(b==4'd9), (a==4'd9), 1'b1 };
    assign OneHertz = (a[0]&&b[0]&&c[0]) && (a[3]&&b[3]&&c[3]);
    
    bcdcount counter0 ( clk, reset, c_enable[0], a );
    bcdcount counter1 ( clk, reset, c_enable[1], b );
    bcdcount counter2 ( clk, reset, c_enable[2], c );
endmodule

  方法2：

module top_module (
    input        clk, 
    input        reset, 
    output       OneHertz, 
    output [2:0] c_enable
);
    wire [3:0] a, b, c;
    
    assign c_enable	= { (a==4'd9)&&(b==4'd9), (a==4'd9), 1'b1 };
    assign OneHertz = (a==4'd9) && (b==4'd9) && (c==4'd9);
    
    bcdcount counter0 ( clk, reset, c_enable[0], a );
    bcdcount counter1 ( clk, reset, c_enable[1], b );
    bcdcount counter2 ( clk, reset, c_enable[2], c );
endmodule

7. Countbcd（4-digit decimal counter）

module top_module (
    input         clk,
    input         reset, 
    output [3:1]  ena,
    output [15:0] q
);
    countbcd M1 ( .q(q[3:0]),   .clk(clk), .reset(reset), .enable(1'b1) );
    countbcd M2 ( .q(q[7:4]),   .clk(clk), .reset(reset), .enable(ena[1]) );
    countbcd M3 ( .q(q[11:8]),  .clk(clk), .reset(reset), .enable(ena[2]) );
    countbcd M4 ( .q(q[15:12]), .clk(clk), .reset(reset), .enable(ena[3]) );
    
    assign ena = { ((q[3:0]==4'd9) && (q[7:4]==4'd9) && (q[11:8]==4'd9)), 
                   ((q[3:0]==4'd9) && (q[7:4]==4'd9)), 
                    (q[3:0]==4'd9)};
endmodule

module countbcd (
    output reg [3:0] q,
    input            clk, 
    input            reset, 
    input            enable
);
    always @(posedge clk) begin
        if (reset) begin
            q <= 0;
        end
        else if (enable && q==4'd9) begin
            q <= 0;
        end
        else if (enable && q<4'd9) begin
            q <= q + 1'b1;
        end
    end
endmodule

8. Count clock（12-hour clock）

这里有个比较迷惑的点就是PM位的循环，它与时钟的循环是错开了一个周期的。

时钟的循环范围是（1-12），而PM的循环范围是（0-11），相当于

1 AM  ➡️  11 AM  ➡️  12 PM  ➡️  1PM  ➡️  11PM   ➡️  12AM   ➡️  1AM   ➡️  ...

所以实际上PM的循环范围是（0（12）-11）【钟表上0与12是重合的】。

  方法1：

module top_module(
    output pm,
    output [7:0] hh,
    output [7:0] mm,
    output [7:0] ss, 
    input  clk,
    input  reset,
    input  ena
);
    wire sso_ena, sst_ena;	// sso使能信号，sst使能信号
    wire mmo_ena, mmt_ena;	// mmo使能信号，mmt使能信号
    wire hho_ena;			// hho使能信号
    wire hht_ena;			// hht使能信号
    wire h_cycle;			// hht、hho置数信号
    wire pm_ena;			// pm翻转信号
    
    wire [3:0] sso, sst;	// 秒钟个位、秒钟十位
    wire [3:0] mmo, mmt;	// 分钟个位、分钟十位
    wire [7:0] hto;			// 时钟

    assign hh = hto;			// 时钟输出赋值
    assign mm = {mmt, mmo};		// 分钟输出赋值
    assign ss = {sst, sso};		// 秒钟输出赋值

    PM		  M1 ( .P(pm),  .CLK(clk), .RST(reset), .ENP(pm_ena) );
    Count_h   M2 ( .Q(hto), .CLK(clk), .RST(reset), .ENT(hht_ena), .ENO(hho_ena), .ENC(h_cycle) );
    Count_ten M3 ( .Q(mmt), .CLK(clk), .RST(reset), .EN(mmt_ena) );
    Count_one M4 ( .Q(mmo), .CLK(clk), .RST(reset), .EN(mmo_ena) );
    Count_ten M5 ( .Q(sst), .CLK(clk), .RST(reset), .EN(sst_ena) );
    Count_one M6 ( .Q(sso), .CLK(clk), .RST(reset), .EN(sso_ena) );
    
    // 各例化模块的使能信号
    assign pm_ena  = hho_ena && (hto[7:4]==4'd1) && (hto[3:0]==4'd1);
    assign h_cycle = hho_ena && (hto[7:4]==4'd1) && (hto[3:0]==4'd2);
    assign hht_ena = hho_ena && (hto[3:0]==4'd9);
    assign hho_ena = mmt_ena && (mmt==4'd5);
    assign mmt_ena = mmo_ena && (mmo==4'd9);
    assign mmo_ena = sst_ena && (sst==4'd5);
    assign sst_ena = sso_ena && (sso==4'd9);
    assign sso_ena = ena;
endmodule


// PM位模块
module PM (
	output P, 
    inout  CLK, RST, 
    input  ENP
);
    always @(posedge CLK) begin
        if (RST) begin
            P <= 1'b0;
        end
        else if (ENP) begin
            P <= ~P;
        end
    end
endmodule


// 时钟模块
module Count_h (
    output reg [7:0] Q,
    input			 CLK, RST, 
    input			 ENT, ENO, ENC
);
    always @(posedge CLK) begin
        if (RST) begin
            Q[7:4] <= 4'd1;
        end
        else if (ENC) begin
            Q[7:4] <= 4'd0;
        end
        else if (ENT) begin
            Q[7:4] <= Q[7:4] + 1'b1;
        end
    end
    
    always @(posedge CLK) begin
        if (RST) begin
            Q[3:0] <= 4'd2;
        end
        else if (ENC) begin
            Q[3:0] <= 4'd1;
        end
        else if (ENO && Q==4'd9) begin
            Q[3:0] <= 4'd0;
        end
        else if (ENO) begin
            Q[3:0] <= Q[3:0] + 1'b1;
        end
    end
endmodule


// 十位片模块
module Count_ten (
    output reg [3:0] Q,
    input			 CLK, RST, 
    input 			 EN
);
    always @(posedge CLK) begin
        if (RST) begin
            Q <= 4'd0;
        end
        else if (EN) begin
            if (Q==4'd5) begin
                Q <= 4'd0;
            end
            else begin
                Q <= Q + 1'b1;
            end
        end
    end
endmodule


// 个位片模块
module Count_one (
    output reg [3:0] Q,
    input			 CLK, RST, 
    input 			 EN
);
    always @(posedge CLK) begin
        if (RST) begin
            Q <= 4'd0;
        end
        else if (EN) begin
            if (Q==4'd9) begin
                Q <= 4'd0;
            end
            else begin
                Q <= Q + 1'b1;
            end
        end
    end
endmodule

  方法2:

module top_module (
    output reg pm,
    output reg [7:0] hh,
    output reg [7:0] mm,
    output reg [7:0] ss, 
    input clk,
    input reset,
    input ena
);
    wire sso_sta, sso_end;					// sso使能信号、sso清零信号
    wire sst_sta, sst_end;					// sst使能信号、sst清零信号
    wire mmo_sta, mmo_end;					// mmo使能信号、mmo清零信号
    wire mmt_sta, mmt_end;					// mmt使能信号、mmt清零信号
    wire hho_sta, hho_end_0, hho_end_1;		// hho使能信号、hho清零信号、hho置1信号
    wire hht_sta, hht_end;					// hht使能信号、hht清零信号
    wire pm_ena;							// pm翻转信号
    
    // PM位 		start
    always @(posedge clk) begin
        if (reset) begin
            pm <= 0;
        end
        else if (pm_ena) begin
            pm <= ~pm;				// pm信号翻转
        end
    end
    
    // 当hh[7:4]==8'd11, mm[7:4]==8'd59, ss[7:4]==8'd59（即11:59:59）时，pm翻转信号为1。
    assign pm_ena = hho_sta && (hh[7:4]==4'd1) && (hh[3:0]==4'd1);
    // 			end
    
    // 时钟十位hht start
    always @(posedge clk) begin
        if (reset) begin
            hh[7:4] <= 1;
        end
        else if (hht_end) begin
            hh[7:4] <= 0;
        end
        else if (hht_sta) begin
            hh[7:4] <= hh[7:4] + 1;
        end
    end
    
    assign hht_sta = hho_end_0;
    assign hht_end = hho_end_1;
    // 			end
    
    
    // 时钟个位hho start
    always @(posedge clk) begin
        if (reset) begin
            hh[3:0] <= 2;
        end
        else if (hho_end_0) begin
            hh[3:0] <= 0;
        end
        else if (hho_end_1) begin
            hh[3:0] <= 1;
        end
        else if (hho_sta) begin
            hh[3:0] <= hh[3:0] + 1;
        end
    end
    
    assign hho_sta = mmt_end;
    assign hho_end_0 = hho_sta && (hh[3:0]==4'd9);
    assign hho_end_1 = hho_sta && (hh[7:4]==4'd1) && (hh[3:0]==4'd2);
    // 			end
    
    
    // 分钟十位mmt start
    always @(posedge clk) begin
        if (reset) begin
            mm[7:4] <= 0;
        end
        else if (mmt_end) begin
            mm[7:4] <= 0;
        end
        else if (mmt_sta) begin
            mm[7:4] <= mm[7:4] + 1;
        end
    end
    
    assign mmt_sta = mmo_end;
    assign mmt_end = mmt_sta && mm[7:4]==4'd5;
    // 			end

    
    // 分钟个位mmo start
    always @(posedge clk) begin
        if (reset) begin
            mm[3:0] <= 0;
        end
        else if (mmo_end) begin
            mm[3:0] <= 0;
        end
        else if (mmo_sta) begin
            mm[3:0] <= mm[3:0] + 1;
        end
    end
    
    assign mmo_sta = sst_end;
    assign mmo_end = mmo_sta && mm[3:0]==4'd9;
    // 			end
    
    
    // 秒钟十位sst start
    always @(posedge clk) begin
        if (reset) begin
            ss[7:4] <= 0;
        end
        else if (sst_end) begin
            ss[7:4] <= 0;
        end
        else if (sst_sta) begin
            ss[7:4] <= ss[7:4] + 1;
        end
    end
    
    assign sst_sta = sso_end;
    assign sst_end = sst_sta && ss[7:4]==4'd5;
    // 			end

    
    // 秒钟个位sso start
    always @(posedge clk) begin
        if (reset) begin
            ss[3:0] <= 0;
        end
        else if (sso_end) begin
            ss[3:0] <= 0;
        end
        else if (sso_sta) begin
            ss[3:0] <= ss[3:0] + 1;
        end
    end
    
    assign sso_sta = ena;
    assign sso_end = sso_sta && (ss[3:0]==4'd9);
    // 			end
endmodule
薄荷煮雪
关注
Circuits--Sequential Logic--Finite State Machines--Fsm3s
weixin_43668420的博客
05-10 147
网址：https://hdlbits.01xz.net/wiki/Fsm3s module top_module( input clk, input in, input reset, output out); // parameter A=0, B=1, C=2, D=3; reg [1:0] state ; reg [1:0] next_state ; always@(posedge clk )
Circuits--Sequential Logic--Latches and Flip-Flops--Dualedge
weixin_43668420的博客
05-13 150
网址：https://hdlbits.01xz.net/wiki/Dualedge 第一种解法： module top_module ( input clk, input d, output q ); reg m = 1'b0; reg n = 1'b0; always@(posedge clk) begin m = d; end always@(negedge c
[HDLBits做题]Sequential Logic --- Latches and Flip-Flops
weixin_39001610的博客
10-17 188
判断是否有边沿变化，可以采用通过一个寄存器储存前一个状态，然后通过对比当前状态来判断是否存在边沿变化，获取上升沿的状态，方式是采用与来比较当前状态和上一个状态，保证当前状态应该为1，上一个状态为0，得到的结果则是发生上升沿的情况。可以分别拆成两个边沿触发器，然后将两个边沿触发器的结果分别作为另一个边沿触发器的上一个输出状态，对比前后两个输出状态，发生变化则输出1，这里可以用异或关系来表示。你熟悉的触发器是在时钟的上升沿触发的，或者是在时钟的下降沿触发的。注：Qold是D触发器在上升沿到来之前的输出。
[HDLBits做题]Sequential Logic --- Shift Registers
weixin_39001610的博客
10-21 113
将触发器的输出标记为Q[7:0]。伽罗瓦LFSR是其中一种特定情况，它的tap（抽头）位置的比特与输出比特进行异或以产生下一个值，而没有抽头位置的比特则参与正常的移位。按照题目意思，首先要构造一个8位移位寄存器，最低位Q[0]输出回到最前端D触发器的输入，包含有enable使能端控制。这个问题中，你将设计一个8x1存储器的电路，其中写入存储器是通过移入来完成的，而读取时“随机访问”，类似于典型的RAM。算数右移的时候，空位不像逻辑右移一样补零，而是补填原数据的最高位（符号位），即正数补0、负数补1。
[HDLBits做题]Sequential Logic --- Counters
weixin_39001610的博客
10-20 101
围绕count4模块构造1-12的计数器，首先考虑三个内部信号，c_enable使能信号，外侧使能则内部count4也使能，所以直接可以将enable与c_enable相连；根据时序图可以看出来该计数器在上升沿计数加一，计数变零有两种情况，一是计数到15后，下一计数归零(此处的归零可以利用进位溢出，因此保持累加即可，但是如果计数范围不是2。按照题目建议设计一个一位十进制计数器bcd4，类似上一题的使用方式，借助前一个计数器输出结果作为下一个计数器的使能端信号，从而实现进位效果。
HDLBits学习（五）Circuits--Sequential Logic(时序逻辑)-Latched and Fli-Flops
m876224398的博客
06-07 598
锁存器相比触发器会消耗更多的资源，所以综合器会在推断出锁存器时产生提醒，防止开发者在不想使用锁存器时，因为代码风格等原因误产生了锁存器。假设你想为这个电路实现分层的Verilog代码，使用其中有触发器和多路复用器的子模块的三个实例。同 D触发器相比，这个元件没有 clk 端口，取而代之的是 ena 端口，所以这是一个锁存器。锁存器的特征在于，相较于 D触发器的触发事件发生于。考虑如下所示的n位移位寄存器电路：为该电路的一级编写一个名为top_module的Verilog模块，包括触发器和多路复用器。
【HDLBits 刷题 6】Circuits（2）Sequential Logic---Latches and Filp Flops
记录学习历程
08-07 4229
这部分的内容比较简单，主要就是学习了创建触发器和锁存器，以及在实际设计中常用的边沿检测。
Circuits--Sequential Logic--Latches and Flip-Flops--Edgedetect
weixin_43668420的博客
05-13 124
网址：https://hdlbits.01xz.net/wiki/Edgedetect module top_module ( input clk, input [7:0] in, output [7:0] pedge ); reg [7:0] r_in; always@(posedge clk) begin r_in = in; end always@(posedge clk)
Circuits--Sequential Logic--Latches and Flip-Flops--Exams/2014 q4a
weixin_43668420的博客
05-12 191
网址：https://hdlbits.01xz.net/wiki/Exams/2014_q4a module top_module ( input clk, input w, R, E, L, output Q ); wire temp1, temp2; assign temp1 = E ? w:Q; assign temp2 = L ? R:temp1; //与上题类似，不做赘述 always @ (posedge clk)
Sequential-logic-circuits.rar_logic_说明及代码
09-21
本资料“Sequential-logic-circuits.rar”包含关于FPGA中时序逻辑电路的详细说明以及Verilog代码实现和仿真的内容。 Verilog是硬件描述语言（HDL）之一，用于描述数字系统，包括时序逻辑和组合逻辑电路。在Verilog...
[HDLBits做题]Sequential Logic ---More Circuits
weixin_39001610的博客
10-24 88
在每个时钟周期，每个单元的下一个状态是由左右两个邻居的异或决定的。下表表达了这个规则更详细的内容，其中下一个状态的值是它本身和左右两个邻居值的函数。在此电路中，创建一个512单元的系统q[511:0]，并在每个时钟周期前进一个步长。在此电路中，创建一个512单元的系统q[511:0]，并在每个时钟周期前进一个步长。在每个时钟周期，每个单元的状态会发生改变。下表表达了这个规则更详细的内容，其中下一个状态的值是它本身和左右两个邻居值的函数。这个游戏是一个二位网格上进行的，每个单元格内为1（存活）或0（死亡）。
HDLBits刷题-Sequential Logic
weixin_44525166的博客
07-14 819
HDLbits刷题
HDLBits学习笔记：Sequential Logic
acmgotoac的博客
04-08 443
99. Four-bit binary counter 没什么说的 module top_module ( input clk, input reset, // Synchronous active-high reset output [3:0] q); initial q = 4'b0; always @(posedge clk) begin if(reset) q <= 4'h0; e
HDLBits学习笔记：Sequential Logic - Finite State Machine
acmgotoac的博客
04-15 128
119. Fsm1 尽量用写时序电路，避免竞争冒险 module top_module( input clk, input areset, // Asynchronous reset to state B input in, output reg out);// parameter A=0, B=1; reg state, next_state; always@(posedge clk or posedge areset)
HDLBits 系列（6）——Sequential Logic（Latches and Flip-Flops）
Bronceyang的博客
09-08 1914
目录 3.2 Sequential Logic 3.2.1 Latches and Flip-Flops 1.D flip-flop 2.D flip-flops 3.DFF with reset 4.DFF with reset value 5.DFF with asynchronous reset 6.DFF with byte enable 7.D Latch 8.DFF 9.DFF 10.DFF+gate 11.Mux and DFF 12.M...
HDLBits 系列（7）——Sequential Logic（Counters、Shift Registers、More Circuits）
Bronceyang的博客
09-09 4009
3.2 Sequential Logic 3.2.2 Counters 1.Four-bit binary counter module top_module ( input clk, input reset, // Synchronous active-high reset output reg [3:0] q); always @(posedge clk)begin if(reset)begin ...
嵌入式常用功能之通讯协议1--IIC
weixin_56228140的博客
11-01 261
Inter-Integrated Circuit(集成电路总线），是由Philips半导体公司（现在的NXP半导体公司）在 八十年代初设计出来的一种简单、双向、二线制总线标准。老式电话，还需要电话中心分转那种连续读随机地址。
嵌入式常用功能之通讯协议1--串口
weixin_56228140的博客
11-01 309
1，简介UART(异步串行通信)：时钟基准不是同一个（比如北京时间和东京时间，同样是三点钟，但是两边有差异）起始位：信号拉低后的第一个时钟数据帧：实际传输的数据奇偶校验：一种比较通用的数据检验方式是否出错停止位：信号拉高后空两个周期表示结束了，停止了波特率：即每秒传输的位数(bit)：960019200115200比如收音机，两边频率相同才能收到对应指定数据比特率： 通信信道每秒传输的信息量称为位传输速率比特率=波特率。
基于FPGA的可控分频器设计与应用
最新发布
zhaoshanshan168的博客
11-04 550
可控分频器的主要功能是将输入的时钟信号频率降低到所需的输出频率，用户可以通过设置分频因子来控制输出频率。1. **时钟信号生成**：在数字系统中生成所需的时钟信号，确保各个模块能够同步工作。常见的计数器有同步计数器和异步计数器，选择合适的计数器结构可以影响分频器的性能。2. **频率合成**：通过调整分频因子实现多种频率输出，以满足不同的系统需求。input wire clk_in, // 输入时钟。output reg clk_out // 输出时钟。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值