FPGA project : clock_key

最新推荐文章于 2026-01-01 23:20:34 发布
原创 最新推荐文章于 2026-01-01 23:20:34 发布 · 104 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fpga开发

博客介绍在clock基础上增加按键控制功能，主要对data_gen模块进行修改。

在clock基础上，增加按键控制功能。

主要修改 data_gen 模块。

 

 

module data_gen
#(
    parameter MAX_1S    = 26'd49_999_999 ,
              NINE      = 4'd9           ,
              FIVE      = 4'd5           
)(
    input           wire                sys_clk     ,
    input           wire                sys_rst_n   ,
    input           wire    [03:00]     key_in      ,

    output          reg     [19:00]     data        ,
    output          wire    [05:00]     point       ,
    output          wire                sign        ,
    output          reg                 seg_en
);

    // reg signal define
    reg     [03:00]     key_r       ;
    reg                 setting     ;
    // reg signal define 
    reg     [25:00]     cnt_1s     ;
    reg                 add_flag   ;
    reg     [03:00]     sec_g      ;
    reg     [03:00]     sec_s      ;
    reg     [03:00]     min_g      ;
    reg     [03:00]     min_s      ;
    reg     [03:00]     hou_g      ;
    reg     [03:00]     hou_s      ;
    reg     [19:00]     data_time  ;

    // [03:00]     key_r       
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            key_r <= 4'b0000 ;
        end else begin
            key_r <= key_in ;
        end
    end
    //             setting     ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            setting <= 1'b0 ;
        end else begin
            if(key_r[0] == 1'b1) begin
                setting <= ~setting ;
            end else begin
                setting <= setting ;
            end
        end
    end
    // [25:00]     cnt_1s     ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            cnt_1s <= 26'd0 ;
        end else begin
            if(setting == 1'b1) begin
                cnt_1s <= cnt_1s ;
            end else begin
                if(cnt_1s == MAX_1S) begin
                    cnt_1s <= 26'd0 ;
                end else begin
                    cnt_1s <= cnt_1s + 1'b1 ;
                end
            end
        end
    end
    //             add_flag    ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            add_flag <= 1'b0 ;
        end else begin
            if(cnt_1s == ( MAX_1S - 1'b1) ) begin
                add_flag <= 1'b1;
            end else begin
                add_flag <= 1'b0 ;
            end
        end
    end
    // [03:00]     sec_g      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            sec_g <= 4'd0 ;
        end else begin
            if(setting == 1'b1) begin
                if(key_r[1] == 1'b1) begin
                    if(sec_g == NINE) begin
                        sec_g <= 4'd0 ;
                    end else begin
                        sec_g <= sec_g + 1'b1 ;
                    end
                end else begin
                    sec_g <= sec_g ;
                end
            end else begin
                if(add_flag) begin
                    if(sec_g == NINE) begin
                        sec_g <= 4'd0 ;
                    end else begin
                        sec_g <= sec_g + 1'b1 ;
                    end
                end else begin
                    sec_g <= sec_g ;
                end
            end
        end
    end
    // [03:00]     sec_s      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            sec_s <= 4'd0 ;
        end else begin
            if(setting == 1'b1) begin
                if(key_r[1] == 1'b1 && sec_g == NINE) begin
                    if(sec_s == FIVE) begin
                        sec_s <= 4'd0 ;
                    end else begin
                        sec_s <= sec_s + 1'b1 ;
                    end
                end else begin
                    sec_s <= sec_s ;
                end
            end else begin
                if(add_flag && ( sec_g == NINE) ) begin
                    if(sec_s == FIVE) begin
                        sec_s <= 4'd0 ;
                    end else begin
                        sec_s <= sec_s + 1'b1 ;
                    end
                end else begin
                    sec_s <= sec_s ;
                end
            end
        end
    end
    // [03:00]     min_g      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            min_g <= 4'b0 ;
        end else begin
            if(setting == 1'b1) begin
                if(key_r[2] == 1'b1) begin
                    if(min_g == NINE) begin
                        min_g <= 4'b0 ;
                    end else begin
                        min_g <= min_g + 1'b1 ;
                    end
                end else begin
                    min_g <= min_g ;
                end
            end else begin
                if(add_flag && (sec_g == NINE) && (sec_s == FIVE)) begin
                    if(min_g == NINE) begin
                        min_g <= 4'd0 ;
                    end else begin
                        min_g <= min_g + 1'b1 ;
                    end
                end else begin
                    min_g <= min_g ;
                end
            end
        end
    end
    // [03:00]     min_s      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            min_s <= 4'd0 ;
        end else begin
            if(setting == 1'b1) begin
                if(key_r[2] == 1'b1 && min_g == NINE) begin
                    if(min_s == FIVE) begin
                        min_s <= 4'd0 ;
                    end else  begin
                        min_s <= min_s + 1'b1 ;
                    end
                end else begin
                    min_s <= min_s ;
                end
            end else begin
                if(add_flag && (sec_g == NINE) && (sec_s == FIVE) && (min_g == NINE)) begin
                    if(min_s == FIVE) begin
                        min_s <= 4'd0 ;
                    end else begin
                        min_s <= min_s + 1'b1 ;
                    end
                end else begin
                    min_s <= min_s ;
                end
            end
        end
    end
    // [03:00]     hou_g      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            hou_g <= 4'd0 ;
        end else begin
            if(setting == 1'b1) begin
                if(key_r[3] == 1'b1) begin
                    if( (hou_s == 4'd2 && hou_g == 3'd3) || (hou_s != 4'd2 && hou_g == NINE) ) begin
                        hou_g <= 4'd0 ;
                    end else begin
                        hou_g <= hou_g + 1'b1 ;
                    end
                end else begin
                    hou_g <= hou_g ;
                end
            end else begin
                if(add_flag && (sec_g == NINE) && (sec_s == FIVE) && (min_g == NINE) && (min_s == FIVE)) begin
                    if( ((hou_s == 4'd2) && (hou_g == 4'd3)) || (hou_s != 4'd2) && (hou_g == NINE) ) begin
                        hou_g <= 4'd0 ;
                    end else begin
                        hou_g <= hou_g + 1'b1 ;
                    end
                end else begin
                    hou_g <= hou_g ;
                end
            end
        end
    end
    // [03:00]     hou_s      ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            hou_s <= 4'd0 ;
        end else begin
            if(setting == 1'b1) begin
                if(hou_s == 4'd2) begin
                    if( (key_r[3] == 1'b1) && (hou_g == 4'd3) ) begin
                        hou_s <= 4'd0 ;
                    end else begin
                        hou_s <= hou_s ;
                    end
                end else begin
                    if( (key_r[3] == 1'b1) && (hou_g == NINE) ) begin
                        hou_s <= hou_s + 1'b1 ;
                    end else begin
                        hou_s <= hou_s ;
                    end
                end
            end else begin
                if(hou_s == 4'd2) begin
                    if(add_flag && (sec_g == NINE) && (sec_s == FIVE) && (min_g == NINE) && (min_s == FIVE) && (hou_g == 4'd3)) begin
                        hou_s <= 4'd0 ;
                    end else begin
                        hou_s <= hou_s ;
                    end
                end else begin
                    if(add_flag && (sec_g == NINE) && (sec_s == FIVE) && (min_g == NINE) && (min_s == FIVE) && (hou_g == NINE)) begin
                        hou_s <= hou_s +1'b1 ;
                    end else begin
                        hou_s <= hou_s ;
                    end
                end
            end 
        end
    end
    // [19:00]     data_time  ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            data_time <= 20'd0 ;
        end else begin
            data_time <= sec_g + sec_s * 4'd10 + min_g * 7'd100 + min_s * 10'd1000 + hou_g * 14'd1000_0 + hou_s * 17'd1000_00 ;
        end
    end
    // output 
    // data
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            data <= 20'd0 ;
        end else begin
            data <= data_time[19:00] ;
        end
    end
    // point
    assign point = 6'b010100 ;
    // sign
    assign sign  = 1'b0 ;
    // seg_en
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            seg_en <= 1'b0 ;
        end else begin
            seg_en <= 1'b1 ;
        end
    end


endmodule
module key_filter
#(
    parameter MAX_CNT_20MS = 20'd999_999 
)(
    input           wire            sys_clk     ,
    input           wire            sys_rst_n   ,
    input           wire    [3:0]   key_in      ,

    output          reg     [3:0]   key_out  
);
    // reg signal define
    reg     [3:0]       key_r0  ;
    reg     [3:0]       key_r1  ;
    reg                 nege    ;
    reg                 pose    ;

    reg     [19:00]     cnt_20ms     ;
    reg                 add_cnt_flag ;
    reg                 flag_20ms    ;

    // key_r0 key_r1 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            key_r0 <= 1'b1 ;
        end else begin
            key_r0 <= key_in ;
        end
    end
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            key_r1 <= 1'b1 ;
        end else begin
            key_r1 <= key_r0 ;
        end
    end

    // nege
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            nege <= 1'b0 ;
        end else begin
            if(| (~key_r0 &  key_r1)) begin
                nege <= 1'b1 ;
            end else begin
                nege <= 1'b0 ;
            end
        end
    end
    // pose
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            pose <= 1'b0 ;
        end else begin
            if(| ( key_r0 & ~key_r1)) begin
                pose <= 1'b1 ;
            end else begin
                pose <= 1'b0 ;
            end
        end
    end

    // add_cnt_flag
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            add_cnt_flag <= 1'b0 ;
        end else begin
            if(nege) begin
                add_cnt_flag <= 1'b1 ;
            end else begin
                if(pose || cnt_20ms == MAX_CNT_20MS) begin
                    add_cnt_flag <= 1'b0 ;
                end else begin
                    add_cnt_flag <= add_cnt_flag ;
                end
            end
        end
    end

    // cnt_20ms 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            cnt_20ms <= 20'd0 ;
        end else begin
            if(add_cnt_flag) begin
                if(cnt_20ms == MAX_CNT_20MS) begin
                    cnt_20ms <= 20'd0 ;
                end else begin
                    cnt_20ms <= cnt_20ms + 20'd1 ;
                end
            end else begin
                cnt_20ms <= 20'd0 ;
            end
        end
    end
    // falg_20ms
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            flag_20ms <= 1'b0 ;
        end else begin
            if(cnt_20ms == MAX_CNT_20MS - 1'b1) begin
                flag_20ms <= 1'b1 ;
            end else begin
                flag_20ms <= 1'b0 ;
            end
        end
    end

    // [3:0]key_out
    always @(posedge sys_clk or negedge sys_rst_n) begin
    // always @(*) begin // 这样的话 会综合成 数据选择器
        if(~sys_rst_n) begin
            key_out <= 4'b0000 ;
        end else begin
            if(flag_20ms) begin
                key_out <= ~key_r1 ;
            end else begin
                key_out <= 4'b0000 ;
            end
        end
    end
endmodule
`timescale 1ns/1ns
module test_key_filter();
    reg                     sys_clk     ;
    reg                     sys_rst_n   ;
    reg         [3:0]       key_in      ;
    reg         [07:00]     cnt_tb      ;

    wire        [3:0]       key_out     ;

    reg                    rand_1 = 1'b1        ;
key_filter 
#(
    .MAX_CNT_20MS           (   50      )
)
key_filter_insert
(
    .sys_clk                ( sys_clk   ),
    .sys_rst_n              ( sys_rst_n ),
    .key_in                 ( key_in    ),

    .key_out                ( key_out   )
);

    parameter CYCLE = 20 ;

    initial begin
        sys_clk    = 1'b1 ;
        sys_rst_n <= 1'b0 ;
        #( CYCLE * 2 )    ;
        sys_rst_n <= 1'b1 ;
        #( 210 )          ;
        sys_rst_n <= 1'b0 ;
        #( CYCLE * 10 )   ;
        sys_rst_n <= 1'b1 ;
        #( CYCLE * 1000 ) ;
        $stop             ;
    end

    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            cnt_tb <= 0 ;
        end else begin
            if(cnt_tb == 249) begin
                cnt_tb <= 0 ;
            end else begin
                cnt_tb <= cnt_tb + 1'b1 ;
            end
        end
    end
    
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            key_in <= 1'b1 ;
        end else begin
            if(( 0 <= cnt_tb && cnt_tb <= 19 )||( 220 <= cnt_tb && cnt_tb <= 249 )) begin
                key_in <= 4'b1111 ;
            end else begin
                if(( 20 <= cnt_tb && cnt_tb <= 69 )||( 170 <= cnt_tb && cnt_tb <= 219 ) ) begin
                    rand_1 = ($random) % 2 ;
                    key_in <= {2'b11,rand_1,1'b1} ;
                end else begin
                    if(70 <= cnt_tb && cnt_tb <= 169) begin
                        key_in <= 4'b1101 ;
                    end else begin
                        key_in <= key_in ;
                    end
                end
            end
        end
    end

    always #( CYCLE / 2 ) sys_clk    = ~sys_clk ;
    
endmodule
`timescale 1ns/1ns
module test_data_gen();
    reg                 sys_clk     ;
    reg                 sys_rst_n   ;
    reg     [03:00]     key_in      ;

    wire    [19:00]     data        ;
    wire    [05:00]     point       ;
    wire                sign        ;
    wire                seg_en      ;


data_gen
#(
    .MAX_1S             ( 26'd10      ) ,
    .NINE               (  4'd9       ) ,
    .FIVE               (  4'd5       )   
)
data_gen_insert
(
    .sys_clk            ( sys_clk    ) ,
    .sys_rst_n          ( sys_rst_n  ) ,
    .key_in             ( key_in     ) ,

    .data               ( data       ) ,
    .point              ( point      ) ,
    .sign               ( sign       ) ,
    .seg_en             ( seg_en     )
);
  
    parameter CYCLE = 20 ;

    initial begin
        sys_clk    = 1'b1 ;
        sys_rst_n <= 1'b0 ;
        key_in    <= 4'b0000 ;
        #( CYCLE * 10 )   ;
        sys_rst_n <= 1'b1 ;
        #( 210 )          ;
        sys_rst_n <= 1'b0 ;
        #( 10 )           ;
        #( CYCLE * 10 )   ;
        sys_rst_n <= 1'b1 ;
        #( CYCLE * 100 )  ;

        key_in    <= 4'b0001 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #( CYCLE * 10 )   ;

        #(CYCLE * 100)    ;

        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0010 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;

        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b0100 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;

        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;
        key_in    <= 4'b1000 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #(CYCLE * 10 )    ;

        #(CYCLE * 100)    ;

        key_in    <= 4'b0001 ;
        #(CYCLE)          ;
        key_in    <= 4'b0000 ;
        #( CYCLE * 100 )  ;
        $stop ;
    end
    always #( CYCLE / 2 ) sys_clk = ~sys_clk ;

endmodule

 

 

 

 

 

 

 

核桃_warrior
关注
FPGA project ： flash_erasure
Meng_long2022的博客
10-10 522
公司提出的一种同步串行接口技术，是一种高速、全双工、同步通信总线，在芯片中只占用四根管脚用来控制及数据。先往板子上固化一个流水灯程序，也就是把生成的.jic文件，写进flash。spi通讯协议有四种模式：模式0和模式3，从设备在sck上升沿采样。重启开发板，流水灯正常工作，说明程序写进了flash。模式0和模式1，在cs_n==1时，sck==0。模式2和模式3，在cs_n==1时，sck==1。，串行外围设备接口）通讯协议，是。模式1和模式2在时钟下降沿采样。比较常用的就是模式0和模式3。
第一个FPGA项目：led_flash简介项目流程和项目中遇到的问题
qq_45656447的博客
10-05 632
第一个FPGA项目：led_flash简介项目流程和项目中遇到的问题 引用“特权同学”在其书中的文字，以激励自己： 理论很重要，实践更重要；理论与实践结合过程中更是需要多思考、多分析、多总结。 一个完整的项目大致应经过以下几步： 分析与综合：综合（synthesis）将RTL设计转变为由FPGA器件中的查找表LUT、触发器FF等各种由底层电路单元组成的网表；在此过程中，综合器会对设计进行优化 约束输入：需要较多的经验累积，表达了设计者期望满足的时序需求 led_flash项目过程： 这里使用的
FPGA project ： flash_read
Meng_long2022的博客
10-13 661
接收数据：比如接收8bit的串行数据，通过miso传递。1，先接收高位。那么通过data保存miso传递的数据，把串行数据，转换为并行数据。有两种常用写法：或者或者：写一个cnt_bit,记录保存到第几bit。2,先接收低位。
FPGA project ： example_ram
Meng_long2022的博客
09-09 209
其他模块代码同example_rom。
FPGA project : example_rom
Meng_long2022的博客
09-07 216
控制模块波形：（其他模块只复用）
FPGA project ： IIC_wr_eeprom
Meng_long2022的博客
10-19 775
在scl为高时，若sda变化，则为起始或终止信号。在scl为低时，（已启动读时隙），sda在scl低电平变化，高电平对sda采样。读时序：分为随机读（单字节读）和顺序读（页读）。写时序：单字节写和页写。
FPGA project ： flash_continue_write
Meng_long2022的博客
10-16 569
本实验学习了通过spi通信协议，驱动flash；完成连续写操作。
FPGA project - ax_debounce
weixin_47663405的博客
04-19 399
【代码】FPGA project - ax_debounce。
FPGA project ：dds
Meng_long2022的博客
09-16 480
【代码】FPGA project ：dds。
混合信号系统仿真挑战：ADC_DAC前端模拟与数字回流协同分析的3大难点突破
[混合信号系统仿真挑战：ADC_DAC前端模拟与数字回流协同分析的3大难点突破](https://e2e.ti.com/cfs-file/__key/communityserver-discussions-components-files/138/powerConsumption.png) # 1. 混合信号系统仿真的...
ARM Cortex-M系列MCU调试实战：JTAG_SWD配置的4个必知技巧与避坑方案
!...# 1. ARM Cortex-M调试基础与JTAG/SWD原理概述 ARM Cortex-M系列处理器广泛应用于嵌入式系统中，其片上调试模块（CoreSight）为开发人员提供了强大的调试能力。JTAG和SWD是两种主流的物理接口，用于与目标芯片建立...
`timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2023/07/08 23:38:24 // Design Name: // Module Name: hmc830_ctrl // Project Name: // Target Devices: // Tool Versions: // Description: // // Dependencies: // // Revision: // Revision 0.01 - File Created // Additional Comments: // ////////////////////////////////////////////////////////////////////////////////// module hmc830_ctrl( input wire clk, output wire rst_n_delay, output wire start_cfg_hmc830 ); //power on 2s start cfg hmc830 parameter TIME_2S = 32'd40; reg [15:0] delay_cnt = 16'd0; reg rst_n_delay_r = 1'b0; always @ (posedge clk) begin if(delay_cnt == 16'd1000) begin delay_cnt <= delay_cnt; rst_n_delay_r <= 1'b1; end else begin delay_cnt <= delay_cnt + 1'b1 ; rst_n_delay_r <= 1'b0; end end assign rst_n_delay = rst_n_delay_r; ////////////////////按键控制配置芯片的寄存器 ///按键消抖 // reg write_key_press; // reg [31:0] delay_cnt1 = 32'd0; // // // parameter T20MS = 32'd999_999; // // always @ (posedge sys_clk or negedge sys_rst_n) // begin // if(~sys_rst_n) // begin // delay_cnt1 <= 32'd0; // end // else if(write_key) // begin // delay_cnt1 <= 32'd0; // end // else if((~write_key) && (delay_cnt1 <= T20MS)) // begin // delay_cnt1 <= delay_cnt1 + 1'b1; // end // else // begin // delay_cnt1 <= delay_cnt1; // end // end // // always @ (posedge sys_clk or negedge sys_rst_n) // begin // if(~sys_rst_n) // begin // write_key_press <= 1'b0; // end // else if(delay_cnt1 == (T20MS - 2)) // begin // write_key_press <= 1'b1; // end // else // begin // write_key_press <= 1'b0; // end // end reg [31:0] delay_time_cnt = 32'd0; // 2s 10 000 000 reg start_cfg_hmc830_r = 1'b0; always @ (posedge clk) begin if(delay_time_cnt == TIME_2S) begin // delay_time_cnt <= delay_time_cnt; delay_time_cnt <= 32'd0; end else begin delay_time_cnt <= delay_time_cnt + 1'b1 ; end end always @ (posedge clk) begin if((delay_time_cnt >= (TIME_2S - 10)) && (delay_time_cnt <= (TIME_2S - 2))) begin start_cfg_hmc830_r <= 1'b1; end else begin start_cfg_hmc830_r <= 1'b0; end end assign start_cfg_hmc830 = start_cfg_hmc830_r; endmodule `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2023/07/08 18:56:30 // Design Name: // Module Name: hmc830_top // Project Name: // Target Devices: // Tool Versions: // Description: // // Dependencies: // // Revision: // Revision 0.01 - File Created // Additional Comments: // ////////////////////////////////////////////////////////////////////////////////// module hmc830_top( input wire clk, //100mhz input wire rst_n , output wire sck_spi, output wire sdi_spi, output wire sen_spi, output wire hmc830_cfg_done ); wire div_clk_out; wire rst_n_delay; wire start_cfg_hmc830; div_clk div_clk( . clk(clk), . div_clk(div_clk_out) ); hmc830_ctrl hmc830_ctrl( . clk(div_clk_out), . rst_n_delay(rst_n_delay), . start_cfg_hmc830(start_cfg_hmc830) ); hmc830 hmc830( . sck_spi(sck_spi), . sdi_spi(sdi_spi), . sen_spi(sen_spi), . done(hmc830_cfg_done), . start(start_cfg_hmc830), . clock(div_clk_out), . reset(rst_n_delay), . FREQ_DATA(250) ); endmodule module TEST_ONE_LED( input wire clk, output wire sck_spi, output wire sdi_spi, output wire sen_spi, output wire cen, input wire pll_sdo_locked, output wire test_locked_led ); assign cen = 1'b1 ; assign test_locked_led = ~pll_sdo_locked ; reg adc_clk_r = 1'b0; always @ (posedge clk) begin adc_clk_r <= ~adc_clk_r; end assign adc_clk = adc_clk_r ; test_dac test_dac( .clk(clk), .dac_clk(dac_clk), .dac_data(dac_data) ); wire rst_n; rst_gen rst_gen( . clk(clk), .rst_n(rst_n) ); wire pll_c0; wire pll_c1; wire pll_locked; // // my_pll my_pll( // inclk0(clk), // c0(pll_c0), // c1(pll_c1), // locked(pll_locked) // ); pll pll( .inclk0(clk), .c0(pll_c0), .c1(pll_c1), .locked(pll_locked) ); wire hmc830_cfg_done ; hmc830_top hmc830_top( . clk(pll_c1), //100mhz // . rst_n() , . sck_spi(sck_spi), . sdi_spi(sdi_spi), . sen_spi(sen_spi), .hmc830_cfg_done(hmc830_cfg_done) ); endmodule `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 21:04:47 12/13/2017 // Design Name: // Module Name: hmc833 // Project Name: // Target Devices: // Tool versions: // Description: // // Dependencies: // // Revision: // Revision 0.01 - File Created // Additional Comments: // ////////////////////////////////////////////////////////////////////////////////// module hmc830( output wire sck_spi, output wire sdi_spi, output reg sen_spi, output reg done, input start, input clock, input reset, input [14:0] FREQ_DATA ); /***************************************************************** 为方便计算N分频器的整数和小数部分，在除法运算中选择改变除数大小，不改变被除数大小 被除数都为FREQ_DATA 在输出频率为3000~6000时，vco频率为1500~3000，除数为3000~6000 除数为Fpd*2 {Fpd[4:0],1'b0} 在输出频率为1500~3000时，vco频率为1500~3000，除数为1500~3000 除数为Fpd 在输出频率为750~1500时，vco频率为1500~3000，除数为750~1500 除数为Fpd/2 {1'b0,Fpd[5:1]}; ******************************************************************/ reg [6:0] Fpd_Divisor; //计算N分频器值的除数 reg Fout_Double_fundament; //输出频率倍频器 0：倍频 1：直通 Vco_Reg03h[0] reg [5:0] Fout_div ; //输出频率分频器 Vco_Reg02h[5:0] wire [14:0] Nint; //N分频器整数部分值 Reg_03h 共19位，高位补0 wire [6:0] Nint_Remainder ; //N分频器整数部余数 wire [30:0] Nfarcdividend; //N分频器小数部分被除数 wire [30:0] Nfarc; //N分频器小数部分值 Reg_04h 只取24位 Nfarc[23:0] reg reckon_done; reg [6:0] reckonTime_cnt; // assign Nfarcdividend = {Nint_Remainder,24'h000000} ; // DIVI_Nfarc DIVI_Nfarc ( // .clk(clock), // input clk // .dividend(Nfarcdividend), // input [30 : 0] dividend // .divisor(Fpd_Divisor), // input [6 : 0] divisor // .quotient(Nfarc) // output [30 : 0] quotient // ); // DIVI_NINT DIVI_NINT ( // .clk(clock), // input clk // .dividend(FREQ_DATA), // input [14 : 0] dividend // .divisor(Fpd_Divisor), // input [6 : 0] divisor // .quotient(Nint), // output [14 : 0] quotient // .fractional(Nint_Remainder)); // output [6 : 0] fractional // parameter Fpd = 6'd50; //鉴相频率50MHz // parameter Fpd = 6'd125; //鉴相频率75MHz // Fout_Double_fundament // always@(negedge clock or negedge reset)begin // if(!reset)Fout_Double_fundament <= 1'b1; // else if(FREQ_DATA > 15'd3000) Fout_Double_fundament <= 1'b0; // else Fout_Double_fundament <= 1'b1; // end // Fout_div // always@(negedge clock or negedge reset)begin // if(!reset) Fout_div <= 6'b00_0001; // else if(FREQ_DATA<=15'd1500) Fout_div <= 6'b00_0010; // else Fout_div <= 6'b00_0001; // end // Fpd_Divisor // always@(negedge clock or negedge reset)begin // if(!reset) Fpd_Divisor <= {1'b0,Fpd}; // else if((FREQ_DATA <= 15'd6000)&&(FREQ_DATA > 15'd3000)) Fpd_Divisor <= {Fpd,1'b0}; // else if((FREQ_DATA <= 15'd3000)&&(FREQ_DATA > 15'd1500)) Fpd_Divisor <= {1'b0,Fpd}; // else if((FREQ_DATA <= 15'd1500)&&(FREQ_DATA > 15'd750)) Fpd_Divisor <= {2'b00,Fpd[5:1]}; // end parameter S_start = 3'h0, S_reckon = 3'h1, S_idle = 3'h2, S_wr = 3'h3, S_ini = 3'h4, S_done = 3'h5; reg [2:0] state,next_state; reg [4:0] bit_cnt; reg [4:0] reg_cnt; reg wr_en,load,wr_end,shift,clr_reg_cnt,reckon; reg [31:0] shift_reg; reg [31:0] reg_init; assign sck_spi = (sen_spi == 1'b1)?clock:1'b0; assign sdi_spi = shift_reg[31]; always@(negedge clock or negedge reset) if(!reset)state <= S_start; else state <= next_state; always@(state or start or bit_cnt or reg_cnt or reckon_done)begin wr_en = 0; load = 0; wr_end = 0; shift = 0; clr_reg_cnt = 0; done = 0; reckon = 0; next_state = state; case(state) S_start: begin if(start == 1'b1) next_state = S_reckon; end S_reckon: begin reckon = 1'b1; if(reckon_done == 1'b1) next_state = S_idle; end S_idle: begin wr_en = 1'b1; load = 1'b1; next_state = S_wr; end S_wr: begin if(bit_cnt == 5'd31)begin wr_end = 1'b1; next_state = S_ini; end else shift = 1'b1; end S_ini: begin if(reg_cnt == 5'd21)begin clr_reg_cnt = 1'b1; next_state = S_done; end else begin wr_en = 1'b1; load = 1'b1; next_state = S_wr; end end S_done: begin // next_state = S_start; //// next_state = next_state; done = 1; end default: next_state = S_start; endcase end //sen_spi always@(negedge clock or negedge reset) if(!reset)sen_spi <= 1'b0; else if(wr_en == 1'b1)sen_spi <= 1'b1; else if(wr_end == 1'b1)sen_spi <= 1'b0; //shift_reg always@(negedge clock or negedge reset) if(!reset)shift_reg <= 32'h0; else if(load == 1'b1)shift_reg <= reg_init; else if(shift == 1'b1)shift_reg <= {shift_reg[30:0],1'b0}; //bit_cnt always@(negedge clock or negedge reset) if(!reset)bit_cnt <= 5'h0; else if(bit_cnt == 5'd31)bit_cnt <= 5'h0; else if(shift == 1'b1)bit_cnt <= bit_cnt + 1'b1; //reg_cnt always@(negedge clock or negedge reset) if(!reset)reg_cnt <= 5'h0; else if(clr_reg_cnt == 1'b1)reg_cnt <= 5'h0; else if(load == 1'b1)reg_cnt <= reg_cnt + 1'b1; // reckonTime_cnt reckon_done always@(negedge clock or negedge reset)begin if(!reset)begin reckonTime_cnt <= 7'd0; reckon_done <= 1'b0; end else if(reckonTime_cnt == 7'd70)begin reckonTime_cnt <= 7'd0; reckon_done <= 1'b1; end else if(reckon == 1'b1)begin reckonTime_cnt <= reckonTime_cnt +1'b1; reckon_done <= reckon_done; end else begin reckonTime_cnt <= 7'd0; reckon_done <= 1'b0; end end always@(reg_cnt or Nint or Fout_div or Nfarc or Fout_Double_fundament)begin case(reg_cnt) 5'd0: reg_init = {1'b0,6'h0,24'h00_00_20,1'b0}; 5'd1: reg_init = {1'b0,6'h0,24'h00_00_20,1'b0}; 5'd2: reg_init = {1'b0,6'h0,24'h00_00_00,1'b0}; 5'd3: reg_init = {1'b0,6'h0,24'h00_00_00,1'b0}; 5'd4: reg_init = {1'b0,6'h1,24'h00_00_02,1'b0}; 5'd5: reg_init = {1'b0,6'h2,24'h00_00_01,1'b0}; //REF DIVIDER R = 2 // 5'd6: reg_init = {1'b0,6'h5,8'h00,3'b111,Fout_div,4'h2,3'b000,1'b0}; //output div vaule Fout_div 射频输出的分频 5'd6: reg_init = {1'b0,6'h5,8'h00,3'b111,6'd24,4'h2,3'b000,1'b0}; //output div vaule Fout_div 射频输出的分频 5'd7: reg_init = {1'b0,6'hb,24'h07_c0_21,1'b0}; 5'd8: reg_init = {1'b0,6'hc,24'h00_00_00,1'b0}; 5'd9: reg_init = {1'b0,6'hf,24'h00_00_81,1'b0}; 5'd10: reg_init = {1'b0,6'h5,9'h000,4'h0,2'h0,1'h0,1'b0,4'h3,3'b000,1'b0}; // output double x2 Fout_Double_fundament // 5'd10: reg_init = {1'b0,6'h5,24'h00_08_18,1'b0}; // output double x2 Fout_Double_fundament 5'd11: reg_init = {1'b0,6'h5,24'h00_16_28,1'b0}; // 24'h00_16_28 = 24'b0000_0000_0001_0110_0010_1000 datasheet default setting 5'd12: reg_init = {1'b0,6'h5,24'h00_60_a0,1'b0}; // 24'h00_60_a0 = 24'b0000_0000_0110_0000_1010_0000 datasheet default setting 5'd13: reg_init = {1'b0,6'h5,24'h00_00_00,1'b0}; 5'd14: reg_init = {1'b0,6'h9,24'h54_23_64,1'b0}; 5'd15: reg_init = {1'b0,6'h8,24'hc1_be_ff,1'b0}; 5'd16: reg_init = {1'b0,6'h7,24'h00_05_4d,1'b0}; 5'd17: reg_init = {1'b0,6'ha,24'h00_20_46,1'b0}; 5'd18: reg_init = {1'b0,6'h6,24'h23_0a_7c,1'b0}; // 5'd19: reg_init = {1'b0,6'h3,9'h000,Nint,1'b0}; // Reg 03h N_INT 60 Nint 5'd19: reg_init = {1'b0,6'h3,9'h000,15'd48,1'b0}; // Reg 03h N_INT 20 Nint min 16 // 5'd20: reg_init = {1'b0,6'h4,Nfarc[23:0],1'b0}; //Reg 04h 5'd20: reg_init = {1'b0,6'h4,24'd0,1'b0}; //Reg 04h default: reg_init = 32'h0000_0000; endcase end endmodule 为什么这个代码可以配置寄存器,而我上边的不行,难道是SPI的时序问题吗
12-25
3. 在FPGA设计中，如何确保状态机的稳定性和可靠性？ 4. 对于HMC830这类射频芯片，配置寄存器的顺序是否有特殊要求？ 您的代码（设计B）能够成功配置HMC830寄存器，而之前的设计A无法配置，主要原因是设计B在SPI...
FPGA在工业控制行业的应用，行业研究文章
weixin_49780322的博客
12-30 801
FPGA是工业控制从**「常规控制」→「精密控制」→「智能控制」的核心升级器件**，其核心价值是解决传统工控芯片「实时性不足、并行性不够、抗干扰差」的痛点，适配工业4.0对高精度、高实时、高可靠、高智能的刚需。从复杂度来看，80%的工业控制FPGA应用集中在「低-中复杂度」（IO采集、EtherCAT从站、简单运动控制），20%的高端场景集中在「高-超高复杂度」（多轴主站、视觉融合、安全联锁），也是工控厂商的技术壁垒所在。
zynq上用verilog实现单稳态电路
2501_94586448的博客
12-31 349
/ 90us对应的时钟周期数 (90,000ns / 20ns)// 状态机：0=空闲，1=脉冲输出。// 90us = 90,000ns = 4500个时钟周期 (20ns * 4500 = 90us)input wire [4:0] delaycount, // 延时计数（0-31）// 时钟周期20ns。// 基本延时90us。.delaycount(5'd10), // 10倍延时 = 900us。· 90us对应的时钟周期数：90,000ns / 20ns = 4500个周期。
FPGA的新一代调试验证工具：forgedaX软件使用指南
最新发布
复及科技的博客
01-01 381
用自动化的“笨”软件，让数据可见，为工程师搭建数字逻辑世界与芯片真实物理世界快速沟通的桥梁，不只是提升设计生产力。
基于米尔 MYD-YM90X 开发板的项目测评与技术分享
Doyoung的专栏
12-29 650
处理器与 FPGA 协同工作：主控 SoC 提供通用计算能力，FPGA 核心则用于定制化逻辑处理。丰富的外设接口：支持多种通信接口，适合工业控制与信号处理场景。官方文档支持：米尔提供了详细的硬件手册与软件移植指南，降低了开发门槛。通过本次开发实践，米尔 MYD-YM90X 开发板展现了其在异构架构与 FPGA 应用方面的优势。硬件滤波方案不仅解决了编码器信号毛刺问题，也为后续的复杂信号处理提供了可扩展的思路。在 FPGA 中实现更复杂的数字滤波算法，如 FIR/IIR 滤波器。
verilog spi slave回环模拟
bruk_spp的博客
12-29 142
本篇作为学习verilog过程中一个动手编码的尝试，主要从网上找的基础代码再加上自己的一些修改。一来可以加深对verilog语法的了解，二来也有助于有硬件有更深入的了解。上述代码比较简单,主要有两个module。一个spi回环模拟模块，一个激励模块。
数字地与模拟地的区别
在读研究生，FPGA电路设计与功能开发。
01-01 136
模拟地和数字地的区别及连接方法 摘要：FPGA设计中的模拟地(GNDADC)和数字地(GND)有显著区别。数字地因高速开关电路会产生大量噪声，而模拟地需要保持"安静"以确保ADC精度。原理图中使用不同符号区分二者，防止EDA软件自动连接。PCB布局时，建议通过磁珠连接两地，磁珠允许直流通过但阻挡高频噪声，从而保护ADC测量精度。这种设计类似于为ADC创建"静音区"，与数字电路的"噪声区"隔离。
CS5567：具有宽占空比范围的60V同步降压DCDC控制器
weixin_73833207的博客
12-29 176
输入欠压锁定（UVLO）带迟滞功能，175℃热关断保护（20℃滞回），断续模式过流保护（打嗝模式），保障系统可靠运行。CS5567E是一款具有宽占空比范围的高性能同步降压控制器，输入电压范围5.5~60V，输出电压可调0.8~55V，适用于无线基础设施、云计算、工业电机驱动、电动自行车、IP摄像头及反相降压/升压稳压器等场景。采用EQA16封装，工作结温-40℃~125℃，环境温度-40℃~85℃，热阻45℃/W，底部带散热片，需搭配PCB散热设计保障高压大电流场景稳定运行。具有迟滞功能的输入UVLO。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值