Exams/review2015 fancytimer

已于 2022-12-26 12:03:10 修改
阅读量142 收藏
点赞数 1
文章标签： fpga开发
于 2022-12-24 22:27:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64880535/article/details/128432112
版权 

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output [3:0] count,
    output counting,
    output done,
    input ack );

    parameter s0=3'd0,s1=3'd1,s2=3'd2,s3=3'd3,s4=3'd4,s_count=3'd5,s_done=3'd6;
    reg [2:0] n_s,s;
    reg [1:0] cnt;
    reg [3:0] reg_count;

    reg [15:0] delay,cnt1;
    
    always@(*) begin
        case(s)
            s0:n_s=data?s1:s0;
            s1:n_s=data?s2:s0;
            s2:n_s=data?s2:s3;
            s3:n_s=data?s4:s0;
            s4:n_s=(cnt==3'd3)?s_count:s4;    
            s_count:n_s=(cnt1==delay-1)?s_done:s_count;  
            s_done:n_s=ack?s0:s_done;
          
        endcase
    end
    
    always@(posedge clk) begin
        if(reset)
            s<=s0;
        else
            s<=n_s;
    end
    
    //shift_cnt_block
    always@(posedge clk) begin
        if(reset)
            cnt<=0;
        else if(s==s4) begin
            if(cnt<3'd3)
                cnt<=cnt+1;
            else
                cnt<=0;
        end  
    end

    //shift_block
    always@(posedge clk) begin
        if(s==s4)
            reg_count<={reg_count[2:0],data};
       
        else
            reg_count<=reg_count;
        
    end
    
    //delay_counting_block
    always@(*) begin
        if(s==s_count)
            delay=(reg_count+1'd1)*10'd1000;
        else
            delay=0;
    end
    
    //cnt1_counting_block
    always@(posedge clk) begin
        if(reset)
            cnt1<=0;
        else if(s==s_count)
            cnt1<=cnt1+1;
        else
            cnt1<=0;
    end
    
    assign counting=(s==s_count);
    assign done=(s==s_done);
	assign count = reg_count - cnt1/1000;    //cnt1每1000个周期后count递减
endmodule

相比上一题，本题增加了实际的计数逻辑以取代输入信号 done_counting，但状态以及转移关系与上一题相同。

设计 dly_val [3:0] ，在 shft_ena 移位使能的情况下，从数据流中读取 4bit 延迟值。

计数逻辑为一个周期为 1000 的计数器，当计数器输出 16’d999 时，将 dly_val 减 1。

功能是不是听上去很熟悉，没错，我们可以分别使用之前实现的 移位寄存器 以及 周期为 1000 的计数器。并在相应状态产生使能信号控制这两个下层模块。

module shft_reg_cntr (
    input clk,
    input shift_ena,
    input count_ena,
    input data,
    output reg [3:0] q);

    always @(posedge clk ) begin
        if(shift_ena)
            q   <=  {q[2:0],data};
        else if(count_ena) begin
            q   <=  q - 4'd1;
        end  
    end
endmodule

module cntr_1k (
    input clk,
    input reset,
    output reg [9:0] q);

    always @(posedge clk ) begin
        if(reset | q == 10'd999)
            q   <=  10'd0;
        else begin
            q   <=  q + 10'd1;
        end  
    end
endmodule

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output [3:0] count,
    output counting,
    output done,
    input ack );

    localparam FSM_W  = 8;
    localparam FSM_W1 = FSM_W - 1'b1;

    reg [FSM_W1:0]   state;
    reg [FSM_W1:0]   nxt_state;

    localparam  IDLE        = 0;
    localparam  S_0         = 1;
    localparam  S_1         = 2;
    localparam  S_11        = 3;
    localparam  S_110       = 4;
    localparam  S_SHFT_ENA  = 5;
    localparam  WAT_CNT_FIN = 6;
    localparam  WAT_ACK     = 7;

    wire            done_counting;

    //assert signal cntr
    reg [1:0]       asrt_cntr;
    wire            asrt_cntr_add;  
    wire            asrt_cntr_clr;  

    //delay val
    wire[3:0]       dly_val;

    wire            dly_val_shft_ena;
    wire            dly_val_dec;

    //delay cntr
    wire [9:0]      dly_cntr;
    wire            dly_cntr_ena;

    //assert signal cntr
    always @(posedge clk) begin
        if(reset) begin
            asrt_cntr              <= 'b0;
        end else if(asrt_cntr_add)begin
            asrt_cntr              <= asrt_cntr + 1'b1;
        end else if(asrt_cntr_clr)begin
            asrt_cntr              <= 'b0;
        end
    end
    assign                  asrt_cntr_add  = state[S_SHFT_ENA];
    assign                  asrt_cntr_clr  = 1'b0; // cntr clear itself

    //delay cntr
    cntr_1k U_cntr_1k(
        .clk        (clk),
        .reset      (~dly_cntr_ena),
        .q          (dly_cntr)
    );
    assign                  dly_cntr_ena  = state[WAT_CNT_FIN   ];

    //delay val
    shft_reg_cntr U_shft_reg_cntr
    (
        .clk        (clk),
        .shift_ena  (dly_val_shft_ena),
        .count_ena  (dly_val_dec),
        .data       (data),
        .q          (dly_val)
    );
    assign                  dly_val_shft_ena    =   state[S_SHFT_ENA ];
    assign                  dly_val_dec         =   (dly_cntr == 16'd999 ) && ~(dly_val == 4'd0);

    assign                  done_counting       =   dly_cntr == 16'd999 && dly_val == 4'd0;

    // State transition logic (combinational)
    always @(*) begin
        nxt_state[IDLE   ]          =   1'b0; // never reach for nxt_state
        nxt_state[S_0    ]          =   (state[IDLE   ] && ~data) || (state[S_1    ] && ~data) || (state[S_0    ] && ~data) 
                            || (state[S_110   ] && ~data) || (state[WAT_ACK       ] && ack);
        nxt_state[S_1    ]          =   (state[IDLE   ] &&  data) || (state[S_0    ] &&  data);
        nxt_state[S_11   ]          =   (state[S_1    ] &&  data) || (state[S_11   ] &&  data);
        nxt_state[S_110  ]          =   (state[S_11   ] && ~data);
        nxt_state[S_SHFT_ENA ]      =   (state[S_110  ] &&  data) || (state[S_SHFT_ENA  ] && ~(asrt_cntr == 2'd3));

        nxt_state[WAT_CNT_FIN   ]   =   (state[S_SHFT_ENA] && asrt_cntr == 2'd3)
                                    || (state[WAT_CNT_FIN   ] && ~done_counting);

        nxt_state[WAT_ACK       ]   =   (state[WAT_CNT_FIN   ] && done_counting) 
                                    || (state[WAT_ACK       ] && ~ack);
    end

    // State flip-flops (sequential)
    always @(posedge clk) begin
        if(reset)
            state   <=  'b10; //SEQ_RCGN
        else begin
            state   <=  nxt_state;
        end  
    end

    //output logic
    assign  done        =   state[WAT_ACK] ;
    assign  counting    =   state[WAT_CNT_FIN];
    assign  count       =   dly_val;
endmodule

三、

module shift_count_module (
    input clk,
	input data,
	input shift_ena,
	input count_ena,
    output reg [3:0] q
	);
 
    always@(posedge clk) begin
        if(shift_ena)
            q<={q[2:0],data};
        else if(count_ena)
            q<=q-1;
    end
    
endmodule
 
module count_1000_module (
	input clk,
	input reset,
    output reg [9:0] q);
    
    always@(posedge clk) begin
        if(reset)
            q<=0;
        else if(q<10'd999)
            q<=q+1;
        else
            q<=0;
    end
    
endmodule

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output [3:0] count,
    output counting,
    output done,
    input ack );
    
    
    reg [6:0] n_state,state; 
    parameter s0=0,s1=1,s2=2,s3=3,s_shift=4,s_count=5,s_done=6;
    
    always@(*) begin
        case(state)
            s0:n_state=data?s1:s0;
            s1:n_state=data?s2:s0;
            s2:n_state=data?s2:s3;
            s3:n_state=data?s_shift:s0;
            s_shift:n_state=(cnt1==3'd3)?s_count:s_shift;    
            s_count:n_state=(counting_finish_ena)?s_done:s_count;  
            s_done:n_state=ack?s0:s_done;
        endcase
    end
    
    reg [1:0] cnt1;
    always@(posedge clk) begin
        if(reset)
            cnt1<=0;
        else if(state==s_shift)
            cnt1<=cnt1+1;
        else
            cnt1<=0;
    end
    
 
    wire [9:0] counting_doing;
    count_1000_module u_1 (
        .clk(clk),
        .reset(state!=s_count),
        .q(counting_doing)
    );
    
    wire [3:0] count_delay;
    wire counting_finish_ena;
    shift_count_module u_2 (
        .clk(clk),
        .data(data),
        .shift_ena(state==s_shift),
        .count_ena(((counting_doing==10'd999)&&(count_delay!=0))),
        .q(count_delay)
    );
    assign counting_finish_ena= (counting_doing==10'd999)&&(count_delay==0);
    
    always@(posedge clk) begin
        if(reset)
            state<=0;
        else
            state<=n_state;
    end
    
    assign count=count_delay;
    assign counting=(state==s_count);
    assign done=(state==s_done);
    
endmodule

0.0959
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hdlbits系列verilog解答（Exams/ece241 2014 q1c）-69
zuoph的博客
05-22 83
hdlbits系列verilog解答（Exams/ece241 2014 q1c）-69
【HDLBits刷题笔记】Exams/ece241 2013 q4
m0_50728139的博客
10-13 354
【HDLBits刷题笔记】Exams/ece241 2013 q4
HDLBits-Exams/review2015 fancytimer
qq_39586852的博客
06-15 503
HDLBits-Exams/review2015 fancytimer解析
HDLBits学习：Exams/review2015 fancytimer
最新发布
weixin_66492206的博客
07-30 832
这应该等于 1000 个周期的延迟，然后等于 1000 个周期的延迟 1，依此类推，直到 1000 个周期为 0。例如，一旦读取了 1101 和延迟[3：0]，电路就不再查看数据输入，直到在完成其他所有操作后恢复搜索。在此示例中，电路计数 2000 个时钟周期，因为 delay[3：0] 值为 4'b0001。此时，电路必须断言完成以通知用户计时器已超时，并等待输入确认为1，然后再被复位以寻找下一次出现的启动序列（1101）。这是五个练习中的第五个部分，该练习从几个较小的电路中构建了一个复杂的计数器。
HDLbits---Exams/review2015 fancytimer
博主毕竟还是人，肯定会有错误，各位看的时候发现错误提出来就好
04-24 766
HDLbits—Exams/review2015 fancytimer 这一题同样困扰了我几天，今天把HDLbits—Fsm serialdp 和这题都给完成了，之前的发现自己犯的错是把输入wire型的放在时序逻辑中输出，但是应该是使用寄存器再assign输出才对。慢慢写倒是一次写出来了。历时2周终于把HDLbits刷完了，接下来学习找工作需要的内容了 module top_module ( input clk, input reset, // Synchronous reset
[Verilog] fancytimer -- HDLBits Solution
wzr2016的博客
12-02 154
【代码】[Verilog] fancytimer -- HDLBits Solution。
Exams/review2015 fsm
qq_64880535的博客
12-23 169
HDL bits
HDLBits Exams/2014 q3fsm 详解
char111的博客
07-18 471
我的思路添加三个状态机以代替对三个周期进行计数，并在状态机跳转时对w=1的次数进行计数。虽然多用了三个状态机，但这种写法网上还没见过，所以分享一下。
HDLBits刷题记录——fancytimer
JJJJJJJerry的博客
01-24 304
导言 定时器是和实际应用很贴近的一道题目。而且我曾在EDA课上做过类似的PJ，可惜当时从未接触过硬件描述语言，最终并没有得到一个正确的时钟计数器。 思路 前面四题（HDLBits<Circuitd<Biulding larger circuits）正是这个complete timer的铺垫 序列检测状态机 移位操作状态机 下行计数器 后面一题用独热码的方式表示状态的转移。我对独热码的理解还有待加强，关键在于： 状态的表示方式是：state中某一位为高，即进入该位代表的状态 下一状态同样
Exams/review2015 fancytimer_HDLbits详解
NJUzzf98的博客
04-17 1082
折磨的一题，铺垫了四题的小BOSS终于来了
Verilog刷题HDLBits——Exams/review2015 fancytimer
weixin_45968042的博客
12-24 782
【代码】Verilog刷题HDLBits——Exams/review2015 fancytimer。
HDLBits Exams/review2015 fancytimer
qq_42282258的博客
06-08 312
Exams/review2015 fancytimer 历时2个小时，终于把这道题给弄得差不多了，但是还是有一些细节没弄明白，特此记录一下。 根据题意得要求 可以大概划分为以下几个电路： 1.序列检测模块 2.移位断定延迟时间模块 3.计数器模块 4.检测ack模块如果刷过HDLBits 就可以知道这道题得前面几道题，其实对应的就是这几个小模块电路因此，参考前面几个模块电路，可以给出如下代码： 其中S1,S11,S110状态是处于序列检测， B0,B1,B2,B3是处于4个时钟周期内用来断定延迟时间的状态
HDLBits在线编程题之Exams/review2015 fancytimer
qq_37590544的博客
10-30 436
Exams/review2015 fancytimer题目代码 题目 地址：HDLBits-Exams/review2015 fancytimer 介绍：花了好长时间写的，记录一下。将计数值量化为以1000为单位，开始时则有delay的1000需要计数。在couting过程中统计已经计了1000次的次数num_1k，将delay减去num_1k即count。 代码 module top_module ( input clk, input reset, // Synchronous
python爬取网页信息，请求url：https://utestapi.ulearning.cn/exams/user/study/getExamReport?examId=96023&traceId=9542570，爬取里面的result.part数组
06-13
url = 'https://utestapi.ulearning.cn/exams/user/study/getExamReport?examId=96023&traceId=9542570' response = requests.get(url) data = json.loads(response.text) result_parts = data['result']['part'] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值